1. module bluebird
   1. function bluebird (executor)
   2. function bluebird.AggregateError (message)
   3. function bluebird.CancellationError (message)
   4. function bluebird.OperationalError (message)
   5. function bluebird.Promise (executor)
   6. function bluebird.PromiseInspection (promise)
   7. function bluebird.RangeError ()
   8. function bluebird.RejectionError (message)
   9. function bluebird.TimeoutError (message)
   10. function bluebird.TypeError ()
   11. function bluebird._SomePromiseArray (values)
   12. function bluebird._peekContext ()
   13. function bluebird.all (promises)
   14. function bluebird.any (promises)
   15. function bluebird.async ()
   16. function bluebird.attempt (fn)
   17. function bluebird.bluebird_core (executor)
   18. function bluebird.cast (obj)
   19. function bluebird.config (opts)
   20. function bluebird.coroutine (generatorFunction, options)
   21. function bluebird.defer ()
   22. function bluebird.delay (ms, value)
   23. function bluebird.each (promises, fn)
   24. function bluebird.filter (promises, fn, options)
   25. function bluebird.fromCallback (fn)
   26. function bluebird.fromNode (fn)
   27. function bluebird.fulfilled (obj)
   28. function bluebird.getNewLibraryCopy ()
   29. function bluebird.hasLongStackTraces ()
   30. function bluebird.is (val)
   31. function bluebird.join ()
   32. function bluebird.longStackTraces ()
   33. function bluebird.map (promises, fn, options, _filter)
   34. function bluebird.mapSeries (promises, fn)
   35. function bluebird.method (fn)
   36. function bluebird.noConflict ()
   37. function bluebird.onPossiblyUnhandledRejection (fn)
   38. function bluebird.onUnhandledRejectionHandled (fn)
   39. function bluebird.pending ()
   40. function bluebird.promisify (fn, options)
   41. function bluebird.promisifyAll (target, options)
   42. function bluebird.props (promises)
   43. function bluebird.queue (capacity)
   44. function bluebird.race (promises)
   45. function bluebird.reduce (promises, fn, initialValue, _each)
   46. function bluebird.reject (reason)
   47. function bluebird.rejected (reason)
   48. function bluebird.resolve (obj)
   49. function bluebird.setScheduler (fn)
   50. function bluebird.settle (promises)
   51. function bluebird.some (promises, howMany)
   52. function bluebird.spawn (generatorFunction)
   53. function bluebird.try (fn)
   54. function bluebird.using ()
   55. object bluebird.AggregateError.prototype
   56. object bluebird.CancellationError.prototype
   57. object bluebird.OperationalError.prototype
   58. object bluebird.PromiseInspection.prototype
   59. object bluebird.TimeoutError.prototype
   60. object bluebird._SomePromiseArray.prototype
   61. object bluebird.async.prototype
   62. object bluebird.bluebird.prototype
   63. object bluebird.bluebird_core.prototype
   64. object bluebird.errors
   65. object bluebird.es5
   66. object bluebird.queue.prototype
   67. object bluebird.util
   68. string bluebird.version
2. module bluebird.AggregateError
   1. function bluebird.AggregateError (message)
3. module bluebird.AggregateError.prototype
   1. boolean bluebird.AggregateError.prototype.isOperational
   2. function bluebird.AggregateError.prototype.constructor (message)
   3. function bluebird.AggregateError.prototype.every ()
   4. function bluebird.AggregateError.prototype.filter ()
   5. function bluebird.AggregateError.prototype.forEach ()
   6. function bluebird.AggregateError.prototype.indexOf ()
   7. function bluebird.AggregateError.prototype.join ()
   8. function bluebird.AggregateError.prototype.lastIndexOf ()
   9. function bluebird.AggregateError.prototype.map ()
   10. function bluebird.AggregateError.prototype.pop ()
   11. function bluebird.AggregateError.prototype.push ()
   12. function bluebird.AggregateError.prototype.reduce ()
   13. function bluebird.AggregateError.prototype.reduceRight ()
   14. function bluebird.AggregateError.prototype.reverse ()
   15. function bluebird.AggregateError.prototype.shift ()
   16. function bluebird.AggregateError.prototype.slice ()
   17. function bluebird.AggregateError.prototype.some ()
   18. function bluebird.AggregateError.prototype.sort ()
   19. function bluebird.AggregateError.prototype.toString ()
   20. function bluebird.AggregateError.prototype.unshift ()
   21. number bluebird.AggregateError.prototype.length
4. module bluebird.CancellationError
   1. function bluebird.CancellationError (message)
5. module bluebird.CancellationError.prototype
   1. function bluebird.CancellationError.prototype.constructor (message)
6. module bluebird.OperationalError
   1. function bluebird.OperationalError (message)
7. module bluebird.OperationalError.prototype
   1. function bluebird.OperationalError.prototype.constructor (message)
8. module bluebird.PromiseInspection
   1. function bluebird.PromiseInspection (promise)
9. module bluebird.PromiseInspection.prototype
   1. function bluebird.PromiseInspection.prototype._settledValue ()
   2. function bluebird.PromiseInspection.prototype.error ()
   3. function bluebird.PromiseInspection.prototype.isCancelled ()
   4. function bluebird.PromiseInspection.prototype.isFulfilled ()
   5. function bluebird.PromiseInspection.prototype.isPending ()
   6. function bluebird.PromiseInspection.prototype.isRejected ()
   7. function bluebird.PromiseInspection.prototype.isResolved ()
   8. function bluebird.PromiseInspection.prototype.reason ()
   9. function bluebird.PromiseInspection.prototype.value ()
10. module bluebird.TimeoutError
    1. function bluebird.TimeoutError (message)
11. module bluebird.TimeoutError.prototype
    1. function bluebird.TimeoutError.prototype.constructor (message)
12. module bluebird._SomePromiseArray
    1. function bluebird._SomePromiseArray (values)
13. module bluebird._SomePromiseArray.prototype
    1. function bluebird._SomePromiseArray.prototype._addFulfilled (value)
    2. function bluebird._SomePromiseArray.prototype._addRejected (reason)
    3. function bluebird._SomePromiseArray.prototype._canPossiblyFulfill ()
    4. function bluebird._SomePromiseArray.prototype._checkOutcome ()
    5. function bluebird._SomePromiseArray.prototype._fulfilled ()
    6. function bluebird._SomePromiseArray.prototype._getRangeError (count)
    7. function bluebird._SomePromiseArray.prototype._init ()
    8. function bluebird._SomePromiseArray.prototype._promiseCancelled ()
    9. function bluebird._SomePromiseArray.prototype._promiseFulfilled (value)
    10. function bluebird._SomePromiseArray.prototype._promiseRejected (reason)
    11. function bluebird._SomePromiseArray.prototype._rejected ()
    12. function bluebird._SomePromiseArray.prototype._resolveEmptyArray ()
    13. function bluebird._SomePromiseArray.prototype.constructor (values)
    14. function bluebird._SomePromiseArray.prototype.howMany ()
    15. function bluebird._SomePromiseArray.prototype.init ()
    16. function bluebird._SomePromiseArray.prototype.setHowMany (count)
    17. function bluebird._SomePromiseArray.prototype.setUnwrap ()
14. module bluebird.async
    1. function bluebird.async ()
    2. object bluebird.async.firstLineError
15. module bluebird.async.prototype
    1. function bluebird.async.prototype._drainQueue (queue)
    2. function bluebird.async.prototype._drainQueues ()
    3. function bluebird.async.prototype._queueTick ()
    4. function bluebird.async.prototype._reset ()
    5. function bluebird.async.prototype.disableTrampolineIfNecessary ()
    6. function bluebird.async.prototype.enableTrampoline ()
    7. function bluebird.async.prototype.fatalError (e, isNode)
    8. function bluebird.async.prototype.hasCustomScheduler ()
    9. function bluebird.async.prototype.haveItemsQueued ()
    10. function bluebird.async.prototype.invoke (fn, receiver, arg)
    11. function bluebird.async.prototype.invokeLater (fn, receiver, arg)
    12. function bluebird.async.prototype.setScheduler (fn)
    13. function bluebird.async.prototype.settlePromises (promise)
    14. function bluebird.async.prototype.throwLater (fn, arg)
16. module bluebird.bluebird
    1. function bluebird.bluebird (executor)
    2. function bluebird.bluebird.AggregateError (message)
    3. function bluebird.bluebird.CancellationError (message)
    4. function bluebird.bluebird.OperationalError (message)
    5. function bluebird.bluebird.Promise (executor)
    6. function bluebird.bluebird.PromiseInspection (promise)
    7. function bluebird.bluebird.RangeError ()
    8. function bluebird.bluebird.RejectionError (message)
    9. function bluebird.bluebird.TimeoutError (message)
    10. function bluebird.bluebird.TypeError ()
    11. function bluebird.bluebird._SomePromiseArray (values)
    12. function bluebird.bluebird._peekContext ()
    13. function bluebird.bluebird.all (promises)
    14. function bluebird.bluebird.any (promises)
    15. function bluebird.bluebird.attempt (fn)
    16. function bluebird.bluebird.bind (thisArg, value)
    17. function bluebird.bluebird.cast (obj)
    18. function bluebird.bluebird.config (opts)
    19. function bluebird.bluebird.coroutine (generatorFunction, options)
    20. function bluebird.bluebird.defer ()
    21. function bluebird.bluebird.delay (ms, value)
    22. function bluebird.bluebird.each (promises, fn)
    23. function bluebird.bluebird.filter (promises, fn, options)
    24. function bluebird.bluebird.fromCallback (fn)
    25. function bluebird.bluebird.fromNode (fn)
    26. function bluebird.bluebird.fulfilled (obj)
    27. function bluebird.bluebird.getNewLibraryCopy ()
    28. function bluebird.bluebird.hasLongStackTraces ()
    29. function bluebird.bluebird.is (val)
    30. function bluebird.bluebird.join ()
    31. function bluebird.bluebird.longStackTraces ()
    32. function bluebird.bluebird.map (promises, fn, options, _filter)
    33. function bluebird.bluebird.mapSeries (promises, fn)
    34. function bluebird.bluebird.method (fn)
    35. function bluebird.bluebird.noConflict ()
    36. function bluebird.bluebird.onPossiblyUnhandledRejection (fn)
    37. function bluebird.bluebird.onUnhandledRejectionHandled (fn)
    38. function bluebird.bluebird.pending ()
    39. function bluebird.bluebird.promisify (fn, options)
    40. function bluebird.bluebird.promisifyAll (target, options)
    41. function bluebird.bluebird.props (promises)
    42. function bluebird.bluebird.race (promises)
    43. function bluebird.bluebird.reduce (promises, fn, initialValue, _each)
    44. function bluebird.bluebird.reject (reason)
    45. function bluebird.bluebird.rejected (reason)
    46. function bluebird.bluebird.resolve (obj)
    47. function bluebird.bluebird.setScheduler (fn)
    48. function bluebird.bluebird.settle (promises)
    49. function bluebird.bluebird.some (promises, howMany)
    50. function bluebird.bluebird.spawn (generatorFunction)
    51. function bluebird.bluebird.try (fn)
    52. function bluebird.bluebird.using ()
    53. string bluebird.bluebird.version
17. module bluebird.bluebird.prototype
    1. function bluebird.bluebird.prototype.__isCancelled ()
    2. function bluebird.bluebird.prototype._addCallbacks ( fulfill, reject, promise, receiver, domain )
    3. function bluebird.bluebird.prototype._attachCancellationCallback (onCancel)
    4. function bluebird.bluebird.prototype._attachExtraTrace (error, ignoreSelf)
    5. function bluebird.bluebird.prototype._boundValue ()
    6. function bluebird.bluebird.prototype._branchHasCancelled ()
    7. function bluebird.bluebird.prototype._cancel ()
    8. function bluebird.bluebird.prototype._cancelBranched ()
    9. function bluebird.bluebird.prototype._cancelBy (canceller)
    10. function bluebird.bluebird.prototype._cancelPromises ()
    11. function bluebird.bluebird.prototype._captureStackTrace ()
    12. function bluebird.bluebird.prototype._clearCallbackDataAtIndex (index)
    13. function bluebird.bluebird.prototype._clearCancellationData ()
    14. function bluebird.bluebird.prototype._doInvokeOnCancel (onCancelCallback, internalOnly)
    15. function bluebird.bluebird.prototype._enoughBranchesHaveCancelled ()
    16. function bluebird.bluebird.prototype._ensurePossibleRejectionHandled ()
    17. function bluebird.bluebird.prototype._execute (executor, resolve, reject)
    18. function bluebird.bluebird.prototype._fireEvent ()
    19. function bluebird.bluebird.prototype._followee ()
    20. function bluebird.bluebird.prototype._fulfill (value)
    21. function bluebird.bluebird.prototype._fulfillPromises (len, value)
    22. function bluebird.bluebird.prototype._fulfillmentHandlerAt (index)
    23. function bluebird.bluebird.prototype._getDisposer ()
    24. function bluebird.bluebird.prototype._invokeInternalOnCancel ()
    25. function bluebird.bluebird.prototype._invokeOnCancel ()
    26. function bluebird.bluebird.prototype._isBound ()
    27. function bluebird.bluebird.prototype._isCancellable ()
    28. function bluebird.bluebird.prototype._isCancelled ()
    29. function bluebird.bluebird.prototype._isDisposable ()
    30. function bluebird.bluebird.prototype._isFateSealed ()
    31. function bluebird.bluebird.prototype._isFinal ()
    32. function bluebird.bluebird.prototype._isFollowing ()
    33. function bluebird.bluebird.prototype._isRejectionUnhandled ()
    34. function bluebird.bluebird.prototype._isUnhandledRejectionNotified ()
    35. function bluebird.bluebird.prototype._length ()
    36. function bluebird.bluebird.prototype._migrateCallback0 (follower)
    37. function bluebird.bluebird.prototype._migrateCallbackAt (follower, index)
    38. function bluebird.bluebird.prototype._notifyUnhandledRejection ()
    39. function bluebird.bluebird.prototype._notifyUnhandledRejectionIsHandled ()
    40. function bluebird.bluebird.prototype._onCancel ()
    41. function bluebird.bluebird.prototype._passThrough (handler, type, success, fail)
    42. function bluebird.bluebird.prototype._peekContext ()
    43. function bluebird.bluebird.prototype._popContext ()
    44. function bluebird.bluebird.prototype._promiseAt (index)
    45. function bluebird.bluebird.prototype._promiseCreated ()
    46. function bluebird.bluebird.prototype._propagateFrom (parent, flags)
    47. function bluebird.bluebird.prototype._proxy (proxyable, arg)
    48. function bluebird.bluebird.prototype._pushContext ()
    49. function bluebird.bluebird.prototype._reason ()
    50. function bluebird.bluebird.prototype._receiverAt (index)
    51. function bluebird.bluebird.prototype._reject (reason)
    52. function bluebird.bluebird.prototype._rejectCallback (reason, synchronous, ignoreNonErrorWarnings)
    53. function bluebird.bluebird.prototype._rejectPromises (len, reason)
    54. function bluebird.bluebird.prototype._rejectionHandlerAt (index)
    55. function bluebird.bluebird.prototype._resolveCallback (value, shouldBind)
    56. function bluebird.bluebird.prototype._resolveFromExecutor (executor)
    57. function bluebird.bluebird.prototype._resolveFromSyncValue (value)
    58. function bluebird.bluebird.prototype._resultCancelled ()
    59. function bluebird.bluebird.prototype._returnedNonUndefined ()
    60. function bluebird.bluebird.prototype._setAsyncGuaranteed ()
    61. function bluebird.bluebird.prototype._setBoundTo (obj)
    62. function bluebird.bluebird.prototype._setCancelled ()
    63. function bluebird.bluebird.prototype._setDisposable (disposer)
    64. function bluebird.bluebird.prototype._setFollowee (promise)
    65. function bluebird.bluebird.prototype._setFollowing ()
    66. function bluebird.bluebird.prototype._setFulfilled ()
    67. function bluebird.bluebird.prototype._setIsFinal ()
    68. function bluebird.bluebird.prototype._setLength (len)
    69. function bluebird.bluebird.prototype._setOnCancel (handler)
    70. function bluebird.bluebird.prototype._setRejected ()
    71. function bluebird.bluebird.prototype._setRejectionIsUnhandled ()
    72. function bluebird.bluebird.prototype._setReturnedNonUndefined ()
    73. function bluebird.bluebird.prototype._setUnhandledRejectionIsNotified ()
    74. function bluebird.bluebird.prototype._setWillBeCancelled ()
    75. function bluebird.bluebird.prototype._settlePromise (promise, handler, receiver, value)
    76. function bluebird.bluebird.prototype._settlePromise0 (handler, value, bitField)
    77. function bluebird.bluebird.prototype._settlePromiseCtx (ctx)
    78. function bluebird.bluebird.prototype._settlePromiseFromHandler ( handler, receiver, value, promise )
    79. function bluebird.bluebird.prototype._settlePromiseLateCancellationObserver (ctx)
    80. function bluebird.bluebird.prototype._settlePromises ()
    81. function bluebird.bluebird.prototype._settledValue ()
    82. function bluebird.bluebird.prototype._target ()
    83. function bluebird.bluebird.prototype._then ( didFulfill, didReject, _, receiver, internalData )
    84. function bluebird.bluebird.prototype._unsetCancelled ()
    85. function bluebird.bluebird.prototype._unsetDisposable ()
    86. function bluebird.bluebird.prototype._unsetOnCancel ()
    87. function bluebird.bluebird.prototype._unsetRejectionIsUnhandled ()
    88. function bluebird.bluebird.prototype._unsetUnhandledRejectionIsNotified ()
    89. function bluebird.bluebird.prototype._value ()
    90. function bluebird.bluebird.prototype._warn (message, shouldUseOwnTrace, promise)
    91. function bluebird.bluebird.prototype.all ()
    92. function bluebird.bluebird.prototype.any ()
    93. function bluebird.bluebird.prototype.asCallback (nodeback, options)
    94. function bluebird.bluebird.prototype.bind (thisArg)
    95. function bluebird.bluebird.prototype.break ()
    96. function bluebird.bluebird.prototype.call (methodName)
    97. function bluebird.bluebird.prototype.cancel ()
    98. function bluebird.bluebird.prototype.catch (fn)
    99. function bluebird.bluebird.prototype.catchReturn (value)
    100. function bluebird.bluebird.prototype.catchThrow (reason)
    101. function bluebird.bluebird.prototype.caught (fn)
    102. function bluebird.bluebird.prototype.delay (ms)
    103. function bluebird.bluebird.prototype.disposer (fn)
    104. function bluebird.bluebird.prototype.done (didFulfill, didReject)
    105. function bluebird.bluebird.prototype.each (fn)
    106. function bluebird.bluebird.prototype.error (fn)
    107. function bluebird.bluebird.prototype.filter (fn, options)
    108. function bluebird.bluebird.prototype.finally (handler)
    109. function bluebird.bluebird.prototype.get (propertyName)
    110. function bluebird.bluebird.prototype.isCancellable ()
    111. function bluebird.bluebird.prototype.isCancelled ()
    112. function bluebird.bluebird.prototype.isFulfilled ()
    113. function bluebird.bluebird.prototype.isPending ()
    114. function bluebird.bluebird.prototype.isRejected ()
    115. function bluebird.bluebird.prototype.isResolved ()
    116. function bluebird.bluebird.prototype.lastly (handler)
    117. function bluebird.bluebird.prototype.map (fn, options)
    118. function bluebird.bluebird.prototype.mapSeries (fn)
    119. function bluebird.bluebird.prototype.nodeify (nodeback, options)
    120. function bluebird.bluebird.prototype.props ()
    121. function bluebird.bluebird.prototype.race ()
    122. function bluebird.bluebird.prototype.reason ()
    123. function bluebird.bluebird.prototype.reduce (fn, initialValue)
    124. function bluebird.bluebird.prototype.reflect ()
    125. function bluebird.bluebird.prototype.return (value)
    126. function bluebird.bluebird.prototype.settle ()
    127. function bluebird.bluebird.prototype.some (howMany)
    128. function bluebird.bluebird.prototype.spread (fn)
    129. function bluebird.bluebird.prototype.suppressUnhandledRejections ()
    130. function bluebird.bluebird.prototype.tap (handler)
    131. function bluebird.bluebird.prototype.tapCatch (handlerOrPredicate)
    132. function bluebird.bluebird.prototype.then (didFulfill, didReject)
    133. function bluebird.bluebird.prototype.thenReturn (value)
    134. function bluebird.bluebird.prototype.thenThrow (reason)
    135. function bluebird.bluebird.prototype.throw (reason)
    136. function bluebird.bluebird.prototype.timeout (ms, message)
    137. function bluebird.bluebird.prototype.toJSON ()
    138. function bluebird.bluebird.prototype.toString ()
    139. function bluebird.bluebird.prototype.value ()
18. module bluebird.bluebird_core
    1. function bluebird.bluebird_core (executor)
    2. function bluebird.bluebird_core.AggregateError (message)
    3. function bluebird.bluebird_core.CancellationError (message)
    4. function bluebird.bluebird_core.OperationalError (message)
    5. function bluebird.bluebird_core.Promise (executor)
    6. function bluebird.bluebird_core.PromiseInspection (promise)
    7. function bluebird.bluebird_core.RangeError ()
    8. function bluebird.bluebird_core.RejectionError (message)
    9. function bluebird.bluebird_core.TimeoutError (message)
    10. function bluebird.bluebird_core.TypeError ()
    11. function bluebird.bluebird_core._peekContext ()
    12. function bluebird.bluebird_core.all (promises)
    13. function bluebird.bluebird_core.attempt (fn)
    14. function bluebird.bluebird_core.bind (thisArg, value)
    15. function bluebird.bluebird_core.cast (obj)
    16. function bluebird.bluebird_core.config (opts)
    17. function bluebird.bluebird_core.defer ()
    18. function bluebird.bluebird_core.fromCallback (fn)
    19. function bluebird.bluebird_core.fromNode (fn)
    20. function bluebird.bluebird_core.fulfilled (obj)
    21. function bluebird.bluebird_core.getNewLibraryCopy ()
    22. function bluebird.bluebird_core.hasLongStackTraces ()
    23. function bluebird.bluebird_core.is (val)
    24. function bluebird.bluebird_core.join ()
    25. function bluebird.bluebird_core.longStackTraces ()
    26. function bluebird.bluebird_core.method (fn)
    27. function bluebird.bluebird_core.noConflict ()
    28. function bluebird.bluebird_core.onPossiblyUnhandledRejection (fn)
    29. function bluebird.bluebird_core.onUnhandledRejectionHandled (fn)
    30. function bluebird.bluebird_core.pending ()
    31. function bluebird.bluebird_core.reject (reason)
    32. function bluebird.bluebird_core.rejected (reason)
    33. function bluebird.bluebird_core.resolve (obj)
    34. function bluebird.bluebird_core.setScheduler (fn)
    35. function bluebird.bluebird_core.try (fn)
    36. string bluebird.bluebird_core.version
