www.aleph1.co.uk Git - yaffs-website/blob - node_modules/bluebird/js/release/promise.js

   1 "use strict";
   2 module.exports = function() {
   3 var makeSelfResolutionError = function () {
   4     return new TypeError("circular promise resolution chain\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
   5 };
   6 var reflectHandler = function() {
   7     return new Promise.PromiseInspection(this._target());
   8 };
   9 var apiRejection = function(msg) {
  10     return Promise.reject(new TypeError(msg));
  11 };
  12 function Proxyable() {}
  13 var UNDEFINED_BINDING = {};
  14 var util = require("./util");
  15
  16 var getDomain;
  17 if (util.isNode) {
  18     getDomain = function() {
  19         var ret = process.domain;
  20         if (ret === undefined) ret = null;
  21         return ret;
  22     };
  23 } else {
  24     getDomain = function() {
  25         return null;
  26     };
  27 }
  28 util.notEnumerableProp(Promise, "_getDomain", getDomain);
  29
  30 var es5 = require("./es5");
  31 var Async = require("./async");
  32 var async = new Async();
  33 es5.defineProperty(Promise, "_async", {value: async});
  34 var errors = require("./errors");
  35 var TypeError = Promise.TypeError = errors.TypeError;
  36 Promise.RangeError = errors.RangeError;
  37 var CancellationError = Promise.CancellationError = errors.CancellationError;
  38 Promise.TimeoutError = errors.TimeoutError;
  39 Promise.OperationalError = errors.OperationalError;
  40 Promise.RejectionError = errors.OperationalError;
  41 Promise.AggregateError = errors.AggregateError;
  42 var INTERNAL = function(){};
  43 var APPLY = {};
  44 var NEXT_FILTER = {};
  45 var tryConvertToPromise = require("./thenables")(Promise, INTERNAL);
  46 var PromiseArray =
  47     require("./promise_array")(Promise, INTERNAL,
  48                                tryConvertToPromise, apiRejection, Proxyable);
  49 var Context = require("./context")(Promise);
  50  /*jshint unused:false*/
  51 var createContext = Context.create;
  52 var debug = require("./debuggability")(Promise, Context);
  53 var CapturedTrace = debug.CapturedTrace;
  54 var PassThroughHandlerContext =
  55     require("./finally")(Promise, tryConvertToPromise);
  56 var catchFilter = require("./catch_filter")(NEXT_FILTER);
  57 var nodebackForPromise = require("./nodeback");
  58 var errorObj = util.errorObj;
  59 var tryCatch = util.tryCatch;
  60 function check(self, executor) {
  61     if (typeof executor !== "function") {
  62         throw new TypeError("expecting a function but got " + util.classString(executor));
  63     }
  64     if (self.constructor !== Promise) {
  65         throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
  66     }
  67 }
  68
  69 function Promise(executor) {
  70     this._bitField = 0;
  71     this._fulfillmentHandler0 = undefined;
  72     this._rejectionHandler0 = undefined;
  73     this._promise0 = undefined;
  74     this._receiver0 = undefined;
  75     if (executor !== INTERNAL) {
  76         check(this, executor);
  77         this._resolveFromExecutor(executor);
  78     }
  79     this._promiseCreated();
  80 }
  81
  82 Promise.prototype.toString = function () {
  83     return "[object Promise]";
  84 };
  85
  86 Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
  87     var len = arguments.length;
  88     if (len > 1) {
  89         var catchInstances = new Array(len - 1),
  90             j = 0, i;
  91         for (i = 0; i < len - 1; ++i) {
  92             var item = arguments[i];
  93             if (util.isObject(item)) {
  94                 catchInstances[j++] = item;
  95             } else {
  96                 return apiRejection("expecting an object but got " + util.classString(item));
  97             }
  98         }
  99         catchInstances.length = j;
 100         fn = arguments[i];
 101         return this.then(undefined, catchFilter(catchInstances, fn, this));
 102     }
 103     return this.then(undefined, fn);
 104 };
 105
 106 Promise.prototype.reflect = function () {
 107     return this._then(reflectHandler,
 108         reflectHandler, undefined, this, undefined);
 109 };
 110
 111 Promise.prototype.then = function (didFulfill, didReject) {
 112     if (debug.warnings() && arguments.length > 0 &&
 113         typeof didFulfill !== "function" &&
 114         typeof didReject !== "function") {
 115         var msg = ".then() only accepts functions but was passed: " +
 116                 util.classString(didFulfill);
 117         if (arguments.length > 1) {
 118             msg += ", " + util.classString(didReject);
 119         }
 120         this._warn(msg);
 121     }
 122     return this._then(didFulfill, didReject, undefined, undefined, undefined);
 123 };
 124
 125 Promise.prototype.done = function (didFulfill, didReject) {
 126     var promise =
 127         this._then(didFulfill, didReject, undefined, undefined, undefined);
 128     promise._setIsFinal();
 129 };
 130
 131 Promise.prototype.spread = function (fn) {
 132     if (typeof fn !== "function") {
 133         return apiRejection("expecting a function but got " + util.classString(fn));
 134     }
 135     return this.all()._then(fn, undefined, undefined, APPLY, undefined);
 136 };
 137
 138 Promise.prototype.toJSON = function () {
 139     var ret = {
 140         isFulfilled: false,
 141         isRejected: false,
 142         fulfillmentValue: undefined,
 143         rejectionReason: undefined
 144     };
 145     if (this.isFulfilled()) {
 146         ret.fulfillmentValue = this.value();
 147         ret.isFulfilled = true;
 148     } else if (this.isRejected()) {
 149         ret.rejectionReason = this.reason();
 150         ret.isRejected = true;
 151     }
 152     return ret;
 153 };
 154
 155 Promise.prototype.all = function () {
 156     if (arguments.length > 0) {
 157         this._warn(".all() was passed arguments but it does not take any");
 158     }
 159     return new PromiseArray(this).promise();
 160 };
 161
 162 Promise.prototype.error = function (fn) {
 163     return this.caught(util.originatesFromRejection, fn);
 164 };
 165
 166 Promise.is = function (val) {
 167     return val instanceof Promise;
 168 };
 169
 170 Promise.fromNode = Promise.fromCallback = function(fn) {
 171     var ret = new Promise(INTERNAL);
 172     ret._captureStackTrace();
 173     var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs
 174                                          : false;
 175     var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));
 176     if (result === errorObj) {
 177         ret._rejectCallback(result.e, true);
 178     }
 179     if (!ret._isFateSealed()) ret._setAsyncGuaranteed();
 180     return ret;
 181 };
 182
 183 Promise.all = function (promises) {
 184     return new PromiseArray(promises).promise();
 185 };
 186
 187 Promise.cast = function (obj) {
 188     var ret = tryConvertToPromise(obj);
 189     if (!(ret instanceof Promise)) {
 190         ret = new Promise(INTERNAL);
 191         ret._captureStackTrace();
 192         ret._setFulfilled();
 193         ret._rejectionHandler0 = obj;
 194     }
 195     return ret;
 196 };
 197
 198 Promise.resolve = Promise.fulfilled = Promise.cast;
 199
 200 Promise.reject = Promise.rejected = function (reason) {
 201     var ret = new Promise(INTERNAL);
 202     ret._captureStackTrace();
 203     ret._rejectCallback(reason, true);
 204     return ret;
 205 };
 206
 207 Promise.setScheduler = function(fn) {
 208     if (typeof fn !== "function") {
 209         throw new TypeError("expecting a function but got " + util.classString(fn));
 210     }
 211     var prev = async._schedule;
 212     async._schedule = fn;
 213     return prev;
 214 };
 215
 216 Promise.prototype._then = function (
 217     didFulfill,
 218     didReject,
 219     _,    receiver,
 220     internalData
 221 ) {
 222     var haveInternalData = internalData !== undefined;
 223     var promise = haveInternalData ? internalData : new Promise(INTERNAL);
 224     var target = this._target();
 225     var bitField = target._bitField;
 226
 227     if (!haveInternalData) {
 228         promise._propagateFrom(this, 3);
 229         promise._captureStackTrace();
 230         if (receiver === undefined &&
 231             ((this._bitField & 2097152) !== 0)) {
 232             if (!((bitField & 50397184) === 0)) {
 233                 receiver = this._boundValue();
 234             } else {
 235                 receiver = target === this ? undefined : this._boundTo;
 236             }
 237         }
 238     }
 239
 240     var domain = getDomain();
 241     if (!((bitField & 50397184) === 0)) {
 242         var handler, value, settler = target._settlePromiseCtx;
 243         if (((bitField & 33554432) !== 0)) {
 244             value = target._rejectionHandler0;
 245             handler = didFulfill;
 246         } else if (((bitField & 16777216) !== 0)) {
 247             value = target._fulfillmentHandler0;
 248             handler = didReject;
 249             target._unsetRejectionIsUnhandled();
 250         } else {
 251             settler = target._settlePromiseLateCancellationObserver;
 252             value = new CancellationError("late cancellation observer");
 253             target._attachExtraTrace(value);
 254             handler = didReject;
 255         }
 256
 257         async.invoke(settler, target, {
 258             handler: domain === null ? handler
 259                 : (typeof handler === "function" && domain.bind(handler)),
 260             promise: promise,
 261             receiver: receiver,
 262             value: value
 263         });
 264     } else {
 265         target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
 266     }
 267
 268     return promise;
 269 };
 270
 271 Promise.prototype._length = function () {
 272     return this._bitField & 65535;
 273 };
 274
 275 Promise.prototype._isFateSealed = function () {
 276     return (this._bitField & 117506048) !== 0;
 277 };
 278
 279 Promise.prototype._isFollowing = function () {
 280     return (this._bitField & 67108864) === 67108864;
 281 };
 282
 283 Promise.prototype._setLength = function (len) {
 284     this._bitField = (this._bitField & -65536) |
 285         (len & 65535);
 286 };
 287
 288 Promise.prototype._setFulfilled = function () {
 289     this._bitField = this._bitField | 33554432;
 290 };
 291
 292 Promise.prototype._setRejected = function () {
 293     this._bitField = this._bitField | 16777216;
 294 };
 295
 296 Promise.prototype._setFollowing = function () {
 297     this._bitField = this._bitField | 67108864;
 298 };
 299
 300 Promise.prototype._setIsFinal = function () {
 301     this._bitField = this._bitField | 4194304;
 302 };
 303
 304 Promise.prototype._isFinal = function () {
 305     return (this._bitField & 4194304) > 0;
 306 };
 307
 308 Promise.prototype._unsetCancelled = function() {
 309     this._bitField = this._bitField & (~65536);
 310 };
 311
 312 Promise.prototype._setCancelled = function() {
 313     this._bitField = this._bitField | 65536;
 314 };
 315
 316 Promise.prototype._setAsyncGuaranteed = function() {
 317     this._bitField = this._bitField | 134217728;
 318 };
 319
 320 Promise.prototype._receiverAt = function (index) {
 321     var ret = index === 0 ? this._receiver0 : this[
 322             index * 4 - 4 + 3];
 323     if (ret === UNDEFINED_BINDING) {
 324         return undefined;
 325     } else if (ret === undefined && this._isBound()) {
 326         return this._boundValue();
 327     }
 328     return ret;
 329 };
 330
 331 Promise.prototype._promiseAt = function (index) {
 332     return this[
 333             index * 4 - 4 + 2];
 334 };
 335
 336 Promise.prototype._fulfillmentHandlerAt = function (index) {
 337     return this[
 338             index * 4 - 4 + 0];
 339 };
 340
 341 Promise.prototype._rejectionHandlerAt = function (index) {
 342     return this[
 343             index * 4 - 4 + 1];
 344 };
 345
 346 Promise.prototype._boundValue = function() {};
 347
 348 Promise.prototype._migrateCallback0 = function (follower) {
 349     var bitField = follower._bitField;
 350     var fulfill = follower._fulfillmentHandler0;
 351     var reject = follower._rejectionHandler0;
 352     var promise = follower._promise0;
 353     var receiver = follower._receiverAt(0);
 354     if (receiver === undefined) receiver = UNDEFINED_BINDING;
 355     this._addCallbacks(fulfill, reject, promise, receiver, null);
 356 };
 357
 358 Promise.prototype._migrateCallbackAt = function (follower, index) {
 359     var fulfill = follower._fulfillmentHandlerAt(index);
 360     var reject = follower._rejectionHandlerAt(index);
 361     var promise = follower._promiseAt(index);
 362     var receiver = follower._receiverAt(index);
 363     if (receiver === undefined) receiver = UNDEFINED_BINDING;
 364     this._addCallbacks(fulfill, reject, promise, receiver, null);
 365 };
 366
 367 Promise.prototype._addCallbacks = function (
 368     fulfill,
 369     reject,
 370     promise,
 371     receiver,
 372     domain
 373 ) {
 374     var index = this._length();
 375
 376     if (index >= 65535 - 4) {
 377         index = 0;
 378         this._setLength(0);
 379     }
 380
 381     if (index === 0) {
 382         this._promise0 = promise;
 383         this._receiver0 = receiver;
 384         if (typeof fulfill === "function") {
 385             this._fulfillmentHandler0 =
 386                 domain === null ? fulfill : domain.bind(fulfill);
 387         }
 388         if (typeof reject === "function") {
 389             this._rejectionHandler0 =
 390                 domain === null ? reject : domain.bind(reject);
 391         }
 392     } else {
 393         var base = index * 4 - 4;
 394         this[base + 2] = promise;
 395         this[base + 3] = receiver;
 396         if (typeof fulfill === "function") {
 397             this[base + 0] =
 398                 domain === null ? fulfill : domain.bind(fulfill);
 399         }
 400         if (typeof reject === "function") {
 401             this[base + 1] =
 402                 domain === null ? reject : domain.bind(reject);
 403         }
 404     }
 405     this._setLength(index + 1);
 406     return index;
 407 };
 408
 409 Promise.prototype._proxy = function (proxyable, arg) {
 410     this._addCallbacks(undefined, undefined, arg, proxyable, null);
 411 };
 412
 413 Promise.prototype._resolveCallback = function(value, shouldBind) {
 414     if (((this._bitField & 117506048) !== 0)) return;
 415     if (value === this)
 416         return this._rejectCallback(makeSelfResolutionError(), false);
 417     var maybePromise = tryConvertToPromise(value, this);
 418     if (!(maybePromise instanceof Promise)) return this._fulfill(value);
 419
 420     if (shouldBind) this._propagateFrom(maybePromise, 2);
 421
 422     var promise = maybePromise._target();
 423     var bitField = promise._bitField;
 424     if (((bitField & 50397184) === 0)) {
 425         var len = this._length();
 426         if (len > 0) promise._migrateCallback0(this);
 427         for (var i = 1; i < len; ++i) {
 428             promise._migrateCallbackAt(this, i);
 429         }
 430         this._setFollowing();
 431         this._setLength(0);
 432         this._setFollowee(promise);
 433     } else if (((bitField & 33554432) !== 0)) {
 434         this._fulfill(promise._value());
 435     } else if (((bitField & 16777216) !== 0)) {
 436         this._reject(promise._reason());
 437     } else {
 438         var reason = new CancellationError("late cancellation observer");
 439         promise._attachExtraTrace(reason);
 440         this._reject(reason);
 441     }
 442 };
 443
 444 Promise.prototype._rejectCallback =
 445 function(reason, synchronous, ignoreNonErrorWarnings) {
 446     var trace = util.ensureErrorObject(reason);
 447     var hasStack = trace === reason;
 448     if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {
 449         var message = "a promise was rejected with a non-error: " +
 450             util.classString(reason);
 451         this._warn(message, true);
 452     }
 453     this._attachExtraTrace(trace, synchronous ? hasStack : false);
 454     this._reject(reason);
 455 };
 456
 457 Promise.prototype._resolveFromExecutor = function (executor) {
 458     var promise = this;
 459     this._captureStackTrace();
 460     this._pushContext();
 461     var synchronous = true;
 462     var r = this._execute(executor, function(value) {
 463         promise._resolveCallback(value);
 464     }, function (reason) {
 465         promise._rejectCallback(reason, synchronous);
 466     });
 467     synchronous = false;
 468     this._popContext();
 469
 470     if (r !== undefined) {
 471         promise._rejectCallback(r, true);
 472     }
 473 };
 474
 475 Promise.prototype._settlePromiseFromHandler = function (
 476     handler, receiver, value, promise
 477 ) {
 478     var bitField = promise._bitField;
 479     if (((bitField & 65536) !== 0)) return;
 480     promise._pushContext();
 481     var x;
 482     if (receiver === APPLY) {
 483         if (!value || typeof value.length !== "number") {
 484             x = errorObj;
 485             x.e = new TypeError("cannot .spread() a non-array: " +
 486                                     util.classString(value));
 487         } else {
 488             x = tryCatch(handler).apply(this._boundValue(), value);
 489         }
 490     } else {
 491         x = tryCatch(handler).call(receiver, value);
 492     }
 493     var promiseCreated = promise._popContext();
 494     bitField = promise._bitField;
 495     if (((bitField & 65536) !== 0)) return;
 496
 497     if (x === NEXT_FILTER) {
 498         promise._reject(value);
 499     } else if (x === errorObj || x === promise) {
 500         var err = x === promise ? makeSelfResolutionError() : x.e;
 501         promise._rejectCallback(err, false);
 502     } else {
 503         debug.checkForgottenReturns(x, promiseCreated, "",  promise, this);
 504         promise._resolveCallback(x);
 505     }
 506 };
 507
 508 Promise.prototype._target = function() {
 509     var ret = this;
 510     while (ret._isFollowing()) ret = ret._followee();
 511     return ret;
 512 };
 513
 514 Promise.prototype._followee = function() {
 515     return this._rejectionHandler0;
 516 };
 517
 518 Promise.prototype._setFollowee = function(promise) {
 519     this._rejectionHandler0 = promise;
 520 };
 521
 522 Promise.prototype._settlePromise = function(promise, handler, receiver, value) {
 523     var isPromise = promise instanceof Promise;
 524     var bitField = this._bitField;
 525     var asyncGuaranteed = ((bitField & 134217728) !== 0);
 526     if (((bitField & 65536) !== 0)) {
 527         if (isPromise) promise._invokeInternalOnCancel();
 528
 529         if (receiver instanceof PassThroughHandlerContext) {
 530             receiver.cancelPromise = promise;
 531             if (tryCatch(handler).call(receiver, value) === errorObj) {
 532                 promise._reject(errorObj.e);
 533             }
 534         } else if (handler === reflectHandler) {
 535             promise._fulfill(reflectHandler.call(receiver));
 536         } else if (receiver instanceof Proxyable) {
 537             receiver._promiseCancelled(promise);
 538         } else if (isPromise || promise instanceof PromiseArray) {
 539             promise._cancel();
 540         } else {
 541             receiver.cancel();
 542         }
 543     } else if (typeof handler === "function") {
 544         if (!isPromise) {
 545             handler.call(receiver, value, promise);
 546         } else {
 547             if (asyncGuaranteed) promise._setAsyncGuaranteed();
 548             this._settlePromiseFromHandler(handler, receiver, value, promise);
 549         }
 550     } else if (receiver instanceof Proxyable) {
 551         if (!receiver._isResolved()) {
 552             if (((bitField & 33554432) !== 0)) {
 553                 receiver._promiseFulfilled(value, promise);
 554             } else {
 555                 receiver._promiseRejected(value, promise);
 556             }
 557         }
 558     } else if (isPromise) {
 559         if (asyncGuaranteed) promise._setAsyncGuaranteed();
 560         if (((bitField & 33554432) !== 0)) {
 561             promise._fulfill(value);
 562         } else {
 563             promise._reject(value);
 564         }
 565     }
 566 };
 567
 568 Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) {
 569     var handler = ctx.handler;
 570     var promise = ctx.promise;
 571     var receiver = ctx.receiver;
 572     var value = ctx.value;
 573     if (typeof handler === "function") {
 574         if (!(promise instanceof Promise)) {
 575             handler.call(receiver, value, promise);
 576         } else {
 577             this._settlePromiseFromHandler(handler, receiver, value, promise);
 578         }
 579     } else if (promise instanceof Promise) {
 580         promise._reject(value);
 581     }
 582 };
 583
 584 Promise.prototype._settlePromiseCtx = function(ctx) {
 585     this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
 586 };
 587
 588 Promise.prototype._settlePromise0 = function(handler, value, bitField) {
 589     var promise = this._promise0;
 590     var receiver = this._receiverAt(0);
 591     this._promise0 = undefined;
 592     this._receiver0 = undefined;
 593     this._settlePromise(promise, handler, receiver, value);
 594 };
 595
 596 Promise.prototype._clearCallbackDataAtIndex = function(index) {
 597     var base = index * 4 - 4;
 598     this[base + 2] =
 599     this[base + 3] =
 600     this[base + 0] =
 601     this[base + 1] = undefined;
 602 };
 603
 604 Promise.prototype._fulfill = function (value) {
 605     var bitField = this._bitField;
 606     if (((bitField & 117506048) >>> 16)) return;
 607     if (value === this) {
 608         var err = makeSelfResolutionError();
 609         this._attachExtraTrace(err);
 610         return this._reject(err);
 611     }
 612     this._setFulfilled();
 613     this._rejectionHandler0 = value;
 614
 615     if ((bitField & 65535) > 0) {
 616         if (((bitField & 134217728) !== 0)) {
 617             this._settlePromises();
 618         } else {
 619             async.settlePromises(this);
 620         }
 621     }
 622 };
 623
 624 Promise.prototype._reject = function (reason) {
 625     var bitField = this._bitField;
 626     if (((bitField & 117506048) >>> 16)) return;
 627     this._setRejected();
 628     this._fulfillmentHandler0 = reason;
 629
 630     if (this._isFinal()) {
 631         return async.fatalError(reason, util.isNode);
 632     }
 633
 634     if ((bitField & 65535) > 0) {
 635         if (((bitField & 134217728) !== 0)) {
 636             this._settlePromises();
 637         } else {
 638             async.settlePromises(this);
 639         }
 640     } else {
 641         this._ensurePossibleRejectionHandled();
 642     }
 643 };
 644
 645 Promise.prototype._fulfillPromises = function (len, value) {
 646     for (var i = 1; i < len; i++) {
 647         var handler = this._fulfillmentHandlerAt(i);
 648         var promise = this._promiseAt(i);
 649         var receiver = this._receiverAt(i);
 650         this._clearCallbackDataAtIndex(i);
 651         this._settlePromise(promise, handler, receiver, value);
 652     }
 653 };
 654
 655 Promise.prototype._rejectPromises = function (len, reason) {
 656     for (var i = 1; i < len; i++) {
 657         var handler = this._rejectionHandlerAt(i);
 658         var promise = this._promiseAt(i);
 659         var receiver = this._receiverAt(i);
 660         this._clearCallbackDataAtIndex(i);
 661         this._settlePromise(promise, handler, receiver, reason);
 662     }
 663 };
 664
 665 Promise.prototype._settlePromises = function () {
 666     var bitField = this._bitField;
 667     var len = (bitField & 65535);
 668
 669     if (len > 0) {
 670         if (((bitField & 16842752) !== 0)) {
 671             var reason = this._fulfillmentHandler0;
 672             this._settlePromise0(this._rejectionHandler0, reason, bitField);
 673             this._rejectPromises(len, reason);
 674         } else {
 675             var value = this._rejectionHandler0;
 676             this._settlePromise0(this._fulfillmentHandler0, value, bitField);
 677             this._fulfillPromises(len, value);
 678         }
 679         this._setLength(0);
 680     }
 681     this._clearCancellationData();
 682 };
 683
 684 Promise.prototype._settledValue = function() {
 685     var bitField = this._bitField;
 686     if (((bitField & 33554432) !== 0)) {
 687         return this._rejectionHandler0;
 688     } else if (((bitField & 16777216) !== 0)) {
 689         return this._fulfillmentHandler0;
 690     }
 691 };
 692
 693 function deferResolve(v) {this.promise._resolveCallback(v);}
 694 function deferReject(v) {this.promise._rejectCallback(v, false);}
 695
 696 Promise.defer = Promise.pending = function() {
 697     debug.deprecated("Promise.defer", "new Promise");
 698     var promise = new Promise(INTERNAL);
 699     return {
 700         promise: promise,
 701         resolve: deferResolve,
 702         reject: deferReject
 703     };
 704 };
 705
 706 util.notEnumerableProp(Promise,
 707                        "_makeSelfResolutionError",
 708                        makeSelfResolutionError);
 709
 710 require("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection,
 711     debug);
 712 require("./bind")(Promise, INTERNAL, tryConvertToPromise, debug);
 713 require("./cancel")(Promise, PromiseArray, apiRejection, debug);
 714 require("./direct_resolve")(Promise);
 715 require("./synchronous_inspection")(Promise);
 716 require("./join")(
 717     Promise, PromiseArray, tryConvertToPromise, INTERNAL, debug);
 718 Promise.Promise = Promise;
 719 require('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
 720 require('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug);
 721 require('./timers.js')(Promise, INTERNAL, debug);
 722 require('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug);
 723 require('./nodeify.js')(Promise);
 724 require('./call_get.js')(Promise);
 725 require('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);
 726 require('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);
 727 require('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
 728 require('./settle.js')(Promise, PromiseArray, debug);
 729 require('./some.js')(Promise, PromiseArray, apiRejection);
 730 require('./promisify.js')(Promise, INTERNAL);
 731 require('./any.js')(Promise);
 732 require('./each.js')(Promise, INTERNAL);
 733 require('./filter.js')(Promise, INTERNAL);
 734
 735     util.toFastProperties(Promise);
 736     util.toFastProperties(Promise.prototype);
 737     function fillTypes(value) {
 738         var p = new Promise(INTERNAL);
 739         p._fulfillmentHandler0 = value;
 740         p._rejectionHandler0 = value;
 741         p._promise0 = value;
 742         p._receiver0 = value;
 743     }
 744     // Complete slack tracking, opt out of field-type tracking and
 745     // stabilize map
 746     fillTypes({a: 1});
 747     fillTypes({b: 2});
 748     fillTypes({c: 3});
 749     fillTypes(1);
 750     fillTypes(function(){});
 751     fillTypes(undefined);
 752     fillTypes(false);
 753     fillTypes(new Promise(INTERNAL));
 754     debug.setBounds(Async.firstLineError, util.lastLineError);
 755     return Promise;
 756
 757 };