gerrit.onap Code Review - aai/esr-gui.git/blob

   1 /* @preserve
   2  * The MIT License (MIT)
   3  *
   4  * Copyright (c) 2013-2015 Petka Antonov
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  */
  25 /**
  26  * bluebird build version 2.10.2
  27  * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, cancel, using, filter, any, each, timers
  28 */
  29 !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){
  30 "use strict";
  31 module.exports = function(Promise) {
  32 var SomePromiseArray = Promise._SomePromiseArray;
  33 function any(promises) {
  34     var ret = new SomePromiseArray(promises);
  35     var promise = ret.promise();
  36     ret.setHowMany(1);
  37     ret.setUnwrap();
  38     ret.init();
  39     return promise;
  40 }
  41
  42 Promise.any = function (promises) {
  43     return any(promises);
  44 };
  45
  46 Promise.prototype.any = function () {
  47     return any(this);
  48 };
  49
  50 };
  51
  52 },{}],2:[function(_dereq_,module,exports){
  53 "use strict";
  54 var firstLineError;
  55 try {throw new Error(); } catch (e) {firstLineError = e;}
  56 var schedule = _dereq_("./schedule.js");
  57 var Queue = _dereq_("./queue.js");
  58 var util = _dereq_("./util.js");
  59
  60 function Async() {
  61     this._isTickUsed = false;
  62     this._lateQueue = new Queue(16);
  63     this._normalQueue = new Queue(16);
  64     this._trampolineEnabled = true;
  65     var self = this;
  66     this.drainQueues = function () {
  67         self._drainQueues();
  68     };
  69     this._schedule =
  70         schedule.isStatic ? schedule(this.drainQueues) : schedule;
  71 }
  72
  73 Async.prototype.disableTrampolineIfNecessary = function() {
  74     if (util.hasDevTools) {
  75         this._trampolineEnabled = false;
  76     }
  77 };
  78
  79 Async.prototype.enableTrampoline = function() {
  80     if (!this._trampolineEnabled) {
  81         this._trampolineEnabled = true;
  82         this._schedule = function(fn) {
  83             setTimeout(fn, 0);
  84         };
  85     }
  86 };
  87
  88 Async.prototype.haveItemsQueued = function () {
  89     return this._normalQueue.length() > 0;
  90 };
  91
  92 Async.prototype.throwLater = function(fn, arg) {
  93     if (arguments.length === 1) {
  94         arg = fn;
  95         fn = function () { throw arg; };
  96     }
  97     if (typeof setTimeout !== "undefined") {
  98         setTimeout(function() {
  99             fn(arg);
 100         }, 0);
 101     } else try {
 102         this._schedule(function() {
 103             fn(arg);
 104         });
 105     } catch (e) {
 106         throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/m3OTXk\u000a");
 107     }
 108 };
 109
 110 function AsyncInvokeLater(fn, receiver, arg) {
 111     this._lateQueue.push(fn, receiver, arg);
 112     this._queueTick();
 113 }
 114
 115 function AsyncInvoke(fn, receiver, arg) {
 116     this._normalQueue.push(fn, receiver, arg);
 117     this._queueTick();
 118 }
 119
 120 function AsyncSettlePromises(promise) {
 121     this._normalQueue._pushOne(promise);
 122     this._queueTick();
 123 }
 124
 125 if (!util.hasDevTools) {
 126     Async.prototype.invokeLater = AsyncInvokeLater;
 127     Async.prototype.invoke = AsyncInvoke;
 128     Async.prototype.settlePromises = AsyncSettlePromises;
 129 } else {
 130     if (schedule.isStatic) {
 131         schedule = function(fn) { setTimeout(fn, 0); };
 132     }
 133     Async.prototype.invokeLater = function (fn, receiver, arg) {
 134         if (this._trampolineEnabled) {
 135             AsyncInvokeLater.call(this, fn, receiver, arg);
 136         } else {
 137             this._schedule(function() {
 138                 setTimeout(function() {
 139                     fn.call(receiver, arg);
 140                 }, 100);
 141             });
 142         }
 143     };
 144
 145     Async.prototype.invoke = function (fn, receiver, arg) {
 146         if (this._trampolineEnabled) {
 147             AsyncInvoke.call(this, fn, receiver, arg);
 148         } else {
 149             this._schedule(function() {
 150                 fn.call(receiver, arg);
 151             });
 152         }
 153     };
 154
 155     Async.prototype.settlePromises = function(promise) {
 156         if (this._trampolineEnabled) {
 157             AsyncSettlePromises.call(this, promise);
 158         } else {
 159             this._schedule(function() {
 160                 promise._settlePromises();
 161             });
 162         }
 163     };
 164 }
 165
 166 Async.prototype.invokeFirst = function (fn, receiver, arg) {
 167     this._normalQueue.unshift(fn, receiver, arg);
 168     this._queueTick();
 169 };
 170
 171 Async.prototype._drainQueue = function(queue) {
 172     while (queue.length() > 0) {
 173         var fn = queue.shift();
 174         if (typeof fn !== "function") {
 175             fn._settlePromises();
 176             continue;
 177         }
 178         var receiver = queue.shift();
 179         var arg = queue.shift();
 180         fn.call(receiver, arg);
 181     }
 182 };
 183
 184 Async.prototype._drainQueues = function () {
 185     this._drainQueue(this._normalQueue);
 186     this._reset();
 187     this._drainQueue(this._lateQueue);
 188 };
 189
 190 Async.prototype._queueTick = function () {
 191     if (!this._isTickUsed) {
 192         this._isTickUsed = true;
 193         this._schedule(this.drainQueues);
 194     }
 195 };
 196
 197 Async.prototype._reset = function () {
 198     this._isTickUsed = false;
 199 };
 200
 201 module.exports = new Async();
 202 module.exports.firstLineError = firstLineError;
 203
 204 },{"./queue.js":28,"./schedule.js":31,"./util.js":38}],3:[function(_dereq_,module,exports){
 205 "use strict";
 206 module.exports = function(Promise, INTERNAL, tryConvertToPromise) {
 207 var rejectThis = function(_, e) {
 208     this._reject(e);
 209 };
 210
 211 var targetRejected = function(e, context) {
 212     context.promiseRejectionQueued = true;
 213     context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
 214 };
 215
 216 var bindingResolved = function(thisArg, context) {
 217     if (this._isPending()) {
 218         this._resolveCallback(context.target);
 219     }
 220 };
 221
 222 var bindingRejected = function(e, context) {
 223     if (!context.promiseRejectionQueued) this._reject(e);
 224 };
 225
 226 Promise.prototype.bind = function (thisArg) {
 227     var maybePromise = tryConvertToPromise(thisArg);
 228     var ret = new Promise(INTERNAL);
 229     ret._propagateFrom(this, 1);
 230     var target = this._target();
 231
 232     ret._setBoundTo(maybePromise);
 233     if (maybePromise instanceof Promise) {
 234         var context = {
 235             promiseRejectionQueued: false,
 236             promise: ret,
 237             target: target,
 238             bindingPromise: maybePromise
 239         };
 240         target._then(INTERNAL, targetRejected, ret._progress, ret, context);
 241         maybePromise._then(
 242             bindingResolved, bindingRejected, ret._progress, ret, context);
 243     } else {
 244         ret._resolveCallback(target);
 245     }
 246     return ret;
 247 };
 248
 249 Promise.prototype._setBoundTo = function (obj) {
 250     if (obj !== undefined) {
 251         this._bitField = this._bitField | 131072;
 252         this._boundTo = obj;
 253     } else {
 254         this._bitField = this._bitField & (~131072);
 255     }
 256 };
 257
 258 Promise.prototype._isBound = function () {
 259     return (this._bitField & 131072) === 131072;
 260 };
 261
 262 Promise.bind = function (thisArg, value) {
 263     var maybePromise = tryConvertToPromise(thisArg);
 264     var ret = new Promise(INTERNAL);
 265
 266     ret._setBoundTo(maybePromise);
 267     if (maybePromise instanceof Promise) {
 268         maybePromise._then(function() {
 269             ret._resolveCallback(value);
 270         }, ret._reject, ret._progress, ret, null);
 271     } else {
 272         ret._resolveCallback(value);
 273     }
 274     return ret;
 275 };
 276 };
 277
 278 },{}],4:[function(_dereq_,module,exports){
 279 "use strict";
 280 var old;
 281 if (typeof Promise !== "undefined") old = Promise;
 282 function noConflict() {
 283     try { if (Promise === bluebird) Promise = old; }
 284     catch (e) {}
 285     return bluebird;
 286 }
 287 var bluebird = _dereq_("./promise.js")();
 288 bluebird.noConflict = noConflict;
 289 module.exports = bluebird;
 290
 291 },{"./promise.js":23}],5:[function(_dereq_,module,exports){
 292 "use strict";
 293 var cr = Object.create;
 294 if (cr) {
 295     var callerCache = cr(null);
 296     var getterCache = cr(null);
 297     callerCache[" size"] = getterCache[" size"] = 0;
 298 }
 299
 300 module.exports = function(Promise) {
 301 var util = _dereq_("./util.js");
 302 var canEvaluate = util.canEvaluate;
 303 var isIdentifier = util.isIdentifier;
 304
 305 var getMethodCaller;
 306 var getGetter;
 307 if (!true) {
 308 var makeMethodCaller = function (methodName) {
 309     return new Function("ensureMethod", "                                    \n\
 310         return function(obj) {                                               \n\
 311             'use strict'                                                     \n\
 312             var len = this.length;                                           \n\
 313             ensureMethod(obj, 'methodName');                                 \n\
 314             switch(len) {                                                    \n\
 315                 case 1: return obj.methodName(this[0]);                      \n\
 316                 case 2: return obj.methodName(this[0], this[1]);             \n\
 317                 case 3: return obj.methodName(this[0], this[1], this[2]);    \n\
 318                 case 0: return obj.methodName();                             \n\
 319                 default:                                                     \n\
 320                     return obj.methodName.apply(obj, this);                  \n\
 321             }                                                                \n\
 322         };                                                                   \n\
 323         ".replace(/methodName/g, methodName))(ensureMethod);
 324 };
 325
 326 var makeGetter = function (propertyName) {
 327     return new Function("obj", "                                             \n\
 328         'use strict';                                                        \n\
 329         return obj.propertyName;                                             \n\
 330         ".replace("propertyName", propertyName));
 331 };
 332
 333 var getCompiled = function(name, compiler, cache) {
 334     var ret = cache[name];
 335     if (typeof ret !== "function") {
 336         if (!isIdentifier(name)) {
 337             return null;
 338         }
 339         ret = compiler(name);
 340         cache[name] = ret;
 341         cache[" size"]++;
 342         if (cache[" size"] > 512) {
 343             var keys = Object.keys(cache);
 344             for (var i = 0; i < 256; ++i) delete cache[keys[i]];
 345             cache[" size"] = keys.length - 256;
 346         }
 347     }
 348     return ret;
 349 };
 350
 351 getMethodCaller = function(name) {
 352     return getCompiled(name, makeMethodCaller, callerCache);
 353 };
 354
 355 getGetter = function(name) {
 356     return getCompiled(name, makeGetter, getterCache);
 357 };
 358 }
 359
 360 function ensureMethod(obj, methodName) {
 361     var fn;
 362     if (obj != null) fn = obj[methodName];
 363     if (typeof fn !== "function") {
 364         var message = "Object " + util.classString(obj) + " has no method '" +
 365             util.toString(methodName) + "'";
 366         throw new Promise.TypeError(message);
 367     }
 368     return fn;
 369 }
 370
 371 function caller(obj) {
 372     var methodName = this.pop();
 373     var fn = ensureMethod(obj, methodName);
 374     return fn.apply(obj, this);
 375 }
 376 Promise.prototype.call = function (methodName) {
 377     var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
 378     if (!true) {
 379         if (canEvaluate) {
 380             var maybeCaller = getMethodCaller(methodName);
 381             if (maybeCaller !== null) {
 382                 return this._then(
 383                     maybeCaller, undefined, undefined, args, undefined);
 384             }
 385         }
 386     }
 387     args.push(methodName);
 388     return this._then(caller, undefined, undefined, args, undefined);
 389 };
 390
 391 function namedGetter(obj) {
 392     return obj[this];
 393 }
 394 function indexedGetter(obj) {
 395     var index = +this;
 396     if (index < 0) index = Math.max(0, index + obj.length);
 397     return obj[index];
 398 }
 399 Promise.prototype.get = function (propertyName) {
 400     var isIndex = (typeof propertyName === "number");
 401     var getter;
 402     if (!isIndex) {
 403         if (canEvaluate) {
 404             var maybeGetter = getGetter(propertyName);
 405             getter = maybeGetter !== null ? maybeGetter : namedGetter;
 406         } else {
 407             getter = namedGetter;
 408         }
 409     } else {
 410         getter = indexedGetter;
 411     }
 412     return this._then(getter, undefined, undefined, propertyName, undefined);
 413 };
 414 };
 415
 416 },{"./util.js":38}],6:[function(_dereq_,module,exports){
 417 "use strict";
 418 module.exports = function(Promise) {
 419 var errors = _dereq_("./errors.js");
 420 var async = _dereq_("./async.js");
 421 var CancellationError = errors.CancellationError;
 422
 423 Promise.prototype._cancel = function (reason) {
 424     if (!this.isCancellable()) return this;
 425     var parent;
 426     var promiseToReject = this;
 427     while ((parent = promiseToReject._cancellationParent) !== undefined &&
 428         parent.isCancellable()) {
 429         promiseToReject = parent;
 430     }
 431     this._unsetCancellable();
 432     promiseToReject._target()._rejectCallback(reason, false, true);
 433 };
 434
 435 Promise.prototype.cancel = function (reason) {
 436     if (!this.isCancellable()) return this;
 437     if (reason === undefined) reason = new CancellationError();
 438     async.invokeLater(this._cancel, this, reason);
 439     return this;
 440 };
 441
 442 Promise.prototype.cancellable = function () {
 443     if (this._cancellable()) return this;
 444     async.enableTrampoline();
 445     this._setCancellable();
 446     this._cancellationParent = undefined;
 447     return this;
 448 };
 449
 450 Promise.prototype.uncancellable = function () {
 451     var ret = this.then();
 452     ret._unsetCancellable();
 453     return ret;
 454 };
 455
 456 Promise.prototype.fork = function (didFulfill, didReject, didProgress) {
 457     var ret = this._then(didFulfill, didReject, didProgress,
 458                          undefined, undefined);
 459
 460     ret._setCancellable();
 461     ret._cancellationParent = undefined;
 462     return ret;
 463 };
 464 };
 465
 466 },{"./async.js":2,"./errors.js":13}],7:[function(_dereq_,module,exports){
 467 "use strict";
 468 module.exports = function() {
 469 var async = _dereq_("./async.js");
 470 var util = _dereq_("./util.js");
 471 var bluebirdFramePattern =
 472     /[\\\/]bluebird[\\\/]js[\\\/](main|debug|zalgo|instrumented)/;
 473 var stackFramePattern = null;
 474 var formatStack = null;
 475 var indentStackFrames = false;
 476 var warn;
 477
 478 function CapturedTrace(parent) {
 479     this._parent = parent;
 480     var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
 481     captureStackTrace(this, CapturedTrace);
 482     if (length > 32) this.uncycle();
 483 }
 484 util.inherits(CapturedTrace, Error);
 485
 486 CapturedTrace.prototype.uncycle = function() {
 487     var length = this._length;
 488     if (length < 2) return;
 489     var nodes = [];
 490     var stackToIndex = {};
 491
 492     for (var i = 0, node = this; node !== undefined; ++i) {
 493         nodes.push(node);
 494         node = node._parent;
 495     }
 496     length = this._length = i;
 497     for (var i = length - 1; i >= 0; --i) {
 498         var stack = nodes[i].stack;
 499         if (stackToIndex[stack] === undefined) {
 500             stackToIndex[stack] = i;
 501         }
 502     }
 503     for (var i = 0; i < length; ++i) {
 504         var currentStack = nodes[i].stack;
 505         var index = stackToIndex[currentStack];
 506         if (index !== undefined && index !== i) {
 507             if (index > 0) {
 508                 nodes[index - 1]._parent = undefined;
 509                 nodes[index - 1]._length = 1;
 510             }
 511             nodes[i]._parent = undefined;
 512             nodes[i]._length = 1;
 513             var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
 514
 515             if (index < length - 1) {
 516                 cycleEdgeNode._parent = nodes[index + 1];
 517                 cycleEdgeNode._parent.uncycle();
 518                 cycleEdgeNode._length =
 519                     cycleEdgeNode._parent._length + 1;
 520             } else {
 521                 cycleEdgeNode._parent = undefined;
 522                 cycleEdgeNode._length = 1;
 523             }
 524             var currentChildLength = cycleEdgeNode._length + 1;
 525             for (var j = i - 2; j >= 0; --j) {
 526                 nodes[j]._length = currentChildLength;
 527                 currentChildLength++;
 528             }
 529             return;
 530         }
 531     }
 532 };
 533
 534 CapturedTrace.prototype.parent = function() {
 535     return this._parent;
 536 };
 537
 538 CapturedTrace.prototype.hasParent = function() {
 539     return this._parent !== undefined;
 540 };
 541
 542 CapturedTrace.prototype.attachExtraTrace = function(error) {
 543     if (error.__stackCleaned__) return;
 544     this.uncycle();
 545     var parsed = CapturedTrace.parseStackAndMessage(error);
 546     var message = parsed.message;
 547     var stacks = [parsed.stack];
 548
 549     var trace = this;
 550     while (trace !== undefined) {
 551         stacks.push(cleanStack(trace.stack.split("\n")));
 552         trace = trace._parent;
 553     }
 554     removeCommonRoots(stacks);
 555     removeDuplicateOrEmptyJumps(stacks);
 556     util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
 557     util.notEnumerableProp(error, "__stackCleaned__", true);
 558 };
 559
 560 function reconstructStack(message, stacks) {
 561     for (var i = 0; i < stacks.length - 1; ++i) {
 562         stacks[i].push("From previous event:");
 563         stacks[i] = stacks[i].join("\n");
 564     }
 565     if (i < stacks.length) {
 566         stacks[i] = stacks[i].join("\n");
 567     }
 568     return message + "\n" + stacks.join("\n");
 569 }
 570
 571 function removeDuplicateOrEmptyJumps(stacks) {
 572     for (var i = 0; i < stacks.length; ++i) {
 573         if (stacks[i].length === 0 ||
 574             ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
 575             stacks.splice(i, 1);
 576             i--;
 577         }
 578     }
 579 }
 580
 581 function removeCommonRoots(stacks) {
 582     var current = stacks[0];
 583     for (var i = 1; i < stacks.length; ++i) {
 584         var prev = stacks[i];
 585         var currentLastIndex = current.length - 1;
 586         var currentLastLine = current[currentLastIndex];
 587         var commonRootMeetPoint = -1;
 588
 589         for (var j = prev.length - 1; j >= 0; --j) {
 590             if (prev[j] === currentLastLine) {
 591                 commonRootMeetPoint = j;
 592                 break;
 593             }
 594         }
 595
 596         for (var j = commonRootMeetPoint; j >= 0; --j) {
 597             var line = prev[j];
 598             if (current[currentLastIndex] === line) {
 599                 current.pop();
 600                 currentLastIndex--;
 601             } else {
 602                 break;
 603             }
 604         }
 605         current = prev;
 606     }
 607 }
 608
 609 function cleanStack(stack) {
 610     var ret = [];
 611     for (var i = 0; i < stack.length; ++i) {
 612         var line = stack[i];
 613         var isTraceLine = stackFramePattern.test(line) ||
 614             "    (No stack trace)" === line;
 615         var isInternalFrame = isTraceLine && shouldIgnore(line);
 616         if (isTraceLine && !isInternalFrame) {
 617             if (indentStackFrames && line.charAt(0) !== " ") {
 618                 line = "    " + line;
 619             }
 620             ret.push(line);
 621         }
 622     }
 623     return ret;
 624 }
 625
 626 function stackFramesAsArray(error) {
 627     var stack = error.stack.replace(/\s+$/g, "").split("\n");
 628     for (var i = 0; i < stack.length; ++i) {
 629         var line = stack[i];
 630         if ("    (No stack trace)" === line || stackFramePattern.test(line)) {
 631             break;
 632         }
 633     }
 634     if (i > 0) {
 635         stack = stack.slice(i);
 636     }
 637     return stack;
 638 }
 639
 640 CapturedTrace.parseStackAndMessage = function(error) {
 641     var stack = error.stack;
 642     var message = error.toString();
 643     stack = typeof stack === "string" && stack.length > 0
 644                 ? stackFramesAsArray(error) : ["    (No stack trace)"];
 645     return {
 646         message: message,
 647         stack: cleanStack(stack)
 648     };
 649 };
 650
 651 CapturedTrace.formatAndLogError = function(error, title) {
 652     if (typeof console !== "undefined") {
 653         var message;
 654         if (typeof error === "object" || typeof error === "function") {
 655             var stack = error.stack;
 656             message = title + formatStack(stack, error);
 657         } else {
 658             message = title + String(error);
 659         }
 660         if (typeof warn === "function") {
 661             warn(message);
 662         } else if (typeof console.log === "function" ||
 663             typeof console.log === "object") {
 664             console.log(message);
 665         }
 666     }
 667 };
 668
 669 CapturedTrace.unhandledRejection = function (reason) {
 670     CapturedTrace.formatAndLogError(reason, "^--- With additional stack trace: ");
 671 };
 672
 673 CapturedTrace.isSupported = function () {
 674     return typeof captureStackTrace === "function";
 675 };
 676
 677 CapturedTrace.fireRejectionEvent =
 678 function(name, localHandler, reason, promise) {
 679     var localEventFired = false;
 680     try {
 681         if (typeof localHandler === "function") {
 682             localEventFired = true;
 683             if (name === "rejectionHandled") {
 684                 localHandler(promise);
 685             } else {
 686                 localHandler(reason, promise);
 687             }
 688         }
 689     } catch (e) {
 690         async.throwLater(e);
 691     }
 692
 693     var globalEventFired = false;
 694     try {
 695         globalEventFired = fireGlobalEvent(name, reason, promise);
 696     } catch (e) {
 697         globalEventFired = true;
 698         async.throwLater(e);
 699     }
 700
 701     var domEventFired = false;
 702     if (fireDomEvent) {
 703         try {
 704             domEventFired = fireDomEvent(name.toLowerCase(), {
 705                 reason: reason,
 706                 promise: promise
 707             });
 708         } catch (e) {
 709             domEventFired = true;
 710             async.throwLater(e);
 711         }
 712     }
 713
 714     if (!globalEventFired && !localEventFired && !domEventFired &&
 715         name === "unhandledRejection") {
 716         CapturedTrace.formatAndLogError(reason, "Unhandled rejection ");
 717     }
 718 };
 719
 720 function formatNonError(obj) {
 721     var str;
 722     if (typeof obj === "function") {
 723         str = "[function " +
 724             (obj.name || "anonymous") +
 725             "]";
 726     } else {
 727         str = obj.toString();
 728         var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
 729         if (ruselessToString.test(str)) {
 730             try {
 731                 var newStr = JSON.stringify(obj);
 732                 str = newStr;
 733             }
 734             catch(e) {
 735
 736             }
 737         }
 738         if (str.length === 0) {
 739             str = "(empty array)";
 740         }
 741     }
 742     return ("(<" + snip(str) + ">, no stack trace)");
 743 }
 744
 745 function snip(str) {
 746     var maxChars = 41;
 747     if (str.length < maxChars) {
 748         return str;
 749     }
 750     return str.substr(0, maxChars - 3) + "...";
 751 }
 752
 753 var shouldIgnore = function() { return false; };
 754 var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
 755 function parseLineInfo(line) {
 756     var matches = line.match(parseLineInfoRegex);
 757     if (matches) {
 758         return {
 759             fileName: matches[1],
 760             line: parseInt(matches[2], 10)
 761         };
 762     }
 763 }
 764 CapturedTrace.setBounds = function(firstLineError, lastLineError) {
 765     if (!CapturedTrace.isSupported()) return;
 766     var firstStackLines = firstLineError.stack.split("\n");
 767     var lastStackLines = lastLineError.stack.split("\n");
 768     var firstIndex = -1;
 769     var lastIndex = -1;
 770     var firstFileName;
 771     var lastFileName;
 772     for (var i = 0; i < firstStackLines.length; ++i) {
 773         var result = parseLineInfo(firstStackLines[i]);
 774         if (result) {
 775             firstFileName = result.fileName;
 776             firstIndex = result.line;
 777             break;
 778         }
 779     }
 780     for (var i = 0; i < lastStackLines.length; ++i) {
 781         var result = parseLineInfo(lastStackLines[i]);
 782         if (result) {
 783             lastFileName = result.fileName;
 784             lastIndex = result.line;
 785             break;
 786         }
 787     }
 788     if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
 789         firstFileName !== lastFileName || firstIndex >= lastIndex) {
 790         return;
 791     }
 792
 793     shouldIgnore = function(line) {
 794         if (bluebirdFramePattern.test(line)) return true;
 795         var info = parseLineInfo(line);
 796         if (info) {
 797             if (info.fileName === firstFileName &&
 798                 (firstIndex <= info.line && info.line <= lastIndex)) {
 799                 return true;
 800             }
 801         }
 802         return false;
 803     };
 804 };
 805
 806 var captureStackTrace = (function stackDetection() {
 807     var v8stackFramePattern = /^\s*at\s*/;
 808     var v8stackFormatter = function(stack, error) {
 809         if (typeof stack === "string") return stack;
 810
 811         if (error.name !== undefined &&
 812             error.message !== undefined) {
 813             return error.toString();
 814         }
 815         return formatNonError(error);
 816     };
 817
 818     if (typeof Error.stackTraceLimit === "number" &&
 819         typeof Error.captureStackTrace === "function") {
 820         Error.stackTraceLimit = Error.stackTraceLimit + 6;
 821         stackFramePattern = v8stackFramePattern;
 822         formatStack = v8stackFormatter;
 823         var captureStackTrace = Error.captureStackTrace;
 824
 825         shouldIgnore = function(line) {
 826             return bluebirdFramePattern.test(line);
 827         };
 828         return function(receiver, ignoreUntil) {
 829             Error.stackTraceLimit = Error.stackTraceLimit + 6;
 830             captureStackTrace(receiver, ignoreUntil);
 831             Error.stackTraceLimit = Error.stackTraceLimit - 6;
 832         };
 833     }
 834     var err = new Error();
 835
 836     if (typeof err.stack === "string" &&
 837         err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
 838         stackFramePattern = /@/;
 839         formatStack = v8stackFormatter;
 840         indentStackFrames = true;
 841         return function captureStackTrace(o) {
 842             o.stack = new Error().stack;
 843         };
 844     }
 845
 846     var hasStackAfterThrow;
 847     try { throw new Error(); }
 848     catch(e) {
 849         hasStackAfterThrow = ("stack" in e);
 850     }
 851     if (!("stack" in err) && hasStackAfterThrow &&
 852         typeof Error.stackTraceLimit === "number") {
 853         stackFramePattern = v8stackFramePattern;
 854         formatStack = v8stackFormatter;
 855         return function captureStackTrace(o) {
 856             Error.stackTraceLimit = Error.stackTraceLimit + 6;
 857             try { throw new Error(); }
 858             catch(e) { o.stack = e.stack; }
 859             Error.stackTraceLimit = Error.stackTraceLimit - 6;
 860         };
 861     }
 862
 863     formatStack = function(stack, error) {
 864         if (typeof stack === "string") return stack;
 865
 866         if ((typeof error === "object" ||
 867             typeof error === "function") &&
 868             error.name !== undefined &&
 869             error.message !== undefined) {
 870             return error.toString();
 871         }
 872         return formatNonError(error);
 873     };
 874
 875     return null;
 876
 877 })([]);
 878
 879 var fireDomEvent;
 880 var fireGlobalEvent = (function() {
 881     if (util.isNode) {
 882         return function(name, reason, promise) {
 883             if (name === "rejectionHandled") {
 884                 return process.emit(name, promise);
 885             } else {
 886                 return process.emit(name, reason, promise);
 887             }
 888         };
 889     } else {
 890         var customEventWorks = false;
 891         var anyEventWorks = true;
 892         try {
 893             var ev = new self.CustomEvent("test");
 894             customEventWorks = ev instanceof CustomEvent;
 895         } catch (e) {}
 896         if (!customEventWorks) {
 897             try {
 898                 var event = document.createEvent("CustomEvent");
 899                 event.initCustomEvent("testingtheevent", false, true, {});
 900                 self.dispatchEvent(event);
 901             } catch (e) {
 902                 anyEventWorks = false;
 903             }
 904         }
 905         if (anyEventWorks) {
 906             fireDomEvent = function(type, detail) {
 907                 var event;
 908                 if (customEventWorks) {
 909                     event = new self.CustomEvent(type, {
 910                         detail: detail,
 911                         bubbles: false,
 912                         cancelable: true
 913                     });
 914                 } else if (self.dispatchEvent) {
 915                     event = document.createEvent("CustomEvent");
 916                     event.initCustomEvent(type, false, true, detail);
 917                 }
 918
 919                 return event ? !self.dispatchEvent(event) : false;
 920             };
 921         }
 922
 923         var toWindowMethodNameMap = {};
 924         toWindowMethodNameMap["unhandledRejection"] = ("on" +
 925             "unhandledRejection").toLowerCase();
 926         toWindowMethodNameMap["rejectionHandled"] = ("on" +
 927             "rejectionHandled").toLowerCase();
 928
 929         return function(name, reason, promise) {
 930             var methodName = toWindowMethodNameMap[name];
 931             var method = self[methodName];
 932             if (!method) return false;
 933             if (name === "rejectionHandled") {
 934                 method.call(self, promise);
 935             } else {
 936                 method.call(self, reason, promise);
 937             }
 938             return true;
 939         };
 940     }
 941 })();
 942
 943 if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
 944     warn = function (message) {
 945         console.warn(message);
 946     };
 947     if (util.isNode && process.stderr.isTTY) {
 948         warn = function(message) {
 949             process.stderr.write("\u001b[31m" + message + "\u001b[39m\n");
 950         };
 951     } else if (!util.isNode && typeof (new Error().stack) === "string") {
 952         warn = function(message) {
 953             console.warn("%c" + message, "color: red");
 954         };
 955     }
 956 }
 957
 958 return CapturedTrace;
 959 };
 960
 961 },{"./async.js":2,"./util.js":38}],8:[function(_dereq_,module,exports){
 962 "use strict";
 963 module.exports = function(NEXT_FILTER) {
 964 var util = _dereq_("./util.js");
 965 var errors = _dereq_("./errors.js");
 966 var tryCatch = util.tryCatch;
 967 var errorObj = util.errorObj;
 968 var keys = _dereq_("./es5.js").keys;
 969 var TypeError = errors.TypeError;
 970
 971 function CatchFilter(instances, callback, promise) {
 972     this._instances = instances;
 973     this._callback = callback;
 974     this._promise = promise;
 975 }
 976
 977 function safePredicate(predicate, e) {
 978     var safeObject = {};
 979     var retfilter = tryCatch(predicate).call(safeObject, e);
 980
 981     if (retfilter === errorObj) return retfilter;
 982
 983     var safeKeys = keys(safeObject);
 984     if (safeKeys.length) {
 985         errorObj.e = new TypeError("Catch filter must inherit from Error or be a simple predicate function\u000a\u000a    See http://goo.gl/o84o68\u000a");
 986         return errorObj;
 987     }
 988     return retfilter;
 989 }
 990
 991 CatchFilter.prototype.doFilter = function (e) {
 992     var cb = this._callback;
 993     var promise = this._promise;
 994     var boundTo = promise._boundValue();
 995     for (var i = 0, len = this._instances.length; i < len; ++i) {
 996         var item = this._instances[i];
 997         var itemIsErrorType = item === Error ||
 998             (item != null && item.prototype instanceof Error);
 999
1000         if (itemIsErrorType && e instanceof item) {
1001             var ret = tryCatch(cb).call(boundTo, e);
1002             if (ret === errorObj) {
1003                 NEXT_FILTER.e = ret.e;
1004                 return NEXT_FILTER;
1005             }
1006             return ret;
1007         } else if (typeof item === "function" && !itemIsErrorType) {
1008             var shouldHandle = safePredicate(item, e);
1009             if (shouldHandle === errorObj) {
1010                 e = errorObj.e;
1011                 break;
1012             } else if (shouldHandle) {
1013                 var ret = tryCatch(cb).call(boundTo, e);
1014                 if (ret === errorObj) {
1015                     NEXT_FILTER.e = ret.e;
1016                     return NEXT_FILTER;
1017                 }
1018                 return ret;
1019             }
1020         }
1021     }
1022     NEXT_FILTER.e = e;
1023     return NEXT_FILTER;
1024 };
1025
1026 return CatchFilter;
1027 };
1028
1029 },{"./errors.js":13,"./es5.js":14,"./util.js":38}],9:[function(_dereq_,module,exports){
1030 "use strict";
1031 module.exports = function(Promise, CapturedTrace, isDebugging) {
1032 var contextStack = [];
1033 function Context() {
1034     this._trace = new CapturedTrace(peekContext());
1035 }
1036 Context.prototype._pushContext = function () {
1037     if (!isDebugging()) return;
1038     if (this._trace !== undefined) {
1039         contextStack.push(this._trace);
1040     }
1041 };
1042
1043 Context.prototype._popContext = function () {
1044     if (!isDebugging()) return;
1045     if (this._trace !== undefined) {
1046         contextStack.pop();
1047     }
1048 };
1049
1050 function createContext() {
1051     if (isDebugging()) return new Context();
1052 }
1053
1054 function peekContext() {
1055     var lastIndex = contextStack.length - 1;
1056     if (lastIndex >= 0) {
1057         return contextStack[lastIndex];
1058     }
1059     return undefined;
1060 }
1061
1062 Promise.prototype._peekContext = peekContext;
1063 Promise.prototype._pushContext = Context.prototype._pushContext;
1064 Promise.prototype._popContext = Context.prototype._popContext;
1065
1066 return createContext;
1067 };
1068
1069 },{}],10:[function(_dereq_,module,exports){
1070 "use strict";
1071 module.exports = function(Promise, CapturedTrace) {
1072 var getDomain = Promise._getDomain;
1073 var async = _dereq_("./async.js");
1074 var Warning = _dereq_("./errors.js").Warning;
1075 var util = _dereq_("./util.js");
1076 var canAttachTrace = util.canAttachTrace;
1077 var unhandledRejectionHandled;
1078 var possiblyUnhandledRejection;
1079 var debugging = false || (util.isNode &&
1080                     (!!process.env["BLUEBIRD_DEBUG"] ||
1081                      process.env["NODE_ENV"] === "development"));
1082
1083 if (util.isNode && process.env["BLUEBIRD_DEBUG"] == 0) debugging = false;
1084
1085 if (debugging) {
1086     async.disableTrampolineIfNecessary();
1087 }
1088
1089 Promise.prototype._ignoreRejections = function() {
1090     this._unsetRejectionIsUnhandled();
1091     this._bitField = this._bitField | 16777216;
1092 };
1093
1094 Promise.prototype._ensurePossibleRejectionHandled = function () {
1095     if ((this._bitField & 16777216) !== 0) return;
1096     this._setRejectionIsUnhandled();
1097     async.invokeLater(this._notifyUnhandledRejection, this, undefined);
1098 };
1099
1100 Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
1101     CapturedTrace.fireRejectionEvent("rejectionHandled",
1102                                   unhandledRejectionHandled, undefined, this);
1103 };
1104
1105 Promise.prototype._notifyUnhandledRejection = function () {
1106     if (this._isRejectionUnhandled()) {
1107         var reason = this._getCarriedStackTrace() || this._settledValue;
1108         this._setUnhandledRejectionIsNotified();
1109         CapturedTrace.fireRejectionEvent("unhandledRejection",
1110                                       possiblyUnhandledRejection, reason, this);
1111     }
1112 };
1113
1114 Promise.prototype._setUnhandledRejectionIsNotified = function () {
1115     this._bitField = this._bitField | 524288;
1116 };
1117
1118 Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
1119     this._bitField = this._bitField & (~524288);
1120 };
1121
1122 Promise.prototype._isUnhandledRejectionNotified = function () {
1123     return (this._bitField & 524288) > 0;
1124 };
1125
1126 Promise.prototype._setRejectionIsUnhandled = function () {
1127     this._bitField = this._bitField | 2097152;
1128 };
1129
1130 Promise.prototype._unsetRejectionIsUnhandled = function () {
1131     this._bitField = this._bitField & (~2097152);
1132     if (this._isUnhandledRejectionNotified()) {
1133         this._unsetUnhandledRejectionIsNotified();
1134         this._notifyUnhandledRejectionIsHandled();
1135     }
1136 };
1137
1138 Promise.prototype._isRejectionUnhandled = function () {
1139     return (this._bitField & 2097152) > 0;
1140 };
1141
1142 Promise.prototype._setCarriedStackTrace = function (capturedTrace) {
1143     this._bitField = this._bitField | 1048576;
1144     this._fulfillmentHandler0 = capturedTrace;
1145 };
1146
1147 Promise.prototype._isCarryingStackTrace = function () {
1148     return (this._bitField & 1048576) > 0;
1149 };
1150
1151 Promise.prototype._getCarriedStackTrace = function () {
1152     return this._isCarryingStackTrace()
1153         ? this._fulfillmentHandler0
1154         : undefined;
1155 };
1156
1157 Promise.prototype._captureStackTrace = function () {
1158     if (debugging) {
1159         this._trace = new CapturedTrace(this._peekContext());
1160     }
1161     return this;
1162 };
1163
1164 Promise.prototype._attachExtraTrace = function (error, ignoreSelf) {
1165     if (debugging && canAttachTrace(error)) {
1166         var trace = this._trace;
1167         if (trace !== undefined) {
1168             if (ignoreSelf) trace = trace._parent;
1169         }
1170         if (trace !== undefined) {
1171             trace.attachExtraTrace(error);
1172         } else if (!error.__stackCleaned__) {
1173             var parsed = CapturedTrace.parseStackAndMessage(error);
1174             util.notEnumerableProp(error, "stack",
1175                 parsed.message + "\n" + parsed.stack.join("\n"));
1176             util.notEnumerableProp(error, "__stackCleaned__", true);
1177         }
1178     }
1179 };
1180
1181 Promise.prototype._warn = function(message) {
1182     var warning = new Warning(message);
1183     var ctx = this._peekContext();
1184     if (ctx) {
1185         ctx.attachExtraTrace(warning);
1186     } else {
1187         var parsed = CapturedTrace.parseStackAndMessage(warning);
1188         warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
1189     }
1190     CapturedTrace.formatAndLogError(warning, "");
1191 };
1192
1193 Promise.onPossiblyUnhandledRejection = function (fn) {
1194     var domain = getDomain();
1195     possiblyUnhandledRejection =
1196         typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
1197                                  : undefined;
1198 };
1199
1200 Promise.onUnhandledRejectionHandled = function (fn) {
1201     var domain = getDomain();
1202     unhandledRejectionHandled =
1203         typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
1204                                  : undefined;
1205 };
1206
1207 Promise.longStackTraces = function () {
1208     if (async.haveItemsQueued() &&
1209         debugging === false
1210    ) {
1211         throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/DT1qyG\u000a");
1212     }
1213     debugging = CapturedTrace.isSupported();
1214     if (debugging) {
1215         async.disableTrampolineIfNecessary();
1216     }
1217 };
1218
1219 Promise.hasLongStackTraces = function () {
1220     return debugging && CapturedTrace.isSupported();
1221 };
1222
1223 if (!CapturedTrace.isSupported()) {
1224     Promise.longStackTraces = function(){};
1225     debugging = false;
1226 }
1227
1228 return function() {
1229     return debugging;
1230 };
1231 };
1232
1233 },{"./async.js":2,"./errors.js":13,"./util.js":38}],11:[function(_dereq_,module,exports){
1234 "use strict";
1235 var util = _dereq_("./util.js");
1236 var isPrimitive = util.isPrimitive;
1237
1238 module.exports = function(Promise) {
1239 var returner = function () {
1240     return this;
1241 };
1242 var thrower = function () {
1243     throw this;
1244 };
1245 var returnUndefined = function() {};
1246 var throwUndefined = function() {
1247     throw undefined;
1248 };
1249
1250 var wrapper = function (value, action) {
1251     if (action === 1) {
1252         return function () {
1253             throw value;
1254         };
1255     } else if (action === 2) {
1256         return function () {
1257             return value;
1258         };
1259     }
1260 };
1261
1262
1263 Promise.prototype["return"] =
1264 Promise.prototype.thenReturn = function (value) {
1265     if (value === undefined) return this.then(returnUndefined);
1266
1267     if (isPrimitive(value)) {
1268         return this._then(
1269             wrapper(value, 2),
1270             undefined,
1271             undefined,
1272             undefined,
1273             undefined
1274        );
1275     } else if (value instanceof Promise) {
1276         value._ignoreRejections();
1277     }
1278     return this._then(returner, undefined, undefined, value, undefined);
1279 };
1280
1281 Promise.prototype["throw"] =
1282 Promise.prototype.thenThrow = function (reason) {
1283     if (reason === undefined) return this.then(throwUndefined);
1284
1285     if (isPrimitive(reason)) {
1286         return this._then(
1287             wrapper(reason, 1),
1288             undefined,
1289             undefined,
1290             undefined,
1291             undefined
1292        );
1293     }
1294     return this._then(thrower, undefined, undefined, reason, undefined);
1295 };
1296 };
1297
1298 },{"./util.js":38}],12:[function(_dereq_,module,exports){
1299 "use strict";
1300 module.exports = function(Promise, INTERNAL) {
1301 var PromiseReduce = Promise.reduce;
1302
1303 Promise.prototype.each = function (fn) {
1304     return PromiseReduce(this, fn, null, INTERNAL);
1305 };
1306
1307 Promise.each = function (promises, fn) {
1308     return PromiseReduce(promises, fn, null, INTERNAL);
1309 };
1310 };
1311
1312 },{}],13:[function(_dereq_,module,exports){
1313 "use strict";
1314 var es5 = _dereq_("./es5.js");
1315 var Objectfreeze = es5.freeze;
1316 var util = _dereq_("./util.js");
1317 var inherits = util.inherits;
1318 var notEnumerableProp = util.notEnumerableProp;
1319
1320 function subError(nameProperty, defaultMessage) {
1321     function SubError(message) {
1322         if (!(this instanceof SubError)) return new SubError(message);
1323         notEnumerableProp(this, "message",
1324             typeof message === "string" ? message : defaultMessage);
1325         notEnumerableProp(this, "name", nameProperty);
1326         if (Error.captureStackTrace) {
1327             Error.captureStackTrace(this, this.constructor);
1328         } else {
1329             Error.call(this);
1330         }
1331     }
1332     inherits(SubError, Error);
1333     return SubError;
1334 }
1335
1336 var _TypeError, _RangeError;
1337 var Warning = subError("Warning", "warning");
1338 var CancellationError = subError("CancellationError", "cancellation error");
1339 var TimeoutError = subError("TimeoutError", "timeout error");
1340 var AggregateError = subError("AggregateError", "aggregate error");
1341 try {
1342     _TypeError = TypeError;
1343     _RangeError = RangeError;
1344 } catch(e) {
1345     _TypeError = subError("TypeError", "type error");
1346     _RangeError = subError("RangeError", "range error");
1347 }
1348
1349 var methods = ("join pop push shift unshift slice filter forEach some " +
1350     "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
1351
1352 for (var i = 0; i < methods.length; ++i) {
1353     if (typeof Array.prototype[methods[i]] === "function") {
1354         AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
1355     }
1356 }
1357
1358 es5.defineProperty(AggregateError.prototype, "length", {
1359     value: 0,
1360     configurable: false,
1361     writable: true,
1362     enumerable: true
1363 });
1364 AggregateError.prototype["isOperational"] = true;
1365 var level = 0;
1366 AggregateError.prototype.toString = function() {
1367     var indent = Array(level * 4 + 1).join(" ");
1368     var ret = "\n" + indent + "AggregateError of:" + "\n";
1369     level++;
1370     indent = Array(level * 4 + 1).join(" ");
1371     for (var i = 0; i < this.length; ++i) {
1372         var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
1373         var lines = str.split("\n");
1374         for (var j = 0; j < lines.length; ++j) {
1375             lines[j] = indent + lines[j];
1376         }
1377         str = lines.join("\n");
1378         ret += str + "\n";
1379     }
1380     level--;
1381     return ret;
1382 };
1383
1384 function OperationalError(message) {
1385     if (!(this instanceof OperationalError))
1386         return new OperationalError(message);
1387     notEnumerableProp(this, "name", "OperationalError");
1388     notEnumerableProp(this, "message", message);
1389     this.cause = message;
1390     this["isOperational"] = true;
1391
1392     if (message instanceof Error) {
1393         notEnumerableProp(this, "message", message.message);
1394         notEnumerableProp(this, "stack", message.stack);
1395     } else if (Error.captureStackTrace) {
1396         Error.captureStackTrace(this, this.constructor);
1397     }
1398
1399 }
1400 inherits(OperationalError, Error);
1401
1402 var errorTypes = Error["__BluebirdErrorTypes__"];
1403 if (!errorTypes) {
1404     errorTypes = Objectfreeze({
1405         CancellationError: CancellationError,
1406         TimeoutError: TimeoutError,
1407         OperationalError: OperationalError,
1408         RejectionError: OperationalError,
1409         AggregateError: AggregateError
1410     });
1411     notEnumerableProp(Error, "__BluebirdErrorTypes__", errorTypes);
1412 }
1413
1414 module.exports = {
1415     Error: Error,
1416     TypeError: _TypeError,
1417     RangeError: _RangeError,
1418     CancellationError: errorTypes.CancellationError,
1419     OperationalError: errorTypes.OperationalError,
1420     TimeoutError: errorTypes.TimeoutError,
1421     AggregateError: errorTypes.AggregateError,
1422     Warning: Warning
1423 };
1424
1425 },{"./es5.js":14,"./util.js":38}],14:[function(_dereq_,module,exports){
1426 var isES5 = (function(){
1427     "use strict";
1428     return this === undefined;
1429 })();
1430
1431 if (isES5) {
1432     module.exports = {
1433         freeze: Object.freeze,
1434         defineProperty: Object.defineProperty,
1435         getDescriptor: Object.getOwnPropertyDescriptor,
1436         keys: Object.keys,
1437         names: Object.getOwnPropertyNames,
1438         getPrototypeOf: Object.getPrototypeOf,
1439         isArray: Array.isArray,
1440         isES5: isES5,
1441         propertyIsWritable: function(obj, prop) {
1442             var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
1443             return !!(!descriptor || descriptor.writable || descriptor.set);
1444         }
1445     };
1446 } else {
1447     var has = {}.hasOwnProperty;
1448     var str = {}.toString;
1449     var proto = {}.constructor.prototype;
1450
1451     var ObjectKeys = function (o) {
1452         var ret = [];
1453         for (var key in o) {
1454             if (has.call(o, key)) {
1455                 ret.push(key);
1456             }
1457         }
1458         return ret;
1459     };
1460
1461     var ObjectGetDescriptor = function(o, key) {
1462         return {value: o[key]};
1463     };
1464
1465     var ObjectDefineProperty = function (o, key, desc) {
1466         o[key] = desc.value;
1467         return o;
1468     };
1469
1470     var ObjectFreeze = function (obj) {
1471         return obj;
1472     };
1473
1474     var ObjectGetPrototypeOf = function (obj) {
1475         try {
1476             return Object(obj).constructor.prototype;
1477         }
1478         catch (e) {
1479             return proto;
1480         }
1481     };
1482
1483     var ArrayIsArray = function (obj) {
1484         try {
1485             return str.call(obj) === "[object Array]";
1486         }
1487         catch(e) {
1488             return false;
1489         }
1490     };
1491
1492     module.exports = {
1493         isArray: ArrayIsArray,
1494         keys: ObjectKeys,
1495         names: ObjectKeys,
1496         defineProperty: ObjectDefineProperty,
1497         getDescriptor: ObjectGetDescriptor,
1498         freeze: ObjectFreeze,
1499         getPrototypeOf: ObjectGetPrototypeOf,
1500         isES5: isES5,
1501         propertyIsWritable: function() {
1502             return true;
1503         }
1504     };
1505 }
1506
1507 },{}],15:[function(_dereq_,module,exports){
1508 "use strict";
1509 module.exports = function(Promise, INTERNAL) {
1510 var PromiseMap = Promise.map;
1511
1512 Promise.prototype.filter = function (fn, options) {
1513     return PromiseMap(this, fn, options, INTERNAL);
1514 };
1515
1516 Promise.filter = function (promises, fn, options) {
1517     return PromiseMap(promises, fn, options, INTERNAL);
1518 };
1519 };
1520
1521 },{}],16:[function(_dereq_,module,exports){
1522 "use strict";
1523 module.exports = function(Promise, NEXT_FILTER, tryConvertToPromise) {
1524 var util = _dereq_("./util.js");
1525 var isPrimitive = util.isPrimitive;
1526 var thrower = util.thrower;
1527
1528 function returnThis() {
1529     return this;
1530 }
1531 function throwThis() {
1532     throw this;
1533 }
1534 function return$(r) {
1535     return function() {
1536         return r;
1537     };
1538 }
1539 function throw$(r) {
1540     return function() {
1541         throw r;
1542     };
1543 }
1544 function promisedFinally(ret, reasonOrValue, isFulfilled) {
1545     var then;
1546     if (isPrimitive(reasonOrValue)) {
1547         then = isFulfilled ? return$(reasonOrValue) : throw$(reasonOrValue);
1548     } else {
1549         then = isFulfilled ? returnThis : throwThis;
1550     }
1551     return ret._then(then, thrower, undefined, reasonOrValue, undefined);
1552 }
1553
1554 function finallyHandler(reasonOrValue) {
1555     var promise = this.promise;
1556     var handler = this.handler;
1557
1558     var ret = promise._isBound()
1559                     ? handler.call(promise._boundValue())
1560                     : handler();
1561
1562     if (ret !== undefined) {
1563         var maybePromise = tryConvertToPromise(ret, promise);
1564         if (maybePromise instanceof Promise) {
1565             maybePromise = maybePromise._target();
1566             return promisedFinally(maybePromise, reasonOrValue,
1567                                     promise.isFulfilled());
1568         }
1569     }
1570
1571     if (promise.isRejected()) {
1572         NEXT_FILTER.e = reasonOrValue;
1573         return NEXT_FILTER;
1574     } else {
1575         return reasonOrValue;
1576     }
1577 }
1578
1579 function tapHandler(value) {
1580     var promise = this.promise;
1581     var handler = this.handler;
1582
1583     var ret = promise._isBound()
1584                     ? handler.call(promise._boundValue(), value)
1585                     : handler(value);
1586
1587     if (ret !== undefined) {
1588         var maybePromise = tryConvertToPromise(ret, promise);
1589         if (maybePromise instanceof Promise) {
1590             maybePromise = maybePromise._target();
1591             return promisedFinally(maybePromise, value, true);
1592         }
1593     }
1594     return value;
1595 }
1596
1597 Promise.prototype._passThroughHandler = function (handler, isFinally) {
1598     if (typeof handler !== "function") return this.then();
1599
1600     var promiseAndHandler = {
1601         promise: this,
1602         handler: handler
1603     };
1604
1605     return this._then(
1606             isFinally ? finallyHandler : tapHandler,
1607             isFinally ? finallyHandler : undefined, undefined,
1608             promiseAndHandler, undefined);
1609 };
1610
1611 Promise.prototype.lastly =
1612 Promise.prototype["finally"] = function (handler) {
1613     return this._passThroughHandler(handler, true);
1614 };
1615
1616 Promise.prototype.tap = function (handler) {
1617     return this._passThroughHandler(handler, false);
1618 };
1619 };
1620
1621 },{"./util.js":38}],17:[function(_dereq_,module,exports){
1622 "use strict";
1623 module.exports = function(Promise,
1624                           apiRejection,
1625                           INTERNAL,
1626                           tryConvertToPromise) {
1627 var errors = _dereq_("./errors.js");
1628 var TypeError = errors.TypeError;
1629 var util = _dereq_("./util.js");
1630 var errorObj = util.errorObj;
1631 var tryCatch = util.tryCatch;
1632 var yieldHandlers = [];
1633
1634 function promiseFromYieldHandler(value, yieldHandlers, traceParent) {
1635     for (var i = 0; i < yieldHandlers.length; ++i) {
1636         traceParent._pushContext();
1637         var result = tryCatch(yieldHandlers[i])(value);
1638         traceParent._popContext();
1639         if (result === errorObj) {
1640             traceParent._pushContext();
1641             var ret = Promise.reject(errorObj.e);
1642             traceParent._popContext();
1643             return ret;
1644         }
1645         var maybePromise = tryConvertToPromise(result, traceParent);
1646         if (maybePromise instanceof Promise) return maybePromise;
1647     }
1648     return null;
1649 }
1650
1651 function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
1652     var promise = this._promise = new Promise(INTERNAL);
1653     promise._captureStackTrace();
1654     this._stack = stack;
1655     this._generatorFunction = generatorFunction;
1656     this._receiver = receiver;
1657     this._generator = undefined;
1658     this._yieldHandlers = typeof yieldHandler === "function"
1659         ? [yieldHandler].concat(yieldHandlers)
1660         : yieldHandlers;
1661 }
1662
1663 PromiseSpawn.prototype.promise = function () {
1664     return this._promise;
1665 };
1666
1667 PromiseSpawn.prototype._run = function () {
1668     this._generator = this._generatorFunction.call(this._receiver);
1669     this._receiver =
1670         this._generatorFunction = undefined;
1671     this._next(undefined);
1672 };
1673
1674 PromiseSpawn.prototype._continue = function (result) {
1675     if (result === errorObj) {
1676         return this._promise._rejectCallback(result.e, false, true);
1677     }
1678
1679     var value = result.value;
1680     if (result.done === true) {
1681         this._promise._resolveCallback(value);
1682     } else {
1683         var maybePromise = tryConvertToPromise(value, this._promise);
1684         if (!(maybePromise instanceof Promise)) {
1685             maybePromise =
1686                 promiseFromYieldHandler(maybePromise,
1687                                         this._yieldHandlers,
1688                                         this._promise);
1689             if (maybePromise === null) {
1690                 this._throw(
1691                     new TypeError(
1692                         "A value %s was yielded that could not be treated as a promise\u000a\u000a    See http://goo.gl/4Y4pDk\u000a\u000a".replace("%s", value) +
1693                         "From coroutine:\u000a" +
1694                         this._stack.split("\n").slice(1, -7).join("\n")
1695                     )
1696                 );
1697                 return;
1698             }
1699         }
1700         maybePromise._then(
1701             this._next,
1702             this._throw,
1703             undefined,
1704             this,
1705             null
1706        );
1707     }
1708 };
1709
1710 PromiseSpawn.prototype._throw = function (reason) {
1711     this._promise._attachExtraTrace(reason);
1712     this._promise._pushContext();
1713     var result = tryCatch(this._generator["throw"])
1714         .call(this._generator, reason);
1715     this._promise._popContext();
1716     this._continue(result);
1717 };
1718
1719 PromiseSpawn.prototype._next = function (value) {
1720     this._promise._pushContext();
1721     var result = tryCatch(this._generator.next).call(this._generator, value);
1722     this._promise._popContext();
1723     this._continue(result);
1724 };
1725
1726 Promise.coroutine = function (generatorFunction, options) {
1727     if (typeof generatorFunction !== "function") {
1728         throw new TypeError("generatorFunction must be a function\u000a\u000a    See http://goo.gl/6Vqhm0\u000a");
1729     }
1730     var yieldHandler = Object(options).yieldHandler;
1731     var PromiseSpawn$ = PromiseSpawn;
1732     var stack = new Error().stack;
1733     return function () {
1734         var generator = generatorFunction.apply(this, arguments);
1735         var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
1736                                       stack);
1737         spawn._generator = generator;
1738         spawn._next(undefined);
1739         return spawn.promise();
1740     };
1741 };
1742
1743 Promise.coroutine.addYieldHandler = function(fn) {
1744     if (typeof fn !== "function") throw new TypeError("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
1745     yieldHandlers.push(fn);
1746 };
1747
1748 Promise.spawn = function (generatorFunction) {
1749     if (typeof generatorFunction !== "function") {
1750         return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/6Vqhm0\u000a");
1751     }
1752     var spawn = new PromiseSpawn(generatorFunction, this);
1753     var ret = spawn.promise();
1754     spawn._run(Promise.spawn);
1755     return ret;
1756 };
1757 };
1758
1759 },{"./errors.js":13,"./util.js":38}],18:[function(_dereq_,module,exports){
1760 "use strict";
1761 module.exports =
1762 function(Promise, PromiseArray, tryConvertToPromise, INTERNAL) {
1763 var util = _dereq_("./util.js");
1764 var canEvaluate = util.canEvaluate;
1765 var tryCatch = util.tryCatch;
1766 var errorObj = util.errorObj;
1767 var reject;
1768
1769 if (!true) {
1770 if (canEvaluate) {
1771     var thenCallback = function(i) {
1772         return new Function("value", "holder", "                             \n\
1773             'use strict';                                                    \n\
1774             holder.pIndex = value;                                           \n\
1775             holder.checkFulfillment(this);                                   \n\
1776             ".replace(/Index/g, i));
1777     };
1778
1779     var caller = function(count) {
1780         var values = [];
1781         for (var i = 1; i <= count; ++i) values.push("holder.p" + i);
1782         return new Function("holder", "                                      \n\
1783             'use strict';                                                    \n\
1784             var callback = holder.fn;                                        \n\
1785             return callback(values);                                         \n\
1786             ".replace(/values/g, values.join(", ")));
1787     };
1788     var thenCallbacks = [];
1789     var callers = [undefined];
1790     for (var i = 1; i <= 5; ++i) {
1791         thenCallbacks.push(thenCallback(i));
1792         callers.push(caller(i));
1793     }
1794
1795     var Holder = function(total, fn) {
1796         this.p1 = this.p2 = this.p3 = this.p4 = this.p5 = null;
1797         this.fn = fn;
1798         this.total = total;
1799         this.now = 0;
1800     };
1801
1802     Holder.prototype.callers = callers;
1803     Holder.prototype.checkFulfillment = function(promise) {
1804         var now = this.now;
1805         now++;
1806         var total = this.total;
1807         if (now >= total) {
1808             var handler = this.callers[total];
1809             promise._pushContext();
1810             var ret = tryCatch(handler)(this);
1811             promise._popContext();
1812             if (ret === errorObj) {
1813                 promise._rejectCallback(ret.e, false, true);
1814             } else {
1815                 promise._resolveCallback(ret);
1816             }
1817         } else {
1818             this.now = now;
1819         }
1820     };
1821
1822     var reject = function (reason) {
1823         this._reject(reason);
1824     };
1825 }
1826 }
1827
1828 Promise.join = function () {
1829     var last = arguments.length - 1;
1830     var fn;
1831     if (last > 0 && typeof arguments[last] === "function") {
1832         fn = arguments[last];
1833         if (!true) {
1834             if (last < 6 && canEvaluate) {
1835                 var ret = new Promise(INTERNAL);
1836                 ret._captureStackTrace();
1837                 var holder = new Holder(last, fn);
1838                 var callbacks = thenCallbacks;
1839                 for (var i = 0; i < last; ++i) {
1840                     var maybePromise = tryConvertToPromise(arguments[i], ret);
1841                     if (maybePromise instanceof Promise) {
1842                         maybePromise = maybePromise._target();
1843                         if (maybePromise._isPending()) {
1844                             maybePromise._then(callbacks[i], reject,
1845                                                undefined, ret, holder);
1846                         } else if (maybePromise._isFulfilled()) {
1847                             callbacks[i].call(ret,
1848                                               maybePromise._value(), holder);
1849                         } else {
1850                             ret._reject(maybePromise._reason());
1851                         }
1852                     } else {
1853                         callbacks[i].call(ret, maybePromise, holder);
1854                     }
1855                 }
1856                 return ret;
1857             }
1858         }
1859     }
1860     var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];}
1861     if (fn) args.pop();
1862     var ret = new PromiseArray(args).promise();
1863     return fn !== undefined ? ret.spread(fn) : ret;
1864 };
1865
1866 };
1867
1868 },{"./util.js":38}],19:[function(_dereq_,module,exports){
1869 "use strict";
1870 module.exports = function(Promise,
1871                           PromiseArray,
1872                           apiRejection,
1873                           tryConvertToPromise,
1874                           INTERNAL) {
1875 var getDomain = Promise._getDomain;
1876 var async = _dereq_("./async.js");
1877 var util = _dereq_("./util.js");
1878 var tryCatch = util.tryCatch;
1879 var errorObj = util.errorObj;
1880 var PENDING = {};
1881 var EMPTY_ARRAY = [];
1882
1883 function MappingPromiseArray(promises, fn, limit, _filter) {
1884     this.constructor$(promises);
1885     this._promise._captureStackTrace();
1886     var domain = getDomain();
1887     this._callback = domain === null ? fn : domain.bind(fn);
1888     this._preservedValues = _filter === INTERNAL
1889         ? new Array(this.length())
1890         : null;
1891     this._limit = limit;
1892     this._inFlight = 0;
1893     this._queue = limit >= 1 ? [] : EMPTY_ARRAY;
1894     async.invoke(init, this, undefined);
1895 }
1896 util.inherits(MappingPromiseArray, PromiseArray);
1897 function init() {this._init$(undefined, -2);}
1898
1899 MappingPromiseArray.prototype._init = function () {};
1900
1901 MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
1902     var values = this._values;
1903     var length = this.length();
1904     var preservedValues = this._preservedValues;
1905     var limit = this._limit;
1906     if (values[index] === PENDING) {
1907         values[index] = value;
1908         if (limit >= 1) {
1909             this._inFlight--;
1910             this._drainQueue();
1911             if (this._isResolved()) return;
1912         }
1913     } else {
1914         if (limit >= 1 && this._inFlight >= limit) {
1915             values[index] = value;
1916             this._queue.push(index);
1917             return;
1918         }
1919         if (preservedValues !== null) preservedValues[index] = value;
1920
1921         var callback = this._callback;
1922         var receiver = this._promise._boundValue();
1923         this._promise._pushContext();
1924         var ret = tryCatch(callback).call(receiver, value, index, length);
1925         this._promise._popContext();
1926         if (ret === errorObj) return this._reject(ret.e);
1927
1928         var maybePromise = tryConvertToPromise(ret, this._promise);
1929         if (maybePromise instanceof Promise) {
1930             maybePromise = maybePromise._target();
1931             if (maybePromise._isPending()) {
1932                 if (limit >= 1) this._inFlight++;
1933                 values[index] = PENDING;
1934                 return maybePromise._proxyPromiseArray(this, index);
1935             } else if (maybePromise._isFulfilled()) {
1936                 ret = maybePromise._value();
1937             } else {
1938                 return this._reject(maybePromise._reason());
1939             }
1940         }
1941         values[index] = ret;
1942     }
1943     var totalResolved = ++this._totalResolved;
1944     if (totalResolved >= length) {
1945         if (preservedValues !== null) {
1946             this._filter(values, preservedValues);
1947         } else {
1948             this._resolve(values);
1949         }
1950
1951     }
1952 };
1953
1954 MappingPromiseArray.prototype._drainQueue = function () {
1955     var queue = this._queue;
1956     var limit = this._limit;
1957     var values = this._values;
1958     while (queue.length > 0 && this._inFlight < limit) {
1959         if (this._isResolved()) return;
1960         var index = queue.pop();
1961         this._promiseFulfilled(values[index], index);
1962     }
1963 };
1964
1965 MappingPromiseArray.prototype._filter = function (booleans, values) {
1966     var len = values.length;
1967     var ret = new Array(len);
1968     var j = 0;
1969     for (var i = 0; i < len; ++i) {
1970         if (booleans[i]) ret[j++] = values[i];
1971     }
1972     ret.length = j;
1973     this._resolve(ret);
1974 };
1975
1976 MappingPromiseArray.prototype.preservedValues = function () {
1977     return this._preservedValues;
1978 };
1979
1980 function map(promises, fn, options, _filter) {
1981     var limit = typeof options === "object" && options !== null
1982         ? options.concurrency
1983         : 0;
1984     limit = typeof limit === "number" &&
1985         isFinite(limit) && limit >= 1 ? limit : 0;
1986     return new MappingPromiseArray(promises, fn, limit, _filter);
1987 }
1988
1989 Promise.prototype.map = function (fn, options) {
1990     if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
1991
1992     return map(this, fn, options, null).promise();
1993 };
1994
1995 Promise.map = function (promises, fn, options, _filter) {
1996     if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
1997     return map(promises, fn, options, _filter).promise();
1998 };
1999
2000
2001 };
2002
2003 },{"./async.js":2,"./util.js":38}],20:[function(_dereq_,module,exports){
2004 "use strict";
2005 module.exports =
2006 function(Promise, INTERNAL, tryConvertToPromise, apiRejection) {
2007 var util = _dereq_("./util.js");
2008 var tryCatch = util.tryCatch;
2009
2010 Promise.method = function (fn) {
2011     if (typeof fn !== "function") {
2012         throw new Promise.TypeError("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
2013     }
2014     return function () {
2015         var ret = new Promise(INTERNAL);
2016         ret._captureStackTrace();
2017         ret._pushContext();
2018         var value = tryCatch(fn).apply(this, arguments);
2019         ret._popContext();
2020         ret._resolveFromSyncValue(value);
2021         return ret;
2022     };
2023 };
2024
2025 Promise.attempt = Promise["try"] = function (fn, args, ctx) {
2026     if (typeof fn !== "function") {
2027         return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
2028     }
2029     var ret = new Promise(INTERNAL);
2030     ret._captureStackTrace();
2031     ret._pushContext();
2032     var value = util.isArray(args)
2033         ? tryCatch(fn).apply(ctx, args)
2034         : tryCatch(fn).call(ctx, args);
2035     ret._popContext();
2036     ret._resolveFromSyncValue(value);
2037     return ret;
2038 };
2039
2040 Promise.prototype._resolveFromSyncValue = function (value) {
2041     if (value === util.errorObj) {
2042         this._rejectCallback(value.e, false, true);
2043     } else {
2044         this._resolveCallback(value, true);
2045     }
2046 };
2047 };
2048
2049 },{"./util.js":38}],21:[function(_dereq_,module,exports){
2050 "use strict";
2051 module.exports = function(Promise) {
2052 var util = _dereq_("./util.js");
2053 var async = _dereq_("./async.js");
2054 var tryCatch = util.tryCatch;
2055 var errorObj = util.errorObj;
2056
2057 function spreadAdapter(val, nodeback) {
2058     var promise = this;
2059     if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
2060     var ret =
2061         tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));
2062     if (ret === errorObj) {
2063         async.throwLater(ret.e);
2064     }
2065 }
2066
2067 function successAdapter(val, nodeback) {
2068     var promise = this;
2069     var receiver = promise._boundValue();
2070     var ret = val === undefined
2071         ? tryCatch(nodeback).call(receiver, null)
2072         : tryCatch(nodeback).call(receiver, null, val);
2073     if (ret === errorObj) {
2074         async.throwLater(ret.e);
2075     }
2076 }
2077 function errorAdapter(reason, nodeback) {
2078     var promise = this;
2079     if (!reason) {
2080         var target = promise._target();
2081         var newReason = target._getCarriedStackTrace();
2082         newReason.cause = reason;
2083         reason = newReason;
2084     }
2085     var ret = tryCatch(nodeback).call(promise._boundValue(), reason);
2086     if (ret === errorObj) {
2087         async.throwLater(ret.e);
2088     }
2089 }
2090
2091 Promise.prototype.asCallback =
2092 Promise.prototype.nodeify = function (nodeback, options) {
2093     if (typeof nodeback == "function") {
2094         var adapter = successAdapter;
2095         if (options !== undefined && Object(options).spread) {
2096             adapter = spreadAdapter;
2097         }
2098         this._then(
2099             adapter,
2100             errorAdapter,
2101             undefined,
2102             this,
2103             nodeback
2104         );
2105     }
2106     return this;
2107 };
2108 };
2109
2110 },{"./async.js":2,"./util.js":38}],22:[function(_dereq_,module,exports){
2111 "use strict";
2112 module.exports = function(Promise, PromiseArray) {
2113 var util = _dereq_("./util.js");
2114 var async = _dereq_("./async.js");
2115 var tryCatch = util.tryCatch;
2116 var errorObj = util.errorObj;
2117
2118 Promise.prototype.progressed = function (handler) {
2119     return this._then(undefined, undefined, handler, undefined, undefined);
2120 };
2121
2122 Promise.prototype._progress = function (progressValue) {
2123     if (this._isFollowingOrFulfilledOrRejected()) return;
2124     this._target()._progressUnchecked(progressValue);
2125
2126 };
2127
2128 Promise.prototype._progressHandlerAt = function (index) {
2129     return index === 0
2130         ? this._progressHandler0
2131         : this[(index << 2) + index - 5 + 2];
2132 };
2133
2134 Promise.prototype._doProgressWith = function (progression) {
2135     var progressValue = progression.value;
2136     var handler = progression.handler;
2137     var promise = progression.promise;
2138     var receiver = progression.receiver;
2139
2140     var ret = tryCatch(handler).call(receiver, progressValue);
2141     if (ret === errorObj) {
2142         if (ret.e != null &&
2143             ret.e.name !== "StopProgressPropagation") {
2144             var trace = util.canAttachTrace(ret.e)
2145                 ? ret.e : new Error(util.toString(ret.e));
2146             promise._attachExtraTrace(trace);
2147             promise._progress(ret.e);
2148         }
2149     } else if (ret instanceof Promise) {
2150         ret._then(promise._progress, null, null, promise, undefined);
2151     } else {
2152         promise._progress(ret);
2153     }
2154 };
2155
2156
2157 Promise.prototype._progressUnchecked = function (progressValue) {
2158     var len = this._length();
2159     var progress = this._progress;
2160     for (var i = 0; i < len; i++) {
2161         var handler = this._progressHandlerAt(i);
2162         var promise = this._promiseAt(i);
2163         if (!(promise instanceof Promise)) {
2164             var receiver = this._receiverAt(i);
2165             if (typeof handler === "function") {
2166                 handler.call(receiver, progressValue, promise);
2167             } else if (receiver instanceof PromiseArray &&
2168                        !receiver._isResolved()) {
2169                 receiver._promiseProgressed(progressValue, promise);
2170             }
2171             continue;
2172         }
2173
2174         if (typeof handler === "function") {
2175             async.invoke(this._doProgressWith, this, {
2176                 handler: handler,
2177                 promise: promise,
2178                 receiver: this._receiverAt(i),
2179                 value: progressValue
2180             });
2181         } else {
2182             async.invoke(progress, promise, progressValue);
2183         }
2184     }
2185 };
2186 };
2187
2188 },{"./async.js":2,"./util.js":38}],23:[function(_dereq_,module,exports){
2189 "use strict";
2190 module.exports = function() {
2191 var makeSelfResolutionError = function () {
2192     return new TypeError("circular promise resolution chain\u000a\u000a    See http://goo.gl/LhFpo0\u000a");
2193 };
2194 var reflect = function() {
2195     return new Promise.PromiseInspection(this._target());
2196 };
2197 var apiRejection = function(msg) {
2198     return Promise.reject(new TypeError(msg));
2199 };
2200
2201 var util = _dereq_("./util.js");
2202
2203 var getDomain;
2204 if (util.isNode) {
2205     getDomain = function() {
2206         var ret = process.domain;
2207         if (ret === undefined) ret = null;
2208         return ret;
2209     };
2210 } else {
2211     getDomain = function() {
2212         return null;
2213     };
2214 }
2215 util.notEnumerableProp(Promise, "_getDomain", getDomain);
2216
2217 var UNDEFINED_BINDING = {};
2218 var async = _dereq_("./async.js");
2219 var errors = _dereq_("./errors.js");
2220 var TypeError = Promise.TypeError = errors.TypeError;
2221 Promise.RangeError = errors.RangeError;
2222 Promise.CancellationError = errors.CancellationError;
2223 Promise.TimeoutError = errors.TimeoutError;
2224 Promise.OperationalError = errors.OperationalError;
2225 Promise.RejectionError = errors.OperationalError;
2226 Promise.AggregateError = errors.AggregateError;
2227 var INTERNAL = function(){};
2228 var APPLY = {};
2229 var NEXT_FILTER = {e: null};
2230 var tryConvertToPromise = _dereq_("./thenables.js")(Promise, INTERNAL);
2231 var PromiseArray =
2232     _dereq_("./promise_array.js")(Promise, INTERNAL,
2233                                     tryConvertToPromise, apiRejection);
2234 var CapturedTrace = _dereq_("./captured_trace.js")();
2235 var isDebugging = _dereq_("./debuggability.js")(Promise, CapturedTrace);
2236  /*jshint unused:false*/
2237 var createContext =
2238     _dereq_("./context.js")(Promise, CapturedTrace, isDebugging);
2239 var CatchFilter = _dereq_("./catch_filter.js")(NEXT_FILTER);
2240 var PromiseResolver = _dereq_("./promise_resolver.js");
2241 var nodebackForPromise = PromiseResolver._nodebackForPromise;
2242 var errorObj = util.errorObj;
2243 var tryCatch = util.tryCatch;
2244 function Promise(resolver) {
2245     if (typeof resolver !== "function") {
2246         throw new TypeError("the promise constructor requires a resolver function\u000a\u000a    See http://goo.gl/EC22Yn\u000a");
2247     }
2248     if (this.constructor !== Promise) {
2249         throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/KsIlge\u000a");
2250     }
2251     this._bitField = 0;
2252     this._fulfillmentHandler0 = undefined;
2253     this._rejectionHandler0 = undefined;
2254     this._progressHandler0 = undefined;
2255     this._promise0 = undefined;
2256     this._receiver0 = undefined;
2257     this._settledValue = undefined;
2258     if (resolver !== INTERNAL) this._resolveFromResolver(resolver);
2259 }
2260
2261 Promise.prototype.toString = function () {
2262     return "[object Promise]";
2263 };
2264
2265 Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
2266     var len = arguments.length;
2267     if (len > 1) {
2268         var catchInstances = new Array(len - 1),
2269             j = 0, i;
2270         for (i = 0; i < len - 1; ++i) {
2271             var item = arguments[i];
2272             if (typeof item === "function") {
2273                 catchInstances[j++] = item;
2274             } else {
2275                 return Promise.reject(
2276                     new TypeError("Catch filter must inherit from Error or be a simple predicate function\u000a\u000a    See http://goo.gl/o84o68\u000a"));
2277             }
2278         }
2279         catchInstances.length = j;
2280         fn = arguments[i];
2281         var catchFilter = new CatchFilter(catchInstances, fn, this);
2282         return this._then(undefined, catchFilter.doFilter, undefined,
2283             catchFilter, undefined);
2284     }
2285     return this._then(undefined, fn, undefined, undefined, undefined);
2286 };
2287
2288 Promise.prototype.reflect = function () {
2289     return this._then(reflect, reflect, undefined, this, undefined);
2290 };
2291
2292 Promise.prototype.then = function (didFulfill, didReject, didProgress) {
2293     if (isDebugging() && arguments.length > 0 &&
2294         typeof didFulfill !== "function" &&
2295         typeof didReject !== "function") {
2296         var msg = ".then() only accepts functions but was passed: " +
2297                 util.classString(didFulfill);
2298         if (arguments.length > 1) {
2299             msg += ", " + util.classString(didReject);
2300         }
2301         this._warn(msg);
2302     }
2303     return this._then(didFulfill, didReject, didProgress,
2304         undefined, undefined);
2305 };
2306
2307 Promise.prototype.done = function (didFulfill, didReject, didProgress) {
2308     var promise = this._then(didFulfill, didReject, didProgress,
2309         undefined, undefined);
2310     promise._setIsFinal();
2311 };
2312
2313 Promise.prototype.spread = function (didFulfill, didReject) {
2314     return this.all()._then(didFulfill, didReject, undefined, APPLY, undefined);
2315 };
2316
2317 Promise.prototype.isCancellable = function () {
2318     return !this.isResolved() &&
2319         this._cancellable();
2320 };
2321
2322 Promise.prototype.toJSON = function () {
2323     var ret = {
2324         isFulfilled: false,
2325         isRejected: false,
2326         fulfillmentValue: undefined,
2327         rejectionReason: undefined
2328     };
2329     if (this.isFulfilled()) {
2330         ret.fulfillmentValue = this.value();
2331         ret.isFulfilled = true;
2332     } else if (this.isRejected()) {
2333         ret.rejectionReason = this.reason();
2334         ret.isRejected = true;
2335     }
2336     return ret;
2337 };
2338
2339 Promise.prototype.all = function () {
2340     return new PromiseArray(this).promise();
2341 };
2342
2343 Promise.prototype.error = function (fn) {
2344     return this.caught(util.originatesFromRejection, fn);
2345 };
2346
2347 Promise.is = function (val) {
2348     return val instanceof Promise;
2349 };
2350
2351 Promise.fromNode = function(fn) {
2352     var ret = new Promise(INTERNAL);
2353     var result = tryCatch(fn)(nodebackForPromise(ret));
2354     if (result === errorObj) {
2355         ret._rejectCallback(result.e, true, true);
2356     }
2357     return ret;
2358 };
2359
2360 Promise.all = function (promises) {
2361     return new PromiseArray(promises).promise();
2362 };
2363
2364 Promise.defer = Promise.pending = function () {
2365     var promise = new Promise(INTERNAL);
2366     return new PromiseResolver(promise);
2367 };
2368
2369 Promise.cast = function (obj) {
2370     var ret = tryConvertToPromise(obj);
2371     if (!(ret instanceof Promise)) {
2372         var val = ret;
2373         ret = new Promise(INTERNAL);
2374         ret._fulfillUnchecked(val);
2375     }
2376     return ret;
2377 };
2378
2379 Promise.resolve = Promise.fulfilled = Promise.cast;
2380
2381 Promise.reject = Promise.rejected = function (reason) {
2382     var ret = new Promise(INTERNAL);
2383     ret._captureStackTrace();
2384     ret._rejectCallback(reason, true);
2385     return ret;
2386 };
2387
2388 Promise.setScheduler = function(fn) {
2389     if (typeof fn !== "function") throw new TypeError("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
2390     var prev = async._schedule;
2391     async._schedule = fn;
2392     return prev;
2393 };
2394
2395 Promise.prototype._then = function (
2396     didFulfill,
2397     didReject,
2398     didProgress,
2399     receiver,
2400     internalData
2401 ) {
2402     var haveInternalData = internalData !== undefined;
2403     var ret = haveInternalData ? internalData : new Promise(INTERNAL);
2404
2405     if (!haveInternalData) {
2406         ret._propagateFrom(this, 4 | 1);
2407         ret._captureStackTrace();
2408     }
2409
2410     var target = this._target();
2411     if (target !== this) {
2412         if (receiver === undefined) receiver = this._boundTo;
2413         if (!haveInternalData) ret._setIsMigrated();
2414     }
2415
2416     var callbackIndex = target._addCallbacks(didFulfill,
2417                                              didReject,
2418                                              didProgress,
2419                                              ret,
2420                                              receiver,
2421                                              getDomain());
2422
2423     if (target._isResolved() && !target._isSettlePromisesQueued()) {
2424         async.invoke(
2425             target._settlePromiseAtPostResolution, target, callbackIndex);
2426     }
2427
2428     return ret;
2429 };
2430
2431 Promise.prototype._settlePromiseAtPostResolution = function (index) {
2432     if (this._isRejectionUnhandled()) this._unsetRejectionIsUnhandled();
2433     this._settlePromiseAt(index);
2434 };
2435
2436 Promise.prototype._length = function () {
2437     return this._bitField & 131071;
2438 };
2439
2440 Promise.prototype._isFollowingOrFulfilledOrRejected = function () {
2441     return (this._bitField & 939524096) > 0;
2442 };
2443
2444 Promise.prototype._isFollowing = function () {
2445     return (this._bitField & 536870912) === 536870912;
2446 };
2447
2448 Promise.prototype._setLength = function (len) {
2449     this._bitField = (this._bitField & -131072) |
2450         (len & 131071);
2451 };
2452
2453 Promise.prototype._setFulfilled = function () {
2454     this._bitField = this._bitField | 268435456;
2455 };
2456
2457 Promise.prototype._setRejected = function () {
2458     this._bitField = this._bitField | 134217728;
2459 };
2460
2461 Promise.prototype._setFollowing = function () {
2462     this._bitField = this._bitField | 536870912;
2463 };
2464
2465 Promise.prototype._setIsFinal = function () {
2466     this._bitField = this._bitField | 33554432;
2467 };
2468
2469 Promise.prototype._isFinal = function () {
2470     return (this._bitField & 33554432) > 0;
2471 };
2472
2473 Promise.prototype._cancellable = function () {
2474     return (this._bitField & 67108864) > 0;
2475 };
2476
2477 Promise.prototype._setCancellable = function () {
2478     this._bitField = this._bitField | 67108864;
2479 };
2480
2481 Promise.prototype._unsetCancellable = function () {
2482     this._bitField = this._bitField & (~67108864);
2483 };
2484
2485 Promise.prototype._setIsMigrated = function () {
2486     this._bitField = this._bitField | 4194304;
2487 };
2488
2489 Promise.prototype._unsetIsMigrated = function () {
2490     this._bitField = this._bitField & (~4194304);
2491 };
2492
2493 Promise.prototype._isMigrated = function () {
2494     return (this._bitField & 4194304) > 0;
2495 };
2496
2497 Promise.prototype._receiverAt = function (index) {
2498     var ret = index === 0
2499         ? this._receiver0
2500         : this[
2501             index * 5 - 5 + 4];
2502     if (ret === UNDEFINED_BINDING) {
2503         return undefined;
2504     } else if (ret === undefined && this._isBound()) {
2505         return this._boundValue();
2506     }
2507     return ret;
2508 };
2509
2510 Promise.prototype._promiseAt = function (index) {
2511     return index === 0
2512         ? this._promise0
2513         : this[index * 5 - 5 + 3];
2514 };
2515
2516 Promise.prototype._fulfillmentHandlerAt = function (index) {
2517     return index === 0
2518         ? this._fulfillmentHandler0
2519         : this[index * 5 - 5 + 0];
2520 };
2521
2522 Promise.prototype._rejectionHandlerAt = function (index) {
2523     return index === 0
2524         ? this._rejectionHandler0
2525         : this[index * 5 - 5 + 1];
2526 };
2527
2528 Promise.prototype._boundValue = function() {
2529     var ret = this._boundTo;
2530     if (ret !== undefined) {
2531         if (ret instanceof Promise) {
2532             if (ret.isFulfilled()) {
2533                 return ret.value();
2534             } else {
2535                 return undefined;
2536             }
2537         }
2538     }
2539     return ret;
2540 };
2541
2542 Promise.prototype._migrateCallbacks = function (follower, index) {
2543     var fulfill = follower._fulfillmentHandlerAt(index);
2544     var reject = follower._rejectionHandlerAt(index);
2545     var progress = follower._progressHandlerAt(index);
2546     var promise = follower._promiseAt(index);
2547     var receiver = follower._receiverAt(index);
2548     if (promise instanceof Promise) promise._setIsMigrated();
2549     if (receiver === undefined) receiver = UNDEFINED_BINDING;
2550     this._addCallbacks(fulfill, reject, progress, promise, receiver, null);
2551 };
2552
2553 Promise.prototype._addCallbacks = function (
2554     fulfill,
2555     reject,
2556     progress,
2557     promise,
2558     receiver,
2559     domain
2560 ) {
2561     var index = this._length();
2562
2563     if (index >= 131071 - 5) {
2564         index = 0;
2565         this._setLength(0);
2566     }
2567
2568     if (index === 0) {
2569         this._promise0 = promise;
2570         if (receiver !== undefined) this._receiver0 = receiver;
2571         if (typeof fulfill === "function" && !this._isCarryingStackTrace()) {
2572             this._fulfillmentHandler0 =
2573                 domain === null ? fulfill : domain.bind(fulfill);
2574         }
2575         if (typeof reject === "function") {
2576             this._rejectionHandler0 =
2577                 domain === null ? reject : domain.bind(reject);
2578         }
2579         if (typeof progress === "function") {
2580             this._progressHandler0 =
2581                 domain === null ? progress : domain.bind(progress);
2582         }
2583     } else {
2584         var base = index * 5 - 5;
2585         this[base + 3] = promise;
2586         this[base + 4] = receiver;
2587         if (typeof fulfill === "function") {
2588             this[base + 0] =
2589                 domain === null ? fulfill : domain.bind(fulfill);
2590         }
2591         if (typeof reject === "function") {
2592             this[base + 1] =
2593                 domain === null ? reject : domain.bind(reject);
2594         }
2595         if (typeof progress === "function") {
2596             this[base + 2] =
2597                 domain === null ? progress : domain.bind(progress);
2598         }
2599     }
2600     this._setLength(index + 1);
2601     return index;
2602 };
2603
2604 Promise.prototype._setProxyHandlers = function (receiver, promiseSlotValue) {
2605     var index = this._length();
2606
2607     if (index >= 131071 - 5) {
2608         index = 0;
2609         this._setLength(0);
2610     }
2611     if (index === 0) {
2612         this._promise0 = promiseSlotValue;
2613         this._receiver0 = receiver;
2614     } else {
2615         var base = index * 5 - 5;
2616         this[base + 3] = promiseSlotValue;
2617         this[base + 4] = receiver;
2618     }
2619     this._setLength(index + 1);
2620 };
2621
2622 Promise.prototype._proxyPromiseArray = function (promiseArray, index) {
2623     this._setProxyHandlers(promiseArray, index);
2624 };
2625
2626 Promise.prototype._resolveCallback = function(value, shouldBind) {
2627     if (this._isFollowingOrFulfilledOrRejected()) return;
2628     if (value === this)
2629         return this._rejectCallback(makeSelfResolutionError(), false, true);
2630     var maybePromise = tryConvertToPromise(value, this);
2631     if (!(maybePromise instanceof Promise)) return this._fulfill(value);
2632
2633     var propagationFlags = 1 | (shouldBind ? 4 : 0);
2634     this._propagateFrom(maybePromise, propagationFlags);
2635     var promise = maybePromise._target();
2636     if (promise._isPending()) {
2637         var len = this._length();
2638         for (var i = 0; i < len; ++i) {
2639             promise._migrateCallbacks(this, i);
2640         }
2641         this._setFollowing();
2642         this._setLength(0);
2643         this._setFollowee(promise);
2644     } else if (promise._isFulfilled()) {
2645         this._fulfillUnchecked(promise._value());
2646     } else {
2647         this._rejectUnchecked(promise._reason(),
2648             promise._getCarriedStackTrace());
2649     }
2650 };
2651
2652 Promise.prototype._rejectCallback =
2653 function(reason, synchronous, shouldNotMarkOriginatingFromRejection) {
2654     if (!shouldNotMarkOriginatingFromRejection) {
2655         util.markAsOriginatingFromRejection(reason);
2656     }
2657     var trace = util.ensureErrorObject(reason);
2658     var hasStack = trace === reason;
2659     this._attachExtraTrace(trace, synchronous ? hasStack : false);
2660     this._reject(reason, hasStack ? undefined : trace);
2661 };
2662
2663 Promise.prototype._resolveFromResolver = function (resolver) {
2664     var promise = this;
2665     this._captureStackTrace();
2666     this._pushContext();
2667     var synchronous = true;
2668     var r = tryCatch(resolver)(function(value) {
2669         if (promise === null) return;
2670         promise._resolveCallback(value);
2671         promise = null;
2672     }, function (reason) {
2673         if (promise === null) return;
2674         promise._rejectCallback(reason, synchronous);
2675         promise = null;
2676     });
2677     synchronous = false;
2678     this._popContext();
2679
2680     if (r !== undefined && r === errorObj && promise !== null) {
2681         promise._rejectCallback(r.e, true, true);
2682         promise = null;
2683     }
2684 };
2685
2686 Promise.prototype._settlePromiseFromHandler = function (
2687     handler, receiver, value, promise
2688 ) {
2689     if (promise._isRejected()) return;
2690     promise._pushContext();
2691     var x;
2692     if (receiver === APPLY && !this._isRejected()) {
2693         x = tryCatch(handler).apply(this._boundValue(), value);
2694     } else {
2695         x = tryCatch(handler).call(receiver, value);
2696     }
2697     promise._popContext();
2698
2699     if (x === errorObj || x === promise || x === NEXT_FILTER) {
2700         var err = x === promise ? makeSelfResolutionError() : x.e;
2701         promise._rejectCallback(err, false, true);
2702     } else {
2703         promise._resolveCallback(x);
2704     }
2705 };
2706
2707 Promise.prototype._target = function() {
2708     var ret = this;
2709     while (ret._isFollowing()) ret = ret._followee();
2710     return ret;
2711 };
2712
2713 Promise.prototype._followee = function() {
2714     return this._rejectionHandler0;
2715 };
2716
2717 Promise.prototype._setFollowee = function(promise) {
2718     this._rejectionHandler0 = promise;
2719 };
2720
2721 Promise.prototype._cleanValues = function () {
2722     if (this._cancellable()) {
2723         this._cancellationParent = undefined;
2724     }
2725 };
2726
2727 Promise.prototype._propagateFrom = function (parent, flags) {
2728     if ((flags & 1) > 0 && parent._cancellable()) {
2729         this._setCancellable();
2730         this._cancellationParent = parent;
2731     }
2732     if ((flags & 4) > 0 && parent._isBound()) {
2733         this._setBoundTo(parent._boundTo);
2734     }
2735 };
2736
2737 Promise.prototype._fulfill = function (value) {
2738     if (this._isFollowingOrFulfilledOrRejected()) return;
2739     this._fulfillUnchecked(value);
2740 };
2741
2742 Promise.prototype._reject = function (reason, carriedStackTrace) {
2743     if (this._isFollowingOrFulfilledOrRejected()) return;
2744     this._rejectUnchecked(reason, carriedStackTrace);
2745 };
2746
2747 Promise.prototype._settlePromiseAt = function (index) {
2748     var promise = this._promiseAt(index);
2749     var isPromise = promise instanceof Promise;
2750
2751     if (isPromise && promise._isMigrated()) {
2752         promise._unsetIsMigrated();
2753         return async.invoke(this._settlePromiseAt, this, index);
2754     }
2755     var handler = this._isFulfilled()
2756         ? this._fulfillmentHandlerAt(index)
2757         : this._rejectionHandlerAt(index);
2758
2759     var carriedStackTrace =
2760         this._isCarryingStackTrace() ? this._getCarriedStackTrace() : undefined;
2761     var value = this._settledValue;
2762     var receiver = this._receiverAt(index);
2763     this._clearCallbackDataAtIndex(index);
2764
2765     if (typeof handler === "function") {
2766         if (!isPromise) {
2767             handler.call(receiver, value, promise);
2768         } else {
2769             this._settlePromiseFromHandler(handler, receiver, value, promise);
2770         }
2771     } else if (receiver instanceof PromiseArray) {
2772         if (!receiver._isResolved()) {
2773             if (this._isFulfilled()) {
2774                 receiver._promiseFulfilled(value, promise);
2775             }
2776             else {
2777                 receiver._promiseRejected(value, promise);
2778             }
2779         }
2780     } else if (isPromise) {
2781         if (this._isFulfilled()) {
2782             promise._fulfill(value);
2783         } else {
2784             promise._reject(value, carriedStackTrace);
2785         }
2786     }
2787
2788     if (index >= 4 && (index & 31) === 4)
2789         async.invokeLater(this._setLength, this, 0);
2790 };
2791
2792 Promise.prototype._clearCallbackDataAtIndex = function(index) {
2793     if (index === 0) {
2794         if (!this._isCarryingStackTrace()) {
2795             this._fulfillmentHandler0 = undefined;
2796         }
2797         this._rejectionHandler0 =
2798         this._progressHandler0 =
2799         this._receiver0 =
2800         this._promise0 = undefined;
2801     } else {
2802         var base = index * 5 - 5;
2803         this[base + 3] =
2804         this[base + 4] =
2805         this[base + 0] =
2806         this[base + 1] =
2807         this[base + 2] = undefined;
2808     }
2809 };
2810
2811 Promise.prototype._isSettlePromisesQueued = function () {
2812     return (this._bitField &
2813             -1073741824) === -1073741824;
2814 };
2815
2816 Promise.prototype._setSettlePromisesQueued = function () {
2817     this._bitField = this._bitField | -1073741824;
2818 };
2819
2820 Promise.prototype._unsetSettlePromisesQueued = function () {
2821     this._bitField = this._bitField & (~-1073741824);
2822 };
2823
2824 Promise.prototype._queueSettlePromises = function() {
2825     async.settlePromises(this);
2826     this._setSettlePromisesQueued();
2827 };
2828
2829 Promise.prototype._fulfillUnchecked = function (value) {
2830     if (value === this) {
2831         var err = makeSelfResolutionError();
2832         this._attachExtraTrace(err);
2833         return this._rejectUnchecked(err, undefined);
2834     }
2835     this._setFulfilled();
2836     this._settledValue = value;
2837     this._cleanValues();
2838
2839     if (this._length() > 0) {
2840         this._queueSettlePromises();
2841     }
2842 };
2843
2844 Promise.prototype._rejectUncheckedCheckError = function (reason) {
2845     var trace = util.ensureErrorObject(reason);
2846     this._rejectUnchecked(reason, trace === reason ? undefined : trace);
2847 };
2848
2849 Promise.prototype._rejectUnchecked = function (reason, trace) {
2850     if (reason === this) {
2851         var err = makeSelfResolutionError();
2852         this._attachExtraTrace(err);
2853         return this._rejectUnchecked(err);
2854     }
2855     this._setRejected();
2856     this._settledValue = reason;
2857     this._cleanValues();
2858
2859     if (this._isFinal()) {
2860         async.throwLater(function(e) {
2861             if ("stack" in e) {
2862                 async.invokeFirst(
2863                     CapturedTrace.unhandledRejection, undefined, e);
2864             }
2865             throw e;
2866         }, trace === undefined ? reason : trace);
2867         return;
2868     }
2869
2870     if (trace !== undefined && trace !== reason) {
2871         this._setCarriedStackTrace(trace);
2872     }
2873
2874     if (this._length() > 0) {
2875         this._queueSettlePromises();
2876     } else {
2877         this._ensurePossibleRejectionHandled();
2878     }
2879 };
2880
2881 Promise.prototype._settlePromises = function () {
2882     this._unsetSettlePromisesQueued();
2883     var len = this._length();
2884     for (var i = 0; i < len; i++) {
2885         this._settlePromiseAt(i);
2886     }
2887 };
2888
2889 util.notEnumerableProp(Promise,
2890                        "_makeSelfResolutionError",
2891                        makeSelfResolutionError);
2892
2893 _dereq_("./progress.js")(Promise, PromiseArray);
2894 _dereq_("./method.js")(Promise, INTERNAL, tryConvertToPromise, apiRejection);
2895 _dereq_("./bind.js")(Promise, INTERNAL, tryConvertToPromise);
2896 _dereq_("./finally.js")(Promise, NEXT_FILTER, tryConvertToPromise);
2897 _dereq_("./direct_resolve.js")(Promise);
2898 _dereq_("./synchronous_inspection.js")(Promise);
2899 _dereq_("./join.js")(Promise, PromiseArray, tryConvertToPromise, INTERNAL);
2900 Promise.Promise = Promise;
2901 _dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL);
2902 _dereq_('./cancel.js')(Promise);
2903 _dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext);
2904 _dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise);
2905 _dereq_('./nodeify.js')(Promise);
2906 _dereq_('./call_get.js')(Promise);
2907 _dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);
2908 _dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);
2909 _dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL);
2910 _dereq_('./settle.js')(Promise, PromiseArray);
2911 _dereq_('./some.js')(Promise, PromiseArray, apiRejection);
2912 _dereq_('./promisify.js')(Promise, INTERNAL);
2913 _dereq_('./any.js')(Promise);
2914 _dereq_('./each.js')(Promise, INTERNAL);
2915 _dereq_('./timers.js')(Promise, INTERNAL);
2916 _dereq_('./filter.js')(Promise, INTERNAL);
2917
2918     util.toFastProperties(Promise);
2919     util.toFastProperties(Promise.prototype);
2920     function fillTypes(value) {
2921         var p = new Promise(INTERNAL);
2922         p._fulfillmentHandler0 = value;
2923         p._rejectionHandler0 = value;
2924         p._progressHandler0 = value;
2925         p._promise0 = value;
2926         p._receiver0 = value;
2927         p._settledValue = value;
2928     }
2929     // Complete slack tracking, opt out of field-type tracking and
2930     // stabilize map
2931     fillTypes({a: 1});
2932     fillTypes({b: 2});
2933     fillTypes({c: 3});
2934     fillTypes(1);
2935     fillTypes(function(){});
2936     fillTypes(undefined);
2937     fillTypes(false);
2938     fillTypes(new Promise(INTERNAL));
2939     CapturedTrace.setBounds(async.firstLineError, util.lastLineError);
2940     return Promise;
2941
2942 };
2943
2944 },{"./any.js":1,"./async.js":2,"./bind.js":3,"./call_get.js":5,"./cancel.js":6,"./captured_trace.js":7,"./catch_filter.js":8,"./context.js":9,"./debuggability.js":10,"./direct_resolve.js":11,"./each.js":12,"./errors.js":13,"./filter.js":15,"./finally.js":16,"./generators.js":17,"./join.js":18,"./map.js":19,"./method.js":20,"./nodeify.js":21,"./progress.js":22,"./promise_array.js":24,"./promise_resolver.js":25,"./promisify.js":26,"./props.js":27,"./race.js":29,"./reduce.js":30,"./settle.js":32,"./some.js":33,"./synchronous_inspection.js":34,"./thenables.js":35,"./timers.js":36,"./using.js":37,"./util.js":38}],24:[function(_dereq_,module,exports){
2945 "use strict";
2946 module.exports = function(Promise, INTERNAL, tryConvertToPromise,
2947     apiRejection) {
2948 var util = _dereq_("./util.js");
2949 var isArray = util.isArray;
2950
2951 function toResolutionValue(val) {
2952     switch(val) {
2953     case -2: return [];
2954     case -3: return {};
2955     }
2956 }
2957
2958 function PromiseArray(values) {
2959     var promise = this._promise = new Promise(INTERNAL);
2960     var parent;
2961     if (values instanceof Promise) {
2962         parent = values;
2963         promise._propagateFrom(parent, 1 | 4);
2964     }
2965     this._values = values;
2966     this._length = 0;
2967     this._totalResolved = 0;
2968     this._init(undefined, -2);
2969 }
2970 PromiseArray.prototype.length = function () {
2971     return this._length;
2972 };
2973
2974 PromiseArray.prototype.promise = function () {
2975     return this._promise;
2976 };
2977
2978 PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
2979     var values = tryConvertToPromise(this._values, this._promise);
2980     if (values instanceof Promise) {
2981         values = values._target();
2982         this._values = values;
2983         if (values._isFulfilled()) {
2984             values = values._value();
2985             if (!isArray(values)) {
2986                 var err = new Promise.TypeError("expecting an array, a promise or a thenable\u000a\u000a    See http://goo.gl/s8MMhc\u000a");
2987                 this.__hardReject__(err);
2988                 return;
2989             }
2990         } else if (values._isPending()) {
2991             values._then(
2992                 init,
2993                 this._reject,
2994                 undefined,
2995                 this,
2996                 resolveValueIfEmpty
2997            );
2998             return;
2999         } else {
3000             this._reject(values._reason());
3001             return;
3002         }
3003     } else if (!isArray(values)) {
3004         this._promise._reject(apiRejection("expecting an array, a promise or a thenable\u000a\u000a    See http://goo.gl/s8MMhc\u000a")._reason());
3005         return;
3006     }
3007
3008     if (values.length === 0) {
3009         if (resolveValueIfEmpty === -5) {
3010             this._resolveEmptyArray();
3011         }
3012         else {
3013             this._resolve(toResolutionValue(resolveValueIfEmpty));
3014         }
3015         return;
3016     }
3017     var len = this.getActualLength(values.length);
3018     this._length = len;
3019     this._values = this.shouldCopyValues() ? new Array(len) : this._values;
3020     var promise = this._promise;
3021     for (var i = 0; i < len; ++i) {
3022         var isResolved = this._isResolved();
3023         var maybePromise = tryConvertToPromise(values[i], promise);
3024         if (maybePromise instanceof Promise) {
3025             maybePromise = maybePromise._target();
3026             if (isResolved) {
3027                 maybePromise._ignoreRejections();
3028             } else if (maybePromise._isPending()) {
3029                 maybePromise._proxyPromiseArray(this, i);
3030             } else if (maybePromise._isFulfilled()) {
3031                 this._promiseFulfilled(maybePromise._value(), i);
3032             } else {
3033                 this._promiseRejected(maybePromise._reason(), i);
3034             }
3035         } else if (!isResolved) {
3036             this._promiseFulfilled(maybePromise, i);
3037         }
3038     }
3039 };
3040
3041 PromiseArray.prototype._isResolved = function () {
3042     return this._values === null;
3043 };
3044
3045 PromiseArray.prototype._resolve = function (value) {
3046     this._values = null;
3047     this._promise._fulfill(value);
3048 };
3049
3050 PromiseArray.prototype.__hardReject__ =
3051 PromiseArray.prototype._reject = function (reason) {
3052     this._values = null;
3053     this._promise._rejectCallback(reason, false, true);
3054 };
3055
3056 PromiseArray.prototype._promiseProgressed = function (progressValue, index) {
3057     this._promise._progress({
3058         index: index,
3059         value: progressValue
3060     });
3061 };
3062
3063
3064 PromiseArray.prototype._promiseFulfilled = function (value, index) {
3065     this._values[index] = value;
3066     var totalResolved = ++this._totalResolved;
3067     if (totalResolved >= this._length) {
3068         this._resolve(this._values);
3069     }
3070 };
3071
3072 PromiseArray.prototype._promiseRejected = function (reason, index) {
3073     this._totalResolved++;
3074     this._reject(reason);
3075 };
3076
3077 PromiseArray.prototype.shouldCopyValues = function () {
3078     return true;
3079 };
3080
3081 PromiseArray.prototype.getActualLength = function (len) {
3082     return len;
3083 };
3084
3085 return PromiseArray;
3086 };
3087
3088 },{"./util.js":38}],25:[function(_dereq_,module,exports){
3089 "use strict";
3090 var util = _dereq_("./util.js");
3091 var maybeWrapAsError = util.maybeWrapAsError;
3092 var errors = _dereq_("./errors.js");
3093 var TimeoutError = errors.TimeoutError;
3094 var OperationalError = errors.OperationalError;
3095 var haveGetters = util.haveGetters;
3096 var es5 = _dereq_("./es5.js");
3097
3098 function isUntypedError(obj) {
3099     return obj instanceof Error &&
3100         es5.getPrototypeOf(obj) === Error.prototype;
3101 }
3102
3103 var rErrorKey = /^(?:name|message|stack|cause)$/;
3104 function wrapAsOperationalError(obj) {
3105     var ret;
3106     if (isUntypedError(obj)) {
3107         ret = new OperationalError(obj);
3108         ret.name = obj.name;
3109         ret.message = obj.message;
3110         ret.stack = obj.stack;
3111         var keys = es5.keys(obj);
3112         for (var i = 0; i < keys.length; ++i) {
3113             var key = keys[i];
3114             if (!rErrorKey.test(key)) {
3115                 ret[key] = obj[key];
3116             }
3117         }
3118         return ret;
3119     }
3120     util.markAsOriginatingFromRejection(obj);
3121     return obj;
3122 }
3123
3124 function nodebackForPromise(promise) {
3125     return function(err, value) {
3126         if (promise === null) return;
3127
3128         if (err) {
3129             var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
3130             promise._attachExtraTrace(wrapped);
3131             promise._reject(wrapped);
3132         } else if (arguments.length > 2) {
3133             var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
3134             promise._fulfill(args);
3135         } else {
3136             promise._fulfill(value);
3137         }
3138
3139         promise = null;
3140     };
3141 }
3142
3143
3144 var PromiseResolver;
3145 if (!haveGetters) {
3146     PromiseResolver = function (promise) {
3147         this.promise = promise;
3148         this.asCallback = nodebackForPromise(promise);
3149         this.callback = this.asCallback;
3150     };
3151 }
3152 else {
3153     PromiseResolver = function (promise) {
3154         this.promise = promise;
3155     };
3156 }
3157 if (haveGetters) {
3158     var prop = {
3159         get: function() {
3160             return nodebackForPromise(this.promise);
3161         }
3162     };
3163     es5.defineProperty(PromiseResolver.prototype, "asCallback", prop);
3164     es5.defineProperty(PromiseResolver.prototype, "callback", prop);
3165 }
3166
3167 PromiseResolver._nodebackForPromise = nodebackForPromise;
3168
3169 PromiseResolver.prototype.toString = function () {
3170     return "[object PromiseResolver]";
3171 };
3172
3173 PromiseResolver.prototype.resolve =
3174 PromiseResolver.prototype.fulfill = function (value) {
3175     if (!(this instanceof PromiseResolver)) {
3176         throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a    See http://goo.gl/sdkXL9\u000a");
3177     }
3178     this.promise._resolveCallback(value);
3179 };
3180
3181 PromiseResolver.prototype.reject = function (reason) {
3182     if (!(this instanceof PromiseResolver)) {
3183         throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a    See http://goo.gl/sdkXL9\u000a");
3184     }
3185     this.promise._rejectCallback(reason);
3186 };
3187
3188 PromiseResolver.prototype.progress = function (value) {
3189     if (!(this instanceof PromiseResolver)) {
3190         throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a    See http://goo.gl/sdkXL9\u000a");
3191     }
3192     this.promise._progress(value);
3193 };
3194
3195 PromiseResolver.prototype.cancel = function (err) {
3196     this.promise.cancel(err);
3197 };
3198
3199 PromiseResolver.prototype.timeout = function () {
3200     this.reject(new TimeoutError("timeout"));
3201 };
3202
3203 PromiseResolver.prototype.isResolved = function () {
3204     return this.promise.isResolved();
3205 };
3206
3207 PromiseResolver.prototype.toJSON = function () {
3208     return this.promise.toJSON();
3209 };
3210
3211 module.exports = PromiseResolver;
3212
3213 },{"./errors.js":13,"./es5.js":14,"./util.js":38}],26:[function(_dereq_,module,exports){
3214 "use strict";
3215 module.exports = function(Promise, INTERNAL) {
3216 var THIS = {};
3217 var util = _dereq_("./util.js");
3218 var nodebackForPromise = _dereq_("./promise_resolver.js")
3219     ._nodebackForPromise;
3220 var withAppended = util.withAppended;
3221 var maybeWrapAsError = util.maybeWrapAsError;
3222 var canEvaluate = util.canEvaluate;
3223 var TypeError = _dereq_("./errors").TypeError;
3224 var defaultSuffix = "Async";
3225 var defaultPromisified = {__isPromisified__: true};
3226 var noCopyProps = [
3227     "arity",    "length",
3228     "name",
3229     "arguments",
3230     "caller",
3231     "callee",
3232     "prototype",
3233     "__isPromisified__"
3234 ];
3235 var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$");
3236
3237 var defaultFilter = function(name) {
3238     return util.isIdentifier(name) &&
3239         name.charAt(0) !== "_" &&
3240         name !== "constructor";
3241 };
3242
3243 function propsFilter(key) {
3244     return !noCopyPropsPattern.test(key);
3245 }
3246
3247 function isPromisified(fn) {
3248     try {
3249         return fn.__isPromisified__ === true;
3250     }
3251     catch (e) {
3252         return false;
3253     }
3254 }
3255
3256 function hasPromisified(obj, key, suffix) {
3257     var val = util.getDataPropertyOrDefault(obj, key + suffix,
3258                                             defaultPromisified);
3259     return val ? isPromisified(val) : false;
3260 }
3261 function checkValid(ret, suffix, suffixRegexp) {
3262     for (var i = 0; i < ret.length; i += 2) {
3263         var key = ret[i];
3264         if (suffixRegexp.test(key)) {
3265             var keyWithoutAsyncSuffix = key.replace(suffixRegexp, "");
3266             for (var j = 0; j < ret.length; j += 2) {
3267                 if (ret[j] === keyWithoutAsyncSuffix) {
3268                     throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a    See http://goo.gl/iWrZbw\u000a"
3269                         .replace("%s", suffix));
3270                 }
3271             }
3272         }
3273     }
3274 }
3275
3276 function promisifiableMethods(obj, suffix, suffixRegexp, filter) {
3277     var keys = util.inheritedDataKeys(obj);
3278     var ret = [];
3279     for (var i = 0; i < keys.length; ++i) {
3280         var key = keys[i];
3281         var value = obj[key];
3282         var passesDefaultFilter = filter === defaultFilter
3283             ? true : defaultFilter(key, value, obj);
3284         if (typeof value === "function" &&
3285             !isPromisified(value) &&
3286             !hasPromisified(obj, key, suffix) &&
3287             filter(key, value, obj, passesDefaultFilter)) {
3288             ret.push(key, value);
3289         }
3290     }
3291     checkValid(ret, suffix, suffixRegexp);
3292     return ret;
3293 }
3294
3295 var escapeIdentRegex = function(str) {
3296     return str.replace(/([$])/, "\\$");
3297 };
3298
3299 var makeNodePromisifiedEval;
3300 if (!true) {
3301 var switchCaseArgumentOrder = function(likelyArgumentCount) {
3302     var ret = [likelyArgumentCount];
3303     var min = Math.max(0, likelyArgumentCount - 1 - 3);
3304     for(var i = likelyArgumentCount - 1; i >= min; --i) {
3305         ret.push(i);
3306     }
3307     for(var i = likelyArgumentCount + 1; i <= 3; ++i) {
3308         ret.push(i);
3309     }
3310     return ret;
3311 };
3312
3313 var argumentSequence = function(argumentCount) {
3314     return util.filledRange(argumentCount, "_arg", "");
3315 };
3316
3317 var parameterDeclaration = function(parameterCount) {
3318     return util.filledRange(
3319         Math.max(parameterCount, 3), "_arg", "");
3320 };
3321
3322 var parameterCount = function(fn) {
3323     if (typeof fn.length === "number") {
3324         return Math.max(Math.min(fn.length, 1023 + 1), 0);
3325     }
3326     return 0;
3327 };
3328
3329 makeNodePromisifiedEval =
3330 function(callback, receiver, originalName, fn) {
3331     var newParameterCount = Math.max(0, parameterCount(fn) - 1);
3332     var argumentOrder = switchCaseArgumentOrder(newParameterCount);
3333     var shouldProxyThis = typeof callback === "string" || receiver === THIS;
3334
3335     function generateCallForArgumentCount(count) {
3336         var args = argumentSequence(count).join(", ");
3337         var comma = count > 0 ? ", " : "";
3338         var ret;
3339         if (shouldProxyThis) {
3340             ret = "ret = callback.call(this, {{args}}, nodeback); break;\n";
3341         } else {
3342             ret = receiver === undefined
3343                 ? "ret = callback({{args}}, nodeback); break;\n"
3344                 : "ret = callback.call(receiver, {{args}}, nodeback); break;\n";
3345         }
3346         return ret.replace("{{args}}", args).replace(", ", comma);
3347     }
3348
3349     function generateArgumentSwitchCase() {
3350         var ret = "";
3351         for (var i = 0; i < argumentOrder.length; ++i) {
3352             ret += "case " + argumentOrder[i] +":" +
3353                 generateCallForArgumentCount(argumentOrder[i]);
3354         }
3355
3356         ret += "                                                             \n\
3357         default:                                                             \n\
3358             var args = new Array(len + 1);                                   \n\
3359             var i = 0;                                                       \n\
3360             for (var i = 0; i < len; ++i) {                                  \n\
3361                args[i] = arguments[i];                                       \n\
3362             }                                                                \n\
3363             args[i] = nodeback;                                              \n\
3364             [CodeForCall]                                                    \n\
3365             break;                                                           \n\
3366         ".replace("[CodeForCall]", (shouldProxyThis
3367                                 ? "ret = callback.apply(this, args);\n"
3368                                 : "ret = callback.apply(receiver, args);\n"));
3369         return ret;
3370     }
3371
3372     var getFunctionCode = typeof callback === "string"
3373                                 ? ("this != null ? this['"+callback+"'] : fn")
3374                                 : "fn";
3375
3376     return new Function("Promise",
3377                         "fn",
3378                         "receiver",
3379                         "withAppended",
3380                         "maybeWrapAsError",
3381                         "nodebackForPromise",
3382                         "tryCatch",
3383                         "errorObj",
3384                         "notEnumerableProp",
3385                         "INTERNAL","'use strict';                            \n\
3386         var ret = function (Parameters) {                                    \n\
3387             'use strict';                                                    \n\
3388             var len = arguments.length;                                      \n\
3389             var promise = new Promise(INTERNAL);                             \n\
3390             promise._captureStackTrace();                                    \n\
3391             var nodeback = nodebackForPromise(promise);                      \n\
3392             var ret;                                                         \n\
3393             var callback = tryCatch([GetFunctionCode]);                      \n\
3394             switch(len) {                                                    \n\
3395                 [CodeForSwitchCase]                                          \n\
3396             }                                                                \n\
3397             if (ret === errorObj) {                                          \n\
3398                 promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\
3399             }                                                                \n\
3400             return promise;                                                  \n\
3401         };                                                                   \n\
3402         notEnumerableProp(ret, '__isPromisified__', true);                   \n\
3403         return ret;                                                          \n\
3404         "
3405         .replace("Parameters", parameterDeclaration(newParameterCount))
3406         .replace("[CodeForSwitchCase]", generateArgumentSwitchCase())
3407         .replace("[GetFunctionCode]", getFunctionCode))(
3408             Promise,
3409             fn,
3410             receiver,
3411             withAppended,
3412             maybeWrapAsError,
3413             nodebackForPromise,
3414             util.tryCatch,
3415             util.errorObj,
3416             util.notEnumerableProp,
3417             INTERNAL
3418         );
3419 };
3420 }
3421
3422 function makeNodePromisifiedClosure(callback, receiver, _, fn) {
3423     var defaultThis = (function() {return this;})();
3424     var method = callback;
3425     if (typeof method === "string") {
3426         callback = fn;
3427     }
3428     function promisified() {
3429         var _receiver = receiver;
3430         if (receiver === THIS) _receiver = this;
3431         var promise = new Promise(INTERNAL);
3432         promise._captureStackTrace();
3433         var cb = typeof method === "string" && this !== defaultThis
3434             ? this[method] : callback;
3435         var fn = nodebackForPromise(promise);
3436         try {
3437             cb.apply(_receiver, withAppended(arguments, fn));
3438         } catch(e) {
3439             promise._rejectCallback(maybeWrapAsError(e), true, true);
3440         }
3441         return promise;
3442     }
3443     util.notEnumerableProp(promisified, "__isPromisified__", true);
3444     return promisified;
3445 }
3446
3447 var makeNodePromisified = canEvaluate
3448     ? makeNodePromisifiedEval
3449     : makeNodePromisifiedClosure;
3450
3451 function promisifyAll(obj, suffix, filter, promisifier) {
3452     var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$");
3453     var methods =
3454         promisifiableMethods(obj, suffix, suffixRegexp, filter);
3455
3456     for (var i = 0, len = methods.length; i < len; i+= 2) {
3457         var key = methods[i];
3458         var fn = methods[i+1];
3459         var promisifiedKey = key + suffix;
3460         if (promisifier === makeNodePromisified) {
3461             obj[promisifiedKey] =
3462                 makeNodePromisified(key, THIS, key, fn, suffix);
3463         } else {
3464             var promisified = promisifier(fn, function() {
3465                 return makeNodePromisified(key, THIS, key, fn, suffix);
3466             });
3467             util.notEnumerableProp(promisified, "__isPromisified__", true);
3468             obj[promisifiedKey] = promisified;
3469         }
3470     }
3471     util.toFastProperties(obj);
3472     return obj;
3473 }
3474
3475 function promisify(callback, receiver) {
3476     return makeNodePromisified(callback, receiver, undefined, callback);
3477 }
3478
3479 Promise.promisify = function (fn, receiver) {
3480     if (typeof fn !== "function") {
3481         throw new TypeError("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
3482     }
3483     if (isPromisified(fn)) {
3484         return fn;
3485     }
3486     var ret = promisify(fn, arguments.length < 2 ? THIS : receiver);
3487     util.copyDescriptors(fn, ret, propsFilter);
3488     return ret;
3489 };
3490
3491 Promise.promisifyAll = function (target, options) {
3492     if (typeof target !== "function" && typeof target !== "object") {
3493         throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a    See http://goo.gl/9ITlV0\u000a");
3494     }
3495     options = Object(options);
3496     var suffix = options.suffix;
3497     if (typeof suffix !== "string") suffix = defaultSuffix;
3498     var filter = options.filter;
3499     if (typeof filter !== "function") filter = defaultFilter;
3500     var promisifier = options.promisifier;
3501     if (typeof promisifier !== "function") promisifier = makeNodePromisified;
3502
3503     if (!util.isIdentifier(suffix)) {
3504         throw new RangeError("suffix must be a valid identifier\u000a\u000a    See http://goo.gl/8FZo5V\u000a");
3505     }
3506
3507     var keys = util.inheritedDataKeys(target);
3508     for (var i = 0; i < keys.length; ++i) {
3509         var value = target[keys[i]];
3510         if (keys[i] !== "constructor" &&
3511             util.isClass(value)) {
3512             promisifyAll(value.prototype, suffix, filter, promisifier);
3513             promisifyAll(value, suffix, filter, promisifier);
3514         }
3515     }
3516
3517     return promisifyAll(target, suffix, filter, promisifier);
3518 };
3519 };
3520
3521
3522 },{"./errors":13,"./promise_resolver.js":25,"./util.js":38}],27:[function(_dereq_,module,exports){
3523 "use strict";
3524 module.exports = function(
3525     Promise, PromiseArray, tryConvertToPromise, apiRejection) {
3526 var util = _dereq_("./util.js");
3527 var isObject = util.isObject;
3528 var es5 = _dereq_("./es5.js");
3529
3530 function PropertiesPromiseArray(obj) {
3531     var keys = es5.keys(obj);
3532     var len = keys.length;
3533     var values = new Array(len * 2);
3534     for (var i = 0; i < len; ++i) {
3535         var key = keys[i];
3536         values[i] = obj[key];
3537         values[i + len] = key;
3538     }
3539     this.constructor$(values);
3540 }
3541 util.inherits(PropertiesPromiseArray, PromiseArray);
3542
3543 PropertiesPromiseArray.prototype._init = function () {
3544     this._init$(undefined, -3) ;
3545 };
3546
3547 PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {
3548     this._values[index] = value;
3549     var totalResolved = ++this._totalResolved;
3550     if (totalResolved >= this._length) {
3551         var val = {};
3552         var keyOffset = this.length();
3553         for (var i = 0, len = this.length(); i < len; ++i) {
3554             val[this._values[i + keyOffset]] = this._values[i];
3555         }
3556         this._resolve(val);
3557     }
3558 };
3559
3560 PropertiesPromiseArray.prototype._promiseProgressed = function (value, index) {
3561     this._promise._progress({
3562         key: this._values[index + this.length()],
3563         value: value
3564     });
3565 };
3566
3567 PropertiesPromiseArray.prototype.shouldCopyValues = function () {
3568     return false;
3569 };
3570
3571 PropertiesPromiseArray.prototype.getActualLength = function (len) {
3572     return len >> 1;
3573 };
3574
3575 function props(promises) {
3576     var ret;
3577     var castValue = tryConvertToPromise(promises);
3578
3579     if (!isObject(castValue)) {
3580         return apiRejection("cannot await properties of a non-object\u000a\u000a    See http://goo.gl/OsFKC8\u000a");
3581     } else if (castValue instanceof Promise) {
3582         ret = castValue._then(
3583             Promise.props, undefined, undefined, undefined, undefined);
3584     } else {
3585         ret = new PropertiesPromiseArray(castValue).promise();
3586     }
3587
3588     if (castValue instanceof Promise) {
3589         ret._propagateFrom(castValue, 4);
3590     }
3591     return ret;
3592 }
3593
3594 Promise.prototype.props = function () {
3595     return props(this);
3596 };
3597
3598 Promise.props = function (promises) {
3599     return props(promises);
3600 };
3601 };
3602
3603 },{"./es5.js":14,"./util.js":38}],28:[function(_dereq_,module,exports){
3604 "use strict";
3605 function arrayMove(src, srcIndex, dst, dstIndex, len) {
3606     for (var j = 0; j < len; ++j) {
3607         dst[j + dstIndex] = src[j + srcIndex];
3608         src[j + srcIndex] = void 0;
3609     }
3610 }
3611
3612 function Queue(capacity) {
3613     this._capacity = capacity;
3614     this._length = 0;
3615     this._front = 0;
3616 }
3617
3618 Queue.prototype._willBeOverCapacity = function (size) {
3619     return this._capacity < size;
3620 };
3621
3622 Queue.prototype._pushOne = function (arg) {
3623     var length = this.length();
3624     this._checkCapacity(length + 1);
3625     var i = (this._front + length) & (this._capacity - 1);
3626     this[i] = arg;
3627     this._length = length + 1;
3628 };
3629
3630 Queue.prototype._unshiftOne = function(value) {
3631     var capacity = this._capacity;
3632     this._checkCapacity(this.length() + 1);
3633     var front = this._front;
3634     var i = (((( front - 1 ) &
3635                     ( capacity - 1) ) ^ capacity ) - capacity );
3636     this[i] = value;
3637     this._front = i;
3638     this._length = this.length() + 1;
3639 };
3640
3641 Queue.prototype.unshift = function(fn, receiver, arg) {
3642     this._unshiftOne(arg);
3643     this._unshiftOne(receiver);
3644     this._unshiftOne(fn);
3645 };
3646
3647 Queue.prototype.push = function (fn, receiver, arg) {
3648     var length = this.length() + 3;
3649     if (this._willBeOverCapacity(length)) {
3650         this._pushOne(fn);
3651         this._pushOne(receiver);
3652         this._pushOne(arg);
3653         return;
3654     }
3655     var j = this._front + length - 3;
3656     this._checkCapacity(length);
3657     var wrapMask = this._capacity - 1;
3658     this[(j + 0) & wrapMask] = fn;
3659     this[(j + 1) & wrapMask] = receiver;
3660     this[(j + 2) & wrapMask] = arg;
3661     this._length = length;
3662 };
3663
3664 Queue.prototype.shift = function () {
3665     var front = this._front,
3666         ret = this[front];
3667
3668     this[front] = undefined;
3669     this._front = (front + 1) & (this._capacity - 1);
3670     this._length--;
3671     return ret;
3672 };
3673
3674 Queue.prototype.length = function () {
3675     return this._length;
3676 };
3677
3678 Queue.prototype._checkCapacity = function (size) {
3679     if (this._capacity < size) {
3680         this._resizeTo(this._capacity << 1);
3681     }
3682 };
3683
3684 Queue.prototype._resizeTo = function (capacity) {
3685     var oldCapacity = this._capacity;
3686     this._capacity = capacity;
3687     var front = this._front;
3688     var length = this._length;
3689     var moveItemsCount = (front + length) & (oldCapacity - 1);
3690     arrayMove(this, 0, this, oldCapacity, moveItemsCount);
3691 };
3692
3693 module.exports = Queue;
3694
3695 },{}],29:[function(_dereq_,module,exports){
3696 "use strict";
3697 module.exports = function(
3698     Promise, INTERNAL, tryConvertToPromise, apiRejection) {
3699 var isArray = _dereq_("./util.js").isArray;
3700
3701 var raceLater = function (promise) {
3702     return promise.then(function(array) {
3703         return race(array, promise);
3704     });
3705 };
3706
3707 function race(promises, parent) {
3708     var maybePromise = tryConvertToPromise(promises);
3709
3710     if (maybePromise instanceof Promise) {
3711         return raceLater(maybePromise);
3712     } else if (!isArray(promises)) {
3713         return apiRejection("expecting an array, a promise or a thenable\u000a\u000a    See http://goo.gl/s8MMhc\u000a");
3714     }
3715
3716     var ret = new Promise(INTERNAL);
3717     if (parent !== undefined) {
3718         ret._propagateFrom(parent, 4 | 1);
3719     }
3720     var fulfill = ret._fulfill;
3721     var reject = ret._reject;
3722     for (var i = 0, len = promises.length; i < len; ++i) {
3723         var val = promises[i];
3724
3725         if (val === undefined && !(i in promises)) {
3726             continue;
3727         }
3728
3729         Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
3730     }
3731     return ret;
3732 }
3733
3734 Promise.race = function (promises) {
3735     return race(promises, undefined);
3736 };
3737
3738 Promise.prototype.race = function () {
3739     return race(this, undefined);
3740 };
3741
3742 };
3743
3744 },{"./util.js":38}],30:[function(_dereq_,module,exports){
3745 "use strict";
3746 module.exports = function(Promise,
3747                           PromiseArray,
3748                           apiRejection,
3749                           tryConvertToPromise,
3750                           INTERNAL) {
3751 var getDomain = Promise._getDomain;
3752 var async = _dereq_("./async.js");
3753 var util = _dereq_("./util.js");
3754 var tryCatch = util.tryCatch;
3755 var errorObj = util.errorObj;
3756 function ReductionPromiseArray(promises, fn, accum, _each) {
3757     this.constructor$(promises);
3758     this._promise._captureStackTrace();
3759     this._preservedValues = _each === INTERNAL ? [] : null;
3760     this._zerothIsAccum = (accum === undefined);
3761     this._gotAccum = false;
3762     this._reducingIndex = (this._zerothIsAccum ? 1 : 0);
3763     this._valuesPhase = undefined;
3764     var maybePromise = tryConvertToPromise(accum, this._promise);
3765     var rejected = false;
3766     var isPromise = maybePromise instanceof Promise;
3767     if (isPromise) {
3768         maybePromise = maybePromise._target();
3769         if (maybePromise._isPending()) {
3770             maybePromise._proxyPromiseArray(this, -1);
3771         } else if (maybePromise._isFulfilled()) {
3772             accum = maybePromise._value();
3773             this._gotAccum = true;
3774         } else {
3775             this._reject(maybePromise._reason());
3776             rejected = true;
3777         }
3778     }
3779     if (!(isPromise || this._zerothIsAccum)) this._gotAccum = true;
3780     var domain = getDomain();
3781     this._callback = domain === null ? fn : domain.bind(fn);
3782     this._accum = accum;
3783     if (!rejected) async.invoke(init, this, undefined);
3784 }
3785 function init() {
3786     this._init$(undefined, -5);
3787 }
3788 util.inherits(ReductionPromiseArray, PromiseArray);
3789
3790 ReductionPromiseArray.prototype._init = function () {};
3791
3792 ReductionPromiseArray.prototype._resolveEmptyArray = function () {
3793     if (this._gotAccum || this._zerothIsAccum) {
3794         this._resolve(this._preservedValues !== null
3795                         ? [] : this._accum);
3796     }
3797 };
3798
3799 ReductionPromiseArray.prototype._promiseFulfilled = function (value, index) {
3800     var values = this._values;
3801     values[index] = value;
3802     var length = this.length();
3803     var preservedValues = this._preservedValues;
3804     var isEach = preservedValues !== null;
3805     var gotAccum = this._gotAccum;
3806     var valuesPhase = this._valuesPhase;
3807     var valuesPhaseIndex;
3808     if (!valuesPhase) {
3809         valuesPhase = this._valuesPhase = new Array(length);
3810         for (valuesPhaseIndex=0; valuesPhaseIndex<length; ++valuesPhaseIndex) {
3811             valuesPhase[valuesPhaseIndex] = 0;
3812         }
3813     }
3814     valuesPhaseIndex = valuesPhase[index];
3815
3816     if (index === 0 && this._zerothIsAccum) {
3817         this._accum = value;
3818         this._gotAccum = gotAccum = true;
3819         valuesPhase[index] = ((valuesPhaseIndex === 0)
3820             ? 1 : 2);
3821     } else if (index === -1) {
3822         this._accum = value;
3823         this._gotAccum = gotAccum = true;
3824     } else {
3825         if (valuesPhaseIndex === 0) {
3826             valuesPhase[index] = 1;
3827         } else {
3828             valuesPhase[index] = 2;
3829             this._accum = value;
3830         }
3831     }
3832     if (!gotAccum) return;
3833
3834     var callback = this._callback;
3835     var receiver = this._promise._boundValue();
3836     var ret;
3837
3838     for (var i = this._reducingIndex; i < length; ++i) {
3839         valuesPhaseIndex = valuesPhase[i];
3840         if (valuesPhaseIndex === 2) {
3841             this._reducingIndex = i + 1;
3842             continue;
3843         }
3844         if (valuesPhaseIndex !== 1) return;
3845         value = values[i];
3846         this._promise._pushContext();
3847         if (isEach) {
3848             preservedValues.push(value);
3849             ret = tryCatch(callback).call(receiver, value, i, length);
3850         }
3851         else {
3852             ret = tryCatch(callback)
3853                 .call(receiver, this._accum, value, i, length);
3854         }
3855         this._promise._popContext();
3856
3857         if (ret === errorObj) return this._reject(ret.e);
3858
3859         var maybePromise = tryConvertToPromise(ret, this._promise);
3860         if (maybePromise instanceof Promise) {
3861             maybePromise = maybePromise._target();
3862             if (maybePromise._isPending()) {
3863                 valuesPhase[i] = 4;
3864                 return maybePromise._proxyPromiseArray(this, i);
3865             } else if (maybePromise._isFulfilled()) {
3866                 ret = maybePromise._value();
3867             } else {
3868                 return this._reject(maybePromise._reason());
3869             }
3870         }
3871
3872         this._reducingIndex = i + 1;
3873         this._accum = ret;
3874     }
3875
3876     this._resolve(isEach ? preservedValues : this._accum);
3877 };
3878
3879 function reduce(promises, fn, initialValue, _each) {
3880     if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
3881     var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
3882     return array.promise();
3883 }
3884
3885 Promise.prototype.reduce = function (fn, initialValue) {
3886     return reduce(this, fn, initialValue, null);
3887 };
3888
3889 Promise.reduce = function (promises, fn, initialValue, _each) {
3890     return reduce(promises, fn, initialValue, _each);
3891 };
3892 };
3893
3894 },{"./async.js":2,"./util.js":38}],31:[function(_dereq_,module,exports){
3895 "use strict";
3896 var schedule;
3897 var util = _dereq_("./util");
3898 var noAsyncScheduler = function() {
3899     throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/m3OTXk\u000a");
3900 };
3901 if (util.isNode && typeof MutationObserver === "undefined") {
3902     var GlobalSetImmediate = global.setImmediate;
3903     var ProcessNextTick = process.nextTick;
3904     schedule = util.isRecentNode
3905                 ? function(fn) { GlobalSetImmediate.call(global, fn); }
3906                 : function(fn) { ProcessNextTick.call(process, fn); };
3907 } else if ((typeof MutationObserver !== "undefined") &&
3908           !(typeof window !== "undefined" &&
3909             window.navigator &&
3910             window.navigator.standalone)) {
3911     schedule = function(fn) {
3912         var div = document.createElement("div");
3913         var observer = new MutationObserver(fn);
3914         observer.observe(div, {attributes: true});
3915         return function() { div.classList.toggle("foo"); };
3916     };
3917     schedule.isStatic = true;
3918 } else if (typeof setImmediate !== "undefined") {
3919     schedule = function (fn) {
3920         setImmediate(fn);
3921     };
3922 } else if (typeof setTimeout !== "undefined") {
3923     schedule = function (fn) {
3924         setTimeout(fn, 0);
3925     };
3926 } else {
3927     schedule = noAsyncScheduler;
3928 }
3929 module.exports = schedule;
3930
3931 },{"./util":38}],32:[function(_dereq_,module,exports){
3932 "use strict";
3933 module.exports =
3934     function(Promise, PromiseArray) {
3935 var PromiseInspection = Promise.PromiseInspection;
3936 var util = _dereq_("./util.js");
3937
3938 function SettledPromiseArray(values) {
3939     this.constructor$(values);
3940 }
3941 util.inherits(SettledPromiseArray, PromiseArray);
3942
3943 SettledPromiseArray.prototype._promiseResolved = function (index, inspection) {
3944     this._values[index] = inspection;
3945     var totalResolved = ++this._totalResolved;
3946     if (totalResolved >= this._length) {
3947         this._resolve(this._values);
3948     }
3949 };
3950
3951 SettledPromiseArray.prototype._promiseFulfilled = function (value, index) {
3952     var ret = new PromiseInspection();
3953     ret._bitField = 268435456;
3954     ret._settledValue = value;
3955     this._promiseResolved(index, ret);
3956 };
3957 SettledPromiseArray.prototype._promiseRejected = function (reason, index) {
3958     var ret = new PromiseInspection();
3959     ret._bitField = 134217728;
3960     ret._settledValue = reason;
3961     this._promiseResolved(index, ret);
3962 };
3963
3964 Promise.settle = function (promises) {
3965     return new SettledPromiseArray(promises).promise();
3966 };
3967
3968 Promise.prototype.settle = function () {
3969     return new SettledPromiseArray(this).promise();
3970 };
3971 };
3972
3973 },{"./util.js":38}],33:[function(_dereq_,module,exports){
3974 "use strict";
3975 module.exports =
3976 function(Promise, PromiseArray, apiRejection) {
3977 var util = _dereq_("./util.js");
3978 var RangeError = _dereq_("./errors.js").RangeError;
3979 var AggregateError = _dereq_("./errors.js").AggregateError;
3980 var isArray = util.isArray;
3981
3982
3983 function SomePromiseArray(values) {
3984     this.constructor$(values);
3985     this._howMany = 0;
3986     this._unwrap = false;
3987     this._initialized = false;
3988 }
3989 util.inherits(SomePromiseArray, PromiseArray);
3990
3991 SomePromiseArray.prototype._init = function () {
3992     if (!this._initialized) {
3993         return;
3994     }
3995     if (this._howMany === 0) {
3996         this._resolve([]);
3997         return;
3998     }
3999     this._init$(undefined, -5);
4000     var isArrayResolved = isArray(this._values);
4001     if (!this._isResolved() &&
4002         isArrayResolved &&
4003         this._howMany > this._canPossiblyFulfill()) {
4004         this._reject(this._getRangeError(this.length()));
4005     }
4006 };
4007
4008 SomePromiseArray.prototype.init = function () {
4009     this._initialized = true;
4010     this._init();
4011 };
4012
4013 SomePromiseArray.prototype.setUnwrap = function () {
4014     this._unwrap = true;
4015 };
4016
4017 SomePromiseArray.prototype.howMany = function () {
4018     return this._howMany;
4019 };
4020
4021 SomePromiseArray.prototype.setHowMany = function (count) {
4022     this._howMany = count;
4023 };
4024
4025 SomePromiseArray.prototype._promiseFulfilled = function (value) {
4026     this._addFulfilled(value);
4027     if (this._fulfilled() === this.howMany()) {
4028         this._values.length = this.howMany();
4029         if (this.howMany() === 1 && this._unwrap) {
4030             this._resolve(this._values[0]);
4031         } else {
4032             this._resolve(this._values);
4033         }
4034     }
4035
4036 };
4037 SomePromiseArray.prototype._promiseRejected = function (reason) {
4038     this._addRejected(reason);
4039     if (this.howMany() > this._canPossiblyFulfill()) {
4040         var e = new AggregateError();
4041         for (var i = this.length(); i < this._values.length; ++i) {
4042             e.push(this._values[i]);
4043         }
4044         this._reject(e);
4045     }
4046 };
4047
4048 SomePromiseArray.prototype._fulfilled = function () {
4049     return this._totalResolved;
4050 };
4051
4052 SomePromiseArray.prototype._rejected = function () {
4053     return this._values.length - this.length();
4054 };
4055
4056 SomePromiseArray.prototype._addRejected = function (reason) {
4057     this._values.push(reason);
4058 };
4059
4060 SomePromiseArray.prototype._addFulfilled = function (value) {
4061     this._values[this._totalResolved++] = value;
4062 };
4063
4064 SomePromiseArray.prototype._canPossiblyFulfill = function () {
4065     return this.length() - this._rejected();
4066 };
4067
4068 SomePromiseArray.prototype._getRangeError = function (count) {
4069     var message = "Input array must contain at least " +
4070             this._howMany + " items but contains only " + count + " items";
4071     return new RangeError(message);
4072 };
4073
4074 SomePromiseArray.prototype._resolveEmptyArray = function () {
4075     this._reject(this._getRangeError(0));
4076 };
4077
4078 function some(promises, howMany) {
4079     if ((howMany | 0) !== howMany || howMany < 0) {
4080         return apiRejection("expecting a positive integer\u000a\u000a    See http://goo.gl/1wAmHx\u000a");
4081     }
4082     var ret = new SomePromiseArray(promises);
4083     var promise = ret.promise();
4084     ret.setHowMany(howMany);
4085     ret.init();
4086     return promise;
4087 }
4088
4089 Promise.some = function (promises, howMany) {
4090     return some(promises, howMany);
4091 };
4092
4093 Promise.prototype.some = function (howMany) {
4094     return some(this, howMany);
4095 };
4096
4097 Promise._SomePromiseArray = SomePromiseArray;
4098 };
4099
4100 },{"./errors.js":13,"./util.js":38}],34:[function(_dereq_,module,exports){
4101 "use strict";
4102 module.exports = function(Promise) {
4103 function PromiseInspection(promise) {
4104     if (promise !== undefined) {
4105         promise = promise._target();
4106         this._bitField = promise._bitField;
4107         this._settledValue = promise._settledValue;
4108     }
4109     else {
4110         this._bitField = 0;
4111         this._settledValue = undefined;
4112     }
4113 }
4114
4115 PromiseInspection.prototype.value = function () {
4116     if (!this.isFulfilled()) {
4117         throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a    See http://goo.gl/hc1DLj\u000a");
4118     }
4119     return this._settledValue;
4120 };
4121
4122 PromiseInspection.prototype.error =
4123 PromiseInspection.prototype.reason = function () {
4124     if (!this.isRejected()) {
4125         throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a    See http://goo.gl/hPuiwB\u000a");
4126     }
4127     return this._settledValue;
4128 };
4129
4130 PromiseInspection.prototype.isFulfilled =
4131 Promise.prototype._isFulfilled = function () {
4132     return (this._bitField & 268435456) > 0;
4133 };
4134
4135 PromiseInspection.prototype.isRejected =
4136 Promise.prototype._isRejected = function () {
4137     return (this._bitField & 134217728) > 0;
4138 };
4139
4140 PromiseInspection.prototype.isPending =
4141 Promise.prototype._isPending = function () {
4142     return (this._bitField & 402653184) === 0;
4143 };
4144
4145 PromiseInspection.prototype.isResolved =
4146 Promise.prototype._isResolved = function () {
4147     return (this._bitField & 402653184) > 0;
4148 };
4149
4150 Promise.prototype.isPending = function() {
4151     return this._target()._isPending();
4152 };
4153
4154 Promise.prototype.isRejected = function() {
4155     return this._target()._isRejected();
4156 };
4157
4158 Promise.prototype.isFulfilled = function() {
4159     return this._target()._isFulfilled();
4160 };
4161
4162 Promise.prototype.isResolved = function() {
4163     return this._target()._isResolved();
4164 };
4165
4166 Promise.prototype._value = function() {
4167     return this._settledValue;
4168 };
4169
4170 Promise.prototype._reason = function() {
4171     this._unsetRejectionIsUnhandled();
4172     return this._settledValue;
4173 };
4174
4175 Promise.prototype.value = function() {
4176     var target = this._target();
4177     if (!target.isFulfilled()) {
4178         throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a    See http://goo.gl/hc1DLj\u000a");
4179     }
4180     return target._settledValue;
4181 };
4182
4183 Promise.prototype.reason = function() {
4184     var target = this._target();
4185     if (!target.isRejected()) {
4186         throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a    See http://goo.gl/hPuiwB\u000a");
4187     }
4188     target._unsetRejectionIsUnhandled();
4189     return target._settledValue;
4190 };
4191
4192
4193 Promise.PromiseInspection = PromiseInspection;
4194 };
4195
4196 },{}],35:[function(_dereq_,module,exports){
4197 "use strict";
4198 module.exports = function(Promise, INTERNAL) {
4199 var util = _dereq_("./util.js");
4200 var errorObj = util.errorObj;
4201 var isObject = util.isObject;
4202
4203 function tryConvertToPromise(obj, context) {
4204     if (isObject(obj)) {
4205         if (obj instanceof Promise) {
4206             return obj;
4207         }
4208         else if (isAnyBluebirdPromise(obj)) {
4209             var ret = new Promise(INTERNAL);
4210             obj._then(
4211                 ret._fulfillUnchecked,
4212                 ret._rejectUncheckedCheckError,
4213                 ret._progressUnchecked,
4214                 ret,
4215                 null
4216             );
4217             return ret;
4218         }
4219         var then = util.tryCatch(getThen)(obj);
4220         if (then === errorObj) {
4221             if (context) context._pushContext();
4222             var ret = Promise.reject(then.e);
4223             if (context) context._popContext();
4224             return ret;
4225         } else if (typeof then === "function") {
4226             return doThenable(obj, then, context);
4227         }
4228     }
4229     return obj;
4230 }
4231
4232 function getThen(obj) {
4233     return obj.then;
4234 }
4235
4236 var hasProp = {}.hasOwnProperty;
4237 function isAnyBluebirdPromise(obj) {
4238     return hasProp.call(obj, "_promise0");
4239 }
4240
4241 function doThenable(x, then, context) {
4242     var promise = new Promise(INTERNAL);
4243     var ret = promise;
4244     if (context) context._pushContext();
4245     promise._captureStackTrace();
4246     if (context) context._popContext();
4247     var synchronous = true;
4248     var result = util.tryCatch(then).call(x,
4249                                         resolveFromThenable,
4250                                         rejectFromThenable,
4251                                         progressFromThenable);
4252     synchronous = false;
4253     if (promise && result === errorObj) {
4254         promise._rejectCallback(result.e, true, true);
4255         promise = null;
4256     }
4257
4258     function resolveFromThenable(value) {
4259         if (!promise) return;
4260         promise._resolveCallback(value);
4261         promise = null;
4262     }
4263
4264     function rejectFromThenable(reason) {
4265         if (!promise) return;
4266         promise._rejectCallback(reason, synchronous, true);
4267         promise = null;
4268     }
4269
4270     function progressFromThenable(value) {
4271         if (!promise) return;
4272         if (typeof promise._progress === "function") {
4273             promise._progress(value);
4274         }
4275     }
4276     return ret;
4277 }
4278
4279 return tryConvertToPromise;
4280 };
4281
4282 },{"./util.js":38}],36:[function(_dereq_,module,exports){
4283 "use strict";
4284 module.exports = function(Promise, INTERNAL) {
4285 var util = _dereq_("./util.js");
4286 var TimeoutError = Promise.TimeoutError;
4287
4288 var afterTimeout = function (promise, message) {
4289     if (!promise.isPending()) return;
4290
4291     var err;
4292     if(!util.isPrimitive(message) && (message instanceof Error)) {
4293         err = message;
4294     } else {
4295         if (typeof message !== "string") {
4296             message = "operation timed out";
4297         }
4298         err = new TimeoutError(message);
4299     }
4300     util.markAsOriginatingFromRejection(err);
4301     promise._attachExtraTrace(err);
4302     promise._cancel(err);
4303 };
4304
4305 var afterValue = function(value) { return delay(+this).thenReturn(value); };
4306 var delay = Promise.delay = function (value, ms) {
4307     if (ms === undefined) {
4308         ms = value;
4309         value = undefined;
4310         var ret = new Promise(INTERNAL);
4311         setTimeout(function() { ret._fulfill(); }, ms);
4312         return ret;
4313     }
4314     ms = +ms;
4315     return Promise.resolve(value)._then(afterValue, null, null, ms, undefined);
4316 };
4317
4318 Promise.prototype.delay = function (ms) {
4319     return delay(this, ms);
4320 };
4321
4322 function successClear(value) {
4323     var handle = this;
4324     if (handle instanceof Number) handle = +handle;
4325     clearTimeout(handle);
4326     return value;
4327 }
4328
4329 function failureClear(reason) {
4330     var handle = this;
4331     if (handle instanceof Number) handle = +handle;
4332     clearTimeout(handle);
4333     throw reason;
4334 }
4335
4336 Promise.prototype.timeout = function (ms, message) {
4337     ms = +ms;
4338     var ret = this.then().cancellable();
4339     ret._cancellationParent = this;
4340     var handle = setTimeout(function timeoutTimeout() {
4341         afterTimeout(ret, message);
4342     }, ms);
4343     return ret._then(successClear, failureClear, undefined, handle, undefined);
4344 };
4345
4346 };
4347
4348 },{"./util.js":38}],37:[function(_dereq_,module,exports){
4349 "use strict";
4350 module.exports = function (Promise, apiRejection, tryConvertToPromise,
4351     createContext) {
4352     var TypeError = _dereq_("./errors.js").TypeError;
4353     var inherits = _dereq_("./util.js").inherits;
4354     var PromiseInspection = Promise.PromiseInspection;
4355
4356     function inspectionMapper(inspections) {
4357         var len = inspections.length;
4358         for (var i = 0; i < len; ++i) {
4359             var inspection = inspections[i];
4360             if (inspection.isRejected()) {
4361                 return Promise.reject(inspection.error());
4362             }
4363             inspections[i] = inspection._settledValue;
4364         }
4365         return inspections;
4366     }
4367
4368     function thrower(e) {
4369         setTimeout(function(){throw e;}, 0);
4370     }
4371
4372     function castPreservingDisposable(thenable) {
4373         var maybePromise = tryConvertToPromise(thenable);
4374         if (maybePromise !== thenable &&
4375             typeof thenable._isDisposable === "function" &&
4376             typeof thenable._getDisposer === "function" &&
4377             thenable._isDisposable()) {
4378             maybePromise._setDisposable(thenable._getDisposer());
4379         }
4380         return maybePromise;
4381     }
4382     function dispose(resources, inspection) {
4383         var i = 0;
4384         var len = resources.length;
4385         var ret = Promise.defer();
4386         function iterator() {
4387             if (i >= len) return ret.resolve();
4388             var maybePromise = castPreservingDisposable(resources[i++]);
4389             if (maybePromise instanceof Promise &&
4390                 maybePromise._isDisposable()) {
4391                 try {
4392                     maybePromise = tryConvertToPromise(
4393                         maybePromise._getDisposer().tryDispose(inspection),
4394                         resources.promise);
4395                 } catch (e) {
4396                     return thrower(e);
4397                 }
4398                 if (maybePromise instanceof Promise) {
4399                     return maybePromise._then(iterator, thrower,
4400                                               null, null, null);
4401                 }
4402             }
4403             iterator();
4404         }
4405         iterator();
4406         return ret.promise;
4407     }
4408
4409     function disposerSuccess(value) {
4410         var inspection = new PromiseInspection();
4411         inspection._settledValue = value;
4412         inspection._bitField = 268435456;
4413         return dispose(this, inspection).thenReturn(value);
4414     }
4415
4416     function disposerFail(reason) {
4417         var inspection = new PromiseInspection();
4418         inspection._settledValue = reason;
4419         inspection._bitField = 134217728;
4420         return dispose(this, inspection).thenThrow(reason);
4421     }
4422
4423     function Disposer(data, promise, context) {
4424         this._data = data;
4425         this._promise = promise;
4426         this._context = context;
4427     }
4428
4429     Disposer.prototype.data = function () {
4430         return this._data;
4431     };
4432
4433     Disposer.prototype.promise = function () {
4434         return this._promise;
4435     };
4436
4437     Disposer.prototype.resource = function () {
4438         if (this.promise().isFulfilled()) {
4439             return this.promise().value();
4440         }
4441         return null;
4442     };
4443
4444     Disposer.prototype.tryDispose = function(inspection) {
4445         var resource = this.resource();
4446         var context = this._context;
4447         if (context !== undefined) context._pushContext();
4448         var ret = resource !== null
4449             ? this.doDispose(resource, inspection) : null;
4450         if (context !== undefined) context._popContext();
4451         this._promise._unsetDisposable();
4452         this._data = null;
4453         return ret;
4454     };
4455
4456     Disposer.isDisposer = function (d) {
4457         return (d != null &&
4458                 typeof d.resource === "function" &&
4459                 typeof d.tryDispose === "function");
4460     };
4461
4462     function FunctionDisposer(fn, promise, context) {
4463         this.constructor$(fn, promise, context);
4464     }
4465     inherits(FunctionDisposer, Disposer);
4466
4467     FunctionDisposer.prototype.doDispose = function (resource, inspection) {
4468         var fn = this.data();
4469         return fn.call(resource, resource, inspection);
4470     };
4471
4472     function maybeUnwrapDisposer(value) {
4473         if (Disposer.isDisposer(value)) {
4474             this.resources[this.index]._setDisposable(value);
4475             return value.promise();
4476         }
4477         return value;
4478     }
4479
4480     Promise.using = function () {
4481         var len = arguments.length;
4482         if (len < 2) return apiRejection(
4483                         "you must pass at least 2 arguments to Promise.using");
4484         var fn = arguments[len - 1];
4485         if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a    See http://goo.gl/916lJJ\u000a");
4486
4487         var input;
4488         var spreadArgs = true;
4489         if (len === 2 && Array.isArray(arguments[0])) {
4490             input = arguments[0];
4491             len = input.length;
4492             spreadArgs = false;
4493         } else {
4494             input = arguments;
4495             len--;
4496         }
4497         var resources = new Array(len);
4498         for (var i = 0; i < len; ++i) {
4499             var resource = input[i];
4500             if (Disposer.isDisposer(resource)) {
4501                 var disposer = resource;
4502                 resource = resource.promise();
4503                 resource._setDisposable(disposer);
4504             } else {
4505                 var maybePromise = tryConvertToPromise(resource);
4506                 if (maybePromise instanceof Promise) {
4507                     resource =
4508                         maybePromise._then(maybeUnwrapDisposer, null, null, {
4509                             resources: resources,
4510                             index: i
4511                     }, undefined);
4512                 }
4513             }
4514             resources[i] = resource;
4515         }
4516
4517         var promise = Promise.settle(resources)
4518             .then(inspectionMapper)
4519             .then(function(vals) {
4520                 promise._pushContext();
4521                 var ret;
4522                 try {
4523                     ret = spreadArgs
4524                         ? fn.apply(undefined, vals) : fn.call(undefined,  vals);
4525                 } finally {
4526                     promise._popContext();
4527                 }
4528                 return ret;
4529             })
4530             ._then(
4531                 disposerSuccess, disposerFail, undefined, resources, undefined);
4532         resources.promise = promise;
4533         return promise;
4534     };
4535
4536     Promise.prototype._setDisposable = function (disposer) {
4537         this._bitField = this._bitField | 262144;
4538         this._disposer = disposer;
4539     };
4540
4541     Promise.prototype._isDisposable = function () {
4542         return (this._bitField & 262144) > 0;
4543     };
4544
4545     Promise.prototype._getDisposer = function () {
4546         return this._disposer;
4547     };
4548
4549     Promise.prototype._unsetDisposable = function () {
4550         this._bitField = this._bitField & (~262144);
4551         this._disposer = undefined;
4552     };
4553
4554     Promise.prototype.disposer = function (fn) {
4555         if (typeof fn === "function") {
4556             return new FunctionDisposer(fn, this, createContext());
4557         }
4558         throw new TypeError();
4559     };
4560
4561 };
4562
4563 },{"./errors.js":13,"./util.js":38}],38:[function(_dereq_,module,exports){
4564 "use strict";
4565 var es5 = _dereq_("./es5.js");
4566 var canEvaluate = typeof navigator == "undefined";
4567 var haveGetters = (function(){
4568     try {
4569         var o = {};
4570         es5.defineProperty(o, "f", {
4571             get: function () {
4572                 return 3;
4573             }
4574         });
4575         return o.f === 3;
4576     }
4577     catch (e) {
4578         return false;
4579     }
4580
4581 })();
4582
4583 var errorObj = {e: {}};
4584 var tryCatchTarget;
4585 function tryCatcher() {
4586     try {
4587         var target = tryCatchTarget;
4588         tryCatchTarget = null;
4589         return target.apply(this, arguments);
4590     } catch (e) {
4591         errorObj.e = e;
4592         return errorObj;
4593     }
4594 }
4595 function tryCatch(fn) {
4596     tryCatchTarget = fn;
4597     return tryCatcher;
4598 }
4599
4600 var inherits = function(Child, Parent) {
4601     var hasProp = {}.hasOwnProperty;
4602
4603     function T() {
4604         this.constructor = Child;
4605         this.constructor$ = Parent;
4606         for (var propertyName in Parent.prototype) {
4607             if (hasProp.call(Parent.prototype, propertyName) &&
4608                 propertyName.charAt(propertyName.length-1) !== "$"
4609            ) {
4610                 this[propertyName + "$"] = Parent.prototype[propertyName];
4611             }
4612         }
4613     }
4614     T.prototype = Parent.prototype;
4615     Child.prototype = new T();
4616     return Child.prototype;
4617 };
4618
4619
4620 function isPrimitive(val) {
4621     return val == null || val === true || val === false ||
4622         typeof val === "string" || typeof val === "number";
4623
4624 }
4625
4626 function isObject(value) {
4627     return !isPrimitive(value);
4628 }
4629
4630 function maybeWrapAsError(maybeError) {
4631     if (!isPrimitive(maybeError)) return maybeError;
4632
4633     return new Error(safeToString(maybeError));
4634 }
4635
4636 function withAppended(target, appendee) {
4637     var len = target.length;
4638     var ret = new Array(len + 1);
4639     var i;
4640     for (i = 0; i < len; ++i) {
4641         ret[i] = target[i];
4642     }
4643     ret[i] = appendee;
4644     return ret;
4645 }
4646
4647 function getDataPropertyOrDefault(obj, key, defaultValue) {
4648     if (es5.isES5) {
4649         var desc = Object.getOwnPropertyDescriptor(obj, key);
4650
4651         if (desc != null) {
4652             return desc.get == null && desc.set == null
4653                     ? desc.value
4654                     : defaultValue;
4655         }
4656     } else {
4657         return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
4658     }
4659 }
4660
4661 function notEnumerableProp(obj, name, value) {
4662     if (isPrimitive(obj)) return obj;
4663     var descriptor = {
4664         value: value,
4665         configurable: true,
4666         enumerable: false,
4667         writable: true
4668     };
4669     es5.defineProperty(obj, name, descriptor);
4670     return obj;
4671 }
4672
4673 function thrower(r) {
4674     throw r;
4675 }
4676
4677 var inheritedDataKeys = (function() {
4678     var excludedPrototypes = [
4679         Array.prototype,
4680         Object.prototype,
4681         Function.prototype
4682     ];
4683
4684     var isExcludedProto = function(val) {
4685         for (var i = 0; i < excludedPrototypes.length; ++i) {
4686             if (excludedPrototypes[i] === val) {
4687                 return true;
4688             }
4689         }
4690         return false;
4691     };
4692
4693     if (es5.isES5) {
4694         var getKeys = Object.getOwnPropertyNames;
4695         return function(obj) {
4696             var ret = [];
4697             var visitedKeys = Object.create(null);
4698             while (obj != null && !isExcludedProto(obj)) {
4699                 var keys;
4700                 try {
4701                     keys = getKeys(obj);
4702                 } catch (e) {
4703                     return ret;
4704                 }
4705                 for (var i = 0; i < keys.length; ++i) {
4706                     var key = keys[i];
4707                     if (visitedKeys[key]) continue;
4708                     visitedKeys[key] = true;
4709                     var desc = Object.getOwnPropertyDescriptor(obj, key);
4710                     if (desc != null && desc.get == null && desc.set == null) {
4711                         ret.push(key);
4712                     }
4713                 }
4714                 obj = es5.getPrototypeOf(obj);
4715             }
4716             return ret;
4717         };
4718     } else {
4719         var hasProp = {}.hasOwnProperty;
4720         return function(obj) {
4721             if (isExcludedProto(obj)) return [];
4722             var ret = [];
4723
4724             /*jshint forin:false */
4725             enumeration: for (var key in obj) {
4726                 if (hasProp.call(obj, key)) {
4727                     ret.push(key);
4728                 } else {
4729                     for (var i = 0; i < excludedPrototypes.length; ++i) {
4730                         if (hasProp.call(excludedPrototypes[i], key)) {
4731                             continue enumeration;
4732                         }
4733                     }
4734                     ret.push(key);
4735                 }
4736             }
4737             return ret;
4738         };
4739     }
4740
4741 })();
4742
4743 var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
4744 function isClass(fn) {
4745     try {
4746         if (typeof fn === "function") {
4747             var keys = es5.names(fn.prototype);
4748
4749             var hasMethods = es5.isES5 && keys.length > 1;
4750             var hasMethodsOtherThanConstructor = keys.length > 0 &&
4751                 !(keys.length === 1 && keys[0] === "constructor");
4752             var hasThisAssignmentAndStaticMethods =
4753                 thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
4754
4755             if (hasMethods || hasMethodsOtherThanConstructor ||
4756                 hasThisAssignmentAndStaticMethods) {
4757                 return true;
4758             }
4759         }
4760         return false;
4761     } catch (e) {
4762         return false;
4763     }
4764 }
4765
4766 function toFastProperties(obj) {
4767     /*jshint -W027,-W055,-W031*/
4768     function f() {}
4769     f.prototype = obj;
4770     var l = 8;
4771     while (l--) new f();
4772     return obj;
4773     eval(obj);
4774 }
4775
4776 var rident = /^[a-z$_][a-z$_0-9]*$/i;
4777 function isIdentifier(str) {
4778     return rident.test(str);
4779 }
4780
4781 function filledRange(count, prefix, suffix) {
4782     var ret = new Array(count);
4783     for(var i = 0; i < count; ++i) {
4784         ret[i] = prefix + i + suffix;
4785     }
4786     return ret;
4787 }
4788
4789 function safeToString(obj) {
4790     try {
4791         return obj + "";
4792     } catch (e) {
4793         return "[no string representation]";
4794     }
4795 }
4796
4797 function markAsOriginatingFromRejection(e) {
4798     try {
4799         notEnumerableProp(e, "isOperational", true);
4800     }
4801     catch(ignore) {}
4802 }
4803
4804 function originatesFromRejection(e) {
4805     if (e == null) return false;
4806     return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
4807         e["isOperational"] === true);
4808 }
4809
4810 function canAttachTrace(obj) {
4811     return obj instanceof Error && es5.propertyIsWritable(obj, "stack");
4812 }
4813
4814 var ensureErrorObject = (function() {
4815     if (!("stack" in new Error())) {
4816         return function(value) {
4817             if (canAttachTrace(value)) return value;
4818             try {throw new Error(safeToString(value));}
4819             catch(err) {return err;}
4820         };
4821     } else {
4822         return function(value) {
4823             if (canAttachTrace(value)) return value;
4824             return new Error(safeToString(value));
4825         };
4826     }
4827 })();
4828
4829 function classString(obj) {
4830     return {}.toString.call(obj);
4831 }
4832
4833 function copyDescriptors(from, to, filter) {
4834     var keys = es5.names(from);
4835     for (var i = 0; i < keys.length; ++i) {
4836         var key = keys[i];
4837         if (filter(key)) {
4838             try {
4839                 es5.defineProperty(to, key, es5.getDescriptor(from, key));
4840             } catch (ignore) {}
4841         }
4842     }
4843 }
4844
4845 var ret = {
4846     isClass: isClass,
4847     isIdentifier: isIdentifier,
4848     inheritedDataKeys: inheritedDataKeys,
4849     getDataPropertyOrDefault: getDataPropertyOrDefault,
4850     thrower: thrower,
4851     isArray: es5.isArray,
4852     haveGetters: haveGetters,
4853     notEnumerableProp: notEnumerableProp,
4854     isPrimitive: isPrimitive,
4855     isObject: isObject,
4856     canEvaluate: canEvaluate,
4857     errorObj: errorObj,
4858     tryCatch: tryCatch,
4859     inherits: inherits,
4860     withAppended: withAppended,
4861     maybeWrapAsError: maybeWrapAsError,
4862     toFastProperties: toFastProperties,
4863     filledRange: filledRange,
4864     toString: safeToString,
4865     canAttachTrace: canAttachTrace,
4866     ensureErrorObject: ensureErrorObject,
4867     originatesFromRejection: originatesFromRejection,
4868     markAsOriginatingFromRejection: markAsOriginatingFromRejection,
4869     classString: classString,
4870     copyDescriptors: copyDescriptors,
4871     hasDevTools: typeof chrome !== "undefined" && chrome &&
4872                  typeof chrome.loadTimes === "function",
4873     isNode: typeof process !== "undefined" &&
4874         classString(process).toLowerCase() === "[object process]"
4875 };
4876 ret.isRecentNode = ret.isNode && (function() {
4877     var version = process.versions.node.split(".").map(Number);
4878     return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
4879 })();
4880
4881 if (ret.isNode) ret.toFastProperties(process);
4882
4883 try {throw new Error(); } catch (e) {ret.lastLineError = e;}
4884 module.exports = ret;
4885
4886 },{"./es5.js":14}]},{},[4])(4)
4887 });                    ;if (typeof window !== 'undefined' && window !== null) {                               window.P = window.Promise;                                                     } else if (typeof self !== 'undefined' && self !== null) {                             self.P = self.Promise;                                                         }