19. module bluebird.bluebird_core.prototype
    1. function bluebird.bluebird_core.prototype.__isCancelled ()
    2. function bluebird.bluebird_core.prototype._addCallbacks ( fulfill, reject, promise, receiver, domain )
    3. function bluebird.bluebird_core.prototype._attachCancellationCallback (onCancel)
    4. function bluebird.bluebird_core.prototype._attachExtraTrace (error, ignoreSelf)
    5. function bluebird.bluebird_core.prototype._boundValue ()
    6. function bluebird.bluebird_core.prototype._branchHasCancelled ()
    7. function bluebird.bluebird_core.prototype._cancel ()
    8. function bluebird.bluebird_core.prototype._cancelBranched ()
    9. function bluebird.bluebird_core.prototype._cancelBy (canceller)
    10. function bluebird.bluebird_core.prototype._cancelPromises ()
    11. function bluebird.bluebird_core.prototype._captureStackTrace ()
    12. function bluebird.bluebird_core.prototype._clearCallbackDataAtIndex (index)
    13. function bluebird.bluebird_core.prototype._clearCancellationData ()
    14. function bluebird.bluebird_core.prototype._doInvokeOnCancel (onCancelCallback, internalOnly)
    15. function bluebird.bluebird_core.prototype._enoughBranchesHaveCancelled ()
    16. function bluebird.bluebird_core.prototype._ensurePossibleRejectionHandled ()
    17. function bluebird.bluebird_core.prototype._execute (executor, resolve, reject)
    18. function bluebird.bluebird_core.prototype._fireEvent ()
    19. function bluebird.bluebird_core.prototype._followee ()
    20. function bluebird.bluebird_core.prototype._fulfill (value)
    21. function bluebird.bluebird_core.prototype._fulfillPromises (len, value)
    22. function bluebird.bluebird_core.prototype._fulfillmentHandlerAt (index)
    23. function bluebird.bluebird_core.prototype._invokeInternalOnCancel ()
    24. function bluebird.bluebird_core.prototype._invokeOnCancel ()
    25. function bluebird.bluebird_core.prototype._isBound ()
    26. function bluebird.bluebird_core.prototype._isCancellable ()
    27. function bluebird.bluebird_core.prototype._isCancelled ()
    28. function bluebird.bluebird_core.prototype._isFateSealed ()
    29. function bluebird.bluebird_core.prototype._isFinal ()
    30. function bluebird.bluebird_core.prototype._isFollowing ()
    31. function bluebird.bluebird_core.prototype._isRejectionUnhandled ()
    32. function bluebird.bluebird_core.prototype._isUnhandledRejectionNotified ()
    33. function bluebird.bluebird_core.prototype._length ()
    34. function bluebird.bluebird_core.prototype._migrateCallback0 (follower)
    35. function bluebird.bluebird_core.prototype._migrateCallbackAt (follower, index)
    36. function bluebird.bluebird_core.prototype._notifyUnhandledRejection ()
    37. function bluebird.bluebird_core.prototype._notifyUnhandledRejectionIsHandled ()
    38. function bluebird.bluebird_core.prototype._onCancel ()
    39. function bluebird.bluebird_core.prototype._passThrough (handler, type, success, fail)
    40. function bluebird.bluebird_core.prototype._peekContext ()
    41. function bluebird.bluebird_core.prototype._popContext ()
    42. function bluebird.bluebird_core.prototype._promiseAt (index)
    43. function bluebird.bluebird_core.prototype._promiseCreated ()
    44. function bluebird.bluebird_core.prototype._propagateFrom (parent, flags)
    45. function bluebird.bluebird_core.prototype._proxy (proxyable, arg)
    46. function bluebird.bluebird_core.prototype._pushContext ()
    47. function bluebird.bluebird_core.prototype._reason ()
    48. function bluebird.bluebird_core.prototype._receiverAt (index)
    49. function bluebird.bluebird_core.prototype._reject (reason)
    50. function bluebird.bluebird_core.prototype._rejectCallback (reason, synchronous, ignoreNonErrorWarnings)
    51. function bluebird.bluebird_core.prototype._rejectPromises (len, reason)
    52. function bluebird.bluebird_core.prototype._rejectionHandlerAt (index)
    53. function bluebird.bluebird_core.prototype._resolveCallback (value, shouldBind)
    54. function bluebird.bluebird_core.prototype._resolveFromExecutor (executor)
    55. function bluebird.bluebird_core.prototype._resolveFromSyncValue (value)
    56. function bluebird.bluebird_core.prototype._resultCancelled ()
    57. function bluebird.bluebird_core.prototype._returnedNonUndefined ()
    58. function bluebird.bluebird_core.prototype._setAsyncGuaranteed ()
    59. function bluebird.bluebird_core.prototype._setBoundTo (obj)
    60. function bluebird.bluebird_core.prototype._setCancelled ()
    61. function bluebird.bluebird_core.prototype._setFollowee (promise)
    62. function bluebird.bluebird_core.prototype._setFollowing ()
    63. function bluebird.bluebird_core.prototype._setFulfilled ()
    64. function bluebird.bluebird_core.prototype._setIsFinal ()
    65. function bluebird.bluebird_core.prototype._setLength (len)
    66. function bluebird.bluebird_core.prototype._setOnCancel (handler)
    67. function bluebird.bluebird_core.prototype._setRejected ()
    68. function bluebird.bluebird_core.prototype._setRejectionIsUnhandled ()
    69. function bluebird.bluebird_core.prototype._setReturnedNonUndefined ()
    70. function bluebird.bluebird_core.prototype._setUnhandledRejectionIsNotified ()
    71. function bluebird.bluebird_core.prototype._setWillBeCancelled ()
    72. function bluebird.bluebird_core.prototype._settlePromise (promise, handler, receiver, value)
    73. function bluebird.bluebird_core.prototype._settlePromise0 (handler, value, bitField)
    74. function bluebird.bluebird_core.prototype._settlePromiseCtx (ctx)
    75. function bluebird.bluebird_core.prototype._settlePromiseFromHandler ( handler, receiver, value, promise )
    76. function bluebird.bluebird_core.prototype._settlePromiseLateCancellationObserver (ctx)
    77. function bluebird.bluebird_core.prototype._settlePromises ()
    78. function bluebird.bluebird_core.prototype._settledValue ()
    79. function bluebird.bluebird_core.prototype._target ()
    80. function bluebird.bluebird_core.prototype._then ( didFulfill, didReject, _, receiver, internalData )
    81. function bluebird.bluebird_core.prototype._unsetCancelled ()
    82. function bluebird.bluebird_core.prototype._unsetOnCancel ()
    83. function bluebird.bluebird_core.prototype._unsetRejectionIsUnhandled ()
    84. function bluebird.bluebird_core.prototype._unsetUnhandledRejectionIsNotified ()
    85. function bluebird.bluebird_core.prototype._value ()
    86. function bluebird.bluebird_core.prototype._warn (message, shouldUseOwnTrace, promise)
    87. function bluebird.bluebird_core.prototype.all ()
    88. function bluebird.bluebird_core.prototype.bind (thisArg)
    89. function bluebird.bluebird_core.prototype.break ()
    90. function bluebird.bluebird_core.prototype.cancel ()
    91. function bluebird.bluebird_core.prototype.catch (fn)
    92. function bluebird.bluebird_core.prototype.catchReturn (value)
    93. function bluebird.bluebird_core.prototype.catchThrow (reason)
    94. function bluebird.bluebird_core.prototype.caught (fn)
    95. function bluebird.bluebird_core.prototype.done (didFulfill, didReject)
    96. function bluebird.bluebird_core.prototype.error (fn)
    97. function bluebird.bluebird_core.prototype.finally (handler)
    98. function bluebird.bluebird_core.prototype.isCancellable ()
    99. function bluebird.bluebird_core.prototype.isCancelled ()
    100. function bluebird.bluebird_core.prototype.isFulfilled ()
    101. function bluebird.bluebird_core.prototype.isPending ()
    102. function bluebird.bluebird_core.prototype.isRejected ()
    103. function bluebird.bluebird_core.prototype.isResolved ()
    104. function bluebird.bluebird_core.prototype.lastly (handler)
    105. function bluebird.bluebird_core.prototype.reason ()
    106. function bluebird.bluebird_core.prototype.reflect ()
    107. function bluebird.bluebird_core.prototype.return (value)
    108. function bluebird.bluebird_core.prototype.spread (fn)
    109. function bluebird.bluebird_core.prototype.suppressUnhandledRejections ()
    110. function bluebird.bluebird_core.prototype.tap (handler)
    111. function bluebird.bluebird_core.prototype.tapCatch (handlerOrPredicate)
    112. function bluebird.bluebird_core.prototype.then (didFulfill, didReject)
    113. function bluebird.bluebird_core.prototype.thenReturn (value)
    114. function bluebird.bluebird_core.prototype.thenThrow (reason)
    115. function bluebird.bluebird_core.prototype.throw (reason)
    116. function bluebird.bluebird_core.prototype.toJSON ()
    117. function bluebird.bluebird_core.prototype.toString ()
    118. function bluebird.bluebird_core.prototype.value ()
20. module bluebird.coroutine
    1. function bluebird.coroutine (generatorFunction, options)
    2. function bluebird.coroutine.addYieldHandler (fn)
21. module bluebird.errors
    1. function bluebird.errors.AggregateError (message)
    2. function bluebird.errors.CancellationError (message)
    3. function bluebird.errors.Error ()
    4. function bluebird.errors.OperationalError (message)
    5. function bluebird.errors.RangeError ()
    6. function bluebird.errors.TimeoutError (message)
    7. function bluebird.errors.TypeError ()
    8. function bluebird.errors.Warning (message)
22. module bluebird.es5
    1. boolean bluebird.es5.isES5
    2. function bluebird.es5.defineProperty ()
    3. function bluebird.es5.freeze ()
    4. function bluebird.es5.getDescriptor ()
    5. function bluebird.es5.getPrototypeOf ()
    6. function bluebird.es5.isArray ()
    7. function bluebird.es5.keys ()
    8. function bluebird.es5.names ()
    9. function bluebird.es5.propertyIsWritable (obj, prop)
23. module bluebird.queue
    1. function bluebird.queue (capacity)
24. module bluebird.queue.prototype
    1. function bluebird.queue.prototype._checkCapacity (size)
    2. function bluebird.queue.prototype._pushOne (arg)
    3. function bluebird.queue.prototype._resizeTo (capacity)
    4. function bluebird.queue.prototype._willBeOverCapacity (size)
    5. function bluebird.queue.prototype.length ()
    6. function bluebird.queue.prototype.push (fn, receiver, arg)
    7. function bluebird.queue.prototype.shift ()
25. module bluebird.util
    1. boolean bluebird.util.canEvaluate
    2. boolean bluebird.util.hasDevTools
    3. boolean bluebird.util.hasEnvVariables
    4. boolean bluebird.util.isNode
    5. boolean bluebird.util.isRecentNode
    6. function bluebird.util.asArray (v)
    7. function bluebird.util.canAttachTrace (obj)
    8. function bluebird.util.classString (obj)
    9. function bluebird.util.copyDescriptors (from, to, filter)
    10. function bluebird.util.domainBind (self, cb)
    11. function bluebird.util.ensureErrorObject (value)
    12. function bluebird.util.env (key)
    13. function bluebird.util.filledRange (count, prefix, suffix)
    14. function bluebird.util.getDataPropertyOrDefault (obj, key, defaultValue)
    15. function bluebird.util.getNativePromise ()
    16. function bluebird.util.inheritedDataKeys (obj)
    17. function bluebird.util.inherits (Child, Parent)
    18. function bluebird.util.isArray ()
    19. function bluebird.util.isClass (fn)
    20. function bluebird.util.isError (obj)
    21. function bluebird.util.isIdentifier (str)
    22. function bluebird.util.isObject (value)
    23. function bluebird.util.isPrimitive (val)
    24. function bluebird.util.markAsOriginatingFromRejection (e)
    25. function bluebird.util.maybeWrapAsError (maybeError)
    26. function bluebird.util.notEnumerableProp (obj, name, value)
    27. function bluebird.util.originatesFromRejection (e)
    28. function bluebird.util.thrower (r)
    29. function bluebird.util.toFastProperties (obj)
    30. function bluebird.util.toString (obj)
    31. function bluebird.util.tryCatch (fn)
    32. function bluebird.util.withAppended (target, appendee)
    33. object bluebird.util.errorObj
    34. object bluebird.util.lastLineError

module bluebird

function bluebird (executor)

• description and source-code

  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);
  }

• example usage

  n/a

function bluebird.AggregateError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.CancellationError (message)

• description and source-code

  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);
      }
  }

• example usage

  ...
  
  PromiseSpawn.prototype._promiseCancelled = function() {
  if (this._isResolved()) return;
  var implementsReturn = typeof this._generator["return"] !== "undefined";
  
  var result;
  if (!implementsReturn) {
      var reason = new Promise.CancellationError(
          "generator .return() sentinel");
      Promise.coroutine.returnSentinel = reason;
      this._promise._attachExtraTrace(reason);
      this._promise._pushContext();
      result = tryCatch(this._generator["throw"]).call(this._generator,
                                                       reason);
      this._promise._popContext();
  ...

function bluebird.OperationalError (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.Promise (executor)

• description and source-code

  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);
  }

• example usage

  n/a

function bluebird.PromiseInspection (promise)

• description and source-code

  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;
      }
  }

• example usage

  ...
  },{"./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");
  ...

function bluebird.RangeError ()

• description and source-code

  function RangeError() { [native code] }

• example usage

  n/a

function bluebird.RejectionError (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.TimeoutError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.TypeError ()

• description and source-code

  function TypeError() { [native code] }

• example usage

  ...
  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();
  ...

function bluebird._SomePromiseArray (values)

• description and source-code

  function SomePromiseArray(values) {
      this.constructor$(values);
      this._howMany = 0;
      this._unwrap = false;
      this._initialized = false;
  }

• example usage

  n/a

function bluebird._peekContext ()

• description and source-code

  _peekContext = function () {}

• example usage

  ...
          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){
  ...

function bluebird.all (promises)

• description and source-code

  all = function (promises) {
      return new PromiseArray(promises).promise();
  }

• example usage

  ...
  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,
  ...

function bluebird.any (promises)

• description and source-code

  any = function (promises) {
      return any(promises);
  }

• example usage

  n/a

function bluebird.async ()

• description and source-code

  function Async() {
      this._customScheduler = false;
      this._isTickUsed = false;
      this._lateQueue = new Queue(16);
      this._normalQueue = new Queue(16);
      this._haveDrainedQueues = false;
      this._trampolineEnabled = true;
      var self = this;
      this.drainQueues = function () {
          self._drainQueues();
      };
      this._schedule = schedule;
  }

• example usage

  n/a

function bluebird.attempt (fn)

• description and source-code

  attempt = 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;
  }

• example usage

  n/a

function bluebird.bluebird_core (executor)

• description and source-code

  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);
  }

• example usage

  n/a

function bluebird.cast (obj)

• description and source-code

  cast = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  ...
      for (var i = 0, len = promises.length; i < len; ++i) {
          var val = promises[i];
  
          if (val === undefined && !(i in promises)) {
              continue;
          }
  
          Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
      }
      return ret;
  }
  
  Promise.race = function (promises) {
      return race(promises, undefined);
  };
  ...

function bluebird.config (opts)

• description and source-code

  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;
          }
      }
      return Promise;
  }

• example usage

  n/a

function bluebird.coroutine (generatorFunction, options)

• description and source-code

  coroutine = function (generatorFunction, options) {
      if (typeof generatorFunction !== "function") {
          throw new TypeError("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
      var yieldHandler = Object(options).yieldHandler;
      var PromiseSpawn$ = PromiseSpawn;
      var stack = new Error().stack;
      return function () {
          var generator = generatorFunction.apply(this, arguments);
          var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
                                        stack);
          var ret = spawn.promise();
          spawn._generator = generator;
          spawn._promiseFulfilled(undefined);
          return ret;
      };
  }

• example usage

  ...
  if (typeof fn !== "function") {
      throw new TypeError("expecting a function but got " + util.classString(fn));
  }
  yieldHandlers.push(fn);
  };
  
  Promise.spawn = function (generatorFunction) {
  debug.deprecated("Promise.spawn()", "Promise.coroutine()");
  if (typeof generatorFunction !== "function") {
      return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  }
  var spawn = new PromiseSpawn(generatorFunction, this);
  var ret = spawn.promise();
  spawn._run(Promise.spawn);
  return ret;
  ...

function bluebird.defer ()

• description and source-code

  defer = function () {
      debug.deprecated("Promise.defer", "new Promise");
      var promise = new Promise(INTERNAL);
      return {
          promise: promise,
          resolve: deferResolve,
          reject: deferReject
      };
  }

• example usage

  n/a

function bluebird.delay (ms, value)

• description and source-code

  delay = function (ms, value) {
      var ret;
      var handle;
      if (value !== undefined) {
          ret = Promise.resolve(value)
                  ._then(afterValue, null, null, ms, undefined);
          if (debug.cancellation() && value instanceof Promise) {
              ret._setOnCancel(value);
          }
      } else {
          ret = new Promise(INTERNAL);
          handle = setTimeout(function() { ret._fulfill(); }, +ms);
          if (debug.cancellation()) {
              ret._setOnCancel(new HandleWrapper(handle));
          }
          ret._captureStackTrace();
      }
      ret._setAsyncGuaranteed();
      return ret;
  }

• example usage

  n/a

function bluebird.each (promises, fn)

• description and source-code

  each = function (promises, fn) {
      return PromiseReduce(promises, fn, INTERNAL, 0)
                ._then(promiseAllThis, undefined, undefined, promises, undefined);
  }

• example usage

  n/a

function bluebird.filter (promises, fn, options)

• description and source-code

  filter = function (promises, fn, options) {
      return PromiseMap(promises, fn, options, INTERNAL);
  }

• example usage

  n/a

function bluebird.fromCallback (fn)

• description and source-code

  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;
  }

• example usage

  n/a

function bluebird.fromNode (fn)

• description and source-code

  fromNode = 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;
  }

• example usage

  n/a

function bluebird.fulfilled (obj)

• description and source-code

  fulfilled = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  n/a

function bluebird.getNewLibraryCopy ()

• description and source-code

  getNewLibraryCopy = 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");
  
  var getDomain;
  if (util.isNode) {
      getDomain = function() {
          var ret = process.domain;
          if (ret === undefined) ret = null;
          return ret;
      };
  } else {
      getDomain = function() {
          return null;
      };
  }
  util.notEnumerableProp(Promise, "_getDomain", getDomain);
  
  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);
  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["catch"] = function (fn) {
      var len = arguments.length;
      if (len > 1) {
          var catchInstances = new Array(len - 1),
              j = 0, i;
          for (i = 0; i < len - 1; ++i) {
              var item = arguments[i];
              if (util.isObject(item)) {
                  catchInstances[j++] = item;
              } else {
                  return apiRejection("Catch statement predicate: " +
                      "expecting an object but got " + util.classString(item));
              }
          }
          catchInstances.length = j;
          fn = arguments[i];
          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.warning...

• example usage

  n/a

function bluebird.hasLongStackTraces ()

• description and source-code

  hasLongStackTraces = function () {
      return config.longStackTraces && longStackTracesIsSupported();
  }

• example usage

  ...
  };
  
  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;
  ...

function bluebird.is (val)

• description and source-code

  is = function (val) {
      return val instanceof Promise;
  }

• example usage

  n/a

function bluebird.join ()

• description and source-code

  join = function () {
      var last = arguments.length - 1;
      var fn;
      if (last > 0 && typeof arguments[last] === "function") {
          fn = arguments[last];
          if (!false) {
              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 domain = getDomain();
                          if (domain !== null) {
                              holder.fn = util.domainBind(domain, holder.fn);
                          }
                      }
                      ret._setAsyncGuaranteed();
                      ret._setOnCancel(holder);
                  }
                  return ret;
              }
          }
      }
      var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];};
      if (fn) args.pop();
      var ret = new PromiseArray(args).promise();
      return fn !== undefined ? ret.spread(fn) : ret;
  }

• example usage

  ...
              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 checkForgottenReturns(returnValue, promiseCreated, name, promise,
  parent) {
  ...

function bluebird.longStackTraces ()

• description and source-code

  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;
          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;
              Context.deactivateLongStackTraces();
              async.enableTrampoline();
              config.longStackTraces = false;
          };
          Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
          Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
          Context.activateLongStackTraces();
          async.disableTrampolineIfNecessary();
      }
  }

• example usage

  ...
  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;
  ...

function bluebird.map (promises, fn, options, _filter)

• description and source-code

  map = function (promises, fn, options, _filter) {
      return map(promises, fn, options, _filter);
  }

• example usage

  ...
  
      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");
  ...

function bluebird.mapSeries (promises, fn)

• description and source-code

  function PromiseMapSeries(promises, fn) {
      return PromiseReduce(promises, fn, INTERNAL, INTERNAL);
  }

• example usage

  n/a

function bluebird.method (fn)

• description and source-code

  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;
      };
  }

• example usage

  n/a

function bluebird.noConflict ()

• description and source-code

  function noConflict() {
      try { if (Promise === bluebird) Promise = old; }
      catch (e) {}
      return bluebird;
  }

• example usage

  n/a

function bluebird.onPossiblyUnhandledRejection (fn)

• description and source-code

  onPossiblyUnhandledRejection = function (fn) {
      var domain = getDomain();
      possiblyUnhandledRejection =
          typeof fn === "function" ? (domain === null ?
                                              fn : util.domainBind(domain, fn))
                                   : undefined;
  }

• example usage

  n/a

function bluebird.onUnhandledRejectionHandled (fn)

• description and source-code

  onUnhandledRejectionHandled = function (fn) {
      var domain = getDomain();
      unhandledRejectionHandled =
          typeof fn === "function" ? (domain === null ?
                                              fn : util.domainBind(domain, fn))
                                   : undefined;
  }

• example usage

  n/a

function bluebird.pending ()

• description and source-code

  pending = function () {
      debug.deprecated("Promise.defer", "new Promise");
      var promise = new Promise(INTERNAL);
      return {
          promise: promise,
          resolve: deferResolve,
          reject: deferReject
      };
  }

• example usage

  n/a

function bluebird.promisify (fn, options)

• description and source-code

  promisify = function (fn, options) {
      if (typeof fn !== "function") {
          throw new TypeError("expecting a function but got " + util.classString(fn));
      }
      if (isPromisified(fn)) {
          return fn;
      }
      options = Object(options);
      var receiver = options.context === undefined ? THIS : options.context;
      var multiArgs = !!options.multiArgs;
      var ret = promisify(fn, receiver, multiArgs);
      util.copyDescriptors(fn, ret, propsFilter);
      return ret;
  }

• example usage

  n/a

function bluebird.promisifyAll (target, options)

• description and source-code

  promisifyAll = function (target, options) {
      if (typeof target !== "function" && typeof target !== "object") {
          throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a    See http://goo.gl/MqrFmX\
  u000a");
      }
      options = Object(options);
      var multiArgs = !!options.multiArgs;
      var suffix = options.suffix;
      if (typeof suffix !== "string") suffix = defaultSuffix;
      var filter = options.filter;
      if (typeof filter !== "function") filter = defaultFilter;
      var promisifier = options.promisifier;
      if (typeof promisifier !== "function") promisifier = makeNodePromisified;
  
      if (!util.isIdentifier(suffix)) {
          throw new RangeError("suffix must be a valid identifier\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
  
      var keys = util.inheritedDataKeys(target);
      for (var i = 0; i < keys.length; ++i) {
          var value = target[keys[i]];
          if (keys[i] !== "constructor" &&
              util.isClass(value)) {
              promisifyAll(value.prototype, suffix, filter, promisifier,
                  multiArgs);
              promisifyAll(value, suffix, filter, promisifier, multiArgs);
          }
      }
  
      return promisifyAll(target, suffix, filter, promisifier, multiArgs);
  }

• example usage

  n/a

function bluebird.props (promises)

• description and source-code

  props = function (promises) {
      return props(promises);
  }

• example usage

  n/a

function bluebird.queue (capacity)

• description and source-code

  function Queue(capacity) {
      this._capacity = capacity;
      this._length = 0;
      this._front = 0;
  }

• example usage

  n/a

function bluebird.race (promises)

• description and source-code

  race = function (promises) {
      return race(promises, undefined);
  }

• example usage

  n/a

function bluebird.reduce (promises, fn, initialValue, _each)

• description and source-code

  reduce = function (promises, fn, initialValue, _each) {
      return reduce(promises, fn, initialValue, _each);
  }

• example usage

  n/a

function bluebird.reject (reason)

• description and source-code

  reject = function (reason) {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._rejectCallback(reason, true);
      return ret;
  }

• example usage

  ...
   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];
  ...

function bluebird.rejected (reason)

• description and source-code

  rejected = function (reason) {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._rejectCallback(reason, true);
      return ret;
  }

• example usage

  n/a

function bluebird.resolve (obj)

• description and source-code

  resolve = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  ...
  };
  
  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 bluebird.setScheduler (fn)

• description and source-code

  setScheduler = function (fn) {
      if (typeof fn !== "function") {
          throw new TypeError("expecting a function but got " + util.classString(fn));
      }
      return async.setScheduler(fn);
  }

• example usage

  ...
  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
  ...

function bluebird.settle (promises)

• description and source-code

  settle = function (promises) {
      debug.deprecated(".settle()", ".reflect()");
      return new SettledPromiseArray(promises).promise();
  }

• example usage

  ...
      var ret = new PromiseInspection();
      ret._bitField = 16777216;
      ret._settledValueField = reason;
      return this._promiseResolved(index, ret);
  };
  
  Promise.settle = function (promises) {
      debug.deprecated(".settle()", ".reflect()");
      return new SettledPromiseArray(promises).promise();
  };
  
  Promise.prototype.settle = function () {
      return Promise.settle(this);
  };
  };
  ...

function bluebird.some (promises, howMany)

• description and source-code

  some = function (promises, howMany) {
      return some(promises, howMany);
  }

• example usage

  n/a

