twitst4tz

promise.js (26986B)

---

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