| "use strict"; |
| module.exports = function() { |
| var makeSelfResolutionError = function () { |
| return new TypeError("circular promise resolution chain\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
| }; |
| var reflectHandler = function() { |
| return new Promise.PromiseInspection(this._target()); |
| }; |
| var apiRejection = function(msg) { |
| return Promise.reject(new TypeError(msg)); |
| }; |
| function Proxyable() {} |
| var UNDEFINED_BINDING = {}; |
| var util = require("./util"); |
| util.setReflectHandler(reflectHandler); |
| |
| var getDomain = function() { |
| var domain = process.domain; |
| if (domain === undefined) { |
| return null; |
| } |
| return domain; |
| }; |
| var getContextDefault = function() { |
| return null; |
| }; |
| var getContextDomain = function() { |
| return { |
| domain: getDomain(), |
| async: null |
| }; |
| }; |
| var AsyncResource = util.isNode && util.nodeSupportsAsyncResource ? |
| require("async_hooks").AsyncResource : null; |
| var getContextAsyncHooks = function() { |
| return { |
| domain: getDomain(), |
| async: new AsyncResource("Bluebird::Promise") |
| }; |
| }; |
| var getContext = util.isNode ? getContextDomain : getContextDefault; |
| util.notEnumerableProp(Promise, "_getContext", getContext); |
| var enableAsyncHooks = function() { |
| getContext = getContextAsyncHooks; |
| util.notEnumerableProp(Promise, "_getContext", getContextAsyncHooks); |
| }; |
| var disableAsyncHooks = function() { |
| getContext = getContextDomain; |
| util.notEnumerableProp(Promise, "_getContext", getContextDomain); |
| }; |
| |
| var es5 = require("./es5"); |
| var Async = require("./async"); |
| var async = new Async(); |
| es5.defineProperty(Promise, "_async", {value: async}); |
| var errors = require("./errors"); |
| var TypeError = Promise.TypeError = errors.TypeError; |
| Promise.RangeError = errors.RangeError; |
| var CancellationError = Promise.CancellationError = errors.CancellationError; |
| Promise.TimeoutError = errors.TimeoutError; |
| Promise.OperationalError = errors.OperationalError; |
| Promise.RejectionError = errors.OperationalError; |
| Promise.AggregateError = errors.AggregateError; |
| var INTERNAL = function(){}; |
| var APPLY = {}; |
| var NEXT_FILTER = {}; |
| var tryConvertToPromise = require("./thenables")(Promise, INTERNAL); |
| var PromiseArray = |
| require("./promise_array")(Promise, INTERNAL, |
| tryConvertToPromise, apiRejection, Proxyable); |
| var Context = require("./context")(Promise); |
| /*jshint unused:false*/ |
| var createContext = Context.create; |
| |
| var debug = require("./debuggability")(Promise, Context, |
| enableAsyncHooks, disableAsyncHooks); |
| var CapturedTrace = debug.CapturedTrace; |
| var PassThroughHandlerContext = |
| require("./finally")(Promise, tryConvertToPromise, NEXT_FILTER); |
| var catchFilter = require("./catch_filter")(NEXT_FILTER); |
| var nodebackForPromise = require("./nodeback"); |
| var errorObj = util.errorObj; |
| var tryCatch = util.tryCatch; |
| function check(self, executor) { |
| if (self == null || self.constructor !== Promise) { |
| throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a See http://goo.gl/MqrFmX\u000a"); |
| } |
| if (typeof executor !== "function") { |
| throw new TypeError("expecting a function but got " + util.classString(executor)); |
| } |
| |
| } |
| |
| function Promise(executor) { |
| if (executor !== INTERNAL) { |
| check(this, executor); |
| } |
| this._bitField = 0; |
| this._fulfillmentHandler0 = undefined; |
| this._rejectionHandler0 = undefined; |
| this._promise0 = undefined; |
| this._receiver0 = undefined; |
| this._resolveFromExecutor(executor); |
| this._promiseCreated(); |
| this._fireEvent("promiseCreated", this); |
| } |
| |
| Promise.prototype.toString = function () { |
| return "[object Promise]"; |
| }; |
| |
| Promise.prototype.caught = Promise.prototype["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]; |
| |
| if (typeof fn !== "function") { |
| throw new TypeError("The last argument to .catch() " + |
| "must be a function, got " + util.toString(fn)); |
| } |
| return this.then(undefined, catchFilter(catchInstances, fn, this)); |
| } |
| return this.then(undefined, fn); |
| }; |
| |
| Promise.prototype.reflect = function () { |
| return this._then(reflectHandler, |
| reflectHandler, undefined, this, undefined); |
| }; |
| |
| Promise.prototype.then = function (didFulfill, didReject) { |
| if (debug.warnings() && arguments.length > 0 && |
| typeof didFulfill !== "function" && |
| typeof didReject !== "function") { |
| var msg = ".then() only accepts functions but was passed: " + |
| util.classString(didFulfill); |
| if (arguments.length > 1) { |
| msg += ", " + util.classString(didReject); |
| } |
| this._warn(msg); |
| } |
| return this._then(didFulfill, didReject, undefined, undefined, undefined); |
| }; |
| |
| Promise.prototype.done = function (didFulfill, didReject) { |
| var promise = |
| this._then(didFulfill, didReject, undefined, undefined, undefined); |
| promise._setIsFinal(); |
| }; |
| |
| Promise.prototype.spread = function (fn) { |
| if (typeof fn !== "function") { |
| return apiRejection("expecting a function but got " + util.classString(fn)); |
| } |
| return this.all()._then(fn, undefined, undefined, APPLY, undefined); |
| }; |
| |
| Promise.prototype.toJSON = function () { |
| var ret = { |
| isFulfilled: false, |
| isRejected: false, |
| fulfillmentValue: undefined, |
| rejectionReason: undefined |
| }; |
| if (this.isFulfilled()) { |
| ret.fulfillmentValue = this.value(); |
| ret.isFulfilled = true; |
| } else if (this.isRejected()) { |
| ret.rejectionReason = this.reason(); |
| ret.isRejected = true; |
| } |
| return ret; |
| }; |
| |
| Promise.prototype.all = function () { |
| if (arguments.length > 0) { |
| this._warn(".all() was passed arguments but it does not take any"); |
| } |
| return new PromiseArray(this).promise(); |
| }; |
| |
| Promise.prototype.error = function (fn) { |
| return this.caught(util.originatesFromRejection, fn); |
| }; |
| |
| Promise.getNewLibraryCopy = module.exports; |
| |
| Promise.is = function (val) { |
| return val instanceof Promise; |
| }; |
| |
| Promise.fromNode = Promise.fromCallback = function(fn) { |
| var ret = new Promise(INTERNAL); |
| ret._captureStackTrace(); |
| var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs |
| : false; |
| var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs)); |
| if (result === errorObj) { |
| ret._rejectCallback(result.e, true); |
| } |
| if (!ret._isFateSealed()) ret._setAsyncGuaranteed(); |
| return ret; |
| }; |
| |
| Promise.all = function (promises) { |
| return new PromiseArray(promises).promise(); |
| }; |
| |
| Promise.cast = function (obj) { |
| var ret = tryConvertToPromise(obj); |
| if (!(ret instanceof Promise)) { |
| ret = new Promise(INTERNAL); |
| ret._captureStackTrace(); |
| ret._setFulfilled(); |
| ret._rejectionHandler0 = obj; |
| } |
| return ret; |
| }; |
| |
| Promise.resolve = Promise.fulfilled = Promise.cast; |
| |
| Promise.reject = Promise.rejected = function (reason) { |
| var ret = new Promise(INTERNAL); |
| ret._captureStackTrace(); |
| ret._rejectCallback(reason, true); |
| return ret; |
| }; |
| |
| Promise.setScheduler = function(fn) { |
| if (typeof fn !== "function") { |
| throw new TypeError("expecting a function but got " + util.classString(fn)); |
| } |
| return async.setScheduler(fn); |
| }; |
| |
| Promise.prototype._then = function ( |
| didFulfill, |
| didReject, |
| _, receiver, |
| internalData |
| ) { |
| var haveInternalData = internalData !== undefined; |
| var promise = haveInternalData ? internalData : new Promise(INTERNAL); |
| var target = this._target(); |
| var bitField = target._bitField; |
| |
| if (!haveInternalData) { |
| promise._propagateFrom(this, 3); |
| promise._captureStackTrace(); |
| if (receiver === undefined && |
| ((this._bitField & 2097152) !== 0)) { |
| if (!((bitField & 50397184) === 0)) { |
| receiver = this._boundValue(); |
| } else { |
| receiver = target === this ? undefined : this._boundTo; |
| } |
| } |
| this._fireEvent("promiseChained", this, promise); |
| } |
| |
| var context = getContext(); |
| if (!((bitField & 50397184) === 0)) { |
| var handler, value, settler = target._settlePromiseCtx; |
| if (((bitField & 33554432) !== 0)) { |
| value = target._rejectionHandler0; |
| handler = didFulfill; |
| } else if (((bitField & 16777216) !== 0)) { |
| value = target._fulfillmentHandler0; |
| handler = didReject; |
| target._unsetRejectionIsUnhandled(); |
| } else { |
| settler = target._settlePromiseLateCancellationObserver; |
| value = new CancellationError("late cancellation observer"); |
| target._attachExtraTrace(value); |
| handler = didReject; |
| } |
| |
| async.invoke(settler, target, { |
| handler: util.contextBind(context, handler), |
| promise: promise, |
| receiver: receiver, |
| value: value |
| }); |
| } else { |
| target._addCallbacks(didFulfill, didReject, promise, |
| receiver, context); |
| } |
| |
| return promise; |
| }; |
| |
| Promise.prototype._length = function () { |
| return this._bitField & 65535; |
| }; |
| |
| Promise.prototype._isFateSealed = function () { |
| return (this._bitField & 117506048) !== 0; |
| }; |
| |
| Promise.prototype._isFollowing = function () { |
| return (this._bitField & 67108864) === 67108864; |
| }; |
| |
| Promise.prototype._setLength = function (len) { |
| this._bitField = (this._bitField & -65536) | |
| (len & 65535); |
| }; |
| |
| Promise.prototype._setFulfilled = function () { |
| this._bitField = this._bitField | 33554432; |
| this._fireEvent("promiseFulfilled", this); |
| }; |
| |
| Promise.prototype._setRejected = function () { |
| this._bitField = this._bitField | 16777216; |
| this._fireEvent("promiseRejected", this); |
| }; |
| |
| Promise.prototype._setFollowing = function () { |
| this._bitField = this._bitField | 67108864; |
| this._fireEvent("promiseResolved", this); |
| }; |
| |
| Promise.prototype._setIsFinal = function () { |
| this._bitField = this._bitField | 4194304; |
| }; |
| |
| Promise.prototype._isFinal = function () { |
| return (this._bitField & 4194304) > 0; |
| }; |
| |
| Promise.prototype._unsetCancelled = function() { |
| this._bitField = this._bitField & (~65536); |
| }; |
| |
| Promise.prototype._setCancelled = function() { |
| this._bitField = this._bitField | 65536; |
| this._fireEvent("promiseCancelled", this); |
| }; |
| |
| Promise.prototype._setWillBeCancelled = function() { |
| this._bitField = this._bitField | 8388608; |
| }; |
| |
| Promise.prototype._setAsyncGuaranteed = function() { |
| if (async.hasCustomScheduler()) return; |
| var bitField = this._bitField; |
| this._bitField = bitField | |
| (((bitField & 536870912) >> 2) ^ |
| 134217728); |
| }; |
| |
| Promise.prototype._setNoAsyncGuarantee = function() { |
| this._bitField = (this._bitField | 536870912) & |
| (~134217728); |
| }; |
| |
| Promise.prototype._receiverAt = function (index) { |
| var ret = index === 0 ? this._receiver0 : this[ |
| index * 4 - 4 + 3]; |
| if (ret === UNDEFINED_BINDING) { |
| return undefined; |
| } else if (ret === undefined && this._isBound()) { |
| return this._boundValue(); |
| } |
| return ret; |
| }; |
| |
| Promise.prototype._promiseAt = function (index) { |
| return this[ |
| index * 4 - 4 + 2]; |
| }; |
| |
| Promise.prototype._fulfillmentHandlerAt = function (index) { |
| return this[ |
| index * 4 - 4 + 0]; |
| }; |
| |
| Promise.prototype._rejectionHandlerAt = function (index) { |
| return this[ |
| index * 4 - 4 + 1]; |
| }; |
| |
| Promise.prototype._boundValue = function() {}; |
| |
| Promise.prototype._migrateCallback0 = function (follower) { |
| var bitField = follower._bitField; |
| var fulfill = follower._fulfillmentHandler0; |
| var reject = follower._rejectionHandler0; |
| var promise = follower._promise0; |
| var receiver = follower._receiverAt(0); |
| if (receiver === undefined) receiver = UNDEFINED_BINDING; |
| this._addCallbacks(fulfill, reject, promise, receiver, null); |
| }; |
| |
| Promise.prototype._migrateCallbackAt = function (follower, index) { |
| var fulfill = follower._fulfillmentHandlerAt(index); |
| var reject = follower._rejectionHandlerAt(index); |
| var promise = follower._promiseAt(index); |
| var receiver = follower._receiverAt(index); |
| if (receiver === undefined) receiver = UNDEFINED_BINDING; |
| this._addCallbacks(fulfill, reject, promise, receiver, null); |
| }; |
| |
| Promise.prototype._addCallbacks = function ( |
| fulfill, |
| reject, |
| promise, |
| receiver, |
| context |
| ) { |
| var index = this._length(); |
| |
| if (index >= 65535 - 4) { |
| index = 0; |
| this._setLength(0); |
| } |
| |
| if (index === 0) { |
| this._promise0 = promise; |
| this._receiver0 = receiver; |
| if (typeof fulfill === "function") { |
| this._fulfillmentHandler0 = util.contextBind(context, fulfill); |
| } |
| if (typeof reject === "function") { |
| this._rejectionHandler0 = util.contextBind(context, reject); |
| } |
| } else { |
| var base = index * 4 - 4; |
| this[base + 2] = promise; |
| this[base + 3] = receiver; |
| if (typeof fulfill === "function") { |
| this[base + 0] = |
| util.contextBind(context, fulfill); |
| } |
| if (typeof reject === "function") { |
| this[base + 1] = |
| util.contextBind(context, reject); |
| } |
| } |
| this._setLength(index + 1); |
| return index; |
| }; |
| |
| Promise.prototype._proxy = function (proxyable, arg) { |
| this._addCallbacks(undefined, undefined, arg, proxyable, null); |
| }; |
| |
| Promise.prototype._resolveCallback = function(value, shouldBind) { |
| if (((this._bitField & 117506048) !== 0)) return; |
| if (value === this) |
| return this._rejectCallback(makeSelfResolutionError(), false); |
| var maybePromise = tryConvertToPromise(value, this); |
| if (!(maybePromise instanceof Promise)) return this._fulfill(value); |
| |
| if (shouldBind) this._propagateFrom(maybePromise, 2); |
| |
| |
| var promise = maybePromise._target(); |
| |
| if (promise === this) { |
| this._reject(makeSelfResolutionError()); |
| return; |
| } |
| |
| var bitField = promise._bitField; |
| if (((bitField & 50397184) === 0)) { |
| var len = this._length(); |
| if (len > 0) promise._migrateCallback0(this); |
| for (var i = 1; i < len; ++i) { |
| promise._migrateCallbackAt(this, i); |
| } |
| this._setFollowing(); |
| this._setLength(0); |
| this._setFollowee(maybePromise); |
| } else if (((bitField & 33554432) !== 0)) { |
| this._fulfill(promise._value()); |
| } else if (((bitField & 16777216) !== 0)) { |
| this._reject(promise._reason()); |
| } else { |
| var reason = new CancellationError("late cancellation observer"); |
| promise._attachExtraTrace(reason); |
| this._reject(reason); |
| } |
| }; |
| |
| Promise.prototype._rejectCallback = |
| function(reason, synchronous, ignoreNonErrorWarnings) { |
| var trace = util.ensureErrorObject(reason); |
| var hasStack = trace === reason; |
| if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) { |
| var message = "a promise was rejected with a non-error: " + |
| util.classString(reason); |
| this._warn(message, true); |
| } |
| this._attachExtraTrace(trace, synchronous ? hasStack : false); |
| this._reject(reason); |
| }; |
| |
| Promise.prototype._resolveFromExecutor = function (executor) { |
| if (executor === INTERNAL) return; |
| var promise = this; |
| this._captureStackTrace(); |
| this._pushContext(); |
| var synchronous = true; |
| var r = this._execute(executor, function(value) { |
| promise._resolveCallback(value); |
| }, function (reason) { |
| promise._rejectCallback(reason, synchronous); |
| }); |
| synchronous = false; |
| this._popContext(); |
| |
| if (r !== undefined) { |
| promise._rejectCallback(r, true); |
| } |
| }; |
| |
| Promise.prototype._settlePromiseFromHandler = function ( |
| handler, receiver, value, promise |
| ) { |
| var bitField = promise._bitField; |
| if (((bitField & 65536) !== 0)) return; |
| promise._pushContext(); |
| var x; |
| if (receiver === APPLY) { |
| if (!value || typeof value.length !== "number") { |
| x = errorObj; |
| x.e = new TypeError("cannot .spread() a non-array: " + |
| util.classString(value)); |
| } else { |
| x = tryCatch(handler).apply(this._boundValue(), value); |
| } |
| } else { |
| x = tryCatch(handler).call(receiver, value); |
| } |
| var promiseCreated = promise._popContext(); |
| bitField = promise._bitField; |
| if (((bitField & 65536) !== 0)) return; |
| |
| if (x === NEXT_FILTER) { |
| promise._reject(value); |
| } else if (x === errorObj) { |
| promise._rejectCallback(x.e, false); |
| } else { |
| debug.checkForgottenReturns(x, promiseCreated, "", promise, this); |
| promise._resolveCallback(x); |
| } |
| }; |
| |
| Promise.prototype._target = function() { |
| var ret = this; |
| while (ret._isFollowing()) ret = ret._followee(); |
| return ret; |
| }; |
| |
| Promise.prototype._followee = function() { |
| return this._rejectionHandler0; |
| }; |
| |
| Promise.prototype._setFollowee = function(promise) { |
| this._rejectionHandler0 = promise; |
| }; |
| |
| Promise.prototype._settlePromise = function(promise, handler, receiver, value) { |
| var isPromise = promise instanceof Promise; |
| var bitField = this._bitField; |
| var asyncGuaranteed = ((bitField & 134217728) !== 0); |
| if (((bitField & 65536) !== 0)) { |
| if (isPromise) promise._invokeInternalOnCancel(); |
| |
| if (receiver instanceof PassThroughHandlerContext && |
| receiver.isFinallyHandler()) { |
| receiver.cancelPromise = promise; |
| if (tryCatch(handler).call(receiver, value) === errorObj) { |
| promise._reject(errorObj.e); |
| } |
| } else if (handler === reflectHandler) { |
| promise._fulfill(reflectHandler.call(receiver)); |
| } else if (receiver instanceof Proxyable) { |
| receiver._promiseCancelled(promise); |
| } else if (isPromise || promise instanceof PromiseArray) { |
| promise._cancel(); |
| } else { |
| receiver.cancel(); |
| } |
| } else if (typeof handler === "function") { |
| if (!isPromise) { |
| handler.call(receiver, value, promise); |
| } else { |
| if (asyncGuaranteed) promise._setAsyncGuaranteed(); |
| this._settlePromiseFromHandler(handler, receiver, value, promise); |
| } |
| } else if (receiver instanceof Proxyable) { |
| if (!receiver._isResolved()) { |
| if (((bitField & 33554432) !== 0)) { |
| receiver._promiseFulfilled(value, promise); |
| } else { |
| receiver._promiseRejected(value, promise); |
| } |
| } |
| } else if (isPromise) { |
| if (asyncGuaranteed) promise._setAsyncGuaranteed(); |
| if (((bitField & 33554432) !== 0)) { |
| promise._fulfill(value); |
| } else { |
| promise._reject(value); |
| } |
| } |
| }; |
| |
| Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) { |
| var handler = ctx.handler; |
| var promise = ctx.promise; |
| var receiver = ctx.receiver; |
| var value = ctx.value; |
| if (typeof handler === "function") { |
| if (!(promise instanceof Promise)) { |
| handler.call(receiver, value, promise); |
| } else { |
| this._settlePromiseFromHandler(handler, receiver, value, promise); |
| } |
| } else if (promise instanceof Promise) { |
| promise._reject(value); |
| } |
| }; |
| |
| Promise.prototype._settlePromiseCtx = function(ctx) { |
| this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value); |
| }; |
| |
| Promise.prototype._settlePromise0 = function(handler, value, bitField) { |
| var promise = this._promise0; |
| var receiver = this._receiverAt(0); |
| this._promise0 = undefined; |
| this._receiver0 = undefined; |
| this._settlePromise(promise, handler, receiver, value); |
| }; |
| |
| Promise.prototype._clearCallbackDataAtIndex = function(index) { |
| var base = index * 4 - 4; |
| this[base + 2] = |
| this[base + 3] = |
| this[base + 0] = |
| this[base + 1] = undefined; |
| }; |
| |
| Promise.prototype._fulfill = function (value) { |
| var bitField = this._bitField; |
| if (((bitField & 117506048) >>> 16)) return; |
| if (value === this) { |
| var err = makeSelfResolutionError(); |
| this._attachExtraTrace(err); |
| return this._reject(err); |
| } |
| this._setFulfilled(); |
| this._rejectionHandler0 = value; |
| |
| if ((bitField & 65535) > 0) { |
| if (((bitField & 134217728) !== 0)) { |
| this._settlePromises(); |
| } else { |
| async.settlePromises(this); |
| } |
| this._dereferenceTrace(); |
| } |
| }; |
| |
| Promise.prototype._reject = function (reason) { |
| var bitField = this._bitField; |
| if (((bitField & 117506048) >>> 16)) return; |
| this._setRejected(); |
| this._fulfillmentHandler0 = reason; |
| |
| if (this._isFinal()) { |
| return async.fatalError(reason, util.isNode); |
| } |
| |
| if ((bitField & 65535) > 0) { |
| async.settlePromises(this); |
| } else { |
| this._ensurePossibleRejectionHandled(); |
| } |
| }; |
| |
| Promise.prototype._fulfillPromises = function (len, value) { |
| for (var i = 1; i < len; i++) { |
| var handler = this._fulfillmentHandlerAt(i); |
| var promise = this._promiseAt(i); |
| var receiver = this._receiverAt(i); |
| this._clearCallbackDataAtIndex(i); |
| this._settlePromise(promise, handler, receiver, value); |
| } |
| }; |
| |
| Promise.prototype._rejectPromises = function (len, reason) { |
| for (var i = 1; i < len; i++) { |
| var handler = this._rejectionHandlerAt(i); |
| var promise = this._promiseAt(i); |
| var receiver = this._receiverAt(i); |
| this._clearCallbackDataAtIndex(i); |
| this._settlePromise(promise, handler, receiver, reason); |
| } |
| }; |
| |
| Promise.prototype._settlePromises = function () { |
| var bitField = this._bitField; |
| var len = (bitField & 65535); |
| |
| if (len > 0) { |
| if (((bitField & 16842752) !== 0)) { |
| var reason = this._fulfillmentHandler0; |
| this._settlePromise0(this._rejectionHandler0, reason, bitField); |
| this._rejectPromises(len, reason); |
| } else { |
| var value = this._rejectionHandler0; |
| this._settlePromise0(this._fulfillmentHandler0, value, bitField); |
| this._fulfillPromises(len, value); |
| } |
| this._setLength(0); |
| } |
| this._clearCancellationData(); |
| }; |
| |
| Promise.prototype._settledValue = function() { |
| var bitField = this._bitField; |
| if (((bitField & 33554432) !== 0)) { |
| return this._rejectionHandler0; |
| } else if (((bitField & 16777216) !== 0)) { |
| return this._fulfillmentHandler0; |
| } |
| }; |
| |
| if (typeof Symbol !== "undefined" && Symbol.toStringTag) { |
| es5.defineProperty(Promise.prototype, Symbol.toStringTag, { |
| get: function () { |
| return "Object"; |
| } |
| }); |
| } |
| |
| function deferResolve(v) {this.promise._resolveCallback(v);} |
| function deferReject(v) {this.promise._rejectCallback(v, false);} |
| |
| Promise.defer = Promise.pending = function() { |
| debug.deprecated("Promise.defer", "new Promise"); |
| var promise = new Promise(INTERNAL); |
| return { |
| promise: promise, |
| resolve: deferResolve, |
| reject: deferReject |
| }; |
| }; |
| |
| util.notEnumerableProp(Promise, |
| "_makeSelfResolutionError", |
| makeSelfResolutionError); |
| |
| require("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection, |
| debug); |
| require("./bind")(Promise, INTERNAL, tryConvertToPromise, debug); |
| require("./cancel")(Promise, PromiseArray, apiRejection, debug); |
| require("./direct_resolve")(Promise); |
| require("./synchronous_inspection")(Promise); |
| require("./join")( |
| Promise, PromiseArray, tryConvertToPromise, INTERNAL, async); |
| Promise.Promise = Promise; |
| Promise.version = "3.7.1"; |
| require('./call_get.js')(Promise); |
| require('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug); |
| require('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); |
| require('./nodeify.js')(Promise); |
| require('./promisify.js')(Promise, INTERNAL); |
| require('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection); |
| require('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection); |
| require('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); |
| require('./settle.js')(Promise, PromiseArray, debug); |
| require('./some.js')(Promise, PromiseArray, apiRejection); |
| require('./timers.js')(Promise, INTERNAL, debug); |
| require('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug); |
| require('./any.js')(Promise); |
| require('./each.js')(Promise, INTERNAL); |
| require('./filter.js')(Promise, INTERNAL); |
| |
| util.toFastProperties(Promise); |
| util.toFastProperties(Promise.prototype); |
| function fillTypes(value) { |
| var p = new Promise(INTERNAL); |
| p._fulfillmentHandler0 = value; |
| p._rejectionHandler0 = value; |
| p._promise0 = value; |
| p._receiver0 = value; |
| } |
| // Complete slack tracking, opt out of field-type tracking and |
| // stabilize map |
| fillTypes({a: 1}); |
| fillTypes({b: 2}); |
| fillTypes({c: 3}); |
| fillTypes(1); |
| fillTypes(function(){}); |
| fillTypes(undefined); |
| fillTypes(false); |
| fillTypes(new Promise(INTERNAL)); |
| debug.setBounds(Async.firstLineError, util.lastLineError); |
| return Promise; |
| |
| }; |