function bluebird.spawn (generatorFunction)

• description and source-code

  spawn = function (generatorFunction) {
      debug.deprecated("Promise.spawn()", "Promise.coroutine()");
      if (typeof generatorFunction !== "function") {
          return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
      var spawn = new PromiseSpawn(generatorFunction, this);
      var ret = spawn.promise();
      spawn._run(Promise.spawn);
      return ret;
  }

• example usage

  ...
  if (typeof fn !== "function") {
      throw new TypeError("expecting a function but got " + util.classString(fn));
  }
  yieldHandlers.push(fn);
  };
  
  Promise.spawn = function (generatorFunction) {
  debug.deprecated("Promise.spawn()", "Promise.coroutine()");
  if (typeof generatorFunction !== "function") {
      return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  }
  var spawn = new PromiseSpawn(generatorFunction, this);
  var ret = spawn.promise();
  spawn._run(Promise.spawn);
  return ret;
  ...

function bluebird.try (fn)

• description and source-code

  try = function (fn) {
      if (typeof fn !== "function") {
          return apiRejection("expecting a function but got " + util.classString(fn));
      }
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value;
      if (arguments.length > 1) {
          debug.deprecated("calling Promise.try with more than 1 argument");
          var arg = arguments[1];
          var ctx = arguments[2];
          value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
                                    : tryCatch(fn).call(ctx, arg);
      } else {
          value = tryCatch(fn)();
      }
      var promiseCreated = ret._popContext();
      debug.checkForgottenReturns(
          value, promiseCreated, "Promise.try", ret);
      ret._resolveFromSyncValue(value);
      return ret;
  }

• example usage

  n/a

function bluebird.using ()

• description and source-code

  using = function () {
      var len = arguments.length;
      if (len < 2) return apiRejection(
                      "you must pass at least 2 arguments to Promise.using");
      var fn = arguments[len - 1];
      if (typeof fn !== "function") {
          return apiRejection("expecting a function but got " + util.classString(fn));
      }
      var input;
      var spreadArgs = true;
      if (len === 2 && Array.isArray(arguments[0])) {
          input = arguments[0];
          len = input.length;
          spreadArgs = false;
      } else {
          input = arguments;
          len--;
      }
      var resources = new ResourceList(len);
      for (var i = 0; i < len; ++i) {
          var resource = input[i];
          if (Disposer.isDisposer(resource)) {
              var disposer = resource;
              resource = resource.promise();
              resource._setDisposable(disposer);
          } else {
              var maybePromise = tryConvertToPromise(resource);
              if (maybePromise instanceof Promise) {
                  resource =
                      maybePromise._then(maybeUnwrapDisposer, null, null, {
                          resources: resources,
                          index: i
                  }, undefined);
              }
          }
          resources[i] = resource;
      }
  
      var reflectedResources = new Array(resources.length);
      for (var i = 0; i < reflectedResources.length; ++i) {
          reflectedResources[i] = Promise.resolve(resources[i]).reflect();
      }
  
      var resultPromise = Promise.all(reflectedResources)
          .then(function(inspections) {
              for (var i = 0; i < inspections.length; ++i) {
                  var inspection = inspections[i];
                  if (inspection.isRejected()) {
                      errorObj.e = inspection.error();
                      return errorObj;
                  } else if (!inspection.isFulfilled()) {
                      resultPromise.cancel();
                      return;
                  }
                  inspections[i] = inspection.value();
              }
              promise._pushContext();
  
              fn = tryCatch(fn);
              var ret = spreadArgs
                  ? fn.apply(undefined, inspections) : fn(inspections);
              var promiseCreated = promise._popContext();
              debug.checkForgottenReturns(
                  ret, promiseCreated, "Promise.using", promise);
              return ret;
          });
  
      var promise = resultPromise.lastly(function() {
          var inspection = new Promise.PromiseInspection(resultPromise);
          return dispose(resources, inspection);
      });
      resources.promise = promise;
      promise._setOnCancel(resources);
      return promise;
  }

• example usage

  n/a

module bluebird.AggregateError

function bluebird.AggregateError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

module bluebird.AggregateError.prototype

function bluebird.AggregateError.prototype.constructor (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.AggregateError.prototype.every ()

• description and source-code

  function every() { [native code] }

• example usage

  n/a

function bluebird.AggregateError.prototype.filter ()

• description and source-code

  function filter() { [native code] }

• example usage

  n/a

function bluebird.AggregateError.prototype.forEach ()

• description and source-code

  function forEach() { [native code] }

• example usage

  ...
      index++;
  }
  
  return function mapToEntries(map) {
      size = map.size;
      index = 0;
      var ret = new Array(map.size * 2);
      map.forEach(extractEntry, ret);
      return ret;
  };
  })();
  
  var entriesToMap = function(entries) {
  var ret = new Es6Map();
  var length = entries.length / 2 | 0;
  ...

function bluebird.AggregateError.prototype.indexOf ()

• description and source-code

  function indexOf() { [native code] }

• example usage

  ...
          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;
      };
  }
  ...

function bluebird.AggregateError.prototype.join ()

• description and source-code

  function join() { [native code] }

• example usage

  ...
              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 checkForgottenReturns(returnValue, promiseCreated, name, promise,
  parent) {
  ...

function bluebird.AggregateError.prototype.lastIndexOf ()

• description and source-code

  function lastIndexOf() { [native code] }

• example usage

  n/a

function bluebird.AggregateError.prototype.map ()

• description and source-code

  function map() { [native code] }

• example usage

  ...
  
      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");
  ...

function bluebird.AggregateError.prototype.pop ()

• description and source-code

  function pop() { [native code] }

• example usage

  ...
          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 bluebird.AggregateError.prototype.push ()

• description and source-code

  function push() { [native code] }

• example usage

  ...
          });
      } 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 bluebird.AggregateError.prototype.reduce ()

• description and source-code

  function reduce() { [native code] }

• example usage

  n/a

function bluebird.AggregateError.prototype.reduceRight ()

• description and source-code

  function reduceRight() { [native code] }

• example usage

  n/a

function bluebird.AggregateError.prototype.reverse ()

• description and source-code

  function reverse() { [native code] }

• example usage

  n/a

function bluebird.AggregateError.prototype.shift ()

• description and source-code

  function shift() { [native code] }

• example usage

  ...
          });
      }
  };
  }
  
  Async.prototype._drainQueue = function(queue) {
  while (queue.length() > 0) {
      var fn = queue.shift();
      if (typeof fn !== "function") {
          fn._settlePromises();
          continue;
      }
      var receiver = queue.shift();
      var arg = queue.shift();
      fn.call(receiver, arg);
  ...

function bluebird.AggregateError.prototype.slice ()

• description and source-code

  function slice() { [native code] }

• example usage

  ...
  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();
  ...

function bluebird.AggregateError.prototype.some ()

• description and source-code

  function some() { [native code] }

• example usage

  n/a

function bluebird.AggregateError.prototype.sort ()

• description and source-code

  function sort() { [native code] }

• example usage

  n/a

function bluebird.AggregateError.prototype.toString ()

• description and source-code

  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;
  }

• example usage

  ...
  
  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 bluebird.AggregateError.prototype.unshift ()

• description and source-code

  function unshift() { [native code] }

• example usage

  n/a

module bluebird.CancellationError

function bluebird.CancellationError (message)

• description and source-code

  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);
      }
  }

• example usage

  ...
  
  PromiseSpawn.prototype._promiseCancelled = function() {
  if (this._isResolved()) return;
  var implementsReturn = typeof this._generator["return"] !== "undefined";
  
  var result;
  if (!implementsReturn) {
      var reason = new Promise.CancellationError(
          "generator .return() sentinel");
      Promise.coroutine.returnSentinel = reason;
      this._promise._attachExtraTrace(reason);
      this._promise._pushContext();
      result = tryCatch(this._generator["throw"]).call(this._generator,
                                                       reason);
      this._promise._popContext();
  ...

module bluebird.CancellationError.prototype

function bluebird.CancellationError.prototype.constructor (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

module bluebird.OperationalError

function bluebird.OperationalError (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

module bluebird.OperationalError.prototype

function bluebird.OperationalError.prototype.constructor (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

module bluebird.PromiseInspection

function bluebird.PromiseInspection (promise)

• description and source-code

  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;
      }
  }

• example usage

  ...
  },{"./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");
  ...

module bluebird.PromiseInspection.prototype

function bluebird.PromiseInspection.prototype._settledValue ()

• description and source-code

  _settledValue = function () {
      return this._settledValueField;
  }

• example usage

  ...
  
  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 () {
  ...

function bluebird.PromiseInspection.prototype.error ()

• description and source-code

  error = 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();
  }

• example usage

  ...
  }
  
  var resultPromise = Promise.all(reflectedResources)
      .then(function(inspections) {
          for (var i = 0; i < inspections.length; ++i) {
              var inspection = inspections[i];
              if (inspection.isRejected()) {
                  errorObj.e = inspection.error();
                  return errorObj;
              } else if (!inspection.isFulfilled()) {
                  resultPromise.cancel();
                  return;
              }
              inspections[i] = inspection.value();
          }
  ...

function bluebird.PromiseInspection.prototype.isCancelled ()

• description and source-code

  isCancelled = function () {
      return (this._bitField & 8454144) !== 0;
  }

• example usage

  ...
  };
  
  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);
      }
  ...

function bluebird.PromiseInspection.prototype.isFulfilled ()

• description and source-code

  isFulfilled = function () {
      return (this._bitField & 33554432) !== 0;
  }

• example usage

  ...
  }
  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 bluebird.PromiseInspection.prototype.isPending ()

• description and source-code

  isPending = function () {
      return (this._bitField & 50397184) === 0;
  }

• example usage

  ...
  };
  
  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) {
  ...

function bluebird.PromiseInspection.prototype.isRejected ()

• description and source-code

  isRejected = function () {
      return (this._bitField & 16777216) !== 0;
  }

• example usage

  ...
              }
              return maybePromise._then(
                  succeed, fail, undefined, this, undefined);
          }
      }
  }
  
  if (promise.isRejected()) {
      checkCancel(this);
      errorObj.e = reasonOrValue;
      return errorObj;
  } else {
      checkCancel(this);
      return reasonOrValue;
  }
  ...

function bluebird.PromiseInspection.prototype.isResolved ()

• description and source-code

  isResolved = function () {
      return (this._bitField & 50331648) !== 0;
  }

• example usage

  n/a

function bluebird.PromiseInspection.prototype.reason ()

• description and source-code

  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();
  }

• example usage

  ...
      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) {
  ...

function bluebird.PromiseInspection.prototype.value ()

• description and source-code

  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();
  }

• example usage

  ...
  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;
  }
  ...

module bluebird.TimeoutError

function bluebird.TimeoutError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

module bluebird.TimeoutError.prototype

function bluebird.TimeoutError.prototype.constructor (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

module bluebird._SomePromiseArray

function bluebird._SomePromiseArray (values)

• description and source-code

  function SomePromiseArray(values) {
      this.constructor$(values);
      this._howMany = 0;
      this._unwrap = false;
      this._initialized = false;
  }

• example usage

  n/a

module bluebird._SomePromiseArray.prototype

function bluebird._SomePromiseArray.prototype._addFulfilled (value)

• description and source-code

  _addFulfilled = function (value) {
      this._values[this._totalResolved++] = value;
  }

• example usage

  ...
  };
  
  SomePromiseArray.prototype.setHowMany = function (count) {
  this._howMany = count;
  };
  
  SomePromiseArray.prototype._promiseFulfilled = function (value) {
  this._addFulfilled(value);
  if (this._fulfilled() === this.howMany()) {
      this._values.length = this.howMany();
      if (this.howMany() === 1 && this._unwrap) {
          this._resolve(this._values[0]);
      } else {
          this._resolve(this._values);
      }
  ...

function bluebird._SomePromiseArray.prototype._addRejected (reason)

• description and source-code

  _addRejected = function (reason) {
      this._values.push(reason);
  }

• example usage

  ...
      }
      return true;
  }
  return false;
  
  };
  SomePromiseArray.prototype._promiseRejected = function (reason) {
  this._addRejected(reason);
  return this._checkOutcome();
  };
  
  SomePromiseArray.prototype._promiseCancelled = function () {
  if (this._values instanceof Promise || this._values == null) {
      return this._cancel();
  }
  ...

function bluebird._SomePromiseArray.prototype._canPossiblyFulfill ()

• description and source-code

  _canPossiblyFulfill = function () {
      return this.length() - this._rejected();
  }

• example usage

  ...
      this._resolve([]);
      return;
  }
  this._init$(undefined, -5);
  var isArrayResolved = isArray(this._values);
  if (!this._isResolved() &&
      isArrayResolved &&
      this._howMany > this._canPossiblyFulfill()) {
      this._reject(this._getRangeError(this.length()));
  }
  };
  
  SomePromiseArray.prototype.init = function () {
  this._initialized = true;
  this._init();
  ...

function bluebird._SomePromiseArray.prototype._checkOutcome ()

• description and source-code

  _checkOutcome = function () {
      if (this.howMany() > this._canPossiblyFulfill()) {
          var e = new AggregateError();
          for (var i = this.length(); i < this._values.length; ++i) {
              if (this._values[i] !== CANCELLATION) {
                  e.push(this._values[i]);
              }
          }
          if (e.length > 0) {
              this._reject(e);
          } else {
              this._cancel();
          }
          return true;
      }
      return false;
  }

• example usage

  ...
      return true;
  }
  return false;
  
  };
  SomePromiseArray.prototype._promiseRejected = function (reason) {
  this._addRejected(reason);
  return this._checkOutcome();
  };
  
  SomePromiseArray.prototype._promiseCancelled = function () {
  if (this._values instanceof Promise || this._values == null) {
      return this._cancel();
  }
  this._addRejected(CANCELLATION);
  ...

function bluebird._SomePromiseArray.prototype._fulfilled ()

• description and source-code

  _fulfilled = function () {
      return this._totalResolved;
  }

• example usage

  ...
  
  SomePromiseArray.prototype.setHowMany = function (count) {
  this._howMany = count;
  };
  
  SomePromiseArray.prototype._promiseFulfilled = function (value) {
  this._addFulfilled(value);
  if (this._fulfilled() === this.howMany()) {
      this._values.length = this.howMany();
      if (this.howMany() === 1 && this._unwrap) {
          this._resolve(this._values[0]);
      } else {
          this._resolve(this._values);
      }
      return true;
  ...

function bluebird._SomePromiseArray.prototype._getRangeError (count)

• description and source-code

  _getRangeError = function (count) {
      var message = "Input array must contain at least " +
              this._howMany + " items but contains only " + count + " items";
      return new RangeError(message);
  }

• example usage

  ...
          return;
      }
      this._init$(undefined, -5);
      var isArrayResolved = isArray(this._values);
      if (!this._isResolved() &&
          isArrayResolved &&
          this._howMany > this._canPossiblyFulfill()) {
          this._reject(this._getRangeError(this.length()));
      }
  };
  
  SomePromiseArray.prototype.init = function () {
      this._initialized = true;
      this._init();
  };
  ...

function bluebird._SomePromiseArray.prototype._init ()

• description and source-code

  _init = function () {
      if (!this._initialized) {
          return;
      }
      if (this._howMany === 0) {
          this._resolve([]);
          return;
      }
      this._init$(undefined, -5);
      var isArrayResolved = isArray(this._values);
      if (!this._isResolved() &&
          isArrayResolved &&
          this._howMany > this._canPossiblyFulfill()) {
          this._reject(this._getRangeError(this.length()));
      }
  }

• example usage

  ...
      if (values instanceof Promise) {
          promise._propagateFrom(values, 3);
      }
      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;
  };
  ...

function bluebird._SomePromiseArray.prototype._promiseCancelled ()

• description and source-code

  _promiseCancelled = function () {
      if (this._values instanceof Promise || this._values == null) {
          return this._cancel();
      }
      this._addRejected(CANCELLATION);
      return this._checkOutcome();
  }

• example usage

  ...
          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) {
  ...

function bluebird._SomePromiseArray.prototype._promiseFulfilled (value)

• description and source-code

  _promiseFulfilled = function (value) {
      this._addFulfilled(value);
      if (this._fulfilled() === this.howMany()) {
          this._values.length = this.howMany();
          if (this.howMany() === 1 && this._unwrap) {
              this._resolve(this._values[0]);
          } else {
              this._resolve(this._values);
          }
          return true;
      }
      return false;
  
  }

• example usage

  ...
      } 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)) {
  ...

function bluebird._SomePromiseArray.prototype._promiseRejected (reason)

• description and source-code

  _promiseRejected = function (reason) {
      this._addRejected(reason);
      return this._checkOutcome();
  }

• example usage

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

function bluebird._SomePromiseArray.prototype._rejected ()

• description and source-code

  _rejected = function () {
      return this._values.length - this.length();
  }

• example usage

  ...
  };
  
  SomePromiseArray.prototype._addFulfilled = function (value) {
      this._values[this._totalResolved++] = value;
  };
  
  SomePromiseArray.prototype._canPossiblyFulfill = function () {
      return this.length() - this._rejected();
  };
  
  SomePromiseArray.prototype._getRangeError = function (count) {
      var message = "Input array must contain at least " +
              this._howMany + " items but contains only " + count + " items";
      return new RangeError(message);
  };
  ...

function bluebird._SomePromiseArray.prototype._resolveEmptyArray ()

• description and source-code

  _resolveEmptyArray = function () {
      this._reject(this._getRangeError(0));
  }

• example usage

  ...
          "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);
  ...

function bluebird._SomePromiseArray.prototype.constructor (values)

• description and source-code

  function SomePromiseArray(values) {
      this.constructor$(values);
      this._howMany = 0;
      this._unwrap = false;
      this._initialized = false;
  }

• example usage

  n/a

function bluebird._SomePromiseArray.prototype.howMany ()

• description and source-code

  howMany = function () {
      return this._howMany;
  }

• example usage

  ...
  
  SomePromiseArray.prototype.setHowMany = function (count) {
  this._howMany = count;
  };
  
  SomePromiseArray.prototype._promiseFulfilled = function (value) {
  this._addFulfilled(value);
  if (this._fulfilled() === this.howMany()) {
      this._values.length = this.howMany();
      if (this.howMany() === 1 && this._unwrap) {
          this._resolve(this._values[0]);
      } else {
          this._resolve(this._values);
      }
      return true;
  ...

function bluebird._SomePromiseArray.prototype.init ()

• description and source-code

  init = function () {
      this._initialized = true;
      this._init();
  }

• example usage

  ...
  module.exports = function(Promise) {
  var SomePromiseArray = Promise._SomePromiseArray;
  function any(promises) {
      var ret = new SomePromiseArray(promises);
      var promise = ret.promise();
      ret.setHowMany(1);
      ret.setUnwrap();
      ret.init();
      return promise;
  }
  
  Promise.any = function (promises) {
      return any(promises);
  };
  ...

function bluebird._SomePromiseArray.prototype.setHowMany (count)

• description and source-code

  setHowMany = function (count) {
      this._howMany = count;
  }

• example usage

  ...
  !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("
  ;function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined
  "!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module
  ,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_
  ;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");
  throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s
  (n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof _dereq_=="function"&&_dereq_;for(var o=0;o<r
  .length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
  "use strict";
  module.exports = function(Promise) {
  var SomePromiseArray = Promise._SomePromiseArray;
  function any(promises) {
  var ret = new SomePromiseArray(promises);
  var promise = ret.promise();
  ret.setHowMany(1);
  ret.setUnwrap();
  ret.init();
  return promise;
  }
  
  Promise.any = function (promises) {
  return any(promises);
  ...

function bluebird._SomePromiseArray.prototype.setUnwrap ()

• description and source-code

  setUnwrap = function () {
      this._unwrap = true;
  }

• example usage

  ...
  "use strict";
  module.exports = function(Promise) {
  var SomePromiseArray = Promise._SomePromiseArray;
  function any(promises) {
      var ret = new SomePromiseArray(promises);
      var promise = ret.promise();
      ret.setHowMany(1);
      ret.setUnwrap();
      ret.init();
      return promise;
  }
  
  Promise.any = function (promises) {
      return any(promises);
  };
  ...

module bluebird.async

function bluebird.async ()

• description and source-code

  function Async() {
      this._customScheduler = false;
      this._isTickUsed = false;
      this._lateQueue = new Queue(16);
      this._normalQueue = new Queue(16);
      this._haveDrainedQueues = false;
      this._trampolineEnabled = true;
      var self = this;
      this.drainQueues = function () {
          self._drainQueues();
      };
      this._schedule = schedule;
  }

• example usage

  n/a

module bluebird.async.prototype

function bluebird.async.prototype._drainQueue (queue)

• description and source-code

  _drainQueue = function (queue) {
      while (queue.length() > 0) {
          var fn = queue.shift();
          if (typeof fn !== "function") {
              fn._settlePromises();
              continue;
          }
          var receiver = queue.shift();
          var arg = queue.shift();
          fn.call(receiver, arg);
      }
  }

• example usage

  ...
      var receiver = queue.shift();
      var arg = queue.shift();
      fn.call(receiver, arg);
  }
  };
  
  Async.prototype._drainQueues = function () {
  this._drainQueue(this._normalQueue);
  this._reset();
  this._haveDrainedQueues = true;
  this._drainQueue(this._lateQueue);
  };
  
  Async.prototype._queueTick = function () {
  if (!this._isTickUsed) {
  ...

function bluebird.async.prototype._drainQueues ()

• description and source-code

  _drainQueues = function () {
      this._drainQueue(this._normalQueue);
      this._reset();
      this._haveDrainedQueues = true;
      this._drainQueue(this._lateQueue);
  }

• example usage

  ...
  this._isTickUsed = false;
  this._lateQueue = new Queue(16);
  this._normalQueue = new Queue(16);
  this._haveDrainedQueues = false;
  this._trampolineEnabled = true;
  var self = this;
  this.drainQueues = function () {
      self._drainQueues();
  };
  this._schedule = schedule;
  }
  
  Async.prototype.setScheduler = function(fn) {
  var prev = this._schedule;
  this._schedule = fn;
  ...

function bluebird.async.prototype._queueTick ()

• description and source-code

  _queueTick = function () {
      if (!this._isTickUsed) {
          this._isTickUsed = true;
          this._schedule(this.drainQueues);
      }
  }

• example usage

  ...
      } 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 bluebird.async.prototype._reset ()

• description and source-code

  _reset = function () {
      this._isTickUsed = false;
  }

• example usage

  ...
      var arg = queue.shift();
      fn.call(receiver, arg);
  }
  };
  
  Async.prototype._drainQueues = function () {
  this._drainQueue(this._normalQueue);
  this._reset();
  this._haveDrainedQueues = true;
  this._drainQueue(this._lateQueue);
  };
  
  Async.prototype._queueTick = function () {
  if (!this._isTickUsed) {
      this._isTickUsed = true;
  ...

function bluebird.async.prototype.disableTrampolineIfNecessary ()

• description and source-code

  disableTrampolineIfNecessary = function () {
      if (util.hasDevTools) {
          this._trampolineEnabled = false;
      }
  }

• example usage

  ...
              Context.deactivateLongStackTraces();
              async.enableTrampoline();
              config.longStackTraces = false;
          };
          Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
          Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
          Context.activateLongStackTraces();
          async.disableTrampolineIfNecessary();
      }
  };
  
  Promise.hasLongStackTraces = function () {
      return config.longStackTraces && longStackTracesIsSupported();
  };
  ...

function bluebird.async.prototype.enableTrampoline ()

• description and source-code

  enableTrampoline = function () {
      this._trampolineEnabled = true;
  }

• example usage

  ...
      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;
          Context.deactivateLongStackTraces();
          async.enableTrampoline();
          config.longStackTraces = false;
      };
      Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
      Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
      Context.activateLongStackTraces();
      async.disableTrampolineIfNecessary();
  }
  ...

function bluebird.async.prototype.fatalError (e, isNode)

• description and source-code

  fatalError = function (e, isNode) {
      if (isNode) {
          process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) +
              "\n");
          process.exit(2);
      } else {
          this.throwLater(e);
      }
  }

• example usage

  ...
  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();
  }
  ...

function bluebird.async.prototype.hasCustomScheduler ()

• description and source-code

  hasCustomScheduler = function () {
      return this._customScheduler;
  }

• example usage

  ...
  };
  
  Promise.prototype._setWillBeCancelled = function() {
  this._bitField = this._bitField | 8388608;
  };
  
  Promise.prototype._setAsyncGuaranteed = function() {
  if (async.hasCustomScheduler()) return;
  this._bitField = this._bitField | 134217728;
  };
  
  Promise.prototype._receiverAt = function (index) {
  var ret = index === 0 ? this._receiver0 : this[
          index * 4 - 4 + 3];
  if (ret === UNDEFINED_BINDING) {
  ...

function bluebird.async.prototype.haveItemsQueued ()

• description and source-code

  haveItemsQueued = function () {
      return this._isTickUsed || this._haveDrainedQueues;
  }

• example usage

  ...
      typeof fn === "function" ? (domain === null ?
                                          fn : util.domainBind(domain, fn))
                               : undefined;
  };
  
  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;
      config.longStackTraces = true;
      disableLongStackTraces = function() {
  ...

function bluebird.async.prototype.invoke (fn, receiver, arg)

• description and source-code

  function AsyncInvoke(fn, receiver, arg) {
      this._normalQueue.push(fn, receiver, arg);
      this._queueTick();
  }

• example usage

  ...
          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() {
  ...

function bluebird.async.prototype.invokeLater (fn, receiver, arg)

• description and source-code

  function AsyncInvokeLater(fn, receiver, arg) {
      this._lateQueue.push(fn, receiver, arg);
      this._queueTick();
  }

• example usage

  n/a

function bluebird.async.prototype.setScheduler (fn)

• description and source-code

  setScheduler = function (fn) {
      var prev = this._schedule;
      this._schedule = fn;
      this._customScheduler = true;
      return prev;
  }

• example usage

  ...
  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
  ...

function bluebird.async.prototype.settlePromises (promise)

• description and source-code

  function AsyncSettlePromises(promise) {
      this._normalQueue._pushOne(promise);
      this._queueTick();
  }

• example usage

  ...
  this._setFulfilled();
  this._rejectionHandler0 = value;
  
  if ((bitField & 65535) > 0) {
      if (((bitField & 134217728) !== 0)) {
          this._settlePromises();
      } else {
          async.settlePromises(this);
      }
  }
  };
  
  Promise.prototype._reject = function (reason) {
  var bitField = this._bitField;
  if (((bitField & 117506048) >>> 16)) return;
  ...

function bluebird.async.prototype.throwLater (fn, arg)

• description and source-code

  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");
      }
  }

• example usage

  ...
  
  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; };
  ...

module bluebird.bluebird

function bluebird.bluebird (executor)

• description and source-code

  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);
  }

• example usage

  n/a

function bluebird.bluebird.AggregateError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.bluebird.CancellationError (message)

• description and source-code

  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);
      }
  }

• example usage

  ...
  
  PromiseSpawn.prototype._promiseCancelled = function() {
  if (this._isResolved()) return;
  var implementsReturn = typeof this._generator["return"] !== "undefined";
  
  var result;
  if (!implementsReturn) {
      var reason = new Promise.CancellationError(
          "generator .return() sentinel");
      Promise.coroutine.returnSentinel = reason;
      this._promise._attachExtraTrace(reason);
      this._promise._pushContext();
      result = tryCatch(this._generator["throw"]).call(this._generator,
                                                       reason);
      this._promise._popContext();
  ...

function bluebird.bluebird.OperationalError (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.bluebird.Promise (executor)

• description and source-code

  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);
  }

• example usage

  n/a

function bluebird.bluebird.PromiseInspection (promise)

• description and source-code

  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;
      }
  }

• example usage

  ...
  },{"./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");
  ...

function bluebird.bluebird.RangeError ()

• description and source-code

  function RangeError() { [native code] }

• example usage

  n/a

function bluebird.bluebird.RejectionError (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.bluebird.TimeoutError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.bluebird.TypeError ()

• description and source-code

  function TypeError() { [native code] }

• example usage

  ...
  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();
  ...

function bluebird.bluebird._SomePromiseArray (values)

• description and source-code

  function SomePromiseArray(values) {
      this.constructor$(values);
      this._howMany = 0;
      this._unwrap = false;
      this._initialized = false;
  }

• example usage

  n/a

function bluebird.bluebird._peekContext ()

• description and source-code

  function peekContext() {
      var lastIndex = contextStack.length - 1;
      if (lastIndex >= 0) {
          return contextStack[lastIndex];
      }
      return undefined;
  }

• example usage

  ...
          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){
  ...

function bluebird.bluebird.all (promises)

• description and source-code

  all = function (promises) {
      return new PromiseArray(promises).promise();
  }

• example usage

  ...
  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,
  ...

function bluebird.bluebird.any (promises)

• description and source-code

  any = function (promises) {
      return any(promises);
  }

• example usage

  n/a

function bluebird.bluebird.attempt (fn)

• description and source-code

  attempt = 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;
  }

• example usage

  n/a

function bluebird.bluebird.bind (thisArg, value)

• description and source-code

  bind = function (thisArg, value) {
      return Promise.resolve(value).bind(thisArg);
  }

• example usage

  ...
  };
  
  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 bluebird.bluebird.cast (obj)

• description and source-code

  cast = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  ...
      for (var i = 0, len = promises.length; i < len; ++i) {
          var val = promises[i];
  
          if (val === undefined && !(i in promises)) {
              continue;
          }
  
          Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
      }
      return ret;
  }
  
  Promise.race = function (promises) {
      return race(promises, undefined);
  };
  ...

function bluebird.bluebird.config (opts)

• description and source-code

  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;
          }
      }
      return Promise;
  }

• example usage

  n/a

function bluebird.bluebird.coroutine (generatorFunction, options)

• description and source-code

  coroutine = function (generatorFunction, options) {
      if (typeof generatorFunction !== "function") {
          throw new TypeError("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
      var yieldHandler = Object(options).yieldHandler;
      var PromiseSpawn$ = PromiseSpawn;
      var stack = new Error().stack;
      return function () {
          var generator = generatorFunction.apply(this, arguments);
          var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
                                        stack);
          var ret = spawn.promise();
          spawn._generator = generator;
          spawn._promiseFulfilled(undefined);
          return ret;
      };
  }

• example usage

  ...
  if (typeof fn !== "function") {
      throw new TypeError("expecting a function but got " + util.classString(fn));
  }
  yieldHandlers.push(fn);
  };
  
  Promise.spawn = function (generatorFunction) {
  debug.deprecated("Promise.spawn()", "Promise.coroutine()");
  if (typeof generatorFunction !== "function") {
      return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  }
  var spawn = new PromiseSpawn(generatorFunction, this);
  var ret = spawn.promise();
  spawn._run(Promise.spawn);
  return ret;
  ...

function bluebird.bluebird.defer ()

• description and source-code

  defer = function () {
      debug.deprecated("Promise.defer", "new Promise");
      var promise = new Promise(INTERNAL);
      return {
          promise: promise,
          resolve: deferResolve,
          reject: deferReject
      };
  }

• example usage

  n/a

function bluebird.bluebird.delay (ms, value)

• description and source-code

  delay = function (ms, value) {
      var ret;
      var handle;
      if (value !== undefined) {
          ret = Promise.resolve(value)
                  ._then(afterValue, null, null, ms, undefined);
          if (debug.cancellation() && value instanceof Promise) {
              ret._setOnCancel(value);
          }
      } else {
          ret = new Promise(INTERNAL);
          handle = setTimeout(function() { ret._fulfill(); }, +ms);
          if (debug.cancellation()) {
              ret._setOnCancel(new HandleWrapper(handle));
          }
          ret._captureStackTrace();
      }
      ret._setAsyncGuaranteed();
      return ret;
  }

• example usage

  n/a

function bluebird.bluebird.each (promises, fn)

• description and source-code

  each = function (promises, fn) {
      return PromiseReduce(promises, fn, INTERNAL, 0)
                ._then(promiseAllThis, undefined, undefined, promises, undefined);
  }

• example usage

  n/a

function bluebird.bluebird.filter (promises, fn, options)

• description and source-code

  filter = function (promises, fn, options) {
      return PromiseMap(promises, fn, options, INTERNAL);
  }

• example usage

  n/a

function bluebird.bluebird.fromCallback (fn)

• description and source-code

  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;
  }

• example usage

  n/a

function bluebird.bluebird.fromNode (fn)

• description and source-code

  fromNode = 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;
  }

• example usage

  n/a

function bluebird.bluebird.fulfilled (obj)

• description and source-code

  fulfilled = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  n/a

function bluebird.bluebird.getNewLibraryCopy ()

• description and source-code

  getNewLibraryCopy = 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");
  
  var getDomain;
  if (util.isNode) {
      getDomain = function() {
          var ret = process.domain;
          if (ret === undefined) ret = null;
          return ret;
      };
  } else {
      getDomain = function() {
          return null;
      };
  }
  util.notEnumerableProp(Promise, "_getDomain", getDomain);
  
  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);
  var CapturedTrace = debug.CapturedTrace;
  var PassThroughHandlerContext =
      _dereq_("./finally")(Promise, tryConvertToPromise, NEXT_FILTER);
  var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
  var nodebackForPromise = _dereq_("./nodeback");
  var errorObj = util.errorObj;
  var tryCatch = util.tryCatch;
  function check(self, executor) {
      if (self == null || self.constructor !== Promise) {
          throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
      if (typeof executor !== "function") {
          throw new TypeError("expecting a function but got " + util.classString(executor));
      }
  
  }
  
  function Promise(executor) {
      if (executor !== INTERNAL) {
          check(this, executor);
      }
      this._bitField = 0;
      this._fulfillmentHandler0 = undefined;
      this._rejectionHandler0 = undefined;
      this._promise0 = undefined;
      this._receiver0 = undefined;
      this._resolveFromExecutor(executor);
      this._promiseCreated();
      this._fireEvent("promiseCreated", this);
  }
  
  Promise.prototype.toString = function () {
      return "[object Promise]";
  };
  
  Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
      var len = arguments.length;
      if (len > 1) {
          var catchInstances = new Array(len - 1),
              j = 0, i;
          for (i = 0; i < len - 1; ++i) {
              var item = arguments[i];
              if (util.isObject(item)) {
                  catchInstances[j++] = item;
              } else {
                  return apiRejection("Catch statement predicate: " +
                      "expecting an object but got " + util.classString(item));
              }
          }
          catchInstances.length = j;
          fn = arguments[i];
          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.warning...

• example usage

  n/a

function bluebird.bluebird.hasLongStackTraces ()

• description and source-code

  hasLongStackTraces = function () {
      return config.longStackTraces && longStackTracesIsSupported();
  }

• example usage

  ...
  };
  
  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;
  ...

function bluebird.bluebird.is (val)

• description and source-code

  is = function (val) {
      return val instanceof Promise;
  }

• example usage

  n/a

function bluebird.bluebird.join ()

• description and source-code

  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 domain = getDomain();
                          if (domain !== null) {
                              holder.fn = util.domainBind(domain, 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;
  }

• example usage

  ...
              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 checkForgottenReturns(returnValue, promiseCreated, name, promise,
  parent) {
  ...

function bluebird.bluebird.longStackTraces ()

• description and source-code

  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;
          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;
              Context.deactivateLongStackTraces();
              async.enableTrampoline();
              config.longStackTraces = false;
          };
          Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
          Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
          Context.activateLongStackTraces();
          async.disableTrampolineIfNecessary();
      }
  }

• example usage

  ...
  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;
  ...

function bluebird.bluebird.map (promises, fn, options, _filter)

• description and source-code

  map = function (promises, fn, options, _filter) {
      return map(promises, fn, options, _filter);
  }

• example usage

  ...
  
      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");
  ...

function bluebird.bluebird.mapSeries (promises, fn)

• description and source-code

  function PromiseMapSeries(promises, fn) {
      return PromiseReduce(promises, fn, INTERNAL, INTERNAL);
  }

• example usage

  n/a

function bluebird.bluebird.method (fn)

• description and source-code

  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;
      };
  }

• example usage

  n/a

function bluebird.bluebird.noConflict ()

• description and source-code

  function noConflict() {
      try { if (Promise === bluebird) Promise = old; }
      catch (e) {}
      return bluebird;
  }

• example usage

  n/a

function bluebird.bluebird.onPossiblyUnhandledRejection (fn)

• description and source-code

  onPossiblyUnhandledRejection = function (fn) {
      var domain = getDomain();
      possiblyUnhandledRejection =
          typeof fn === "function" ? (domain === null ?
                                              fn : util.domainBind(domain, fn))
                                   : undefined;
  }

• example usage

  n/a

function bluebird.bluebird.onUnhandledRejectionHandled (fn)

• description and source-code

  onUnhandledRejectionHandled = function (fn) {
      var domain = getDomain();
      unhandledRejectionHandled =
          typeof fn === "function" ? (domain === null ?
                                              fn : util.domainBind(domain, fn))
                                   : undefined;
  }

• example usage

  n/a

function bluebird.bluebird.pending ()

• description and source-code

  pending = function () {
      debug.deprecated("Promise.defer", "new Promise");
      var promise = new Promise(INTERNAL);
      return {
          promise: promise,
          resolve: deferResolve,
          reject: deferReject
      };
  }

• example usage

  n/a

function bluebird.bluebird.promisify (fn, options)

• description and source-code

  promisify = function (fn, options) {
      if (typeof fn !== "function") {
          throw new TypeError("expecting a function but got " + util.classString(fn));
      }
      if (isPromisified(fn)) {
          return fn;
      }
      options = Object(options);
      var receiver = options.context === undefined ? THIS : options.context;
      var multiArgs = !!options.multiArgs;
      var ret = promisify(fn, receiver, multiArgs);
      util.copyDescriptors(fn, ret, propsFilter);
      return ret;
  }

• example usage

  n/a

function bluebird.bluebird.promisifyAll (target, options)

• description and source-code

  promisifyAll = function (target, options) {
      if (typeof target !== "function" && typeof target !== "object") {
          throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a    See http://goo.gl/MqrFmX\
  u000a");
      }
      options = Object(options);
      var multiArgs = !!options.multiArgs;
      var suffix = options.suffix;
      if (typeof suffix !== "string") suffix = defaultSuffix;
      var filter = options.filter;
      if (typeof filter !== "function") filter = defaultFilter;
      var promisifier = options.promisifier;
      if (typeof promisifier !== "function") promisifier = makeNodePromisified;
  
      if (!util.isIdentifier(suffix)) {
          throw new RangeError("suffix must be a valid identifier\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
  
      var keys = util.inheritedDataKeys(target);
      for (var i = 0; i < keys.length; ++i) {
          var value = target[keys[i]];
          if (keys[i] !== "constructor" &&
              util.isClass(value)) {
              promisifyAll(value.prototype, suffix, filter, promisifier,
                  multiArgs);
              promisifyAll(value, suffix, filter, promisifier, multiArgs);
          }
      }
  
      return promisifyAll(target, suffix, filter, promisifier, multiArgs);
  }

• example usage

  n/a

function bluebird.bluebird.props (promises)

• description and source-code

  props = function (promises) {
      return props(promises);
  }

• example usage

  n/a

function bluebird.bluebird.race (promises)

• description and source-code

  race = function (promises) {
      return race(promises, undefined);
  }

• example usage

  n/a

function bluebird.bluebird.reduce (promises, fn, initialValue, _each)

• description and source-code

  reduce = function (promises, fn, initialValue, _each) {
      return reduce(promises, fn, initialValue, _each);
  }

• example usage

  n/a

function bluebird.bluebird.reject (reason)

• description and source-code

  reject = function (reason) {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._rejectCallback(reason, true);
      return ret;
  }

• example usage

  ...
   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];
  ...

function bluebird.bluebird.rejected (reason)

• description and source-code

  rejected = function (reason) {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._rejectCallback(reason, true);
      return ret;
  }

• example usage

  n/a

function bluebird.bluebird.resolve (obj)

• description and source-code

  resolve = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  ...
  };
  
  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 bluebird.bluebird.setScheduler (fn)

• description and source-code

  setScheduler = function (fn) {
      if (typeof fn !== "function") {
          throw new TypeError("expecting a function but got " + util.classString(fn));
      }
      return async.setScheduler(fn);
  }

• example usage

  ...
  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
  ...

function bluebird.bluebird.settle (promises)

• description and source-code

  settle = function (promises) {
      debug.deprecated(".settle()", ".reflect()");
      return new SettledPromiseArray(promises).promise();
  }

• example usage

  ...
      var ret = new PromiseInspection();
      ret._bitField = 16777216;
      ret._settledValueField = reason;
      return this._promiseResolved(index, ret);
  };
  
  Promise.settle = function (promises) {
      debug.deprecated(".settle()", ".reflect()");
      return new SettledPromiseArray(promises).promise();
  };
  
  Promise.prototype.settle = function () {
      return Promise.settle(this);
  };
  };
  ...

function bluebird.bluebird.some (promises, howMany)

• description and source-code

  some = function (promises, howMany) {
      return some(promises, howMany);
  }

• example usage

  n/a

function bluebird.bluebird.spawn (generatorFunction)

• description and source-code

  spawn = function (generatorFunction) {
      debug.deprecated("Promise.spawn()", "Promise.coroutine()");
      if (typeof generatorFunction !== "function") {
          return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
      var spawn = new PromiseSpawn(generatorFunction, this);
      var ret = spawn.promise();
      spawn._run(Promise.spawn);
      return ret;
  }

• example usage

  ...
  if (typeof fn !== "function") {
      throw new TypeError("expecting a function but got " + util.classString(fn));
  }
  yieldHandlers.push(fn);
  };
  
  Promise.spawn = function (generatorFunction) {
  debug.deprecated("Promise.spawn()", "Promise.coroutine()");
  if (typeof generatorFunction !== "function") {
      return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  }
  var spawn = new PromiseSpawn(generatorFunction, this);
  var ret = spawn.promise();
  spawn._run(Promise.spawn);
  return ret;
  ...

function bluebird.bluebird.try (fn)

• description and source-code

  try = function (fn) {
      if (typeof fn !== "function") {
          return apiRejection("expecting a function but got " + util.classString(fn));
      }
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value;
      if (arguments.length > 1) {
          debug.deprecated("calling Promise.try with more than 1 argument");
          var arg = arguments[1];
          var ctx = arguments[2];
          value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
                                    : tryCatch(fn).call(ctx, arg);
      } else {
          value = tryCatch(fn)();
      }
      var promiseCreated = ret._popContext();
      debug.checkForgottenReturns(
          value, promiseCreated, "Promise.try", ret);
      ret._resolveFromSyncValue(value);
      return ret;
  }

• example usage

  n/a

function bluebird.bluebird.using ()

• description and source-code

  using = function () {
      var len = arguments.length;
      if (len < 2) return apiRejection(
                      "you must pass at least 2 arguments to Promise.using");
      var fn = arguments[len - 1];
      if (typeof fn !== "function") {
          return apiRejection("expecting a function but got " + util.classString(fn));
      }
      var input;
      var spreadArgs = true;
      if (len === 2 && Array.isArray(arguments[0])) {
          input = arguments[0];
          len = input.length;
          spreadArgs = false;
      } else {
          input = arguments;
          len--;
      }
      var resources = new ResourceList(len);
      for (var i = 0; i < len; ++i) {
          var resource = input[i];
          if (Disposer.isDisposer(resource)) {
              var disposer = resource;
              resource = resource.promise();
              resource._setDisposable(disposer);
          } else {
              var maybePromise = tryConvertToPromise(resource);
              if (maybePromise instanceof Promise) {
                  resource =
                      maybePromise._then(maybeUnwrapDisposer, null, null, {
                          resources: resources,
                          index: i
                  }, undefined);
              }
          }
          resources[i] = resource;
      }
  
      var reflectedResources = new Array(resources.length);
      for (var i = 0; i < reflectedResources.length; ++i) {
          reflectedResources[i] = Promise.resolve(resources[i]).reflect();
      }
  
      var resultPromise = Promise.all(reflectedResources)
          .then(function(inspections) {
              for (var i = 0; i < inspections.length; ++i) {
                  var inspection = inspections[i];
                  if (inspection.isRejected()) {
                      errorObj.e = inspection.error();
                      return errorObj;
                  } else if (!inspection.isFulfilled()) {
                      resultPromise.cancel();
                      return;
                  }
                  inspections[i] = inspection.value();
              }
              promise._pushContext();
  
              fn = tryCatch(fn);
              var ret = spreadArgs
                  ? fn.apply(undefined, inspections) : fn(inspections);
              var promiseCreated = promise._popContext();
              debug.checkForgottenReturns(
                  ret, promiseCreated, "Promise.using", promise);
              return ret;
          });
  
      var promise = resultPromise.lastly(function() {
          var inspection = new Promise.PromiseInspection(resultPromise);
          return dispose(resources, inspection);
      });
      resources.promise = promise;
      promise._setOnCancel(resources);
      return promise;
  }

• example usage

  n/a

module bluebird.bluebird.prototype

function bluebird.bluebird.prototype.__isCancelled ()

• description and source-code

  __isCancelled = function () {
      return (this._bitField & 65536) === 65536;
  }

• example usage

  ...
  };
  
  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() {
  ...

function bluebird.bluebird.prototype._addCallbacks ( fulfill, reject, promise, receiver, domain )

• description and source-code

  _addCallbacks = function ( fulfill, reject, promise, receiver, domain ) {
      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 =
                  domain === null ? fulfill : util.domainBind(domain, fulfill);
          }
          if (typeof reject === "function") {
              this._rejectionHandler0 =
                  domain === null ? reject : util.domainBind(domain, reject);
          }
      } else {
          var base = index * 4 - 4;
          this[base + 2] = promise;
          this[base + 3] = receiver;
          if (typeof fulfill === "function") {
              this[base + 0] =
                  domain === null ? fulfill : util.domainBind(domain, fulfill);
          }
          if (typeof reject === "function") {
              this[base + 1] =
                  domain === null ? reject : util.domainBind(domain, reject);
          }
      }
      this._setLength(index + 1);
      return index;
  }

• example usage

  ...
              : (typeof handler === "function" &&
                  util.domainBind(domain, handler)),
          promise: promise,
          receiver: receiver,
          value: value
      });
  } else {
      target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
  }
  
  return promise;
  };
  
  Promise.prototype._length = function () {
  return this._bitField & 65535;
  ...

function bluebird.bluebird.prototype._attachCancellationCallback (onCancel)

• description and source-code

  _attachCancellationCallback = function (onCancel) {
      ;
  }

• example usage

  ...
      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) {
  ...

function bluebird.bluebird.prototype._attachExtraTrace (error, ignoreSelf)

• description and source-code

  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);
          }
      }
  }

• example usage

  ...
          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);
      }
  }
  ...

function bluebird.bluebird.prototype._boundValue ()

• description and source-code

  _boundValue = function () {}

• example usage

  ...
  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);
  ...

function bluebird.bluebird.prototype._branchHasCancelled ()

• description and source-code

  _branchHasCancelled = function () {
      this._branchesRemainingToCancel--;
  }

• example usage

  ...
  
  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;
  };
  ...

function bluebird.bluebird.prototype._cancel ()

• description and source-code

  _cancel = function () {
      if (!this._isCancellable()) return;
      this._setCancelled();
      async.invoke(this._cancelPromises, this, undefined);
  }

• example usage

  ...
      }
  }
  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);
  ...

function bluebird.bluebird.prototype._cancelBranched ()

• description and source-code

  _cancelBranched = function () {
      if (this._enoughBranchesHaveCancelled()) {
          this._cancel();
      }
  }

• example usage

  ...
      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()) {
  ...

function bluebird.bluebird.prototype._cancelBy (canceller)

• description and source-code

  _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;
  }

• example usage

  ...
  
  Promise.prototype["break"] = Promise.prototype.cancel = function() {
  if (!debug.cancellation()) return this._warn("cancellation is disabled");
  
  var promise = this;
  var child = promise;
  while (promise._isCancellable()) {
      if (!promise._cancelBy(child)) {
          if (child._isFollowing()) {
              child._followee().cancel();
          } else {
              child._cancelBranched();
          }
          break;
      }
  ...

function bluebird.bluebird.prototype._cancelPromises ()

• description and source-code

  _cancelPromises = function () {
      if (this._length() > 0) this._settlePromises();
  }

• example usage

  n/a

function bluebird.bluebird.prototype._captureStackTrace ()

• description and source-code

  function longStackTracesCaptureStackTrace() {
      this._trace = new CapturedTrace(this._peekContext());
  }

• example usage

  ...
      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) {
  ...

function bluebird.bluebird.prototype._clearCallbackDataAtIndex (index)

• description and source-code

  _clearCallbackDataAtIndex = function (index) {
      var base = index * 4 - 4;
      this[base + 2] =
      this[base + 3] =
      this[base + 0] =
      this[base + 1] = undefined;
  }

• example usage

  ...
  };
  
  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);
  ...

function bluebird.bluebird.prototype._clearCancellationData ()

• description and source-code

  _clearCancellationData = function () {}

• example usage

  ...
      } 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)) {
  ...

function bluebird.bluebird.prototype._doInvokeOnCancel (onCancelCallback, internalOnly)

• description and source-code

  _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);
          }
      }
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird.prototype._enoughBranchesHaveCancelled ()

• description and source-code

  _enoughBranchesHaveCancelled = function () {
      return this._branchesRemainingToCancel === undefined ||
             this._branchesRemainingToCancel <= 0;
  }

• example usage

  ...
  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;
  };
  ...

function bluebird.bluebird.prototype._ensurePossibleRejectionHandled ()

• description and source-code

  _ensurePossibleRejectionHandled = function () {
      if ((this._bitField & 524288) !== 0) return;
      this._setRejectionIsUnhandled();
      var self = this;
      setTimeout(function() {
          self._notifyUnhandledRejection();
      }, 1);
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird.prototype._execute (executor, resolve, reject)

• description and source-code

  _execute = function (executor, resolve, reject) {
      try {
          executor(resolve, reject);
      } catch (e) {
          return e;
      }
  }

• example usage

  ...
  
  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();
  ...

function bluebird.bluebird.prototype._fireEvent ()

• description and source-code

  function defaultFireEvent() { return false; }

• example usage

  ...
      this._bitField = 0;
      this._fulfillmentHandler0 = undefined;
      this._rejectionHandler0 = undefined;
      this._promise0 = undefined;
      this._receiver0 = undefined;
      this._resolveFromExecutor(executor);
      this._promiseCreated();
      this._fireEvent("promiseCreated", this);
  }
  
  Promise.prototype.toString = function () {
      return "[object Promise]";
  };
  
  Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
  ...

function bluebird.bluebird.prototype._followee ()

• description and source-code

  _followee = function () {
      return this._rejectionHandler0;
  }

• example usage

  ...
      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;
  ...

function bluebird.bluebird.prototype._fulfill (value)

• description and source-code

  _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);
          }
      }
  }

• example usage

  ...
      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;
      };
  }
  ...

function bluebird.bluebird.prototype._fulfillPromises (len, value)

• description and source-code

  _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);
      }
  }

• example usage

  ...
          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() {
  ...

function bluebird.bluebird.prototype._fulfillmentHandlerAt (index)

• description and source-code

  _fulfillmentHandlerAt = function (index) {
      return this[
              index * 4 - 4 + 0];
  }

• example usage

  ...
      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);
  };
  ...

function bluebird.bluebird.prototype._getDisposer ()

• description and source-code

  _getDisposer = function () {
      return this._disposer;
  }

• example usage

  ...
  
  function castPreservingDisposable(thenable) {
      var maybePromise = tryConvertToPromise(thenable);
      if (maybePromise !== thenable &&
          typeof thenable._isDisposable === "function" &&
          typeof thenable._getDisposer === "function" &&
          thenable._isDisposable()) {
          maybePromise._setDisposable(thenable._getDisposer());
      }
      return maybePromise;
  }
  function dispose(resources, inspection) {
      var i = 0;
      var len = resources.length;
      var ret = new Promise(INTERNAL);
  ...

function bluebird.bluebird.prototype._invokeInternalOnCancel ()

• description and source-code

  _invokeInternalOnCancel = function () {
      if (this._isCancellable()) {
          this._doInvokeOnCancel(this._onCancel(), true);
          this._unsetOnCancel();
      }
  }

• example usage

  ...
  };
  
  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);
      }
  ...

function bluebird.bluebird.prototype._invokeOnCancel ()

• description and source-code

  _invokeOnCancel = function () {
      var onCancelCallback = this._onCancel();
      this._unsetOnCancel();
      async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
  }

• example usage

  ...
  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;
      }
  ...

function bluebird.bluebird.prototype._isBound ()

• description and source-code

  _isBound = function () {
      return (this._bitField & 2097152) === 2097152;
  }

• example usage

  ...
      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);
  ...

function bluebird.bluebird.prototype._isCancellable ()

• description and source-code

  _isCancellable = function () {
      return this.isPending() && !this._isCancelled();
  }

• example usage

  ...
  var async = Promise._async;
  
  Promise.prototype["break"] = Promise.prototype.cancel = function() {
  if (!debug.cancellation()) return this._warn("cancellation is disabled");
  
  var promise = this;
  var child = promise;
  while (promise._isCancellable()) {
      if (!promise._cancelBy(child)) {
          if (child._isFollowing()) {
              child._followee().cancel();
          } else {
              child._cancelBranched();
          }
          break;
  ...

function bluebird.bluebird.prototype._isCancelled ()

• description and source-code

  _isCancelled = function () {
      return this._target().__isCancelled();
  }

• example usage

  ...
  };
  
  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) {
  ...

function bluebird.bluebird.prototype._isDisposable ()

• description and source-code

  _isDisposable = function () {
      return (this._bitField & 131072) > 0;
  }

• example usage

  ...
  }
  
  function castPreservingDisposable(thenable) {
      var maybePromise = tryConvertToPromise(thenable);
      if (maybePromise !== thenable &&
          typeof thenable._isDisposable === "function" &&
          typeof thenable._getDisposer === "function" &&
          thenable._isDisposable()) {
          maybePromise._setDisposable(thenable._getDisposer());
      }
      return maybePromise;
  }
  function dispose(resources, inspection) {
      var i = 0;
      var len = resources.length;
  ...

function bluebird.bluebird.prototype._isFateSealed ()

• description and source-code

  _isFateSealed = function () {
      return (this._bitField & 117506048) !== 0;
  }

• example usage

  ...
              ret._cancel();
          }
      } else {
          callbacks[i].call(ret, maybePromise, holder);
      }
  }
  
  if (!ret._isFateSealed()) {
      if (holder.asyncNeeded) {
          var domain = getDomain();
          if (domain !== null) {
              holder.fn = util.domainBind(domain, holder.fn);
          }
      }
      ret._setAsyncGuaranteed();
  ...

function bluebird.bluebird.prototype._isFinal ()

• description and source-code

  _isFinal = function () {
      return (this._bitField & 4194304) > 0;
  }

• example usage

  ...
  
  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();
  ...

function bluebird.bluebird.prototype._isFollowing ()

• description and source-code

  _isFollowing = function () {
      return (this._bitField & 67108864) === 67108864;
  }

• example usage

  ...
  Promise.prototype["break"] = Promise.prototype.cancel = function() {
  if (!debug.cancellation()) return this._warn("cancellation is disabled");
  
  var promise = this;
  var child = promise;
  while (promise._isCancellable()) {
      if (!promise._cancelBy(child)) {
          if (child._isFollowing()) {
              child._followee().cancel();
          } else {
              child._cancelBranched();
          }
          break;
      }
  ...

function bluebird.bluebird.prototype._isRejectionUnhandled ()

• description and source-code

  _isRejectionUnhandled = function () {
      return (this._bitField & 1048576) > 0;
  }

• example usage

  ...
  };
  
  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);
      }
  };
  ...

function bluebird.bluebird.prototype._isUnhandledRejectionNotified ()

• description and source-code

  _isUnhandledRejectionNotified = function () {
      return (this._bitField & 262144) > 0;
  }

• example usage

  ...
  
  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;
  ...

function bluebird.bluebird.prototype._length ()

• description and source-code

  _length = function () {
      return this._bitField & 65535;
  }

• example usage

  ...
  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() {
  ...

function bluebird.bluebird.prototype._migrateCallback0 (follower)

• description and source-code

  _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);
  }

• example usage

  ...
      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(promise);
  } else if (((bitField & 33554432) !== 0)) {
  ...

function bluebird.bluebird.prototype._migrateCallbackAt (follower, index)

• description and source-code

  _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);
  }

• example usage

  ...
  }
  
  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(promise);
  } else if (((bitField & 33554432) !== 0)) {
      this._fulfill(promise._value());
  } else if (((bitField & 16777216) !== 0)) {
  ...

function bluebird.bluebird.prototype._notifyUnhandledRejection ()

• description and source-code

  _notifyUnhandledRejection = function () {
      if (this._isRejectionUnhandled()) {
          var reason = this._settledValue();
          this._setUnhandledRejectionIsNotified();
          fireRejectionEvent("unhandledRejection",
                                        possiblyUnhandledRejection, reason, this);
      }
  }

• example usage

  ...
  };
  
  Promise.prototype._ensurePossibleRejectionHandled = function () {
      if ((this._bitField & 524288) !== 0) return;
      this._setRejectionIsUnhandled();
      var self = this;
      setTimeout(function() {
          self._notifyUnhandledRejection();
      }, 1);
  };
  
  Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
      fireRejectionEvent("rejectionHandled",
                                    unhandledRejectionHandled, undefined, this);
  };
  ...

function bluebird.bluebird.prototype._notifyUnhandledRejectionIsHandled ()

• description and source-code

  _notifyUnhandledRejectionIsHandled = function () {
      fireRejectionEvent("rejectionHandled",
                                    unhandledRejectionHandled, undefined, this);
  }

• example usage

  ...
      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;
  };
  ...

function bluebird.bluebird.prototype._onCancel ()

• description and source-code

  _onCancel = function () {}

• example usage

  ...
      } 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);
  ...

function bluebird.bluebird.prototype._passThrough (handler, type, success, fail)

• description and source-code

  _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);
  }

• example usage

  ...
                        undefined,
                        new PassThroughHandlerContext(this, type, handler),
                        undefined);
  };
  
  Promise.prototype.lastly =
  Promise.prototype["finally"] = function (handler) {
      return this._passThrough(handler,
                               0,
                               finallyHandler,
                               finallyHandler);
  };
  
  
  Promise.prototype.tap = function (handler) {
  ...

function bluebird.bluebird.prototype._peekContext ()

• description and source-code

  function peekContext() {
      var lastIndex = contextStack.length - 1;
      if (lastIndex >= 0) {
          return contextStack[lastIndex];
      }
      return undefined;
  }

• example usage

  ...
          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){
  ...

function bluebird.bluebird.prototype._popContext ()

• description and source-code

  _popContext = function () {
      if (this._trace !== undefined) {
          var trace = contextStack.pop();
          var ret = trace._promiseCreated;
          trace._promiseCreated = null;
          return ret;
      }
      return null;
  }

• example usage

  ...
      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\
  ...

function bluebird.bluebird.prototype._promiseAt (index)

• description and source-code

  _promiseAt = function (index) {
      return this[
              index * 4 - 4 + 2];
  }

• example usage

  ...
  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,
  ...

function bluebird.bluebird.prototype._promiseCreated ()

• description and source-code

  _promiseCreated = function () {
      var ctx = this._peekContext();
      if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
  }

• example usage

  ...
      }
      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]";
  };
  ...

function bluebird.bluebird.prototype._propagateFrom (parent, flags)

• description and source-code

  _propagateFrom = function (parent, flags) {
      ;
      ;
  }

• example usage

  ...
  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,
  ...

function bluebird.bluebird.prototype._proxy (proxyable, arg)

• description and source-code

  _proxy = function (proxyable, arg) {
      this._addCallbacks(undefined, undefined, arg, proxyable, null);
  }

• example usage

  ...
  
  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);
  ...

function bluebird.bluebird.prototype._pushContext ()

• description and source-code

  _pushContext = function () {
      if (this._trace !== undefined) {
          this._trace._promiseCreated = null;
          contextStack.push(this._trace);
      }
  }

• example usage

  ...
      [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\
  ...

function bluebird.bluebird.prototype._reason ()

• description and source-code

  _reason = function () {
      this._unsetRejectionIsUnhandled();
      return this._settledValue();
  }

• example usage

  ...
                                 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);
      }
  }
  ...

function bluebird.bluebird.prototype._receiverAt (index)

• description and source-code

  _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;
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird.prototype._reject (reason)

• description and source-code

  _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();
      }
  }

• example usage

  ...
  module.exports.firstLineError = firstLineError;
  
  },{"./queue":17,"./schedule":18,"./util":21}],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);
  };
  ...

function bluebird.bluebird.prototype._rejectCallback (reason, synchronous, ignoreNonErrorWarnings)

• description and source-code

  _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);
  }

• example usage

  ...
  }                                                                \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\
  ...

function bluebird.bluebird.prototype._rejectPromises (len, reason)

• description and source-code

  _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);
      }
  }

• example usage

  ...
  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);
  }
  ...

function bluebird.bluebird.prototype._rejectionHandlerAt (index)

• description and source-code

  _rejectionHandlerAt = function (index) {
      return this[
              index * 4 - 4 + 1];
  }

• example usage

  ...
      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 (
  ...

function bluebird.bluebird.prototype._resolveCallback (value, shouldBind)

• description and source-code

  _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(promise);
      } 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);
      }
  }

• example usage

  ...
  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);
  };
  ...

function bluebird.bluebird.prototype._resolveFromExecutor (executor)

• description and source-code

  _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);
      }
  }

• example usage

  ...
          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]";
  };
  ...

function bluebird.bluebird.prototype._resolveFromSyncValue (value)

• description and source-code

  _resolveFromSyncValue = function (value) {
      if (value === util.errorObj) {
          this._rejectCallback(value.e, false);
      } else {
          this._resolveCallback(value, true);
      }
  }

• example usage

  ...
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value = tryCatch(fn).apply(this, arguments);
      var promiseCreated = ret._popContext();
      debug.checkForgottenReturns(
          value, promiseCreated, "Promise.method", ret);
      ret._resolveFromSyncValue(value);
      return ret;
  };
  };
  
  Promise.attempt = Promise["try"] = function (fn) {
  if (typeof fn !== "function") {
      return apiRejection("expecting a function but got " + util.classString(fn));
  ...

function bluebird.bluebird.prototype._resultCancelled ()

• description and source-code

  _resultCancelled = function () {
      this.cancel();
  }

• example usage

  ...
              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();
  ...

function bluebird.bluebird.prototype._returnedNonUndefined ()

• description and source-code

  _returnedNonUndefined = function () {
      return (this._bitField & 268435456) !== 0;
  }

• example usage

  ...
      }
  }
  
  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");
  ...

function bluebird.bluebird.prototype._setAsyncGuaranteed ()

• description and source-code

  _setAsyncGuaranteed = function () {
      if (async.hasCustomScheduler()) return;
      this._bitField = this._bitField | 134217728;
  }

• example usage

  ...
              if (!ret._isFateSealed()) {
                  if (holder.asyncNeeded) {
                      var domain = getDomain();
                      if (domain !== null) {
                          holder.fn = util.domainBind(domain, holder.fn);
                      }
                  }
                  ret._setAsyncGuaranteed();
                  ret._setOnCancel(holder);
              }
              return ret;
          }
      }
  }
  var args = [].slice.call(arguments);;
  ...

function bluebird.bluebird.prototype._setBoundTo (obj)

• description and source-code

  _setBoundTo = function (obj) {
      if (obj !== undefined) {
          this._bitField = this._bitField | 2097152;
          this._boundTo = obj;
      } else {
          this._bitField = this._bitField & (~2097152);
      }
  }

• example usage

  ...
      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
      };
  ...

function bluebird.bluebird.prototype._setCancelled ()

• description and source-code

  _setCancelled = function () {
      this._bitField = this._bitField | 65536;
      this._fireEvent("promiseCancelled", this);
  }

• example usage

  ...
      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();
  };
  ...

function bluebird.bluebird.prototype._setDisposable (disposer)

• description and source-code

  _setDisposable = function (disposer) {
      this._bitField = this._bitField | 131072;
      this._disposer = disposer;
  }

• example usage

  ...
  
  function castPreservingDisposable(thenable) {
      var maybePromise = tryConvertToPromise(thenable);
      if (maybePromise !== thenable &&
          typeof thenable._isDisposable === "function" &&
          typeof thenable._getDisposer === "function" &&
          thenable._isDisposable()) {
          maybePromise._setDisposable(thenable._getDisposer());
      }
      return maybePromise;
  }
  function dispose(resources, inspection) {
      var i = 0;
      var len = resources.length;
      var ret = new Promise(INTERNAL);
  ...

function bluebird.bluebird.prototype._setFollowee (promise)

• description and source-code

  _setFollowee = function (promise) {
      this._rejectionHandler0 = promise;
  }

• example usage

  ...
      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(promise);
  } 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);
  ...

function bluebird.bluebird.prototype._setFollowing ()

• description and source-code

  _setFollowing = function () {
      this._bitField = this._bitField | 67108864;
      this._fireEvent("promiseResolved", this);
  }

• example usage

  ...
  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(promise);
  } else if (((bitField & 33554432) !== 0)) {
      this._fulfill(promise._value());
  } else if (((bitField & 16777216) !== 0)) {
      this._reject(promise._reason());
  } else {
  ...

function bluebird.bluebird.prototype._setFulfilled ()

• description and source-code

  _setFulfilled = function () {
      this._bitField = this._bitField | 33554432;
      this._fireEvent("promiseFulfilled", this);
  }

• example usage

  ...
  };
  
  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;
  ...

function bluebird.bluebird.prototype._setIsFinal ()

• description and source-code

  _setIsFinal = function () {
      this._bitField = this._bitField | 4194304;
  }

• example usage

  ...
  }
  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);
  ...

function bluebird.bluebird.prototype._setLength (len)

• description and source-code

  _setLength = function (len) {
      this._bitField = (this._bitField & -65536) |
          (len & 65535);
  }

• example usage

  ...
  receiver,
  domain
  ) {
  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 =
  ...

function bluebird.bluebird.prototype._setOnCancel (handler)

• description and source-code

  _setOnCancel = function (handler) { ; }

• example usage

  ...
              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) {
  ...

function bluebird.bluebird.prototype._setRejected ()

• description and source-code

  _setRejected = function () {
      this._bitField = this._bitField | 16777216;
      this._fireEvent("promiseRejected", this);
  }

• example usage

  ...
      }
  }
  };
  
  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) {
  ...

function bluebird.bluebird.prototype._setRejectionIsUnhandled ()

• description and source-code

  _setRejectionIsUnhandled = function () {
      this._bitField = this._bitField | 1048576;
  }

• example usage

  ...
      var target = this._target();
      target._bitField = ((target._bitField & (~1048576)) |
                        524288);
  };
  
  Promise.prototype._ensurePossibleRejectionHandled = function () {
      if ((this._bitField & 524288) !== 0) return;
      this._setRejectionIsUnhandled();
      var self = this;
      setTimeout(function() {
          self._notifyUnhandledRejection();
      }, 1);
  };
  
  Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
  ...

function bluebird.bluebird.prototype._setReturnedNonUndefined ()

• description and source-code

  _setReturnedNonUndefined = function () {
      this._bitField = this._bitField | 268435456;
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird.prototype._setUnhandledRejectionIsNotified ()

• description and source-code

  _setUnhandledRejectionIsNotified = function () {
      this._bitField = this._bitField | 262144;
  }

• example usage

  ...
  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;
  ...

function bluebird.bluebird.prototype._setWillBeCancelled ()

• description and source-code

  _setWillBeCancelled = function () {
      this._bitField = this._bitField | 8388608;
  }

• example usage

  ...
                  promise._followee().cancel();
              } else {
                  promise._cancelBranched();
              }
              break;
          } else {
              if (promise._isFollowing()) promise._followee().cancel();
              promise._setWillBeCancelled();
              child = promise;
              promise = parent;
          }
      }
  };
  
  Promise.prototype._branchHasCancelled = function() {
  ...

function bluebird.bluebird.prototype._settlePromise (promise, handler, receiver, value)

• description and source-code

  _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);
          }
      }
  }

• example usage

  ...
      }
  } 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;
  ...

function bluebird.bluebird.prototype._settlePromise0 (handler, value, bitField)

• description and source-code

  _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);
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird.prototype._settlePromiseCtx (ctx)

• description and source-code

  _settlePromiseCtx = function (ctx) {
      this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
  }

• example usage

  n/a

function bluebird.bluebird.prototype._settlePromiseFromHandler ( handler, receiver, value, promise )

• description and source-code

  _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);
      }
  }

• example usage

  ...
          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);
  ...

function bluebird.bluebird.prototype._settlePromiseLateCancellationObserver (ctx)

• description and source-code

  _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);
      }
  }

• example usage

  n/a

function bluebird.bluebird.prototype._settlePromises ()

• description and source-code

  _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();
  }

• example usage

  ...
  };
  
  Async.prototype.settlePromises = function(promise) {
      if (this._trampolineEnabled) {
          AsyncSettlePromises.call(this, promise);
      } else {
          this._schedule(function() {
              promise._settlePromises();
          });
      }
  };
  }
  
  Async.prototype._drainQueue = function(queue) {
  while (queue.length() > 0) {
  ...

function bluebird.bluebird.prototype._settledValue ()

• description and source-code

  _settledValue = function () {
      var bitField = this._bitField;
      if (((bitField & 33554432) !== 0)) {
          return this._rejectionHandler0;
      } else if (((bitField & 16777216) !== 0)) {
          return this._fulfillmentHandler0;
      }
  }

• example usage

  ...
  
  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 () {
  ...

function bluebird.bluebird.prototype._target ()

• description and source-code

  _target = function () {
      var ret = this;
      while (ret._isFollowing()) ret = ret._followee();
      return ret;
  }

• example usage

  ...
      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
  ...

function bluebird.bluebird.prototype._then ( didFulfill, didReject, _, receiver, internalData )

• description and source-code

  _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 domain = getDomain();
      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: domain === null ? handler
                  : (typeof handler === "function" &&
                      util.domainBind(domain, handler)),
              promise: promise,
              receiver: receiver,
              value: value
          });
      } else {
          target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
      }
  
      return promise;
  }

• example usage

  ...
  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);
      }
  };
  ...

function bluebird.bluebird.prototype._unsetCancelled ()

• description and source-code

  _unsetCancelled = function () {
      this._bitField = this._bitField & (~65536);
  }

• example usage

  n/a

function bluebird.bluebird.prototype._unsetDisposable ()

• description and source-code

  _unsetDisposable = function () {
      this._bitField = this._bitField & (~131072);
      this._disposer = undefined;
  }

• example usage

  ...
  Disposer.prototype.tryDispose = function(inspection) {
      var resource = this.resource();
      var context = this._context;
      if (context !== undefined) context._pushContext();
      var ret = resource !== NULL
          ? this.doDispose(resource, inspection) : null;
      if (context !== undefined) context._popContext();
      this._promise._unsetDisposable();
      this._data = null;
      return ret;
  };
  
  Disposer.isDisposer = function (d) {
      return (d != null &&
              typeof d.resource === "function" &&
  ...

function bluebird.bluebird.prototype._unsetOnCancel ()

• description and source-code

  _unsetOnCancel = function () {
      this._onCancelField = undefined;
  }

• example usage

  ...
          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();
  ...

function bluebird.bluebird.prototype._unsetRejectionIsUnhandled ()

• description and source-code

  _unsetRejectionIsUnhandled = function () {
      this._bitField = this._bitField & (~1048576);
      if (this._isUnhandledRejectionNotified()) {
          this._unsetUnhandledRejectionIsNotified();
          this._notifyUnhandledRejectionIsHandled();
      }
  }

• example usage

  ...
  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;
  }
  ...

function bluebird.bluebird.prototype._unsetUnhandledRejectionIsNotified ()

• description and source-code

  _unsetUnhandledRejectionIsNotified = function () {
      this._bitField = this._bitField & (~262144);
  }

• example usage

  ...
  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;
  };
  ...

function bluebird.bluebird.prototype._value ()

• description and source-code

  _value = function () {
      return this._settledValue();
  }

• example usage

  ...
      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);
  ...

function bluebird.bluebird.prototype._warn (message, shouldUseOwnTrace, promise)

• description and source-code

  _warn = function (message, shouldUseOwnTrace, promise) {
      return warn(message, shouldUseOwnTrace, promise || this);
  }

• example usage

  ...
  module.exports = function(Promise, PromiseArray, apiRejection, debug) {
  var util = _dereq_("./util");
  var tryCatch = util.tryCatch;
  var errorObj = util.errorObj;
  var async = Promise._async;
  
  Promise.prototype["break"] = Promise.prototype.cancel = function() {
  if (!debug.cancellation()) return this._warn("cancellation is disabled");
  
  var promise = this;
  var child = promise;
  while (promise._isCancellable()) {
      if (!promise._cancelBy(child)) {
          if (child._isFollowing()) {
              child._followee().cancel();
  ...

function bluebird.bluebird.prototype.all ()

• description and source-code

  all = function () {
      if (arguments.length > 0) {
          this._warn(".all() was passed arguments but it does not take any");
      }
      return new PromiseArray(this).promise();
  }

• example usage

  ...
  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,
  ...

function bluebird.bluebird.prototype.any ()

• description and source-code

  any = function () {
      return any(this);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.asCallback (nodeback, options)

• description and source-code

  asCallback = function (nodeback, options) {
      if (typeof nodeback == "function") {
          var adapter = successAdapter;
          if (options !== undefined && Object(options).spread) {
              adapter = spreadAdapter;
          }
          this._then(
              adapter,
              errorAdapter,
              undefined,
              this,
              nodeback
          );
      }
      return this;
  }

• example usage

  n/a

function bluebird.bluebird.prototype.bind (thisArg)

• description and source-code

  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;
  }

• example usage

  ...
  };
  
  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 bluebird.bluebird.prototype.break ()

• description and source-code

  break = 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;
          }
      }
  }

• example usage

  n/a

function bluebird.bluebird.prototype.call (methodName)

• description and source-code

  call = function (methodName) {
      var args = [].slice.call(arguments, 1);;
      if (!true) {
          if (canEvaluate) {
              var maybeCaller = getMethodCaller(methodName);
              if (maybeCaller !== null) {
                  return this._then(
                      maybeCaller, undefined, undefined, args, undefined);
              }
          }
      }
      args.push(methodName);
      return this._then(caller, undefined, undefined, args, undefined);
  }

• example usage

  ...
   *
   */
  /**
   * bluebird build version 3.5.1
   * Features enabled: core
   * Features disabled: race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any
  , each
  */
  !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("
  ;function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined
  "!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module
  ,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_
  ;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");
  throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports
  ,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof _dereq_=="function"
  ;&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
  "use strict";
  var firstLineError;
  try {throw new Error(); } catch (e) {firstLineError = e;}
  var schedule = _dereq_("./schedule");
  var Queue = _dereq_("./queue");
  var util = _dereq_("./util");
  ...

function bluebird.bluebird.prototype.cancel ()

• description and source-code

  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;
          }
      }
  }

• example usage

  ...
      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;
  ...

function bluebird.bluebird.prototype.catch (fn)

• description and source-code

  catch = function (fn) {
      var len = arguments.length;
      if (len > 1) {
          var catchInstances = new Array(len - 1),
              j = 0, i;
          for (i = 0; i < len - 1; ++i) {
              var item = arguments[i];
              if (util.isObject(item)) {
                  catchInstances[j++] = item;
              } else {
                  return apiRejection("Catch statement predicate: " +
                      "expecting an object but got " + util.classString(item));
              }
          }
          catchInstances.length = j;
          fn = arguments[i];
          return this.then(undefined, catchFilter(catchInstances, fn, this));
      }
      return this.then(undefined, fn);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.catchReturn (value)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.bluebird.prototype.catchThrow (reason)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.bluebird.prototype.caught (fn)

• description and source-code

  caught = 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];
          return this.then(undefined, catchFilter(catchInstances, fn, this));
      }
      return this.then(undefined, fn);
  }

• example usage

  ...
  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(
  ...

function bluebird.bluebird.prototype.delay (ms)

• description and source-code

  delay = function (ms) {
      return delay(ms, this);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.disposer (fn)

• description and source-code

  disposer = function (fn) {
      if (typeof fn === "function") {
          return new FunctionDisposer(fn, this, createContext());
      }
      throw new TypeError();
  }

• example usage

  n/a

function bluebird.bluebird.prototype.done (didFulfill, didReject)

• description and source-code

  done = function (didFulfill, didReject) {
      var promise =
          this._then(didFulfill, didReject, undefined, undefined, undefined);
      promise._setIsFinal();
  }

• example usage

  n/a

function bluebird.bluebird.prototype.each (fn)

• description and source-code

  each = function (fn) {
      return PromiseReduce(this, fn, INTERNAL, 0)
                ._then(promiseAllThis, undefined, undefined, this, undefined);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.error (fn)

• description and source-code

  error = function (fn) {
      return this.caught(util.originatesFromRejection, fn);
  }

• example usage

  ...
  }
  
  var resultPromise = Promise.all(reflectedResources)
      .then(function(inspections) {
          for (var i = 0; i < inspections.length; ++i) {
              var inspection = inspections[i];
              if (inspection.isRejected()) {
                  errorObj.e = inspection.error();
                  return errorObj;
              } else if (!inspection.isFulfilled()) {
                  resultPromise.cancel();
                  return;
              }
              inspections[i] = inspection.value();
          }
  ...

function bluebird.bluebird.prototype.filter (fn, options)

• description and source-code

  filter = function (fn, options) {
      return PromiseMap(this, fn, options, INTERNAL);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.finally (handler)

• description and source-code

  finally = function (handler) {
      return this._passThrough(handler,
                               0,
                               finallyHandler,
                               finallyHandler);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.get (propertyName)

• description and source-code

  get = function (propertyName) {
      var isIndex = (typeof propertyName === "number");
      var getter;
      if (!isIndex) {
          if (canEvaluate) {
              var maybeGetter = getGetter(propertyName);
              getter = maybeGetter !== null ? maybeGetter : namedGetter;
          } else {
              getter = namedGetter;
          }
      } else {
          getter = indexedGetter;
      }
      return this._then(getter, undefined, undefined, propertyName, undefined);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.isCancellable ()

• description and source-code

  isCancellable = function () {
      return this.isPending() && !this.isCancelled();
  }

• example usage

  n/a

function bluebird.bluebird.prototype.isCancelled ()

• description and source-code

  isCancelled = function () {
      return (this._target()._bitField & 8454144) !== 0;
  }

• example usage

  ...
  };
  
  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);
      }
  ...

function bluebird.bluebird.prototype.isFulfilled ()

• description and source-code

  isFulfilled = function () {
      return isFulfilled.call(this._target());
  }

• example usage

  ...
  }
  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 bluebird.bluebird.prototype.isPending ()

• description and source-code

  isPending = function () {
      return isPending.call(this._target());
  }

• example usage

  ...
  };
  
  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) {
  ...

function bluebird.bluebird.prototype.isRejected ()

• description and source-code

  isRejected = function () {
      return isRejected.call(this._target());
  }

• example usage

  ...
              }
              return maybePromise._then(
                  succeed, fail, undefined, this, undefined);
          }
      }
  }
  
  if (promise.isRejected()) {
      checkCancel(this);
      errorObj.e = reasonOrValue;
      return errorObj;
  } else {
      checkCancel(this);
      return reasonOrValue;
  }
  ...

function bluebird.bluebird.prototype.isResolved ()

• description and source-code

  isResolved = function () {
      return isResolved.call(this._target());
  }

• example usage

  n/a

function bluebird.bluebird.prototype.lastly (handler)

• description and source-code

  lastly = function (handler) {
      return this._passThrough(handler,
                               0,
                               finallyHandler,
                               finallyHandler);
  }

• example usage

  ...
  return null;
  }
  
  function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
  if (debug.cancellation()) {
      var internal = new Promise(INTERNAL);
      var _finallyPromise = this._finallyPromise = new Promise(INTERNAL);
      this._promise = internal.lastly(function() {
          return _finallyPromise;
      });
      internal._captureStackTrace();
      internal._setOnCancel(this);
  } else {
      var promise = this._promise = new Promise(INTERNAL);
      promise._captureStackTrace();
  ...

function bluebird.bluebird.prototype.map (fn, options)

• description and source-code

  map = function (fn, options) {
      return map(this, fn, options, null);
  }

• example usage

  ...
  
      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");
  ...

function bluebird.bluebird.prototype.mapSeries (fn)

• description and source-code

  mapSeries = function (fn) {
      return PromiseReduce(this, fn, INTERNAL, INTERNAL);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.nodeify (nodeback, options)

• description and source-code

  nodeify = function (nodeback, options) {
      if (typeof nodeback == "function") {
          var adapter = successAdapter;
          if (options !== undefined && Object(options).spread) {
              adapter = spreadAdapter;
          }
          this._then(
              adapter,
              errorAdapter,
              undefined,
              this,
              nodeback
          );
      }
      return this;
  }

• example usage

  n/a

function bluebird.bluebird.prototype.props ()

• description and source-code

  props = function () {
      return props(this);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.race ()

• description and source-code

  race = function () {
      return race(this, undefined);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.reason ()

• description and source-code

  reason = function () {
      var target = this._target();
      target._unsetRejectionIsUnhandled();
      return reason.call(target);
  }

• example usage

  ...
      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) {
  ...

function bluebird.bluebird.prototype.reduce (fn, initialValue)

• description and source-code

  reduce = function (fn, initialValue) {
      return reduce(this, fn, initialValue, null);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.reflect ()

• description and source-code

  reflect = function () {
      return this._then(reflectHandler,
          reflectHandler, undefined, this, undefined);
  }

• example usage

  ...
      var ret = new PromiseInspection();
      ret._bitField = 16777216;
      ret._settledValueField = reason;
      return this._promiseResolved(index, ret);
  };
  
  Promise.settle = function (promises) {
      debug.deprecated(".settle()", ".reflect()");
      return new SettledPromiseArray(promises).promise();
  };
  
  Promise.prototype.settle = function () {
      return Promise.settle(this);
  };
  };
  ...

function bluebird.bluebird.prototype.return (value)

• description and source-code

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

• example usage

  ...
  PromiseSpawn.prototype._promiseCancelled = function() {
  if (this._isResolved()) return;
  var implementsReturn = typeof this._generator["return"] !== "undefined";
  
  var result;
  if (!implementsReturn) {
      var reason = new Promise.CancellationError(
          "generator .return() sentinel");
      Promise.coroutine.returnSentinel = reason;
      this._promise._attachExtraTrace(reason);
      this._promise._pushContext();
      result = tryCatch(this._generator["throw"]).call(this._generator,
                                                       reason);
      this._promise._popContext();
  } else {
  ...

function bluebird.bluebird.prototype.settle ()

• description and source-code

  settle = function () {
      return Promise.settle(this);
  }

• example usage

  ...
      var ret = new PromiseInspection();
      ret._bitField = 16777216;
      ret._settledValueField = reason;
      return this._promiseResolved(index, ret);
  };
  
  Promise.settle = function (promises) {
      debug.deprecated(".settle()", ".reflect()");
      return new SettledPromiseArray(promises).promise();
  };
  
  Promise.prototype.settle = function () {
      return Promise.settle(this);
  };
  };
  ...

function bluebird.bluebird.prototype.some (howMany)

• description and source-code

  some = function (howMany) {
      return some(this, howMany);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.spread (fn)

• description and source-code

  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);
  }

• example usage

  ...
                  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 bluebird.bluebird.prototype.suppressUnhandledRejections ()

• description and source-code

  suppressUnhandledRejections = function () {
      var target = this._target();
      target._bitField = ((target._bitField & (~1048576)) |
                        524288);
  }

• example usage

  ...
  }
  function thrower() {
  throw this.reason;
  }
  
  Promise.prototype["return"] =
  Promise.prototype.thenReturn = function (value) {
  if (value instanceof Promise) value.suppressUnhandledRejections();
  return this._then(
      returner, undefined, undefined, {value: value}, undefined);
  };
  
  Promise.prototype["throw"] =
  Promise.prototype.thenThrow = function (reason) {
  return this._then(
  ...

function bluebird.bluebird.prototype.tap (handler)

• description and source-code

  tap = function (handler) {
      return this._passThrough(handler, 1, finallyHandler);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.tapCatch (handlerOrPredicate)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.bluebird.prototype.then (didFulfill, didReject)

• description and source-code

  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);
  }

• example usage

  ...
      } 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);
  };
  ...

function bluebird.bluebird.prototype.thenReturn (value)

• description and source-code

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

• example usage

  ...
  this.handle = handle;
  }
  
  HandleWrapper.prototype._resultCancelled = function() {
  clearTimeout(this.handle);
  };
  
  var afterValue = function(value) { return delay(+this).thenReturn(value); };
  var delay = Promise.delay = function (ms, value) {
  var ret;
  var handle;
  if (value !== undefined) {
      ret = Promise.resolve(value)
              ._then(afterValue, null, null, ms, undefined);
      if (debug.cancellation() && value instanceof Promise) {
  ...

function bluebird.bluebird.prototype.thenThrow (reason)

• description and source-code

  thenThrow = function (reason) {
      return this._then(
          thrower, undefined, undefined, {reason: reason}, undefined);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.throw (reason)

• description and source-code

  throw = function (reason) {
      return this._then(
          thrower, undefined, undefined, {reason: reason}, undefined);
  }

• example usage

  n/a

function bluebird.bluebird.prototype.timeout (ms, message)

• description and source-code

  timeout = function (ms, message) {
      ms = +ms;
      var ret, parent;
  
      var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() {
          if (ret.isPending()) {
              afterTimeout(ret, message, parent);
          }
      }, ms));
  
      if (debug.cancellation()) {
          parent = this.then();
          ret = parent._then(successClear, failureClear,
                              undefined, handleWrapper, undefined);
          ret._setOnCancel(handleWrapper);
      } else {
          ret = this._then(successClear, failureClear,
                              undefined, handleWrapper, undefined);
      }
  
      return ret;
  }

• example usage

  n/a

function bluebird.bluebird.prototype.toJSON ()

• description and source-code

  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;
  }

• example usage

  n/a

function bluebird.bluebird.prototype.toString ()

• description and source-code

  toString = function () {
      return "[object Promise]";
  }

• example usage

  ...
  
  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 bluebird.bluebird.prototype.value ()

• description and source-code

  value = function () {
      return value.call(this._target());
  }

• example usage

  ...
  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;
  }
  ...

module bluebird.bluebird_core

function bluebird.bluebird_core (executor)

• description and source-code

  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);
  }

• example usage

  n/a

function bluebird.bluebird_core.AggregateError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.bluebird_core.CancellationError (message)

• description and source-code

  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);
      }
  }

• example usage

  ...
  
  PromiseSpawn.prototype._promiseCancelled = function() {
  if (this._isResolved()) return;
  var implementsReturn = typeof this._generator["return"] !== "undefined";
  
  var result;
  if (!implementsReturn) {
      var reason = new Promise.CancellationError(
          "generator .return() sentinel");
      Promise.coroutine.returnSentinel = reason;
      this._promise._attachExtraTrace(reason);
      this._promise._pushContext();
      result = tryCatch(this._generator["throw"]).call(this._generator,
                                                       reason);
      this._promise._popContext();
  ...

function bluebird.bluebird_core.OperationalError (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.bluebird_core.Promise (executor)

• description and source-code

  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);
  }

• example usage

  n/a

function bluebird.bluebird_core.PromiseInspection (promise)

• description and source-code

  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;
      }
  }

• example usage

  ...
  },{"./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");
  ...

function bluebird.bluebird_core.RangeError ()

• description and source-code

  function RangeError() { [native code] }

• example usage

  n/a

function bluebird.bluebird_core.RejectionError (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.bluebird_core.TimeoutError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.bluebird_core.TypeError ()

• description and source-code

  function TypeError() { [native code] }

• example usage

  ...
  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();
  ...

function bluebird.bluebird_core._peekContext ()

• description and source-code

  function peekContext() {
      var lastIndex = contextStack.length - 1;
      if (lastIndex >= 0) {
          return contextStack[lastIndex];
      }
      return undefined;
  }

• example usage

  ...
          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){
  ...

function bluebird.bluebird_core.all (promises)

• description and source-code

  all = function (promises) {
      return new PromiseArray(promises).promise();
  }

• example usage

  ...
  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,
  ...

function bluebird.bluebird_core.attempt (fn)

• description and source-code

  attempt = 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;
  }

• example usage

  n/a

function bluebird.bluebird_core.bind (thisArg, value)

• description and source-code

  bind = function (thisArg, value) {
      return Promise.resolve(value).bind(thisArg);
  }

• example usage

  ...
  };
  
  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 bluebird.bluebird_core.cast (obj)

• description and source-code

  cast = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  ...
      for (var i = 0, len = promises.length; i < len; ++i) {
          var val = promises[i];
  
          if (val === undefined && !(i in promises)) {
              continue;
          }
  
          Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
      }
      return ret;
  }
  
  Promise.race = function (promises) {
      return race(promises, undefined);
  };
  ...

function bluebird.bluebird_core.config (opts)

• description and source-code

  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;
          }
      }
      return Promise;
  }

• example usage

  n/a

function bluebird.bluebird_core.defer ()

• description and source-code

  defer = function () {
      debug.deprecated("Promise.defer", "new Promise");
      var promise = new Promise(INTERNAL);
      return {
          promise: promise,
          resolve: deferResolve,
          reject: deferReject
      };
  }

• example usage

  n/a

function bluebird.bluebird_core.fromCallback (fn)

• description and source-code

  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;
  }

• example usage

  n/a

function bluebird.bluebird_core.fromNode (fn)

• description and source-code

  fromNode = 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;
  }

• example usage

  n/a

function bluebird.bluebird_core.fulfilled (obj)

• description and source-code

  fulfilled = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  n/a

function bluebird.bluebird_core.getNewLibraryCopy ()

• description and source-code

  getNewLibraryCopy = 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");
  
  var getDomain;
  if (util.isNode) {
      getDomain = function() {
          var ret = process.domain;
          if (ret === undefined) ret = null;
          return ret;
      };
  } else {
      getDomain = function() {
          return null;
      };
  }
  util.notEnumerableProp(Promise, "_getDomain", getDomain);
  
  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);
  var CapturedTrace = debug.CapturedTrace;
  var PassThroughHandlerContext =
      _dereq_("./finally")(Promise, tryConvertToPromise, NEXT_FILTER);
  var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
  var nodebackForPromise = _dereq_("./nodeback");
  var errorObj = util.errorObj;
  var tryCatch = util.tryCatch;
  function check(self, executor) {
      if (self == null || self.constructor !== Promise) {
          throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
      if (typeof executor !== "function") {
          throw new TypeError("expecting a function but got " + util.classString(executor));
      }
  
  }
  
  function Promise(executor) {
      if (executor !== INTERNAL) {
          check(this, executor);
      }
      this._bitField = 0;
      this._fulfillmentHandler0 = undefined;
      this._rejectionHandler0 = undefined;
      this._promise0 = undefined;
      this._receiver0 = undefined;
      this._resolveFromExecutor(executor);
      this._promiseCreated();
      this._fireEvent("promiseCreated", this);
  }
  
  Promise.prototype.toString = function () {
      return "[object Promise]";
  };
  
  Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
      var len = arguments.length;
      if (len > 1) {
          var catchInstances = new Array(len - 1),
              j = 0, i;
          for (i = 0; i < len - 1; ++i) {
              var item = arguments[i];
              if (util.isObject(item)) {
                  catchInstances[j++] = item;
              } else {
                  return apiRejection("Catch statement predicate: " +
                      "expecting an object but got " + util.classString(item));
              }
          }
          catchInstances.length = j;
          fn = arguments[i];
          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.warning...

• example usage

  n/a

function bluebird.bluebird_core.hasLongStackTraces ()

• description and source-code

  hasLongStackTraces = function () {
      return config.longStackTraces && longStackTracesIsSupported();
  }

• example usage

  ...
  };
  
  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;
  ...

function bluebird.bluebird_core.is (val)

• description and source-code

  is = function (val) {
      return val instanceof Promise;
  }

• example usage

  n/a

function bluebird.bluebird_core.join ()

• description and source-code

  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 domain = getDomain();
                          if (domain !== null) {
                              holder.fn = util.domainBind(domain, 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;
  }

• example usage

  ...
              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 checkForgottenReturns(returnValue, promiseCreated, name, promise,
  parent) {
  ...

function bluebird.bluebird_core.longStackTraces ()

• description and source-code

  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;
          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;
              Context.deactivateLongStackTraces();
              async.enableTrampoline();
              config.longStackTraces = false;
          };
          Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
          Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
          Context.activateLongStackTraces();
          async.disableTrampolineIfNecessary();
      }
  }

• example usage

  ...
  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;
  ...

function bluebird.bluebird_core.method (fn)

• description and source-code

  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;
      };
  }

• example usage

  n/a

function bluebird.bluebird_core.noConflict ()

• description and source-code

  function noConflict() {
      try { if (Promise === bluebird) Promise = old; }
      catch (e) {}
      return bluebird;
  }

• example usage

  n/a

function bluebird.bluebird_core.onPossiblyUnhandledRejection (fn)

• description and source-code

  onPossiblyUnhandledRejection = function (fn) {
      var domain = getDomain();
      possiblyUnhandledRejection =
          typeof fn === "function" ? (domain === null ?
                                              fn : util.domainBind(domain, fn))
                                   : undefined;
  }

• example usage

  n/a

function bluebird.bluebird_core.onUnhandledRejectionHandled (fn)

• description and source-code

  onUnhandledRejectionHandled = function (fn) {
      var domain = getDomain();
      unhandledRejectionHandled =
          typeof fn === "function" ? (domain === null ?
                                              fn : util.domainBind(domain, fn))
                                   : undefined;
  }

• example usage

  n/a

function bluebird.bluebird_core.pending ()

• description and source-code

  pending = function () {
      debug.deprecated("Promise.defer", "new Promise");
      var promise = new Promise(INTERNAL);
      return {
          promise: promise,
          resolve: deferResolve,
          reject: deferReject
      };
  }

• example usage

  n/a

function bluebird.bluebird_core.reject (reason)

• description and source-code

  reject = function (reason) {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._rejectCallback(reason, true);
      return ret;
  }

• example usage

  ...
   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];
  ...

function bluebird.bluebird_core.rejected (reason)

• description and source-code

  rejected = function (reason) {
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._rejectCallback(reason, true);
      return ret;
  }

• example usage

  n/a

function bluebird.bluebird_core.resolve (obj)

• description and source-code

  resolve = function (obj) {
      var ret = tryConvertToPromise(obj);
      if (!(ret instanceof Promise)) {
          ret = new Promise(INTERNAL);
          ret._captureStackTrace();
          ret._setFulfilled();
          ret._rejectionHandler0 = obj;
      }
      return ret;
  }

• example usage

  ...
  };
  
  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 bluebird.bluebird_core.setScheduler (fn)

• description and source-code

  setScheduler = function (fn) {
      if (typeof fn !== "function") {
          throw new TypeError("expecting a function but got " + util.classString(fn));
      }
      return async.setScheduler(fn);
  }

• example usage

  ...
  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
  ...

function bluebird.bluebird_core.try (fn)

• description and source-code

  try = function (fn) {
      if (typeof fn !== "function") {
          return apiRejection("expecting a function but got " + util.classString(fn));
      }
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value;
      if (arguments.length > 1) {
          debug.deprecated("calling Promise.try with more than 1 argument");
          var arg = arguments[1];
          var ctx = arguments[2];
          value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
                                    : tryCatch(fn).call(ctx, arg);
      } else {
          value = tryCatch(fn)();
      }
      var promiseCreated = ret._popContext();
      debug.checkForgottenReturns(
          value, promiseCreated, "Promise.try", ret);
      ret._resolveFromSyncValue(value);
      return ret;
  }

• example usage

  n/a

module bluebird.bluebird_core.prototype

function bluebird.bluebird_core.prototype.__isCancelled ()

• description and source-code

  __isCancelled = function () {
      return (this._bitField & 65536) === 65536;
  }

• example usage

  ...
  };
  
  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() {
  ...

function bluebird.bluebird_core.prototype._addCallbacks ( fulfill, reject, promise, receiver, domain )

• description and source-code

  _addCallbacks = function ( fulfill, reject, promise, receiver, domain ) {
      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 =
                  domain === null ? fulfill : util.domainBind(domain, fulfill);
          }
          if (typeof reject === "function") {
              this._rejectionHandler0 =
                  domain === null ? reject : util.domainBind(domain, reject);
          }
      } else {
          var base = index * 4 - 4;
          this[base + 2] = promise;
          this[base + 3] = receiver;
          if (typeof fulfill === "function") {
              this[base + 0] =
                  domain === null ? fulfill : util.domainBind(domain, fulfill);
          }
          if (typeof reject === "function") {
              this[base + 1] =
                  domain === null ? reject : util.domainBind(domain, reject);
          }
      }
      this._setLength(index + 1);
      return index;
  }

• example usage

  ...
              : (typeof handler === "function" &&
                  util.domainBind(domain, handler)),
          promise: promise,
          receiver: receiver,
          value: value
      });
  } else {
      target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
  }
  
  return promise;
  };
  
  Promise.prototype._length = function () {
  return this._bitField & 65535;
  ...

function bluebird.bluebird_core.prototype._attachCancellationCallback (onCancel)

• description and source-code

  _attachCancellationCallback = function (onCancel) {
      ;
  }

• example usage

  ...
      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) {
  ...

function bluebird.bluebird_core.prototype._attachExtraTrace (error, ignoreSelf)

• description and source-code

  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);
          }
      }
  }

• example usage

  ...
          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);
      }
  }
  ...

function bluebird.bluebird_core.prototype._boundValue ()

• description and source-code

  _boundValue = function () {}

• example usage

  ...
  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);
  ...

function bluebird.bluebird_core.prototype._branchHasCancelled ()

• description and source-code

  _branchHasCancelled = function () {
      this._branchesRemainingToCancel--;
  }

• example usage

  ...
  
  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;
  };
  ...

function bluebird.bluebird_core.prototype._cancel ()

• description and source-code

  _cancel = function () {
      if (!this._isCancellable()) return;
      this._setCancelled();
      async.invoke(this._cancelPromises, this, undefined);
  }

• example usage

  ...
      }
  }
  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);
  ...

function bluebird.bluebird_core.prototype._cancelBranched ()

• description and source-code

  _cancelBranched = function () {
      if (this._enoughBranchesHaveCancelled()) {
          this._cancel();
      }
  }

• example usage

  ...
      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()) {
  ...

function bluebird.bluebird_core.prototype._cancelBy (canceller)

• description and source-code

  _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;
  }

• example usage

  ...
  
  Promise.prototype["break"] = Promise.prototype.cancel = function() {
  if (!debug.cancellation()) return this._warn("cancellation is disabled");
  
  var promise = this;
  var child = promise;
  while (promise._isCancellable()) {
      if (!promise._cancelBy(child)) {
          if (child._isFollowing()) {
              child._followee().cancel();
          } else {
              child._cancelBranched();
          }
          break;
      }
  ...

function bluebird.bluebird_core.prototype._cancelPromises ()

• description and source-code

  _cancelPromises = function () {
      if (this._length() > 0) this._settlePromises();
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype._captureStackTrace ()

• description and source-code

  function longStackTracesCaptureStackTrace() {
      this._trace = new CapturedTrace(this._peekContext());
  }

• example usage

  ...
      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) {
  ...

function bluebird.bluebird_core.prototype._clearCallbackDataAtIndex (index)

• description and source-code

  _clearCallbackDataAtIndex = function (index) {
      var base = index * 4 - 4;
      this[base + 2] =
      this[base + 3] =
      this[base + 0] =
      this[base + 1] = undefined;
  }

• example usage

  ...
  };
  
  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);
  ...

function bluebird.bluebird_core.prototype._clearCancellationData ()

• description and source-code

  _clearCancellationData = function () {}

• example usage

  ...
      } 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)) {
  ...

function bluebird.bluebird_core.prototype._doInvokeOnCancel (onCancelCallback, internalOnly)

• description and source-code

  _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);
          }
      }
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird_core.prototype._enoughBranchesHaveCancelled ()

• description and source-code

  _enoughBranchesHaveCancelled = function () {
      return this._branchesRemainingToCancel === undefined ||
             this._branchesRemainingToCancel <= 0;
  }

• example usage

  ...
  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;
  };
  ...

function bluebird.bluebird_core.prototype._ensurePossibleRejectionHandled ()

• description and source-code

  _ensurePossibleRejectionHandled = function () {
      if ((this._bitField & 524288) !== 0) return;
      this._setRejectionIsUnhandled();
      var self = this;
      setTimeout(function() {
          self._notifyUnhandledRejection();
      }, 1);
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird_core.prototype._execute (executor, resolve, reject)

• description and source-code

  _execute = function (executor, resolve, reject) {
      try {
          executor(resolve, reject);
      } catch (e) {
          return e;
      }
  }

• example usage

  ...
  
  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();
  ...

function bluebird.bluebird_core.prototype._fireEvent ()

• description and source-code

  function defaultFireEvent() { return false; }

• example usage

  ...
      this._bitField = 0;
      this._fulfillmentHandler0 = undefined;
      this._rejectionHandler0 = undefined;
      this._promise0 = undefined;
      this._receiver0 = undefined;
      this._resolveFromExecutor(executor);
      this._promiseCreated();
      this._fireEvent("promiseCreated", this);
  }
  
  Promise.prototype.toString = function () {
      return "[object Promise]";
  };
  
  Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
  ...

function bluebird.bluebird_core.prototype._followee ()

• description and source-code

  _followee = function () {
      return this._rejectionHandler0;
  }

• example usage

  ...
      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;
  ...

function bluebird.bluebird_core.prototype._fulfill (value)

• description and source-code

  _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);
          }
      }
  }

• example usage

  ...
      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;
      };
  }
  ...

function bluebird.bluebird_core.prototype._fulfillPromises (len, value)

• description and source-code

  _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);
      }
  }

• example usage

  ...
          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() {
  ...

function bluebird.bluebird_core.prototype._fulfillmentHandlerAt (index)

• description and source-code

  _fulfillmentHandlerAt = function (index) {
      return this[
              index * 4 - 4 + 0];
  }

• example usage

  ...
      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);
  };
  ...

function bluebird.bluebird_core.prototype._invokeInternalOnCancel ()

• description and source-code

  _invokeInternalOnCancel = function () {
      if (this._isCancellable()) {
          this._doInvokeOnCancel(this._onCancel(), true);
          this._unsetOnCancel();
      }
  }

• example usage

  ...
  };
  
  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);
      }
  ...

function bluebird.bluebird_core.prototype._invokeOnCancel ()

• description and source-code

  _invokeOnCancel = function () {
      var onCancelCallback = this._onCancel();
      this._unsetOnCancel();
      async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
  }

• example usage

  ...
  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;
      }
  ...

function bluebird.bluebird_core.prototype._isBound ()

• description and source-code

  _isBound = function () {
      return (this._bitField & 2097152) === 2097152;
  }

• example usage

  ...
      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);
  ...

function bluebird.bluebird_core.prototype._isCancellable ()

• description and source-code

  _isCancellable = function () {
      return this.isPending() && !this._isCancelled();
  }

• example usage

  ...
  var async = Promise._async;
  
  Promise.prototype["break"] = Promise.prototype.cancel = function() {
  if (!debug.cancellation()) return this._warn("cancellation is disabled");
  
  var promise = this;
  var child = promise;
  while (promise._isCancellable()) {
      if (!promise._cancelBy(child)) {
          if (child._isFollowing()) {
              child._followee().cancel();
          } else {
              child._cancelBranched();
          }
          break;
  ...

function bluebird.bluebird_core.prototype._isCancelled ()

• description and source-code

  _isCancelled = function () {
      return this._target().__isCancelled();
  }

• example usage

  ...
  };
  
  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) {
  ...

function bluebird.bluebird_core.prototype._isFateSealed ()

• description and source-code

  _isFateSealed = function () {
      return (this._bitField & 117506048) !== 0;
  }

• example usage

  ...
              ret._cancel();
          }
      } else {
          callbacks[i].call(ret, maybePromise, holder);
      }
  }
  
  if (!ret._isFateSealed()) {
      if (holder.asyncNeeded) {
          var domain = getDomain();
          if (domain !== null) {
              holder.fn = util.domainBind(domain, holder.fn);
          }
      }
      ret._setAsyncGuaranteed();
  ...

function bluebird.bluebird_core.prototype._isFinal ()

• description and source-code

  _isFinal = function () {
      return (this._bitField & 4194304) > 0;
  }

• example usage

  ...
  
  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();
  ...

function bluebird.bluebird_core.prototype._isFollowing ()

• description and source-code

  _isFollowing = function () {
      return (this._bitField & 67108864) === 67108864;
  }

• example usage

  ...
  Promise.prototype["break"] = Promise.prototype.cancel = function() {
  if (!debug.cancellation()) return this._warn("cancellation is disabled");
  
  var promise = this;
  var child = promise;
  while (promise._isCancellable()) {
      if (!promise._cancelBy(child)) {
          if (child._isFollowing()) {
              child._followee().cancel();
          } else {
              child._cancelBranched();
          }
          break;
      }
  ...

function bluebird.bluebird_core.prototype._isRejectionUnhandled ()

• description and source-code

  _isRejectionUnhandled = function () {
      return (this._bitField & 1048576) > 0;
  }

• example usage

  ...
  };
  
  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);
      }
  };
  ...

function bluebird.bluebird_core.prototype._isUnhandledRejectionNotified ()

• description and source-code

  _isUnhandledRejectionNotified = function () {
      return (this._bitField & 262144) > 0;
  }

• example usage

  ...
  
  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;
  ...

function bluebird.bluebird_core.prototype._length ()

• description and source-code

  _length = function () {
      return this._bitField & 65535;
  }

• example usage

  ...
  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() {
  ...

function bluebird.bluebird_core.prototype._migrateCallback0 (follower)

• description and source-code

  _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);
  }

• example usage

  ...
      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(promise);
  } else if (((bitField & 33554432) !== 0)) {
  ...

function bluebird.bluebird_core.prototype._migrateCallbackAt (follower, index)

• description and source-code

  _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);
  }

• example usage

  ...
  }
  
  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(promise);
  } else if (((bitField & 33554432) !== 0)) {
      this._fulfill(promise._value());
  } else if (((bitField & 16777216) !== 0)) {
  ...

function bluebird.bluebird_core.prototype._notifyUnhandledRejection ()

• description and source-code

  _notifyUnhandledRejection = function () {
      if (this._isRejectionUnhandled()) {
          var reason = this._settledValue();
          this._setUnhandledRejectionIsNotified();
          fireRejectionEvent("unhandledRejection",
                                        possiblyUnhandledRejection, reason, this);
      }
  }

• example usage

  ...
  };
  
  Promise.prototype._ensurePossibleRejectionHandled = function () {
      if ((this._bitField & 524288) !== 0) return;
      this._setRejectionIsUnhandled();
      var self = this;
      setTimeout(function() {
          self._notifyUnhandledRejection();
      }, 1);
  };
  
  Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
      fireRejectionEvent("rejectionHandled",
                                    unhandledRejectionHandled, undefined, this);
  };
  ...

function bluebird.bluebird_core.prototype._notifyUnhandledRejectionIsHandled ()

• description and source-code

  _notifyUnhandledRejectionIsHandled = function () {
      fireRejectionEvent("rejectionHandled",
                                    unhandledRejectionHandled, undefined, this);
  }

• example usage

  ...
      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;
  };
  ...

function bluebird.bluebird_core.prototype._onCancel ()

• description and source-code

  _onCancel = function () {}

• example usage

  ...
      } 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);
  ...

function bluebird.bluebird_core.prototype._passThrough (handler, type, success, fail)

• description and source-code

  _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);
  }

• example usage

  ...
                        undefined,
                        new PassThroughHandlerContext(this, type, handler),
                        undefined);
  };
  
  Promise.prototype.lastly =
  Promise.prototype["finally"] = function (handler) {
      return this._passThrough(handler,
                               0,
                               finallyHandler,
                               finallyHandler);
  };
  
  
  Promise.prototype.tap = function (handler) {
  ...

function bluebird.bluebird_core.prototype._peekContext ()

• description and source-code

  function peekContext() {
      var lastIndex = contextStack.length - 1;
      if (lastIndex >= 0) {
          return contextStack[lastIndex];
      }
      return undefined;
  }

• example usage

  ...
          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){
  ...

function bluebird.bluebird_core.prototype._popContext ()

• description and source-code

  _popContext = function () {
      if (this._trace !== undefined) {
          var trace = contextStack.pop();
          var ret = trace._promiseCreated;
          trace._promiseCreated = null;
          return ret;
      }
      return null;
  }

• example usage

  ...
      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\
  ...

function bluebird.bluebird_core.prototype._promiseAt (index)

• description and source-code

  _promiseAt = function (index) {
      return this[
              index * 4 - 4 + 2];
  }

• example usage

  ...
  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,
  ...

function bluebird.bluebird_core.prototype._promiseCreated ()

• description and source-code

  _promiseCreated = function () {
      var ctx = this._peekContext();
      if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
  }

• example usage

  ...
      }
      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]";
  };
  ...

function bluebird.bluebird_core.prototype._propagateFrom (parent, flags)

• description and source-code

  _propagateFrom = function (parent, flags) {
      ;
      ;
  }

• example usage

  ...
  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,
  ...

function bluebird.bluebird_core.prototype._proxy (proxyable, arg)

• description and source-code

  _proxy = function (proxyable, arg) {
      this._addCallbacks(undefined, undefined, arg, proxyable, null);
  }

• example usage

  ...
  
  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);
  ...

function bluebird.bluebird_core.prototype._pushContext ()

• description and source-code

  _pushContext = function () {
      if (this._trace !== undefined) {
          this._trace._promiseCreated = null;
          contextStack.push(this._trace);
      }
  }

• example usage

  ...
      [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\
  ...

function bluebird.bluebird_core.prototype._reason ()

• description and source-code

  _reason = function () {
      this._unsetRejectionIsUnhandled();
      return this._settledValue();
  }

• example usage

  ...
                                 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);
      }
  }
  ...

function bluebird.bluebird_core.prototype._receiverAt (index)

• description and source-code

  _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;
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird_core.prototype._reject (reason)

• description and source-code

  _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();
      }
  }

• example usage

  ...
  module.exports.firstLineError = firstLineError;
  
  },{"./queue":17,"./schedule":18,"./util":21}],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);
  };
  ...

function bluebird.bluebird_core.prototype._rejectCallback (reason, synchronous, ignoreNonErrorWarnings)

• description and source-code

  _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);
  }

• example usage

  ...
  }                                                                \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\
  ...

function bluebird.bluebird_core.prototype._rejectPromises (len, reason)

• description and source-code

  _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);
      }
  }

• example usage

  ...
  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);
  }
  ...

function bluebird.bluebird_core.prototype._rejectionHandlerAt (index)

• description and source-code

  _rejectionHandlerAt = function (index) {
      return this[
              index * 4 - 4 + 1];
  }

• example usage

  ...
      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 (
  ...

function bluebird.bluebird_core.prototype._resolveCallback (value, shouldBind)

• description and source-code

  _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(promise);
      } 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);
      }
  }

• example usage

  ...
  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);
  };
  ...

function bluebird.bluebird_core.prototype._resolveFromExecutor (executor)

• description and source-code

  _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);
      }
  }

• example usage

  ...
          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]";
  };
  ...

function bluebird.bluebird_core.prototype._resolveFromSyncValue (value)

• description and source-code

  _resolveFromSyncValue = function (value) {
      if (value === util.errorObj) {
          this._rejectCallback(value.e, false);
      } else {
          this._resolveCallback(value, true);
      }
  }

• example usage

  ...
      var ret = new Promise(INTERNAL);
      ret._captureStackTrace();
      ret._pushContext();
      var value = tryCatch(fn).apply(this, arguments);
      var promiseCreated = ret._popContext();
      debug.checkForgottenReturns(
          value, promiseCreated, "Promise.method", ret);
      ret._resolveFromSyncValue(value);
      return ret;
  };
  };
  
  Promise.attempt = Promise["try"] = function (fn) {
  if (typeof fn !== "function") {
      return apiRejection("expecting a function but got " + util.classString(fn));
  ...

function bluebird.bluebird_core.prototype._resultCancelled ()

• description and source-code

  _resultCancelled = function () {
      this.cancel();
  }

• example usage

  ...
              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();
  ...

function bluebird.bluebird_core.prototype._returnedNonUndefined ()

• description and source-code

  _returnedNonUndefined = function () {
      return (this._bitField & 268435456) !== 0;
  }

• example usage

  ...
      }
  }
  
  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");
  ...

function bluebird.bluebird_core.prototype._setAsyncGuaranteed ()

• description and source-code

  _setAsyncGuaranteed = function () {
      if (async.hasCustomScheduler()) return;
      this._bitField = this._bitField | 134217728;
  }

• example usage

  ...
              if (!ret._isFateSealed()) {
                  if (holder.asyncNeeded) {
                      var domain = getDomain();
                      if (domain !== null) {
                          holder.fn = util.domainBind(domain, holder.fn);
                      }
                  }
                  ret._setAsyncGuaranteed();
                  ret._setOnCancel(holder);
              }
              return ret;
          }
      }
  }
  var args = [].slice.call(arguments);;
  ...

function bluebird.bluebird_core.prototype._setBoundTo (obj)

• description and source-code

  _setBoundTo = function (obj) {
      if (obj !== undefined) {
          this._bitField = this._bitField | 2097152;
          this._boundTo = obj;
      } else {
          this._bitField = this._bitField & (~2097152);
      }
  }

• example usage

  ...
      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
      };
  ...

function bluebird.bluebird_core.prototype._setCancelled ()

• description and source-code

  _setCancelled = function () {
      this._bitField = this._bitField | 65536;
      this._fireEvent("promiseCancelled", this);
  }

• example usage

  ...
      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();
  };
  ...

function bluebird.bluebird_core.prototype._setFollowee (promise)

• description and source-code

  _setFollowee = function (promise) {
      this._rejectionHandler0 = promise;
  }

• example usage

  ...
      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(promise);
  } 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);
  ...

function bluebird.bluebird_core.prototype._setFollowing ()

• description and source-code

  _setFollowing = function () {
      this._bitField = this._bitField | 67108864;
      this._fireEvent("promiseResolved", this);
  }

• example usage

  ...
  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(promise);
  } else if (((bitField & 33554432) !== 0)) {
      this._fulfill(promise._value());
  } else if (((bitField & 16777216) !== 0)) {
      this._reject(promise._reason());
  } else {
  ...

function bluebird.bluebird_core.prototype._setFulfilled ()

• description and source-code

  _setFulfilled = function () {
      this._bitField = this._bitField | 33554432;
      this._fireEvent("promiseFulfilled", this);
  }

• example usage

  ...
  };
  
  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;
  ...

function bluebird.bluebird_core.prototype._setIsFinal ()

• description and source-code

  _setIsFinal = function () {
      this._bitField = this._bitField | 4194304;
  }

• example usage

  ...
  }
  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);
  ...

function bluebird.bluebird_core.prototype._setLength (len)

• description and source-code

  _setLength = function (len) {
      this._bitField = (this._bitField & -65536) |
          (len & 65535);
  }

• example usage

  ...
  receiver,
  domain
  ) {
  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 =
  ...

function bluebird.bluebird_core.prototype._setOnCancel (handler)

• description and source-code

  _setOnCancel = function (handler) { ; }

• example usage

  ...
              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) {
  ...

function bluebird.bluebird_core.prototype._setRejected ()

• description and source-code

  _setRejected = function () {
      this._bitField = this._bitField | 16777216;
      this._fireEvent("promiseRejected", this);
  }

• example usage

  ...
      }
  }
  };
  
  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) {
  ...

function bluebird.bluebird_core.prototype._setRejectionIsUnhandled ()

• description and source-code

  _setRejectionIsUnhandled = function () {
      this._bitField = this._bitField | 1048576;
  }

• example usage

  ...
      var target = this._target();
      target._bitField = ((target._bitField & (~1048576)) |
                        524288);
  };
  
  Promise.prototype._ensurePossibleRejectionHandled = function () {
      if ((this._bitField & 524288) !== 0) return;
      this._setRejectionIsUnhandled();
      var self = this;
      setTimeout(function() {
          self._notifyUnhandledRejection();
      }, 1);
  };
  
  Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
  ...

function bluebird.bluebird_core.prototype._setReturnedNonUndefined ()

• description and source-code

  _setReturnedNonUndefined = function () {
      this._bitField = this._bitField | 268435456;
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird_core.prototype._setUnhandledRejectionIsNotified ()

• description and source-code

  _setUnhandledRejectionIsNotified = function () {
      this._bitField = this._bitField | 262144;
  }

• example usage

  ...
  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;
  ...

function bluebird.bluebird_core.prototype._setWillBeCancelled ()

• description and source-code

  _setWillBeCancelled = function () {
      this._bitField = this._bitField | 8388608;
  }

• example usage

  ...
                  promise._followee().cancel();
              } else {
                  promise._cancelBranched();
              }
              break;
          } else {
              if (promise._isFollowing()) promise._followee().cancel();
              promise._setWillBeCancelled();
              child = promise;
              promise = parent;
          }
      }
  };
  
  Promise.prototype._branchHasCancelled = function() {
  ...

function bluebird.bluebird_core.prototype._settlePromise (promise, handler, receiver, value)

• description and source-code

  _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);
          }
      }
  }

• example usage

  ...
      }
  } 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;
  ...

function bluebird.bluebird_core.prototype._settlePromise0 (handler, value, bitField)

• description and source-code

  _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);
  }

• example usage

  ...
  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);
  ...

function bluebird.bluebird_core.prototype._settlePromiseCtx (ctx)

• description and source-code

  _settlePromiseCtx = function (ctx) {
      this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype._settlePromiseFromHandler ( handler, receiver, value, promise )

• description and source-code

  _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);
      }
  }

• example usage

  ...
          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);
  ...

function bluebird.bluebird_core.prototype._settlePromiseLateCancellationObserver (ctx)

• description and source-code

  _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);
      }
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype._settlePromises ()

• description and source-code

  _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();
  }

• example usage

  ...
  };
  
  Async.prototype.settlePromises = function(promise) {
      if (this._trampolineEnabled) {
          AsyncSettlePromises.call(this, promise);
      } else {
          this._schedule(function() {
              promise._settlePromises();
          });
      }
  };
  }
  
  Async.prototype._drainQueue = function(queue) {
  while (queue.length() > 0) {
  ...

function bluebird.bluebird_core.prototype._settledValue ()

• description and source-code

  _settledValue = function () {
      var bitField = this._bitField;
      if (((bitField & 33554432) !== 0)) {
          return this._rejectionHandler0;
      } else if (((bitField & 16777216) !== 0)) {
          return this._fulfillmentHandler0;
      }
  }

• example usage

  ...
  
  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 () {
  ...

function bluebird.bluebird_core.prototype._target ()

• description and source-code

  _target = function () {
      var ret = this;
      while (ret._isFollowing()) ret = ret._followee();
      return ret;
  }

• example usage

  ...
      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
  ...

function bluebird.bluebird_core.prototype._then ( didFulfill, didReject, _, receiver, internalData )

• description and source-code

  _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 domain = getDomain();
      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: domain === null ? handler
                  : (typeof handler === "function" &&
                      util.domainBind(domain, handler)),
              promise: promise,
              receiver: receiver,
              value: value
          });
      } else {
          target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
      }
  
      return promise;
  }

• example usage

  ...
  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);
      }
  };
  ...

function bluebird.bluebird_core.prototype._unsetCancelled ()

• description and source-code

  _unsetCancelled = function () {
      this._bitField = this._bitField & (~65536);
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype._unsetOnCancel ()

• description and source-code

  _unsetOnCancel = function () {
      this._onCancelField = undefined;
  }

• example usage

  ...
          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();
  ...

function bluebird.bluebird_core.prototype._unsetRejectionIsUnhandled ()

• description and source-code

  _unsetRejectionIsUnhandled = function () {
      this._bitField = this._bitField & (~1048576);
      if (this._isUnhandledRejectionNotified()) {
          this._unsetUnhandledRejectionIsNotified();
          this._notifyUnhandledRejectionIsHandled();
      }
  }

• example usage

  ...
  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;
  }
  ...

function bluebird.bluebird_core.prototype._unsetUnhandledRejectionIsNotified ()

• description and source-code

  _unsetUnhandledRejectionIsNotified = function () {
      this._bitField = this._bitField & (~262144);
  }

• example usage

  ...
  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;
  };
  ...

function bluebird.bluebird_core.prototype._value ()

• description and source-code

  _value = function () {
      return this._settledValue();
  }

• example usage

  ...
      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);
  ...

function bluebird.bluebird_core.prototype._warn (message, shouldUseOwnTrace, promise)

• description and source-code

  _warn = function (message, shouldUseOwnTrace, promise) {
      return warn(message, shouldUseOwnTrace, promise || this);
  }

• example usage

  ...
  module.exports = function(Promise, PromiseArray, apiRejection, debug) {
  var util = _dereq_("./util");
  var tryCatch = util.tryCatch;
  var errorObj = util.errorObj;
  var async = Promise._async;
  
  Promise.prototype["break"] = Promise.prototype.cancel = function() {
  if (!debug.cancellation()) return this._warn("cancellation is disabled");
  
  var promise = this;
  var child = promise;
  while (promise._isCancellable()) {
      if (!promise._cancelBy(child)) {
          if (child._isFollowing()) {
              child._followee().cancel();
  ...

function bluebird.bluebird_core.prototype.all ()

• description and source-code

  all = function () {
      if (arguments.length > 0) {
          this._warn(".all() was passed arguments but it does not take any");
      }
      return new PromiseArray(this).promise();
  }

• example usage

  ...
  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,
  ...

function bluebird.bluebird_core.prototype.bind (thisArg)

• description and source-code

  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;
  }

• example usage

  ...
  };
  
  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 bluebird.bluebird_core.prototype.break ()

• description and source-code

  break = 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;
          }
      }
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.cancel ()

• description and source-code

  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;
          }
      }
  }

• example usage

  ...
      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;
  ...

function bluebird.bluebird_core.prototype.catch (fn)

• description and source-code

  catch = function (fn) {
      var len = arguments.length;
      if (len > 1) {
          var catchInstances = new Array(len - 1),
              j = 0, i;
          for (i = 0; i < len - 1; ++i) {
              var item = arguments[i];
              if (util.isObject(item)) {
                  catchInstances[j++] = item;
              } else {
                  return apiRejection("Catch statement predicate: " +
                      "expecting an object but got " + util.classString(item));
              }
          }
          catchInstances.length = j;
          fn = arguments[i];
          return this.then(undefined, catchFilter(catchInstances, fn, this));
      }
      return this.then(undefined, fn);
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.catchReturn (value)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.catchThrow (reason)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.caught (fn)

• description and source-code

  caught = 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];
          return this.then(undefined, catchFilter(catchInstances, fn, this));
      }
      return this.then(undefined, fn);
  }

• example usage

  ...
  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(
  ...

function bluebird.bluebird_core.prototype.done (didFulfill, didReject)

• description and source-code

  done = function (didFulfill, didReject) {
      var promise =
          this._then(didFulfill, didReject, undefined, undefined, undefined);
      promise._setIsFinal();
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.error (fn)

• description and source-code

  error = function (fn) {
      return this.caught(util.originatesFromRejection, fn);
  }

• example usage

  ...
  }
  
  var resultPromise = Promise.all(reflectedResources)
      .then(function(inspections) {
          for (var i = 0; i < inspections.length; ++i) {
              var inspection = inspections[i];
              if (inspection.isRejected()) {
                  errorObj.e = inspection.error();
                  return errorObj;
              } else if (!inspection.isFulfilled()) {
                  resultPromise.cancel();
                  return;
              }
              inspections[i] = inspection.value();
          }
  ...

function bluebird.bluebird_core.prototype.finally (handler)

• description and source-code

  finally = function (handler) {
      return this._passThrough(handler,
                               0,
                               finallyHandler,
                               finallyHandler);
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.isCancellable ()

• description and source-code

  isCancellable = function () {
      return this.isPending() && !this.isCancelled();
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.isCancelled ()

• description and source-code

  isCancelled = function () {
      return (this._target()._bitField & 8454144) !== 0;
  }

• example usage

  ...
  };
  
  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);
      }
  ...

function bluebird.bluebird_core.prototype.isFulfilled ()

• description and source-code

  isFulfilled = function () {
      return isFulfilled.call(this._target());
  }

• example usage

  ...
  }
  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 bluebird.bluebird_core.prototype.isPending ()

• description and source-code

  isPending = function () {
      return isPending.call(this._target());
  }

• example usage

  ...
  };
  
  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) {
  ...

function bluebird.bluebird_core.prototype.isRejected ()

• description and source-code

  isRejected = function () {
      return isRejected.call(this._target());
  }

• example usage

  ...
              }
              return maybePromise._then(
                  succeed, fail, undefined, this, undefined);
          }
      }
  }
  
  if (promise.isRejected()) {
      checkCancel(this);
      errorObj.e = reasonOrValue;
      return errorObj;
  } else {
      checkCancel(this);
      return reasonOrValue;
  }
  ...

function bluebird.bluebird_core.prototype.isResolved ()

• description and source-code

  isResolved = function () {
      return isResolved.call(this._target());
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.lastly (handler)

• description and source-code

  lastly = function (handler) {
      return this._passThrough(handler,
                               0,
                               finallyHandler,
                               finallyHandler);
  }

• example usage

  ...
  return null;
  }
  
  function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
  if (debug.cancellation()) {
      var internal = new Promise(INTERNAL);
      var _finallyPromise = this._finallyPromise = new Promise(INTERNAL);
      this._promise = internal.lastly(function() {
          return _finallyPromise;
      });
      internal._captureStackTrace();
      internal._setOnCancel(this);
  } else {
      var promise = this._promise = new Promise(INTERNAL);
      promise._captureStackTrace();
  ...

function bluebird.bluebird_core.prototype.reason ()

• description and source-code

  reason = function () {
      var target = this._target();
      target._unsetRejectionIsUnhandled();
      return reason.call(target);
  }

• example usage

  ...
      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) {
  ...

function bluebird.bluebird_core.prototype.reflect ()

• description and source-code

  reflect = function () {
      return this._then(reflectHandler,
          reflectHandler, undefined, this, undefined);
  }

• example usage

  ...
      var ret = new PromiseInspection();
      ret._bitField = 16777216;
      ret._settledValueField = reason;
      return this._promiseResolved(index, ret);
  };
  
  Promise.settle = function (promises) {
      debug.deprecated(".settle()", ".reflect()");
      return new SettledPromiseArray(promises).promise();
  };
  
  Promise.prototype.settle = function () {
      return Promise.settle(this);
  };
  };
  ...

function bluebird.bluebird_core.prototype.return (value)

• description and source-code

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

• example usage

  ...
  PromiseSpawn.prototype._promiseCancelled = function() {
  if (this._isResolved()) return;
  var implementsReturn = typeof this._generator["return"] !== "undefined";
  
  var result;
  if (!implementsReturn) {
      var reason = new Promise.CancellationError(
          "generator .return() sentinel");
      Promise.coroutine.returnSentinel = reason;
      this._promise._attachExtraTrace(reason);
      this._promise._pushContext();
      result = tryCatch(this._generator["throw"]).call(this._generator,
                                                       reason);
      this._promise._popContext();
  } else {
  ...

function bluebird.bluebird_core.prototype.spread (fn)

• description and source-code

  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);
  }

• example usage

  ...
                  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 bluebird.bluebird_core.prototype.suppressUnhandledRejections ()

• description and source-code

  suppressUnhandledRejections = function () {
      var target = this._target();
      target._bitField = ((target._bitField & (~1048576)) |
                        524288);
  }

• example usage

  ...
  }
  function thrower() {
  throw this.reason;
  }
  
  Promise.prototype["return"] =
  Promise.prototype.thenReturn = function (value) {
  if (value instanceof Promise) value.suppressUnhandledRejections();
  return this._then(
      returner, undefined, undefined, {value: value}, undefined);
  };
  
  Promise.prototype["throw"] =
  Promise.prototype.thenThrow = function (reason) {
  return this._then(
  ...

function bluebird.bluebird_core.prototype.tap (handler)

• description and source-code

  tap = function (handler) {
      return this._passThrough(handler, 1, finallyHandler);
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.tapCatch (handlerOrPredicate)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.then (didFulfill, didReject)

• description and source-code

  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);
  }

• example usage

  ...
      } 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);
  };
  ...

function bluebird.bluebird_core.prototype.thenReturn (value)

• description and source-code

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

• example usage

  ...
  this.handle = handle;
  }
  
  HandleWrapper.prototype._resultCancelled = function() {
  clearTimeout(this.handle);
  };
  
  var afterValue = function(value) { return delay(+this).thenReturn(value); };
  var delay = Promise.delay = function (ms, value) {
  var ret;
  var handle;
  if (value !== undefined) {
      ret = Promise.resolve(value)
              ._then(afterValue, null, null, ms, undefined);
      if (debug.cancellation() && value instanceof Promise) {
  ...

function bluebird.bluebird_core.prototype.thenThrow (reason)

• description and source-code

  thenThrow = function (reason) {
      return this._then(
          thrower, undefined, undefined, {reason: reason}, undefined);
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.throw (reason)

• description and source-code

  throw = function (reason) {
      return this._then(
          thrower, undefined, undefined, {reason: reason}, undefined);
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.toJSON ()

• description and source-code

  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;
  }

• example usage

  n/a

function bluebird.bluebird_core.prototype.toString ()

• description and source-code

  toString = function () {
      return "[object Promise]";
  }

• example usage

  ...
  
  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 bluebird.bluebird_core.prototype.value ()

• description and source-code

  value = function () {
      return value.call(this._target());
  }

• example usage

  ...
  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;
  }
  ...

module bluebird.coroutine

function bluebird.coroutine (generatorFunction, options)

• description and source-code

  coroutine = function (generatorFunction, options) {
      if (typeof generatorFunction !== "function") {
          throw new TypeError("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
      }
      var yieldHandler = Object(options).yieldHandler;
      var PromiseSpawn$ = PromiseSpawn;
      var stack = new Error().stack;
      return function () {
          var generator = generatorFunction.apply(this, arguments);
          var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
                                        stack);
          var ret = spawn.promise();
          spawn._generator = generator;
          spawn._promiseFulfilled(undefined);
          return ret;
      };
  }

• example usage

  ...
  if (typeof fn !== "function") {
      throw new TypeError("expecting a function but got " + util.classString(fn));
  }
  yieldHandlers.push(fn);
  };
  
  Promise.spawn = function (generatorFunction) {
  debug.deprecated("Promise.spawn()", "Promise.coroutine()");
  if (typeof generatorFunction !== "function") {
      return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  }
  var spawn = new PromiseSpawn(generatorFunction, this);
  var ret = spawn.promise();
  spawn._run(Promise.spawn);
  return ret;
  ...

function bluebird.coroutine.addYieldHandler (fn)

• description and source-code

  addYieldHandler = function (fn) {
      if (typeof fn !== "function") {
          throw new TypeError("expecting a function but got " + util.classString(fn));
      }
      yieldHandlers.push(fn);
  }

• example usage

  n/a

module bluebird.errors

function bluebird.errors.AggregateError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.errors.CancellationError (message)

• description and source-code

  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);
      }
  }

• example usage

  ...
  
  PromiseSpawn.prototype._promiseCancelled = function() {
  if (this._isResolved()) return;
  var implementsReturn = typeof this._generator["return"] !== "undefined";
  
  var result;
  if (!implementsReturn) {
      var reason = new Promise.CancellationError(
          "generator .return() sentinel");
      Promise.coroutine.returnSentinel = reason;
      this._promise._attachExtraTrace(reason);
      this._promise._pushContext();
      result = tryCatch(this._generator["throw"]).call(this._generator,
                                                       reason);
      this._promise._popContext();
  ...

function bluebird.errors.Error ()

• description and source-code

  function Error() { [native code] }

• example usage

  n/a

function bluebird.errors.OperationalError (message)

• description and source-code

  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);
      }
  
  }

• example usage

  n/a

function bluebird.errors.RangeError ()

• description and source-code

  function RangeError() { [native code] }

• example usage

  n/a

function bluebird.errors.TimeoutError (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

function bluebird.errors.TypeError ()

• description and source-code

  function TypeError() { [native code] }

• example usage

  ...
  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();
  ...

function bluebird.errors.Warning (message)

• description and source-code

  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);
      }
  }

• example usage

  n/a

module bluebird.es5

function bluebird.es5.defineProperty ()

• description and source-code

  function defineProperty() { [native code] }

• example usage

  ...
  
  for (var i = 0; i < methods.length; ++i) {
      if (typeof Array.prototype[methods[i]] === "function") {
          AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
      }
  }
  
  es5.defineProperty(AggregateError.prototype, "length", {
      value: 0,
      configurable: false,
      writable: true,
      enumerable: true
  });
  AggregateError.prototype["isOperational"] = true;
  var level = 0;
  ...

function bluebird.es5.freeze ()

• description and source-code

  function freeze() { [native code] }

• example usage

  n/a

function bluebird.es5.getDescriptor ()

• description and source-code

  function getOwnPropertyDescriptor() { [native code] }

• example usage

  ...
  
  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)) {
  ...

function bluebird.es5.getPrototypeOf ()

• description and source-code

  function getPrototypeOf() { [native code] }

• example usage

  ...
  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);
  ...

function bluebird.es5.isArray ()

• description and source-code

  function isArray() { [native code] }

• example usage

  ...
  };
  
  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());
  ...

function bluebird.es5.keys ()

• description and source-code

  function keys() { [native code] }

• example usage

  ...
  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;
  ...

function bluebird.es5.names ()

• description and source-code

  function getOwnPropertyNames() { [native code] }

• example usage

  ...
  
  })();
  
  var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
  function isClass(fn) {
      try {
          if (typeof fn === "function") {
  var keys = es5.names(fn.prototype);
  
  var hasMethods = es5.isES5 && keys.length > 1;
  var hasMethodsOtherThanConstructor = keys.length > 0 &&
      !(keys.length === 1 && keys[0] === "constructor");
  var hasThisAssignmentAndStaticMethods =
      thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
  ...

function bluebird.es5.propertyIsWritable (obj, prop)

• description and source-code

  propertyIsWritable = function (obj, prop) {
      var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
      return !!(!descriptor || descriptor.writable || descriptor.set);
  }

• example usage

  ...
  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));}
  ...

module bluebird.queue

function bluebird.queue (capacity)

• description and source-code

  function Queue(capacity) {
      this._capacity = capacity;
      this._length = 0;
      this._front = 0;
  }

• example usage

  n/a

module bluebird.queue.prototype

function bluebird.queue.prototype._checkCapacity (size)

• description and source-code

  _checkCapacity = function (size) {
      if (this._capacity < size) {
          this._resizeTo(this._capacity << 1);
      }
  }

• example usage

  ...
  
  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;
  ...

function bluebird.queue.prototype._pushOne (arg)

• description and source-code

  _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;
  }

• example usage

  ...
  
  function AsyncInvoke(fn, receiver, arg) {
  this._normalQueue.push(fn, receiver, arg);
  this._queueTick();
  }
  
  function AsyncSettlePromises(promise) {
  this._normalQueue._pushOne(promise);
  this._queueTick();
  }
  
  if (!util.hasDevTools) {
  Async.prototype.invokeLater = AsyncInvokeLater;
  Async.prototype.invoke = AsyncInvoke;
  Async.prototype.settlePromises = AsyncSettlePromises;
  ...

function bluebird.queue.prototype._resizeTo (capacity)

• description and source-code

  _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);
  }

• example usage

  ...
  
  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;
  ...

function bluebird.queue.prototype._willBeOverCapacity (size)

• description and source-code

  _willBeOverCapacity = function (size) {
      return this._capacity < size;
  }

• example usage

  ...
  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);
  ...

function bluebird.queue.prototype.length ()

• description and source-code

  length = function () {
      return this._length;
  }

• example usage

  ...
              promise._settlePromises();
          });
      }
  };
  }
  
  Async.prototype._drainQueue = function(queue) {
  while (queue.length() > 0) {
      var fn = queue.shift();
      if (typeof fn !== "function") {
          fn._settlePromises();
          continue;
      }
      var receiver = queue.shift();
      var arg = queue.shift();
  ...

function bluebird.queue.prototype.push (fn, receiver, arg)

• description and source-code

  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;
  }

• example usage

  ...
          });
      } 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 bluebird.queue.prototype.shift ()

• description and source-code

  shift = function () {
      var front = this._front,
          ret = this[front];
  
      this[front] = undefined;
      this._front = (front + 1) & (this._capacity - 1);
      this._length--;
      return ret;
  }

• example usage

  ...
          });
      }
  };
  }
  
  Async.prototype._drainQueue = function(queue) {
  while (queue.length() > 0) {
      var fn = queue.shift();
      if (typeof fn !== "function") {
          fn._settlePromises();
          continue;
      }
      var receiver = queue.shift();
      var arg = queue.shift();
      fn.call(receiver, arg);
  ...

module bluebird.util

function bluebird.util.asArray (v)

• description and source-code

  asArray = function (v) {
      if (es5.isArray(v)) {
          return v;
      } else if (v != null && typeof v[Symbol.iterator] === "function") {
          return ArrayFrom(v);
      }
      return null;
  }

• example usage

  ...
          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;
  }
  ...

function bluebird.util.canAttachTrace (obj)

• description and source-code

  function canAttachTrace(obj) {
      return isError(obj) && es5.propertyIsWritable(obj, "stack");
  }

• example usage

  n/a

function bluebird.util.classString (obj)

• description and source-code

  function classString(obj) {
      return {}.toString.call(obj);
  }

• example usage

  ...
  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,
  ...

function bluebird.util.copyDescriptors (from, to, filter)

• description and source-code

  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) {}
          }
      }
  }

• example usage

  ...
  if (isPromisified(fn)) {
      return fn;
  }
  options = Object(options);
  var receiver = options.context === undefined ? THIS : options.context;
  var multiArgs = !!options.multiArgs;
  var ret = promisify(fn, receiver, multiArgs);
  util.copyDescriptors(fn, ret, propsFilter);
  return ret;
  };
  
  Promise.promisifyAll = function (target, options) {
  if (typeof target !== "function" && typeof target !== "object") {
      throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  }
  ...

function bluebird.util.domainBind (self, cb)

• description and source-code

  function domainBind(self, cb) {
      return self.bind(cb);
  }

• example usage

  ...
  return warn(message, shouldUseOwnTrace, promise || this);
  };
  
  Promise.onPossiblyUnhandledRejection = function (fn) {
  var domain = getDomain();
  possiblyUnhandledRejection =
      typeof fn === "function" ? (domain === null ?
                                          fn : util.domainBind(domain, fn))
                               : undefined;
  };
  
  Promise.onUnhandledRejectionHandled = function (fn) {
  var domain = getDomain();
  unhandledRejectionHandled =
      typeof fn === "function" ? (domain === null ?
  ...

function bluebird.util.ensureErrorObject (value)

• description and source-code

  ensureErrorObject = function (value) {
      if (canAttachTrace(value)) return value;
      return new Error(safeToString(value));
  }

• example usage

  ...
      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);
  ...

function bluebird.util.env (key)

• description and source-code

  function env(key) {
      return hasEnvVariables ? process.env[key] : undefined;
  }

• example usage

  ...
  /[\\\/]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")));
  ...

function bluebird.util.filledRange (count, prefix, suffix)

• description and source-code

  function filledRange(count, prefix, suffix) {
      var ret = new Array(count);
      for(var i = 0; i < count; ++i) {
          ret[i] = prefix + i + suffix;
      }
      return ret;
  }

• example usage

  ...
      for(var i = likelyArgumentCount + 1; i <= 3; ++i) {
          ret.push(i);
      }
      return ret;
  };
  
  var argumentSequence = function(argumentCount) {
      return util.filledRange(argumentCount, "_arg", "");
  };
  
  var parameterDeclaration = function(parameterCount) {
      return util.filledRange(
          Math.max(parameterCount, 3), "_arg", "");
  };
  ...

function bluebird.util.getDataPropertyOrDefault (obj, key, defaultValue)

• description and source-code

  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;
      }
  }

• example usage

  ...
  }
  catch (e) {
      return false;
  }
  }
  
  function hasPromisified(obj, key, suffix) {
  var val = util.getDataPropertyOrDefault(obj, key + suffix,
                                          defaultPromisified);
  return val ? isPromisified(val) : false;
  }
  function checkValid(ret, suffix, suffixRegexp) {
  for (var i = 0; i < ret.length; i += 2) {
      var key = ret[i];
      if (suffixRegexp.test(key)) {
  ...

function bluebird.util.getNativePromise ()

• description and source-code

  function getNativePromise() {
      if (typeof Promise === "function") {
          try {
              var promise = new Promise(function(){});
              if ({}.toString.call(promise) === "[object Promise]") {
                  return Promise;
              }
          } catch (e) {}
      }
  }

• example usage

  ...
  },{}],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" &&
  ...

function bluebird.util.inheritedDataKeys (obj)

• description and source-code

  inheritedDataKeys = 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;
  }

• example usage

  ...
              }
          }
      }
  }
  }
  
  function promisifiableMethods(obj, suffix, suffixRegexp, filter) {
  var keys = util.inheritedDataKeys(obj);
  var ret = [];
  for (var i = 0; i < keys.length; ++i) {
      var key = keys[i];
      var value = obj[key];
      var passesDefaultFilter = filter === defaultFilter
          ? true : defaultFilter(key, value, obj);
      if (typeof value === "function" &&
  ...

function bluebird.util.inherits (Child, Parent)

• description and source-code

  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;
  }

• example usage

  ...
  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 = {};
  ...

function bluebird.util.isArray ()

• description and source-code

  function isArray() { [native code] }

• example usage

  ...
  };
  
  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());
  ...

function bluebird.util.isClass (fn)

• description and source-code

  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;
      }
  }

• example usage

  ...
      throw new RangeError("suffix must be a valid identifier\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  }
  
  var keys = util.inheritedDataKeys(target);
  for (var i = 0; i < keys.length; ++i) {
      var value = target[keys[i]];
      if (keys[i] !== "constructor" &&
          util.isClass(value)) {
          promisifyAll(value.prototype, suffix, filter, promisifier,
              multiArgs);
          promisifyAll(value, suffix, filter, promisifier, multiArgs);
      }
  }
  
  return promisifyAll(target, suffix, filter, promisifier, multiArgs);
  ...

function bluebird.util.isError (obj)

• description and source-code

  function isError(obj) {
      return obj instanceof Error ||
          (obj !== null &&
             typeof obj === "object" &&
             typeof obj.message === "string" &&
             typeof obj.name === "string");
  }

• example usage

  n/a

function bluebird.util.isIdentifier (str)

• description and source-code

  function isIdentifier(str) {
      return rident.test(str);
  }

• example usage

  ...
      "callee",
      "prototype",
      "__isPromisified__"
  ];
  var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$");
  
  var defaultFilter = function(name) {
      return util.isIdentifier(name) &&
          name.charAt(0) !== "_" &&
          name !== "constructor";
  };
  
  function propsFilter(key) {
      return !noCopyPropsPattern.test(key);
  }
  ...

function bluebird.util.isObject (value)

• description and source-code

  function isObject(value) {
      return typeof value === "function" ||
             typeof value === "object" && value !== null;
  }

• example usage

  ...
  } 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;
          }
      }
  ...

function bluebird.util.isPrimitive (val)

• description and source-code

  function isPrimitive(val) {
      return val == null || val === true || val === false ||
          typeof val === "string" || typeof val === "number";
  
  }

• example usage

  n/a

function bluebird.util.markAsOriginatingFromRejection (e)

• description and source-code

  function markAsOriginatingFromRejection(e) {
      try {
          notEnumerableProp(e, "isOperational", true);
      }
      catch(ignore) {}
  }

• example usage

  ...
          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) {
  ...

function bluebird.util.maybeWrapAsError (maybeError)

• description and source-code

  function maybeWrapAsError(maybeError) {
      if (!isPrimitive(maybeError)) return maybeError;
  
      return new Error(safeToString(maybeError));
  }

• example usage

  n/a

function bluebird.util.notEnumerableProp (obj, name, value)

• description and source-code

  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;
  }

• example usage

  ...
          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 checkForgottenReturns(returnValue, promiseCreated, name, promise,
  ...

function bluebird.util.originatesFromRejection (e)

• description and source-code

  function originatesFromRejection(e) {
      if (e == null) return false;
      return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
          e["isOperational"] === true);
  }

• example usage

  n/a

function bluebird.util.thrower (r)

• description and source-code

  function thrower(r) {
      throw r;
  }

• example usage

  n/a

function bluebird.util.toFastProperties (obj)

• description and source-code

  function toFastProperties(obj) {
      /*jshint -W027,-W055,-W031*/
      function FakeConstructor() {}
      FakeConstructor.prototype = obj;
      var l = 8;
      while (l--) new FakeConstructor();
      return obj;
      eval(obj);
  }

• example usage

  ...
  _dereq_("./direct_resolve")(Promise);
  _dereq_("./synchronous_inspection")(Promise);
  _dereq_("./join")(
  Promise, PromiseArray, tryConvertToPromise, INTERNAL, async, getDomain);
  Promise.Promise = Promise;
  Promise.version = "3.5.1";
  
  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;
  ...

function bluebird.util.toString (obj)

• description and source-code

  function safeToString(obj) {
      try {
          return obj + "";
      } catch (e) {
          return "[no string representation]";
      }
  }

• example usage

  ...
  
  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 bluebird.util.tryCatch (fn)

• description and source-code

  function tryCatch(fn) {
      tryCatchTarget = fn;
      return tryCatcher;
  }

• example usage

  ...
  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 bluebird.util.withAppended (target, appendee)

• description and source-code

  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;
  }

• example usage

  n/a