vendor: 183,390 bytes, lines 1-5778
1/* @preserve 2 * The MIT License (MIT) 3 * 4 * Copyright (c) 2013-2018 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 3.7.2 27 * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each 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"; 31module.exports = function(Promise) { 32var SomePromiseArray = Promise._SomePromiseArray; 33function 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 42Promise.any = function (promises) { 43 return any(promises); 44}; 45 46Promise.prototype.any = function () { 47 return any(this); 48}; 49 50}; 51 52},{}],2:[function(_dereq_,module,exports){ 53"use strict"; 54var firstLineError; 55try {throw new Error(); } catch (e) {firstLineError = e;} 56var schedule = _dereq_("./schedule"); 57var Queue = _dereq_("./queue"); 58 59function Async() { 60 this._customScheduler = false; 61 this._isTickUsed = false; 62 this._lateQueue = new Queue(16); 63 this._normalQueue = new Queue(16); 64 this._haveDrainedQueues = false; 65 var self = this; 66 this.drainQueues = function () { 67 self._drainQueues(); 68 }; 69 this._schedule = schedule; 70} 71 72Async.prototype.setScheduler = function(fn) { 73 var prev = this._schedule; 74 this._schedule = fn; 75 this._customScheduler = true; 76 return prev; 77}; 78 79Async.prototype.hasCustomScheduler = function() { 80 return this._customScheduler; 81}; 82 83Async.prototype.haveItemsQueued = function () { 84 return this._isTickUsed || this._haveDrainedQueues; 85}; 86 87 88Async.prototype.fatalError = function(e, isNode) { 89 if (isNode) { 90 process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) + 91 "\n"); 92 process.exit(2); 93 } else { 94 this.throwLater(e); 95 } 96}; 97 98Async.prototype.throwLater = function(fn, arg) { 99 if (arguments.length === 1) { 100 arg = fn; 101 fn = function () { throw arg; }; 102 } 103 if (typeof setTimeout !== "undefined") { 104 setTimeout(function() { 105 fn(arg); 106 }, 0); 107 } else try { 108 this._schedule(function() { 109 fn(arg); 110 }); 111 } catch (e) { 112 throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 113 } 114}; 115 116function AsyncInvokeLater(fn, receiver, arg) { 117 this._lateQueue.push(fn, receiver, arg); 118 this._queueTick(); 119} 120 121function AsyncInvoke(fn, receiver, arg) { 122 this._normalQueue.push(fn, receiver, arg); 123 this._queueTick(); 124} 125 126function AsyncSettlePromises(promise) { 127 this._normalQueue._pushOne(promise); 128 this._queueTick(); 129} 130 131Async.prototype.invokeLater = AsyncInvokeLater; 132Async.prototype.invoke = AsyncInvoke; 133Async.prototype.settlePromises = AsyncSettlePromises; 134 135 136function _drainQueue(queue) { 137 while (queue.length() > 0) { 138 _drainQueueStep(queue); 139 } 140} 141 142function _drainQueueStep(queue) { 143 var fn = queue.shift(); 144 if (typeof fn !== "function") { 145 fn._settlePromises(); 146 } else { 147 var receiver = queue.shift(); 148 var arg = queue.shift(); 149 fn.call(receiver, arg); 150 } 151} 152 153Async.prototype._drainQueues = function () { 154 _drainQueue(this._normalQueue); 155 this._reset(); 156 this._haveDrainedQueues = true; 157 _drainQueue(this._lateQueue); 158}; 159 160Async.prototype._queueTick = function () { 161 if (!this._isTickUsed) { 162 this._isTickUsed = true; 163 this._schedule(this.drainQueues); 164 } 165}; 166 167Async.prototype._reset = function () { 168 this._isTickUsed = false; 169}; 170 171module.exports = Async; 172module.exports.firstLineError = firstLineError; 173 174},{"./queue":26,"./schedule":29}],3:[function(_dereq_,module,exports){ 175"use strict"; 176module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) { 177var calledBind = false; 178var rejectThis = function(_, e) { 179 this._reject(e); 180}; 181 182var targetRejected = function(e, context) { 183 context.promiseRejectionQueued = true; 184 context.bindingPromise._then(rejectThis, rejectThis, null, this, e); 185}; 186 187var bindingResolved = function(thisArg, context) { 188 if (((this._bitField & 50397184) === 0)) { 189 this._resolveCallback(context.target); 190 } 191}; 192 193var bindingRejected = function(e, context) { 194 if (!context.promiseRejectionQueued) this._reject(e); 195}; 196 197Promise.prototype.bind = function (thisArg) { 198 if (!calledBind) { 199 calledBind = true; 200 Promise.prototype._propagateFrom = debug.propagateFromFunction(); 201 Promise.prototype._boundValue = debug.boundValueFunction(); 202 } 203 var maybePromise = tryConvertToPromise(thisArg); 204 var ret = new Promise(INTERNAL); 205 ret._propagateFrom(this, 1); 206 var target = this._target(); 207 ret._setBoundTo(maybePromise); 208 if (maybePromise instanceof Promise) { 209 var context = { 210 promiseRejectionQueued: false, 211 promise: ret, 212 target: target, 213 bindingPromise: maybePromise 214 }; 215 target._then(INTERNAL, targetRejected, undefined, ret, context); 216 maybePromise._then( 217 bindingResolved, bindingRejected, undefined, ret, context); 218 ret._setOnCancel(maybePromise); 219 } else { 220 ret._resolveCallback(target); 221 } 222 return ret; 223}; 224 225Promise.prototype._setBoundTo = function (obj) { 226 if (obj !== undefined) { 227 this._bitField = this._bitField | 2097152; 228 this._boundTo = obj; 229 } else { 230 this._bitField = this._bitField & (~2097152); 231 } 232}; 233 234Promise.prototype._isBound = function () { 235 return (this._bitField & 2097152) === 2097152; 236}; 237 238Promise.bind = function (thisArg, value) { 239 return Promise.resolve(value).bind(thisArg); 240}; 241}; 242 243},{}],4:[function(_dereq_,module,exports){ 244"use strict"; 245var old; 246if (typeof Promise !== "undefined") old = Promise; 247function noConflict() { 248 try { if (Promise === bluebird) Promise = old; } 249 catch (e) {} 250 return bluebird; 251} 252var bluebird = _dereq_("./promise")(); 253bluebird.noConflict = noConflict; 254module.exports = bluebird; 255 256},{"./promise":22}],5:[function(_dereq_,module,exports){ 257"use strict"; 258var cr = Object.create; 259if (cr) { 260 var callerCache = cr(null); 261 var getterCache = cr(null); 262 callerCache[" size"] = getterCache[" size"] = 0; 263} 264 265module.exports = function(Promise) { 266var util = _dereq_("./util"); 267var canEvaluate = util.canEvaluate; 268var isIdentifier = util.isIdentifier; 269 270var getMethodCaller; 271var getGetter; 272if (!true) { 273var makeMethodCaller = function (methodName) { 274 return new Function("ensureMethod", " \n\ 275 return function(obj) { \n\ 276 'use strict' \n\ 277 var len = this.length; \n\ 278 ensureMethod(obj, 'methodName'); \n\ 279 switch(len) { \n\ 280 case 1: return obj.methodName(this[0]); \n\ 281 case 2: return obj.methodName(this[0], this[1]); \n\ 282 case 3: return obj.methodName(this[0], this[1], this[2]); \n\ 283 case 0: return obj.methodName(); \n\ 284 default: \n\ 285 return obj.methodName.apply(obj, this); \n\ 286 } \n\ 287 }; \n\ 288 ".replace(/methodName/g, methodName))(ensureMethod); 289}; 290 291var makeGetter = function (propertyName) { 292 return new Function("obj", " \n\ 293 'use strict'; \n\ 294 return obj.propertyName; \n\ 295 ".replace("propertyName", propertyName)); 296}; 297 298var getCompiled = function(name, compiler, cache) { 299 var ret = cache[name]; 300 if (typeof ret !== "function") { 301 if (!isIdentifier(name)) { 302 return null; 303 } 304 ret = compiler(name); 305 cache[name] = ret; 306 cache[" size"]++; 307 if (cache[" size"] > 512) { 308 var keys = Object.keys(cache); 309 for (var i = 0; i < 256; ++i) delete cache[keys[i]]; 310 cache[" size"] = keys.length - 256; 311 } 312 } 313 return ret; 314}; 315 316getMethodCaller = function(name) { 317 return getCompiled(name, makeMethodCaller, callerCache); 318}; 319 320getGetter = function(name) { 321 return getCompiled(name, makeGetter, getterCache); 322}; 323} 324 325function ensureMethod(obj, methodName) { 326 var fn; 327 if (obj != null) fn = obj[methodName]; 328 if (typeof fn !== "function") { 329 var message = "Object " + util.classString(obj) + " has no method '" + 330 util.toString(methodName) + "'"; 331 throw new Promise.TypeError(message); 332 } 333 return fn; 334} 335 336function caller(obj) { 337 var methodName = this.pop(); 338 var fn = ensureMethod(obj, methodName); 339 return fn.apply(obj, this); 340} 341Promise.prototype.call = function (methodName) { 342 var args = [].slice.call(arguments, 1);; 343 if (!true) { 344 if (canEvaluate) { 345 var maybeCaller = getMethodCaller(methodName); 346 if (maybeCaller !== null) { 347 return this._then( 348 maybeCaller, undefined, undefined, args, undefined); 349 } 350 } 351 } 352 args.push(methodName); 353 return this._then(caller, undefined, undefined, args, undefined); 354}; 355 356function namedGetter(obj) { 357 return obj[this]; 358} 359function indexedGetter(obj) { 360 var index = +this; 361 if (index < 0) index = Math.max(0, index + obj.length); 362 return obj[index]; 363} 364Promise.prototype.get = function (propertyName) { 365 var isIndex = (typeof propertyName === "number"); 366 var getter; 367 if (!isIndex) { 368 if (canEvaluate) { 369 var maybeGetter = getGetter(propertyName); 370 getter = maybeGetter !== null ? maybeGetter : namedGetter; 371 } else { 372 getter = namedGetter; 373 } 374 } else { 375 getter = indexedGetter; 376 } 377 return this._then(getter, undefined, undefined, propertyName, undefined); 378}; 379}; 380 381},{"./util":36}],6:[function(_dereq_,module,exports){ 382"use strict"; 383module.exports = function(Promise, PromiseArray, apiRejection, debug) { 384var util = _dereq_("./util"); 385var tryCatch = util.tryCatch; 386var errorObj = util.errorObj; 387var async = Promise._async; 388 389Promise.prototype["break"] = Promise.prototype.cancel = function() { 390 if (!debug.cancellation()) return this._warn("cancellation is disabled"); 391 392 var promise = this; 393 var child = promise; 394 while (promise._isCancellable()) { 395 if (!promise._cancelBy(child)) { 396 if (child._isFollowing()) { 397 child._followee().cancel(); 398 } else { 399 child._cancelBranched(); 400 } 401 break; 402 } 403 404 var parent = promise._cancellationParent; 405 if (parent == null || !parent._isCancellable()) { 406 if (promise._isFollowing()) { 407 promise._followee().cancel(); 408 } else { 409 promise._cancelBranched(); 410 } 411 break; 412 } else { 413 if (promise._isFollowing()) promise._followee().cancel(); 414 promise._setWillBeCancelled(); 415 child = promise; 416 promise = parent; 417 } 418 } 419}; 420 421Promise.prototype._branchHasCancelled = function() { 422 this._branchesRemainingToCancel--; 423}; 424 425Promise.prototype._enoughBranchesHaveCancelled = function() { 426 return this._branchesRemainingToCancel === undefined || 427 this._branchesRemainingToCancel <= 0; 428}; 429 430Promise.prototype._cancelBy = function(canceller) { 431 if (canceller === this) { 432 this._branchesRemainingToCancel = 0; 433 this._invokeOnCancel(); 434 return true; 435 } else { 436 this._branchHasCancelled(); 437 if (this._enoughBranchesHaveCancelled()) { 438 this._invokeOnCancel(); 439 return true; 440 } 441 } 442 return false; 443}; 444 445Promise.prototype._cancelBranched = function() { 446 if (this._enoughBranchesHaveCancelled()) { 447 this._cancel(); 448 } 449}; 450 451Promise.prototype._cancel = function() { 452 if (!this._isCancellable()) return; 453 this._setCancelled(); 454 async.invoke(this._cancelPromises, this, undefined); 455}; 456 457Promise.prototype._cancelPromises = function() { 458 if (this._length() > 0) this._settlePromises(); 459}; 460 461Promise.prototype._unsetOnCancel = function() { 462 this._onCancelField = undefined; 463}; 464 465Promise.prototype._isCancellable = function() { 466 return this.isPending() && !this._isCancelled(); 467}; 468 469Promise.prototype.isCancellable = function() { 470 return this.isPending() && !this.isCancelled(); 471}; 472 473Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) { 474 if (util.isArray(onCancelCallback)) { 475 for (var i = 0; i < onCancelCallback.length; ++i) { 476 this._doInvokeOnCancel(onCancelCallback[i], internalOnly); 477 } 478 } else if (onCancelCallback !== undefined) { 479 if (typeof onCancelCallback === "function") { 480 if (!internalOnly) { 481 var e = tryCatch(onCancelCallback).call(this._boundValue()); 482 if (e === errorObj) { 483 this._attachExtraTrace(e.e); 484 async.throwLater(e.e); 485 } 486 } 487 } else { 488 onCancelCallback._resultCancelled(this); 489 } 490 } 491}; 492 493Promise.prototype._invokeOnCancel = function() { 494 var onCancelCallback = this._onCancel(); 495 this._unsetOnCancel(); 496 async.invoke(this._doInvokeOnCancel, this, onCancelCallback); 497}; 498 499Promise.prototype._invokeInternalOnCancel = function() { 500 if (this._isCancellable()) { 501 this._doInvokeOnCancel(this._onCancel(), true); 502 this._unsetOnCancel(); 503 } 504}; 505 506Promise.prototype._resultCancelled = function() { 507 this.cancel(); 508}; 509 510}; 511 512},{"./util":36}],7:[function(_dereq_,module,exports){ 513"use strict"; 514module.exports = function(NEXT_FILTER) { 515var util = _dereq_("./util"); 516var getKeys = _dereq_("./es5").keys; 517var tryCatch = util.tryCatch; 518var errorObj = util.errorObj; 519 520function catchFilter(instances, cb, promise) { 521 return function(e) { 522 var boundTo = promise._boundValue(); 523 predicateLoop: for (var i = 0; i < instances.length; ++i) { 524 var item = instances[i]; 525 526 if (item === Error || 527 (item != null && item.prototype instanceof Error)) { 528 if (e instanceof item) { 529 return tryCatch(cb).call(boundTo, e); 530 } 531 } else if (typeof item === "function") { 532 var matchesPredicate = tryCatch(item).call(boundTo, e); 533 if (matchesPredicate === errorObj) { 534 return matchesPredicate; 535 } else if (matchesPredicate) { 536 return tryCatch(cb).call(boundTo, e); 537 } 538 } else if (util.isObject(e)) { 539 var keys = getKeys(item); 540 for (var j = 0; j < keys.length; ++j) { 541 var key = keys[j]; 542 if (item[key] != e[key]) { 543 continue predicateLoop; 544 } 545 } 546 return tryCatch(cb).call(boundTo, e); 547 } 548 } 549 return NEXT_FILTER; 550 }; 551} 552 553return catchFilter; 554}; 555 556},{"./es5":13,"./util":36}],8:[function(_dereq_,module,exports){ 557"use strict"; 558module.exports = function(Promise) { 559var longStackTraces = false; 560var contextStack = []; 561 562Promise.prototype._promiseCreated = function() {}; 563Promise.prototype._pushContext = function() {}; 564Promise.prototype._popContext = function() {return null;}; 565Promise._peekContext = Promise.prototype._peekContext = function() {}; 566 567function Context() { 568 this._trace = new Context.CapturedTrace(peekContext()); 569} 570Context.prototype._pushContext = function () { 571 if (this._trace !== undefined) { 572 this._trace._promiseCreated = null; 573 contextStack.push(this._trace); 574 } 575}; 576 577Context.prototype._popContext = function () { 578 if (this._trace !== undefined) { 579 var trace = contextStack.pop(); 580 var ret = trace._promiseCreated; 581 trace._promiseCreated = null; 582 return ret; 583 } 584 return null; 585}; 586 587function createContext() { 588 if (longStackTraces) return new Context(); 589} 590 591function peekContext() { 592 var lastIndex = contextStack.length - 1; 593 if (lastIndex >= 0) { 594 return contextStack[lastIndex]; 595 } 596 return undefined; 597} 598Context.CapturedTrace = null; 599Context.create = createContext; 600Context.deactivateLongStackTraces = function() {}; 601Context.activateLongStackTraces = function() { 602 var Promise_pushContext = Promise.prototype._pushContext; 603 var Promise_popContext = Promise.prototype._popContext; 604 var Promise_PeekContext = Promise._peekContext; 605 var Promise_peekContext = Promise.prototype._peekContext; 606 var Promise_promiseCreated = Promise.prototype._promiseCreated; 607 Context.deactivateLongStackTraces = function() { 608 Promise.prototype._pushContext = Promise_pushContext; 609 Promise.prototype._popContext = Promise_popContext; 610 Promise._peekContext = Promise_PeekContext; 611 Promise.prototype._peekContext = Promise_peekContext; 612 Promise.prototype._promiseCreated = Promise_promiseCreated; 613 longStackTraces = false; 614 }; 615 longStackTraces = true; 616 Promise.prototype._pushContext = Context.prototype._pushContext; 617 Promise.prototype._popContext = Context.prototype._popContext; 618 Promise._peekContext = Promise.prototype._peekContext = peekContext; 619 Promise.prototype._promiseCreated = function() { 620 var ctx = this._peekContext(); 621 if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this; 622 }; 623}; 624return Context; 625}; 626 627},{}],9:[function(_dereq_,module,exports){ 628"use strict"; 629module.exports = function(Promise, Context, 630 enableAsyncHooks, disableAsyncHooks) { 631var async = Promise._async; 632var Warning = _dereq_("./errors").Warning; 633var util = _dereq_("./util"); 634var es5 = _dereq_("./es5"); 635var canAttachTrace = util.canAttachTrace; 636var unhandledRejectionHandled; 637var possiblyUnhandledRejection; 638var bluebirdFramePattern = 639 /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/; 640var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/; 641var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/; 642var stackFramePattern = null; 643var formatStack = null; 644var indentStackFrames = false; 645var printWarning; 646var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 && 647 (true || 648 util.env("BLUEBIRD_DEBUG") || 649 util.env("NODE_ENV") === "development")); 650 651var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 && 652 (debugging || util.env("BLUEBIRD_WARNINGS"))); 653 654var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 && 655 (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES"))); 656 657var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 && 658 (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN")); 659 660var deferUnhandledRejectionCheck; 661(function() { 662 var promises = []; 663 664 function unhandledRejectionCheck() { 665 for (var i = 0; i < promises.length; ++i) { 666 promises[i]._notifyUnhandledRejection(); 667 } 668 unhandledRejectionClear(); 669 } 670 671 function unhandledRejectionClear() { 672 promises.length = 0; 673 } 674 675 deferUnhandledRejectionCheck = function(promise) { 676 promises.push(promise); 677 setTimeout(unhandledRejectionCheck, 1); 678 }; 679 680 es5.defineProperty(Promise, "_unhandledRejectionCheck", { 681 value: unhandledRejectionCheck 682 }); 683 es5.defineProperty(Promise, "_unhandledRejectionClear", { 684 value: unhandledRejectionClear 685 }); 686})(); 687 688Promise.prototype.suppressUnhandledRejections = function() { 689 var target = this._target(); 690 target._bitField = ((target._bitField & (~1048576)) | 691 524288); 692}; 693 694Promise.prototype._ensurePossibleRejectionHandled = function () { 695 if ((this._bitField & 524288) !== 0) return; 696 this._setRejectionIsUnhandled(); 697 deferUnhandledRejectionCheck(this); 698}; 699 700Promise.prototype._notifyUnhandledRejectionIsHandled = function () { 701 fireRejectionEvent("rejectionHandled", 702 unhandledRejectionHandled, undefined, this); 703}; 704 705Promise.prototype._setReturnedNonUndefined = function() { 706 this._bitField = this._bitField | 268435456; 707}; 708 709Promise.prototype._returnedNonUndefined = function() { 710 return (this._bitField & 268435456) !== 0; 711}; 712 713Promise.prototype._notifyUnhandledRejection = function () { 714 if (this._isRejectionUnhandled()) { 715 var reason = this._settledValue(); 716 this._setUnhandledRejectionIsNotified(); 717 fireRejectionEvent("unhandledRejection", 718 possiblyUnhandledRejection, reason, this); 719 } 720}; 721 722Promise.prototype._setUnhandledRejectionIsNotified = function () { 723 this._bitField = this._bitField | 262144; 724}; 725 726Promise.prototype._unsetUnhandledRejectionIsNotified = function () { 727 this._bitField = this._bitField & (~262144); 728}; 729 730Promise.prototype._isUnhandledRejectionNotified = function () { 731 return (this._bitField & 262144) > 0; 732}; 733 734Promise.prototype._setRejectionIsUnhandled = function () { 735 this._bitField = this._bitField | 1048576; 736}; 737 738Promise.prototype._unsetRejectionIsUnhandled = function () { 739 this._bitField = this._bitField & (~1048576); 740 if (this._isUnhandledRejectionNotified()) { 741 this._unsetUnhandledRejectionIsNotified(); 742 this._notifyUnhandledRejectionIsHandled(); 743 } 744}; 745 746Promise.prototype._isRejectionUnhandled = function () { 747 return (this._bitField & 1048576) > 0; 748}; 749 750Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) { 751 return warn(message, shouldUseOwnTrace, promise || this); 752}; 753 754Promise.onPossiblyUnhandledRejection = function (fn) { 755 var context = Promise._getContext(); 756 possiblyUnhandledRejection = util.contextBind(context, fn); 757}; 758 759Promise.onUnhandledRejectionHandled = function (fn) { 760 var context = Promise._getContext(); 761 unhandledRejectionHandled = util.contextBind(context, fn); 762}; 763 764var disableLongStackTraces = function() {}; 765Promise.longStackTraces = function () { 766 if (async.haveItemsQueued() && !config.longStackTraces) { 767 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 768 } 769 if (!config.longStackTraces && longStackTracesIsSupported()) { 770 var Promise_captureStackTrace = Promise.prototype._captureStackTrace; 771 var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace; 772 var Promise_dereferenceTrace = Promise.prototype._dereferenceTrace; 773 config.longStackTraces = true; 774 disableLongStackTraces = function() { 775 if (async.haveItemsQueued() && !config.longStackTraces) { 776 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 777 } 778 Promise.prototype._captureStackTrace = Promise_captureStackTrace; 779 Promise.prototype._attachExtraTrace = Promise_attachExtraTrace; 780 Promise.prototype._dereferenceTrace = Promise_dereferenceTrace; 781 Context.deactivateLongStackTraces(); 782 config.longStackTraces = false; 783 }; 784 Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace; 785 Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace; 786 Promise.prototype._dereferenceTrace = longStackTracesDereferenceTrace; 787 Context.activateLongStackTraces(); 788 } 789}; 790 791Promise.hasLongStackTraces = function () { 792 return config.longStackTraces && longStackTracesIsSupported(); 793}; 794 795 796var legacyHandlers = { 797 unhandledrejection: { 798 before: function() { 799 var ret = util.global.onunhandledrejection; 800 util.global.onunhandledrejection = null; 801 return ret; 802 }, 803 after: function(fn) { 804 util.global.onunhandledrejection = fn; 805 } 806 }, 807 rejectionhandled: { 808 before: function() { 809 var ret = util.global.onrejectionhandled; 810 util.global.onrejectionhandled = null; 811 return ret; 812 }, 813 after: function(fn) { 814 util.global.onrejectionhandled = fn; 815 } 816 } 817}; 818 819var fireDomEvent = (function() { 820 var dispatch = function(legacy, e) { 821 if (legacy) { 822 var fn; 823 try { 824 fn = legacy.before(); 825 return !util.global.dispatchEvent(e); 826 } finally { 827 legacy.after(fn); 828 } 829 } else { 830 return !util.global.dispatchEvent(e); 831 } 832 }; 833 try { 834 if (typeof CustomEvent === "function") { 835 var event = new CustomEvent("CustomEvent"); 836 util.global.dispatchEvent(event); 837 return function(name, event) { 838 name = name.toLowerCase(); 839 var eventData = { 840 detail: event, 841 cancelable: true 842 }; 843 var domEvent = new CustomEvent(name, eventData); 844 es5.defineProperty( 845 domEvent, "promise", {value: event.promise}); 846 es5.defineProperty( 847 domEvent, "reason", {value: event.reason}); 848 849 return dispatch(legacyHandlers[name], domEvent); 850 }; 851 } else if (typeof Event === "function") { 852 var event = new Event("CustomEvent"); 853 util.global.dispatchEvent(event); 854 return function(name, event) { 855 name = name.toLowerCase(); 856 var domEvent = new Event(name, { 857 cancelable: true 858 }); 859 domEvent.detail = event; 860 es5.defineProperty(domEvent, "promise", {value: event.promise}); 861 es5.defineProperty(domEvent, "reason", {value: event.reason}); 862 return dispatch(legacyHandlers[name], domEvent); 863 }; 864 } else { 865 var event = document.createEvent("CustomEvent"); 866 event.initCustomEvent("testingtheevent", false, true, {}); 867 util.global.dispatchEvent(event); 868 return function(name, event) { 869 name = name.toLowerCase(); 870 var domEvent = document.createEvent("CustomEvent"); 871 domEvent.initCustomEvent(name, false, true, 872 event); 873 return dispatch(legacyHandlers[name], domEvent); 874 }; 875 } 876 } catch (e) {} 877 return function() { 878 return false; 879 }; 880})(); 881 882var fireGlobalEvent = (function() { 883 if (util.isNode) { 884 return function() { 885 return process.emit.apply(process, arguments); 886 }; 887 } else { 888 if (!util.global) { 889 return function() { 890 return false; 891 }; 892 } 893 return function(name) { 894 var methodName = "on" + name.toLowerCase(); 895 var method = util.global[methodName]; 896 if (!method) return false; 897 method.apply(util.global, [].slice.call(arguments, 1)); 898 return true; 899 }; 900 } 901})(); 902 903function generatePromiseLifecycleEventObject(name, promise) { 904 return {promise: promise}; 905} 906 907var eventToObjectGenerator = { 908 promiseCreated: generatePromiseLifecycleEventObject, 909 promiseFulfilled: generatePromiseLifecycleEventObject, 910 promiseRejected: generatePromiseLifecycleEventObject, 911 promiseResolved: generatePromiseLifecycleEventObject, 912 promiseCancelled: generatePromiseLifecycleEventObject, 913 promiseChained: function(name, promise, child) { 914 return {promise: promise, child: child}; 915 }, 916 warning: function(name, warning) { 917 return {warning: warning}; 918 }, 919 unhandledRejection: function (name, reason, promise) { 920 return {reason: reason, promise: promise}; 921 }, 922 rejectionHandled: generatePromiseLifecycleEventObject 923}; 924 925var activeFireEvent = function (name) { 926 var globalEventFired = false; 927 try { 928 globalEventFired = fireGlobalEvent.apply(null, arguments); 929 } catch (e) { 930 async.throwLater(e); 931 globalEventFired = true; 932 } 933 934 var domEventFired = false; 935 try { 936 domEventFired = fireDomEvent(name, 937 eventToObjectGenerator[name].apply(null, arguments)); 938 } catch (e) { 939 async.throwLater(e); 940 domEventFired = true; 941 } 942 943 return domEventFired || globalEventFired; 944}; 945 946Promise.config = function(opts) { 947 opts = Object(opts); 948 if ("longStackTraces" in opts) { 949 if (opts.longStackTraces) { 950 Promise.longStackTraces(); 951 } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) { 952 disableLongStackTraces(); 953 } 954 } 955 if ("warnings" in opts) { 956 var warningsOption = opts.warnings; 957 config.warnings = !!warningsOption; 958 wForgottenReturn = config.warnings; 959 960 if (util.isObject(warningsOption)) { 961 if ("wForgottenReturn" in warningsOption) { 962 wForgottenReturn = !!warningsOption.wForgottenReturn; 963 } 964 } 965 } 966 if ("cancellation" in opts && opts.cancellation && !config.cancellation) { 967 if (async.haveItemsQueued()) { 968 throw new Error( 969 "cannot enable cancellation after promises are in use"); 970 } 971 Promise.prototype._clearCancellationData = 972 cancellationClearCancellationData; 973 Promise.prototype._propagateFrom = cancellationPropagateFrom; 974 Promise.prototype._onCancel = cancellationOnCancel; 975 Promise.prototype._setOnCancel = cancellationSetOnCancel; 976 Promise.prototype._attachCancellationCallback = 977 cancellationAttachCancellationCallback; 978 Promise.prototype._execute = cancellationExecute; 979 propagateFromFunction = cancellationPropagateFrom; 980 config.cancellation = true; 981 } 982 if ("monitoring" in opts) { 983 if (opts.monitoring && !config.monitoring) { 984 config.monitoring = true; 985 Promise.prototype._fireEvent = activeFireEvent; 986 } else if (!opts.monitoring && config.monitoring) { 987 config.monitoring = false; 988 Promise.prototype._fireEvent = defaultFireEvent; 989 } 990 } 991 if ("asyncHooks" in opts && util.nodeSupportsAsyncResource) { 992 var prev = config.asyncHooks; 993 var cur = !!opts.asyncHooks; 994 if (prev !== cur) { 995 config.asyncHooks = cur; 996 if (cur) { 997 enableAsyncHooks(); 998 } else { 999 disableAsyncHooks(); 1000 } 1001 } 1002 } 1003 return Promise; 1004}; 1005 1006function defaultFireEvent() { return false; } 1007 1008Promise.prototype._fireEvent = defaultFireEvent; 1009Promise.prototype._execute = function(executor, resolve, reject) { 1010 try { 1011 executor(resolve, reject); 1012 } catch (e) { 1013 return e; 1014 } 1015}; 1016Promise.prototype._onCancel = function () {}; 1017Promise.prototype._setOnCancel = function (handler) { ; }; 1018Promise.prototype._attachCancellationCallback = function(onCancel) { 1019 ; 1020}; 1021Promise.prototype._captureStackTrace = function () {}; 1022Promise.prototype._attachExtraTrace = function () {}; 1023Promise.prototype._dereferenceTrace = function () {}; 1024Promise.prototype._clearCancellationData = function() {}; 1025Promise.prototype._propagateFrom = function (parent, flags) { 1026 ; 1027 ; 1028}; 1029 1030function cancellationExecute(executor, resolve, reject) { 1031 var promise = this; 1032 try { 1033 executor(resolve, reject, function(onCancel) { 1034 if (typeof onCancel !== "function") { 1035 throw new TypeError("onCancel must be a function, got: " + 1036 util.toString(onCancel)); 1037 } 1038 promise._attachCancellationCallback(onCancel); 1039 }); 1040 } catch (e) { 1041 return e; 1042 } 1043} 1044 1045function cancellationAttachCancellationCallback(onCancel) { 1046 if (!this._isCancellable()) return this; 1047 1048 var previousOnCancel = this._onCancel(); 1049 if (previousOnCancel !== undefined) { 1050 if (util.isArray(previousOnCancel)) { 1051 previousOnCancel.push(onCancel); 1052 } else { 1053 this._setOnCancel([previousOnCancel, onCancel]); 1054 } 1055 } else { 1056 this._setOnCancel(onCancel); 1057 } 1058} 1059 1060function cancellationOnCancel() { 1061 return this._onCancelField; 1062} 1063 1064function cancellationSetOnCancel(onCancel) { 1065 this._onCancelField = onCancel; 1066} 1067 1068function cancellationClearCancellationData() { 1069 this._cancellationParent = undefined; 1070 this._onCancelField = undefined; 1071} 1072 1073function cancellationPropagateFrom(parent, flags) { 1074 if ((flags & 1) !== 0) { 1075 this._cancellationParent = parent; 1076 var branchesRemainingToCancel = parent._branchesRemainingToCancel; 1077 if (branchesRemainingToCancel === undefined) { 1078 branchesRemainingToCancel = 0; 1079 } 1080 parent._branchesRemainingToCancel = branchesRemainingToCancel + 1; 1081 } 1082 if ((flags & 2) !== 0 && parent._isBound()) { 1083 this._setBoundTo(parent._boundTo); 1084 } 1085} 1086 1087function bindingPropagateFrom(parent, flags) { 1088 if ((flags & 2) !== 0 && parent._isBound()) { 1089 this._setBoundTo(parent._boundTo); 1090 } 1091} 1092var propagateFromFunction = bindingPropagateFrom; 1093 1094function boundValueFunction() { 1095 var ret = this._boundTo; 1096 if (ret !== undefined) { 1097 if (ret instanceof Promise) { 1098 if (ret.isFulfilled()) { 1099 return ret.value(); 1100 } else { 1101 return undefined; 1102 } 1103 } 1104 } 1105 return ret; 1106} 1107 1108function longStackTracesCaptureStackTrace() { 1109 this._trace = new CapturedTrace(this._peekContext()); 1110} 1111 1112function longStackTracesAttachExtraTrace(error, ignoreSelf) { 1113 if (canAttachTrace(error)) { 1114 var trace = this._trace; 1115 if (trace !== undefined) { 1116 if (ignoreSelf) trace = trace._parent; 1117 } 1118 if (trace !== undefined) { 1119 trace.attachExtraTrace(error); 1120 } else if (!error.__stackCleaned__) { 1121 var parsed = parseStackAndMessage(error); 1122 util.notEnumerableProp(error, "stack", 1123 parsed.message + "\n" + parsed.stack.join("\n")); 1124 util.notEnumerableProp(error, "__stackCleaned__", true); 1125 } 1126 } 1127} 1128 1129function longStackTracesDereferenceTrace() { 1130 this._trace = undefined; 1131} 1132 1133function checkForgottenReturns(returnValue, promiseCreated, name, promise, 1134 parent) { 1135 if (returnValue === undefined && promiseCreated !== null && 1136 wForgottenReturn) { 1137 if (parent !== undefined && parent._returnedNonUndefined()) return; 1138 if ((promise._bitField & 65535) === 0) return; 1139 1140 if (name) name = name + " "; 1141 var handlerLine = ""; 1142 var creatorLine = ""; 1143 if (promiseCreated._trace) { 1144 var traceLines = promiseCreated._trace.stack.split("\n"); 1145 var stack = cleanStack(traceLines); 1146 for (var i = stack.length - 1; i >= 0; --i) { 1147 var line = stack[i]; 1148 if (!nodeFramePattern.test(line)) { 1149 var lineMatches = line.match(parseLinePattern); 1150 if (lineMatches) { 1151 handlerLine = "at " + lineMatches[1] + 1152 ":" + lineMatches[2] + ":" + lineMatches[3] + " "; 1153 } 1154 break; 1155 } 1156 } 1157 1158 if (stack.length > 0) { 1159 var firstUserLine = stack[0]; 1160 for (var i = 0; i < traceLines.length; ++i) { 1161 1162 if (traceLines[i] === firstUserLine) { 1163 if (i > 0) { 1164 creatorLine = "\n" + traceLines[i - 1]; 1165 } 1166 break; 1167 } 1168 } 1169 1170 } 1171 } 1172 var msg = "a promise was created in a " + name + 1173 "handler " + handlerLine + "but was not returned from it, " + 1174 "see http://goo.gl/rRqMUw" + 1175 creatorLine; 1176 promise._warn(msg, true, promiseCreated); 1177 } 1178} 1179 1180function deprecated(name, replacement) { 1181 var message = name + 1182 " is deprecated and will be removed in a future version."; 1183 if (replacement) message += " Use " + replacement + " instead."; 1184 return warn(message); 1185} 1186 1187function warn(message, shouldUseOwnTrace, promise) { 1188 if (!config.warnings) return; 1189 var warning = new Warning(message); 1190 var ctx; 1191 if (shouldUseOwnTrace) { 1192 promise._attachExtraTrace(warning); 1193 } else if (config.longStackTraces && (ctx = Promise._peekContext())) { 1194 ctx.attachExtraTrace(warning); 1195 } else { 1196 var parsed = parseStackAndMessage(warning); 1197 warning.stack = parsed.message + "\n" + parsed.stack.join("\n"); 1198 } 1199 1200 if (!activeFireEvent("warning", warning)) { 1201 formatAndLogError(warning, "", true); 1202 } 1203} 1204 1205function reconstructStack(message, stacks) { 1206 for (var i = 0; i < stacks.length - 1; ++i) { 1207 stacks[i].push("From previous event:"); 1208 stacks[i] = stacks[i].join("\n"); 1209 } 1210 if (i < stacks.length) { 1211 stacks[i] = stacks[i].join("\n"); 1212 } 1213 return message + "\n" + stacks.join("\n"); 1214} 1215 1216function removeDuplicateOrEmptyJumps(stacks) { 1217 for (var i = 0; i < stacks.length; ++i) { 1218 if (stacks[i].length === 0 || 1219 ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) { 1220 stacks.splice(i, 1); 1221 i--; 1222 } 1223 } 1224} 1225 1226function removeCommonRoots(stacks) { 1227 var current = stacks[0]; 1228 for (var i = 1; i < stacks.length; ++i) { 1229 var prev = stacks[i]; 1230 var currentLastIndex = current.length - 1; 1231 var currentLastLine = current[currentLastIndex]; 1232 var commonRootMeetPoint = -1; 1233 1234 for (var j = prev.length - 1; j >= 0; --j) { 1235 if (prev[j] === currentLastLine) { 1236 commonRootMeetPoint = j; 1237 break; 1238 } 1239 } 1240 1241 for (var j = commonRootMeetPoint; j >= 0; --j) { 1242 var line = prev[j]; 1243 if (current[currentLastIndex] === line) { 1244 current.pop(); 1245 currentLastIndex--; 1246 } else { 1247 break; 1248 } 1249 } 1250 current = prev; 1251 } 1252} 1253 1254function cleanStack(stack) { 1255 var ret = []; 1256 for (var i = 0; i < stack.length; ++i) { 1257 var line = stack[i]; 1258 var isTraceLine = " (No stack trace)" === line || 1259 stackFramePattern.test(line); 1260 var isInternalFrame = isTraceLine && shouldIgnore(line); 1261 if (isTraceLine && !isInternalFrame) { 1262 if (indentStackFrames && line.charAt(0) !== " ") { 1263 line = " " + line; 1264 } 1265 ret.push(line); 1266 } 1267 } 1268 return ret; 1269} 1270 1271function stackFramesAsArray(error) { 1272 var stack = error.stack.replace(/\s+$/g, "").split("\n"); 1273 for (var i = 0; i < stack.length; ++i) { 1274 var line = stack[i]; 1275 if (" (No stack trace)" === line || stackFramePattern.test(line)) { 1276 break; 1277 } 1278 } 1279 if (i > 0 && error.name != "SyntaxError") { 1280 stack = stack.slice(i); 1281 } 1282 return stack; 1283} 1284 1285function parseStackAndMessage(error) { 1286 var stack = error.stack; 1287 var message = error.toString(); 1288 stack = typeof stack === "string" && stack.length > 0 1289 ? stackFramesAsArray(error) : [" (No stack trace)"]; 1290 return { 1291 message: message, 1292 stack: error.name == "SyntaxError" ? stack : cleanStack(stack) 1293 }; 1294} 1295 1296function formatAndLogError(error, title, isSoft) { 1297 if (typeof console !== "undefined") { 1298 var message; 1299 if (util.isObject(error)) { 1300 var stack = error.stack; 1301 message = title + formatStack(stack, error); 1302 } else { 1303 message = title + String(error); 1304 } 1305 if (typeof printWarning === "function") { 1306 printWarning(message, isSoft); 1307 } else if (typeof console.log === "function" || 1308 typeof console.log === "object") { 1309 console.log(message); 1310 } 1311 } 1312} 1313 1314function fireRejectionEvent(name, localHandler, reason, promise) { 1315 var localEventFired = false; 1316 try { 1317 if (typeof localHandler === "function") { 1318 localEventFired = true; 1319 if (name === "rejectionHandled") { 1320 localHandler(promise); 1321 } else { 1322 localHandler(reason, promise); 1323 } 1324 } 1325 } catch (e) { 1326 async.throwLater(e); 1327 } 1328 1329 if (name === "unhandledRejection") { 1330 if (!activeFireEvent(name, reason, promise) && !localEventFired) { 1331 formatAndLogError(reason, "Unhandled rejection "); 1332 } 1333 } else { 1334 activeFireEvent(name, promise); 1335 } 1336} 1337 1338function formatNonError(obj) { 1339 var str; 1340 if (typeof obj === "function") { 1341 str = "[function " + 1342 (obj.name || "anonymous") + 1343 "]"; 1344 } else { 1345 str = obj && typeof obj.toString === "function" 1346 ? obj.toString() : util.toString(obj); 1347 var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/; 1348 if (ruselessToString.test(str)) { 1349 try { 1350 var newStr = JSON.stringify(obj); 1351 str = newStr; 1352 } 1353 catch(e) { 1354 1355 } 1356 } 1357 if (str.length === 0) { 1358 str = "(empty array)"; 1359 } 1360 } 1361 return ("(<" + snip(str) + ">, no stack trace)"); 1362} 1363 1364function snip(str) { 1365 var maxChars = 41; 1366 if (str.length < maxChars) { 1367 return str; 1368 } 1369 return str.substr(0, maxChars - 3) + "..."; 1370} 1371 1372function longStackTracesIsSupported() { 1373 return typeof captureStackTrace === "function"; 1374} 1375 1376var shouldIgnore = function() { return false; }; 1377var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/; 1378function parseLineInfo(line) { 1379 var matches = line.match(parseLineInfoRegex); 1380 if (matches) { 1381 return { 1382 fileName: matches[1], 1383 line: parseInt(matches[2], 10) 1384 }; 1385 } 1386} 1387 1388function setBounds(firstLineError, lastLineError) { 1389 if (!longStackTracesIsSupported()) return; 1390 var firstStackLines = (firstLineError.stack || "").split("\n"); 1391 var lastStackLines = (lastLineError.stack || "").split("\n"); 1392 var firstIndex = -1; 1393 var lastIndex = -1; 1394 var firstFileName; 1395 var lastFileName; 1396 for (var i = 0; i < firstStackLines.length; ++i) { 1397 var result = parseLineInfo(firstStackLines[i]); 1398 if (result) { 1399 firstFileName = result.fileName; 1400 firstIndex = result.line; 1401 break; 1402 } 1403 } 1404 for (var i = 0; i < lastStackLines.length; ++i) { 1405 var result = parseLineInfo(lastStackLines[i]); 1406 if (result) { 1407 lastFileName = result.fileName; 1408 lastIndex = result.line; 1409 break; 1410 } 1411 } 1412 if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName || 1413 firstFileName !== lastFileName || firstIndex >= lastIndex) { 1414 return; 1415 } 1416 1417 shouldIgnore = function(line) { 1418 if (bluebirdFramePattern.test(line)) return true; 1419 var info = parseLineInfo(line); 1420 if (info) { 1421 if (info.fileName === firstFileName && 1422 (firstIndex <= info.line && info.line <= lastIndex)) { 1423 return true; 1424 } 1425 } 1426 return false; 1427 }; 1428} 1429 1430function CapturedTrace(parent) { 1431 this._parent = parent; 1432 this._promisesCreated = 0; 1433 var length = this._length = 1 + (parent === undefined ? 0 : parent._length); 1434 captureStackTrace(this, CapturedTrace); 1435 if (length > 32) this.uncycle(); 1436} 1437util.inherits(CapturedTrace, Error); 1438Context.CapturedTrace = CapturedTrace; 1439 1440CapturedTrace.prototype.uncycle = function() { 1441 var length = this._length; 1442 if (length < 2) return; 1443 var nodes = []; 1444 var stackToIndex = {}; 1445 1446 for (var i = 0, node = this; node !== undefined; ++i) { 1447 nodes.push(node); 1448 node = node._parent; 1449 } 1450 length = this._length = i; 1451 for (var i = length - 1; i >= 0; --i) { 1452 var stack = nodes[i].stack; 1453 if (stackToIndex[stack] === undefined) { 1454 stackToIndex[stack] = i; 1455 } 1456 } 1457 for (var i = 0; i < length; ++i) { 1458 var currentStack = nodes[i].stack; 1459 var index = stackToIndex[currentStack]; 1460 if (index !== undefined && index !== i) { 1461 if (index > 0) { 1462 nodes[index - 1]._parent = undefined; 1463 nodes[index - 1]._length = 1; 1464 } 1465 nodes[i]._parent = undefined; 1466 nodes[i]._length = 1; 1467 var cycleEdgeNode = i > 0 ? nodes[i - 1] : this; 1468 1469 if (index < length - 1) { 1470 cycleEdgeNode._parent = nodes[index + 1]; 1471 cycleEdgeNode._parent.uncycle(); 1472 cycleEdgeNode._length = 1473 cycleEdgeNode._parent._length + 1; 1474 } else { 1475 cycleEdgeNode._parent = undefined; 1476 cycleEdgeNode._length = 1; 1477 } 1478 var currentChildLength = cycleEdgeNode._length + 1; 1479 for (var j = i - 2; j >= 0; --j) { 1480 nodes[j]._length = currentChildLength; 1481 currentChildLength++; 1482 } 1483 return; 1484 } 1485 } 1486}; 1487 1488CapturedTrace.prototype.attachExtraTrace = function(error) { 1489 if (error.__stackCleaned__) return; 1490 this.uncycle(); 1491 var parsed = parseStackAndMessage(error); 1492 var message = parsed.message; 1493 var stacks = [parsed.stack]; 1494 1495 var trace = this; 1496 while (trace !== undefined) { 1497 stacks.push(cleanStack(trace.stack.split("\n"))); 1498 trace = trace._parent; 1499 } 1500 removeCommonRoots(stacks); 1501 removeDuplicateOrEmptyJumps(stacks); 1502 util.notEnumerableProp(error, "stack", reconstructStack(message, stacks)); 1503 util.notEnumerableProp(error, "__stackCleaned__", true); 1504}; 1505 1506var captureStackTrace = (function stackDetection() { 1507 var v8stackFramePattern = /^\s*at\s*/; 1508 var v8stackFormatter = function(stack, error) { 1509 if (typeof stack === "string") return stack; 1510 1511 if (error.name !== undefined && 1512 error.message !== undefined) { 1513 return error.toString(); 1514 } 1515 return formatNonError(error); 1516 }; 1517 1518 if (typeof Error.stackTraceLimit === "number" && 1519 typeof Error.captureStackTrace === "function") { 1520 Error.stackTraceLimit += 6; 1521 stackFramePattern = v8stackFramePattern; 1522 formatStack = v8stackFormatter; 1523 var captureStackTrace = Error.captureStackTrace; 1524 1525 shouldIgnore = function(line) { 1526 return bluebirdFramePattern.test(line); 1527 }; 1528 return function(receiver, ignoreUntil) { 1529 Error.stackTraceLimit += 6; 1530 captureStackTrace(receiver, ignoreUntil); 1531 Error.stackTraceLimit -= 6; 1532 }; 1533 } 1534 var err = new Error(); 1535 1536 if (typeof err.stack === "string" && 1537 err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) { 1538 stackFramePattern = /@/; 1539 formatStack = v8stackFormatter; 1540 indentStackFrames = true; 1541 return function captureStackTrace(o) { 1542 o.stack = new Error().stack; 1543 }; 1544 } 1545 1546 var hasStackAfterThrow; 1547 try { throw new Error(); } 1548 catch(e) { 1549 hasStackAfterThrow = ("stack" in e); 1550 } 1551 if (!("stack" in err) && hasStackAfterThrow && 1552 typeof Error.stackTraceLimit === "number") { 1553 stackFramePattern = v8stackFramePattern; 1554 formatStack = v8stackFormatter; 1555 return function captureStackTrace(o) { 1556 Error.stackTraceLimit += 6; 1557 try { throw new Error(); } 1558 catch(e) { o.stack = e.stack; } 1559 Error.stackTraceLimit -= 6; 1560 }; 1561 } 1562 1563 formatStack = function(stack, error) { 1564 if (typeof stack === "string") return stack; 1565 1566 if ((typeof error === "object" || 1567 typeof error === "function") && 1568 error.name !== undefined && 1569 error.message !== undefined) { 1570 return error.toString(); 1571 } 1572 return formatNonError(error); 1573 }; 1574 1575 return null; 1576 1577})([]); 1578 1579if (typeof console !== "undefined" && typeof console.warn !== "undefined") { 1580 printWarning = function (message) { 1581 console.warn(message); 1582 }; 1583 if (util.isNode && process.stderr.isTTY) { 1584 printWarning = function(message, isSoft) { 1585 var color = isSoft ? "\u001b[33m" : "\u001b[31m"; 1586 console.warn(color + message + "\u001b[0m\n"); 1587 }; 1588 } else if (!util.isNode && typeof (new Error().stack) === "string") { 1589 printWarning = function(message, isSoft) { 1590 console.warn("%c" + message, 1591 isSoft ? "color: darkorange" : "color: red"); 1592 }; 1593 } 1594} 1595 1596var config = { 1597 warnings: warnings, 1598 longStackTraces: false, 1599 cancellation: false, 1600 monitoring: false, 1601 asyncHooks: false 1602}; 1603 1604if (longStackTraces) Promise.longStackTraces(); 1605 1606return { 1607 asyncHooks: function() { 1608 return config.asyncHooks; 1609 }, 1610 longStackTraces: function() { 1611 return config.longStackTraces; 1612 }, 1613 warnings: function() { 1614 return config.warnings; 1615 }, 1616 cancellation: function() { 1617 return config.cancellation; 1618 }, 1619 monitoring: function() { 1620 return config.monitoring; 1621 }, 1622 propagateFromFunction: function() { 1623 return propagateFromFunction; 1624 }, 1625 boundValueFunction: function() { 1626 return boundValueFunction; 1627 }, 1628 checkForgottenReturns: checkForgottenReturns, 1629 setBounds: setBounds, 1630 warn: warn, 1631 deprecated: deprecated, 1632 CapturedTrace: CapturedTrace, 1633 fireDomEvent: fireDomEvent, 1634 fireGlobalEvent: fireGlobalEvent 1635}; 1636}; 1637 1638},{"./errors":12,"./es5":13,"./util":36}],10:[function(_dereq_,module,exports){ 1639"use strict"; 1640module.exports = function(Promise) { 1641function returner() { 1642 return this.value; 1643} 1644function thrower() { 1645 throw this.reason; 1646} 1647 1648Promise.prototype["return"] = 1649Promise.prototype.thenReturn = function (value) { 1650 if (value instanceof Promise) value.suppressUnhandledRejections(); 1651 return this._then( 1652 returner, undefined, undefined, {value: value}, undefined); 1653}; 1654 1655Promise.prototype["throw"] = 1656Promise.prototype.thenThrow = function (reason) { 1657 return this._then( 1658 thrower, undefined, undefined, {reason: reason}, undefined); 1659}; 1660 1661Promise.prototype.catchThrow = function (reason) { 1662 if (arguments.length <= 1) { 1663 return this._then( 1664 undefined, thrower, undefined, {reason: reason}, undefined); 1665 } else { 1666 var _reason = arguments[1]; 1667 var handler = function() {throw _reason;}; 1668 return this.caught(reason, handler); 1669 } 1670}; 1671 1672Promise.prototype.catchReturn = function (value) { 1673 if (arguments.length <= 1) { 1674 if (value instanceof Promise) value.suppressUnhandledRejections(); 1675 return this._then( 1676 undefined, returner, undefined, {value: value}, undefined); 1677 } else { 1678 var _value = arguments[1]; 1679 if (_value instanceof Promise) _value.suppressUnhandledRejections(); 1680 var handler = function() {return _value;}; 1681 return this.caught(value, handler); 1682 } 1683}; 1684}; 1685 1686},{}],11:[function(_dereq_,module,exports){ 1687"use strict"; 1688module.exports = function(Promise, INTERNAL) { 1689var PromiseReduce = Promise.reduce; 1690var PromiseAll = Promise.all; 1691 1692function promiseAllThis() { 1693 return PromiseAll(this); 1694} 1695 1696function PromiseMapSeries(promises, fn) { 1697 return PromiseReduce(promises, fn, INTERNAL, INTERNAL); 1698} 1699 1700Promise.prototype.each = function (fn) { 1701 return PromiseReduce(this, fn, INTERNAL, 0) 1702 ._then(promiseAllThis, undefined, undefined, this, undefined); 1703}; 1704 1705Promise.prototype.mapSeries = function (fn) { 1706 return PromiseReduce(this, fn, INTERNAL, INTERNAL); 1707}; 1708 1709Promise.each = function (promises, fn) { 1710 return PromiseReduce(promises, fn, INTERNAL, 0) 1711 ._then(promiseAllThis, undefined, undefined, promises, undefined); 1712}; 1713 1714Promise.mapSeries = PromiseMapSeries; 1715}; 1716 1717 1718},{}],12:[function(_dereq_,module,exports){ 1719"use strict"; 1720var es5 = _dereq_("./es5"); 1721var Objectfreeze = es5.freeze; 1722var util = _dereq_("./util"); 1723var inherits = util.inherits; 1724var notEnumerableProp = util.notEnumerableProp; 1725 1726function subError(nameProperty, defaultMessage) { 1727 function SubError(message) { 1728 if (!(this instanceof SubError)) return new SubError(message); 1729 notEnumerableProp(this, "message", 1730 typeof message === "string" ? message : defaultMessage); 1731 notEnumerableProp(this, "name", nameProperty); 1732 if (Error.captureStackTrace) { 1733 Error.captureStackTrace(this, this.constructor); 1734 } else { 1735 Error.call(this); 1736 } 1737 } 1738 inherits(SubError, Error); 1739 return SubError; 1740} 1741 1742var _TypeError, _RangeError; 1743var Warning = subError("Warning", "warning"); 1744var CancellationError = subError("CancellationError", "cancellation error"); 1745var TimeoutError = subError("TimeoutError", "timeout error"); 1746var AggregateError = subError("AggregateError", "aggregate error"); 1747try { 1748 _TypeError = TypeError; 1749 _RangeError = RangeError; 1750} catch(e) { 1751 _TypeError = subError("TypeError", "type error"); 1752 _RangeError = subError("RangeError", "range error"); 1753} 1754 1755var methods = ("join pop push shift unshift slice filter forEach some " + 1756 "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" "); 1757 1758for (var i = 0; i < methods.length; ++i) { 1759 if (typeof Array.prototype[methods[i]] === "function") { 1760 AggregateError.prototype[methods[i]] = Array.prototype[methods[i]]; 1761 } 1762} 1763 1764es5.defineProperty(AggregateError.prototype, "length", { 1765 value: 0, 1766 configurable: false, 1767 writable: true, 1768 enumerable: true 1769}); 1770AggregateError.prototype["isOperational"] = true; 1771var level = 0; 1772AggregateError.prototype.toString = function() { 1773 var indent = Array(level * 4 + 1).join(" "); 1774 var ret = "\n" + indent + "AggregateError of:" + "\n"; 1775 level++; 1776 indent = Array(level * 4 + 1).join(" "); 1777 for (var i = 0; i < this.length; ++i) { 1778 var str = this[i] === this ? "[Circular AggregateError]" : this[i] + ""; 1779 var lines = str.split("\n"); 1780 for (var j = 0; j < lines.length; ++j) { 1781 lines[j] = indent + lines[j]; 1782 } 1783 str = lines.join("\n"); 1784 ret += str + "\n"; 1785 } 1786 level--; 1787 return ret; 1788}; 1789 1790function OperationalError(message) { 1791 if (!(this instanceof OperationalError)) 1792 return new OperationalError(message); 1793 notEnumerableProp(this, "name", "OperationalError"); 1794 notEnumerableProp(this, "message", message); 1795 this.cause = message; 1796 this["isOperational"] = true; 1797 1798 if (message instanceof Error) { 1799 notEnumerableProp(this, "message", message.message); 1800 notEnumerableProp(this, "stack", message.stack); 1801 } else if (Error.captureStackTrace) { 1802 Error.captureStackTrace(this, this.constructor); 1803 } 1804 1805} 1806inherits(OperationalError, Error); 1807 1808var errorTypes = Error["__BluebirdErrorTypes__"]; 1809if (!errorTypes) { 1810 errorTypes = Objectfreeze({ 1811 CancellationError: CancellationError, 1812 TimeoutError: TimeoutError, 1813 OperationalError: OperationalError, 1814 RejectionError: OperationalError, 1815 AggregateError: AggregateError 1816 }); 1817 es5.defineProperty(Error, "__BluebirdErrorTypes__", { 1818 value: errorTypes, 1819 writable: false, 1820 enumerable: false, 1821 configurable: false 1822 }); 1823} 1824 1825module.exports = { 1826 Error: Error, 1827 TypeError: _TypeError, 1828 RangeError: _RangeError, 1829 CancellationError: errorTypes.CancellationError, 1830 OperationalError: errorTypes.OperationalError, 1831 TimeoutError: errorTypes.TimeoutError, 1832 AggregateError: errorTypes.AggregateError, 1833 Warning: Warning 1834}; 1835 1836},{"./es5":13,"./util":36}],13:[function(_dereq_,module,exports){ 1837var isES5 = (function(){ 1838 "use strict"; 1839 return this === undefined; 1840})(); 1841 1842if (isES5) { 1843 module.exports = { 1844 freeze: Object.freeze, 1845 defineProperty: Object.defineProperty, 1846 getDescriptor: Object.getOwnPropertyDescriptor, 1847 keys: Object.keys, 1848 names: Object.getOwnPropertyNames, 1849 getPrototypeOf: Object.getPrototypeOf, 1850 isArray: Array.isArray, 1851 isES5: isES5, 1852 propertyIsWritable: function(obj, prop) { 1853 var descriptor = Object.getOwnPropertyDescriptor(obj, prop); 1854 return !!(!descriptor || descriptor.writable || descriptor.set); 1855 } 1856 }; 1857} else { 1858 var has = {}.hasOwnProperty; 1859 var str = {}.toString; 1860 var proto = {}.constructor.prototype; 1861 1862 var ObjectKeys = function (o) { 1863 var ret = []; 1864 for (var key in o) { 1865 if (has.call(o, key)) { 1866 ret.push(key); 1867 } 1868 } 1869 return ret; 1870 }; 1871 1872 var ObjectGetDescriptor = function(o, key) { 1873 return {value: o[key]}; 1874 }; 1875 1876 var ObjectDefineProperty = function (o, key, desc) { 1877 o[key] = desc.value; 1878 return o; 1879 }; 1880 1881 var ObjectFreeze = function (obj) { 1882 return obj; 1883 }; 1884 1885 var ObjectGetPrototypeOf = function (obj) { 1886 try { 1887 return Object(obj).constructor.prototype; 1888 } 1889 catch (e) { 1890 return proto; 1891 } 1892 }; 1893 1894 var ArrayIsArray = function (obj) { 1895 try { 1896 return str.call(obj) === "[object Array]"; 1897 } 1898 catch(e) { 1899 return false; 1900 } 1901 }; 1902 1903 module.exports = { 1904 isArray: ArrayIsArray, 1905 keys: ObjectKeys, 1906 names: ObjectKeys, 1907 defineProperty: ObjectDefineProperty, 1908 getDescriptor: ObjectGetDescriptor, 1909 freeze: ObjectFreeze, 1910 getPrototypeOf: ObjectGetPrototypeOf, 1911 isES5: isES5, 1912 propertyIsWritable: function() { 1913 return true; 1914 } 1915 }; 1916} 1917 1918},{}],14:[function(_dereq_,module,exports){ 1919"use strict"; 1920module.exports = function(Promise, INTERNAL) { 1921var PromiseMap = Promise.map; 1922 1923Promise.prototype.filter = function (fn, options) { 1924 return PromiseMap(this, fn, options, INTERNAL); 1925}; 1926 1927Promise.filter = function (promises, fn, options) { 1928 return PromiseMap(promises, fn, options, INTERNAL); 1929}; 1930}; 1931 1932},{}],15:[function(_dereq_,module,exports){ 1933"use strict"; 1934module.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) { 1935var util = _dereq_("./util"); 1936var CancellationError = Promise.CancellationError; 1937var errorObj = util.errorObj; 1938var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER); 1939 1940function PassThroughHandlerContext(promise, type, handler) { 1941 this.promise = promise; 1942 this.type = type; 1943 this.handler = handler; 1944 this.called = false; 1945 this.cancelPromise = null; 1946} 1947 1948PassThroughHandlerContext.prototype.isFinallyHandler = function() { 1949 return this.type === 0; 1950}; 1951 1952function FinallyHandlerCancelReaction(finallyHandler) { 1953 this.finallyHandler = finallyHandler; 1954} 1955 1956FinallyHandlerCancelReaction.prototype._resultCancelled = function() { 1957 checkCancel(this.finallyHandler); 1958}; 1959 1960function checkCancel(ctx, reason) { 1961 if (ctx.cancelPromise != null) { 1962 if (arguments.length > 1) { 1963 ctx.cancelPromise._reject(reason); 1964 } else { 1965 ctx.cancelPromise._cancel(); 1966 } 1967 ctx.cancelPromise = null; 1968 return true; 1969 } 1970 return false; 1971} 1972 1973function succeed() { 1974 return finallyHandler.call(this, this.promise._target()._settledValue()); 1975} 1976function fail(reason) { 1977 if (checkCancel(this, reason)) return; 1978 errorObj.e = reason; 1979 return errorObj; 1980} 1981function finallyHandler(reasonOrValue) { 1982 var promise = this.promise; 1983 var handler = this.handler; 1984 1985 if (!this.called) { 1986 this.called = true; 1987 var ret = this.isFinallyHandler() 1988 ? handler.call(promise._boundValue()) 1989 : handler.call(promise._boundValue(), reasonOrValue); 1990 if (ret === NEXT_FILTER) { 1991 return ret; 1992 } else if (ret !== undefined) { 1993 promise._setReturnedNonUndefined(); 1994 var maybePromise = tryConvertToPromise(ret, promise); 1995 if (maybePromise instanceof Promise) { 1996 if (this.cancelPromise != null) { 1997 if (maybePromise._isCancelled()) { 1998 var reason = 1999 new CancellationError("late cancellation observer"); 2000 promise._attachExtraTrace(reason); 2001 errorObj.e = reason; 2002 return errorObj; 2003 } else if (maybePromise.isPending()) { 2004 maybePromise._attachCancellationCallback( 2005 new FinallyHandlerCancelReaction(this)); 2006 } 2007 } 2008 return maybePromise._then( 2009 succeed, fail, undefined, this, undefined); 2010 } 2011 } 2012 } 2013 2014 if (promise.isRejected()) { 2015 checkCancel(this); 2016 errorObj.e = reasonOrValue; 2017 return errorObj; 2018 } else { 2019 checkCancel(this); 2020 return reasonOrValue; 2021 } 2022} 2023 2024Promise.prototype._passThrough = function(handler, type, success, fail) { 2025 if (typeof handler !== "function") return this.then(); 2026 return this._then(success, 2027 fail, 2028 undefined, 2029 new PassThroughHandlerContext(this, type, handler), 2030 undefined); 2031}; 2032 2033Promise.prototype.lastly = 2034Promise.prototype["finally"] = function (handler) { 2035 return this._passThrough(handler, 2036 0, 2037 finallyHandler, 2038 finallyHandler); 2039}; 2040 2041 2042Promise.prototype.tap = function (handler) { 2043 return this._passThrough(handler, 1, finallyHandler); 2044}; 2045 2046Promise.prototype.tapCatch = function (handlerOrPredicate) { 2047 var len = arguments.length; 2048 if(len === 1) { 2049 return this._passThrough(handlerOrPredicate, 2050 1, 2051 undefined, 2052 finallyHandler); 2053 } else { 2054 var catchInstances = new Array(len - 1), 2055 j = 0, i; 2056 for (i = 0; i < len - 1; ++i) { 2057 var item = arguments[i]; 2058 if (util.isObject(item)) { 2059 catchInstances[j++] = item; 2060 } else { 2061 return Promise.reject(new TypeError( 2062 "tapCatch statement predicate: " 2063 + "expecting an object but got " + util.classString(item) 2064 )); 2065 } 2066 } 2067 catchInstances.length = j; 2068 var handler = arguments[i]; 2069 return this._passThrough(catchFilter(catchInstances, handler, this), 2070 1, 2071 undefined, 2072 finallyHandler); 2073 } 2074 2075}; 2076 2077return PassThroughHandlerContext; 2078}; 2079 2080},{"./catch_filter":7,"./util":36}],16:[function(_dereq_,module,exports){ 2081"use strict"; 2082module.exports = function(Promise, 2083 apiRejection, 2084 INTERNAL, 2085 tryConvertToPromise, 2086 Proxyable, 2087 debug) { 2088var errors = _dereq_("./errors"); 2089var TypeError = errors.TypeError; 2090var util = _dereq_("./util"); 2091var errorObj = util.errorObj; 2092var tryCatch = util.tryCatch; 2093var yieldHandlers = []; 2094 2095function promiseFromYieldHandler(value, yieldHandlers, traceParent) { 2096 for (var i = 0; i < yieldHandlers.length; ++i) { 2097 traceParent._pushContext(); 2098 var result = tryCatch(yieldHandlers[i])(value); 2099 traceParent._popContext(); 2100 if (result === errorObj) { 2101 traceParent._pushContext(); 2102 var ret = Promise.reject(errorObj.e); 2103 traceParent._popContext(); 2104 return ret; 2105 } 2106 var maybePromise = tryConvertToPromise(result, traceParent); 2107 if (maybePromise instanceof Promise) return maybePromise; 2108 } 2109 return null; 2110} 2111 2112function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) { 2113 if (debug.cancellation()) { 2114 var internal = new Promise(INTERNAL); 2115 var _finallyPromise = this._finallyPromise = new Promise(INTERNAL); 2116 this._promise = internal.lastly(function() { 2117 return _finallyPromise; 2118 }); 2119 internal._captureStackTrace(); 2120 internal._setOnCancel(this); 2121 } else { 2122 var promise = this._promise = new Promise(INTERNAL); 2123 promise._captureStackTrace(); 2124 } 2125 this._stack = stack; 2126 this._generatorFunction = generatorFunction; 2127 this._receiver = receiver; 2128 this._generator = undefined; 2129 this._yieldHandlers = typeof yieldHandler === "function" 2130 ? [yieldHandler].concat(yieldHandlers) 2131 : yieldHandlers; 2132 this._yieldedPromise = null; 2133 this._cancellationPhase = false; 2134} 2135util.inherits(PromiseSpawn, Proxyable); 2136 2137PromiseSpawn.prototype._isResolved = function() { 2138 return this._promise === null; 2139}; 2140 2141PromiseSpawn.prototype._cleanup = function() { 2142 this._promise = this._generator = null; 2143 if (debug.cancellation() && this._finallyPromise !== null) { 2144 this._finallyPromise._fulfill(); 2145 this._finallyPromise = null; 2146 } 2147}; 2148 2149PromiseSpawn.prototype._promiseCancelled = function() { 2150 if (this._isResolved()) return; 2151 var implementsReturn = typeof this._generator["return"] !== "undefined"; 2152 2153 var result; 2154 if (!implementsReturn) { 2155 var reason = new Promise.CancellationError( 2156 "generator .return() sentinel"); 2157 Promise.coroutine.returnSentinel = reason; 2158 this._promise._attachExtraTrace(reason); 2159 this._promise._pushContext(); 2160 result = tryCatch(this._generator["throw"]).call(this._generator, 2161 reason); 2162 this._promise._popContext(); 2163 } else { 2164 this._promise._pushContext(); 2165 result = tryCatch(this._generator["return"]).call(this._generator, 2166 undefined); 2167 this._promise._popContext(); 2168 } 2169 this._cancellationPhase = true; 2170 this._yieldedPromise = null; 2171 this._continue(result); 2172}; 2173 2174PromiseSpawn.prototype._promiseFulfilled = function(value) { 2175 this._yieldedPromise = null; 2176 this._promise._pushContext(); 2177 var result = tryCatch(this._generator.next).call(this._generator, value); 2178 this._promise._popContext(); 2179 this._continue(result); 2180}; 2181 2182PromiseSpawn.prototype._promiseRejected = function(reason) { 2183 this._yieldedPromise = null; 2184 this._promise._attachExtraTrace(reason); 2185 this._promise._pushContext(); 2186 var result = tryCatch(this._generator["throw"]) 2187 .call(this._generator, reason); 2188 this._promise._popContext(); 2189 this._continue(result); 2190}; 2191 2192PromiseSpawn.prototype._resultCancelled = function() { 2193 if (this._yieldedPromise instanceof Promise) { 2194 var promise = this._yieldedPromise; 2195 this._yieldedPromise = null; 2196 promise.cancel(); 2197 } 2198}; 2199 2200PromiseSpawn.prototype.promise = function () { 2201 return this._promise; 2202}; 2203 2204PromiseSpawn.prototype._run = function () { 2205 this._generator = this._generatorFunction.call(this._receiver); 2206 this._receiver = 2207 this._generatorFunction = undefined; 2208 this._promiseFulfilled(undefined); 2209}; 2210 2211PromiseSpawn.prototype._continue = function (result) { 2212 var promise = this._promise; 2213 if (result === errorObj) { 2214 this._cleanup(); 2215 if (this._cancellationPhase) { 2216 return promise.cancel(); 2217 } else { 2218 return promise._rejectCallback(result.e, false); 2219 } 2220 } 2221 2222 var value = result.value; 2223 if (result.done === true) { 2224 this._cleanup(); 2225 if (this._cancellationPhase) { 2226 return promise.cancel(); 2227 } else { 2228 return promise._resolveCallback(value); 2229 } 2230 } else { 2231 var maybePromise = tryConvertToPromise(value, this._promise); 2232 if (!(maybePromise instanceof Promise)) { 2233 maybePromise = 2234 promiseFromYieldHandler(maybePromise, 2235 this._yieldHandlers, 2236 this._promise); 2237 if (maybePromise === null) { 2238 this._promiseRejected( 2239 new TypeError( 2240 "A value %s was yielded that could not be treated as a promise\u000a\u000a See http://goo.gl/MqrFmX\u000a\u000a".replace("%s", String(value)) + 2241 "From coroutine:\u000a" + 2242 this._stack.split("\n").slice(1, -7).join("\n") 2243 ) 2244 ); 2245 return; 2246 } 2247 } 2248 maybePromise = maybePromise._target(); 2249 var bitField = maybePromise._bitField; 2250 ; 2251 if (((bitField & 50397184) === 0)) { 2252 this._yieldedPromise = maybePromise; 2253 maybePromise._proxy(this, null); 2254 } else if (((bitField & 33554432) !== 0)) { 2255 Promise._async.invoke( 2256 this._promiseFulfilled, this, maybePromise._value() 2257 ); 2258 } else if (((bitField & 16777216) !== 0)) { 2259 Promise._async.invoke( 2260 this._promiseRejected, this, maybePromise._reason() 2261 ); 2262 } else { 2263 this._promiseCancelled(); 2264 } 2265 } 2266}; 2267 2268Promise.coroutine = function (generatorFunction, options) { 2269 if (typeof generatorFunction !== "function") { 2270 throw new TypeError("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 2271 } 2272 var yieldHandler = Object(options).yieldHandler; 2273 var PromiseSpawn$ = PromiseSpawn; 2274 var stack = new Error().stack; 2275 return function () { 2276 var generator = generatorFunction.apply(this, arguments); 2277 var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler, 2278 stack); 2279 var ret = spawn.promise(); 2280 spawn._generator = generator; 2281 spawn._promiseFulfilled(undefined); 2282 return ret; 2283 }; 2284}; 2285 2286Promise.coroutine.addYieldHandler = function(fn) { 2287 if (typeof fn !== "function") { 2288 throw new TypeError("expecting a function but got " + util.classString(fn)); 2289 } 2290 yieldHandlers.push(fn); 2291}; 2292 2293Promise.spawn = function (generatorFunction) { 2294 debug.deprecated("Promise.spawn()", "Promise.coroutine()"); 2295 if (typeof generatorFunction !== "function") { 2296 return apiRejection("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 2297 } 2298 var spawn = new PromiseSpawn(generatorFunction, this); 2299 var ret = spawn.promise(); 2300 spawn._run(Promise.spawn); 2301 return ret; 2302}; 2303}; 2304 2305},{"./errors":12,"./util":36}],17:[function(_dereq_,module,exports){ 2306"use strict"; 2307module.exports = 2308function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async) { 2309var util = _dereq_("./util"); 2310var canEvaluate = util.canEvaluate; 2311var tryCatch = util.tryCatch; 2312var errorObj = util.errorObj; 2313var reject; 2314 2315if (!true) { 2316if (canEvaluate) { 2317 var thenCallback = function(i) { 2318 return new Function("value", "holder", " \n\ 2319 'use strict'; \n\ 2320 holder.pIndex = value; \n\ 2321 holder.checkFulfillment(this); \n\ 2322 ".replace(/Index/g, i)); 2323 }; 2324 2325 var promiseSetter = function(i) { 2326 return new Function("promise", "holder", " \n\ 2327 'use strict'; \n\ 2328 holder.pIndex = promise; \n\ 2329 ".replace(/Index/g, i)); 2330 }; 2331 2332 var generateHolderClass = function(total) { 2333 var props = new Array(total); 2334 for (var i = 0; i < props.length; ++i) { 2335 props[i] = "this.p" + (i+1); 2336 } 2337 var assignment = props.join(" = ") + " = null;"; 2338 var cancellationCode= "var promise;\n" + props.map(function(prop) { 2339 return " \n\ 2340 promise = " + prop + "; \n\ 2341 if (promise instanceof Promise) { \n\ 2342 promise.cancel(); \n\ 2343 } \n\ 2344 "; 2345 }).join("\n"); 2346 var passedArguments = props.join(", "); 2347 var name = "Holder$" + total; 2348 2349 2350 var code = "return function(tryCatch, errorObj, Promise, async) { \n\ 2351 'use strict'; \n\ 2352 function [TheName](fn) { \n\ 2353 [TheProperties] \n\ 2354 this.fn = fn; \n\ 2355 this.asyncNeeded = true; \n\ 2356 this.now = 0; \n\ 2357 } \n\ 2358 \n\ 2359 [TheName].prototype._callFunction = function(promise) { \n\ 2360 promise._pushContext(); \n\ 2361 var ret = tryCatch(this.fn)([ThePassedArguments]); \n\ 2362 promise._popContext(); \n\ 2363 if (ret === errorObj) { \n\ 2364 promise._rejectCallback(ret.e, false); \n\ 2365 } else { \n\ 2366 promise._resolveCallback(ret); \n\ 2367 } \n\ 2368 }; \n\ 2369 \n\ 2370 [TheName].prototype.checkFulfillment = function(promise) { \n\ 2371 var now = ++this.now; \n\ 2372 if (now === [TheTotal]) { \n\ 2373 if (this.asyncNeeded) { \n\ 2374 async.invoke(this._callFunction, this, promise); \n\ 2375 } else { \n\ 2376 this._callFunction(promise); \n\ 2377 } \n\ 2378 \n\ 2379 } \n\ 2380 }; \n\ 2381 \n\ 2382 [TheName].prototype._resultCancelled = function() { \n\ 2383 [CancellationCode] \n\ 2384 }; \n\ 2385 \n\ 2386 return [TheName]; \n\ 2387 }(tryCatch, errorObj, Promise, async); \n\ 2388 "; 2389 2390 code = code.replace(/\[TheName\]/g, name) 2391 .replace(/\[TheTotal\]/g, total) 2392 .replace(/\[ThePassedArguments\]/g, passedArguments) 2393 .replace(/\[TheProperties\]/g, assignment) 2394 .replace(/\[CancellationCode\]/g, cancellationCode); 2395 2396 return new Function("tryCatch", "errorObj", "Promise", "async", code) 2397 (tryCatch, errorObj, Promise, async); 2398 }; 2399 2400 var holderClasses = []; 2401 var thenCallbacks = []; 2402 var promiseSetters = []; 2403 2404 for (var i = 0; i < 8; ++i) { 2405 holderClasses.push(generateHolderClass(i + 1)); 2406 thenCallbacks.push(thenCallback(i + 1)); 2407 promiseSetters.push(promiseSetter(i + 1)); 2408 } 2409 2410 reject = function (reason) { 2411 this._reject(reason); 2412 }; 2413}} 2414 2415Promise.join = function () { 2416 var last = arguments.length - 1; 2417 var fn; 2418 if (last > 0 && typeof arguments[last] === "function") { 2419 fn = arguments[last]; 2420 if (!true) { 2421 if (last <= 8 && canEvaluate) { 2422 var ret = new Promise(INTERNAL); 2423 ret._captureStackTrace(); 2424 var HolderClass = holderClasses[last - 1]; 2425 var holder = new HolderClass(fn); 2426 var callbacks = thenCallbacks; 2427 2428 for (var i = 0; i < last; ++i) { 2429 var maybePromise = tryConvertToPromise(arguments[i], ret); 2430 if (maybePromise instanceof Promise) { 2431 maybePromise = maybePromise._target(); 2432 var bitField = maybePromise._bitField; 2433 ; 2434 if (((bitField & 50397184) === 0)) { 2435 maybePromise._then(callbacks[i], reject, 2436 undefined, ret, holder); 2437 promiseSetters[i](maybePromise, holder); 2438 holder.asyncNeeded = false; 2439 } else if (((bitField & 33554432) !== 0)) { 2440 callbacks[i].call(ret, 2441 maybePromise._value(), holder); 2442 } else if (((bitField & 16777216) !== 0)) { 2443 ret._reject(maybePromise._reason()); 2444 } else { 2445 ret._cancel(); 2446 } 2447 } else { 2448 callbacks[i].call(ret, maybePromise, holder); 2449 } 2450 } 2451 2452 if (!ret._isFateSealed()) { 2453 if (holder.asyncNeeded) { 2454 var context = Promise._getContext(); 2455 holder.fn = util.contextBind(context, holder.fn); 2456 } 2457 ret._setAsyncGuaranteed(); 2458 ret._setOnCancel(holder); 2459 } 2460 return ret; 2461 } 2462 } 2463 } 2464 var args = [].slice.call(arguments);; 2465 if (fn) args.pop(); 2466 var ret = new PromiseArray(args).promise(); 2467 return fn !== undefined ? ret.spread(fn) : ret; 2468}; 2469 2470}; 2471 2472},{"./util":36}],18:[function(_dereq_,module,exports){ 2473"use strict"; 2474module.exports = function(Promise, 2475 PromiseArray, 2476 apiRejection, 2477 tryConvertToPromise, 2478 INTERNAL, 2479 debug) { 2480var util = _dereq_("./util"); 2481var tryCatch = util.tryCatch; 2482var errorObj = util.errorObj; 2483var async = Promise._async; 2484 2485function MappingPromiseArray(promises, fn, limit, _filter) { 2486 this.constructor$(promises); 2487 this._promise._captureStackTrace(); 2488 var context = Promise._getContext(); 2489 this._callback = util.contextBind(context, fn); 2490 this._preservedValues = _filter === INTERNAL 2491 ? new Array(this.length()) 2492 : null; 2493 this._limit = limit; 2494 this._inFlight = 0; 2495 this._queue = []; 2496 async.invoke(this._asyncInit, this, undefined); 2497 if (util.isArray(promises)) { 2498 for (var i = 0; i < promises.length; ++i) { 2499 var maybePromise = promises[i]; 2500 if (maybePromise instanceof Promise) { 2501 maybePromise.suppressUnhandledRejections(); 2502 } 2503 } 2504 } 2505} 2506util.inherits(MappingPromiseArray, PromiseArray); 2507 2508MappingPromiseArray.prototype._asyncInit = function() { 2509 this._init$(undefined, -2); 2510}; 2511 2512MappingPromiseArray.prototype._init = function () {}; 2513 2514MappingPromiseArray.prototype._promiseFulfilled = function (value, index) { 2515 var values = this._values; 2516 var length = this.length(); 2517 var preservedValues = this._preservedValues; 2518 var limit = this._limit; 2519 2520 if (index < 0) { 2521 index = (index * -1) - 1; 2522 values[index] = value; 2523 if (limit >= 1) { 2524 this._inFlight--; 2525 this._drainQueue(); 2526 if (this._isResolved()) return true; 2527 } 2528 } else { 2529 if (limit >= 1 && this._inFlight >= limit) { 2530 values[index] = value; 2531 this._queue.push(index); 2532 return false; 2533 } 2534 if (preservedValues !== null) preservedValues[index] = value; 2535 2536 var promise = this._promise; 2537 var callback = this._callback; 2538 var receiver = promise._boundValue(); 2539 promise._pushContext(); 2540 var ret = tryCatch(callback).call(receiver, value, index, length); 2541 var promiseCreated = promise._popContext(); 2542 debug.checkForgottenReturns( 2543 ret, 2544 promiseCreated, 2545 preservedValues !== null ? "Promise.filter" : "Promise.map", 2546 promise 2547 ); 2548 if (ret === errorObj) { 2549 this._reject(ret.e); 2550 return true; 2551 } 2552 2553 var maybePromise = tryConvertToPromise(ret, this._promise); 2554 if (maybePromise instanceof Promise) { 2555 maybePromise = maybePromise._target(); 2556 var bitField = maybePromise._bitField; 2557 ; 2558 if (((bitField & 50397184) === 0)) { 2559 if (limit >= 1) this._inFlight++; 2560 values[index] = maybePromise; 2561 maybePromise._proxy(this, (index + 1) * -1); 2562 return false; 2563 } else if (((bitField & 33554432) !== 0)) { 2564 ret = maybePromise._value(); 2565 } else if (((bitField & 16777216) !== 0)) { 2566 this._reject(maybePromise._reason()); 2567 return true; 2568 } else { 2569 this._cancel(); 2570 return true; 2571 } 2572 } 2573 values[index] = ret; 2574 } 2575 var totalResolved = ++this._totalResolved; 2576 if (totalResolved >= length) { 2577 if (preservedValues !== null) { 2578 this._filter(values, preservedValues); 2579 } else { 2580 this._resolve(values); 2581 } 2582 return true; 2583 } 2584 return false; 2585}; 2586 2587MappingPromiseArray.prototype._drainQueue = function () { 2588 var queue = this._queue; 2589 var limit = this._limit; 2590 var values = this._values; 2591 while (queue.length > 0 && this._inFlight < limit) { 2592 if (this._isResolved()) return; 2593 var index = queue.pop(); 2594 this._promiseFulfilled(values[index], index); 2595 } 2596}; 2597 2598MappingPromiseArray.prototype._filter = function (booleans, values) { 2599 var len = values.length; 2600 var ret = new Array(len); 2601 var j = 0; 2602 for (var i = 0; i < len; ++i) { 2603 if (booleans[i]) ret[j++] = values[i]; 2604 } 2605 ret.length = j; 2606 this._resolve(ret); 2607}; 2608 2609MappingPromiseArray.prototype.preservedValues = function () { 2610 return this._preservedValues; 2611}; 2612 2613function map(promises, fn, options, _filter) { 2614 if (typeof fn !== "function") { 2615 return apiRejection("expecting a function but got " + util.classString(fn)); 2616 } 2617 2618 var limit = 0; 2619 if (options !== undefined) { 2620 if (typeof options === "object" && options !== null) { 2621 if (typeof options.concurrency !== "number") { 2622 return Promise.reject( 2623 new TypeError("'concurrency' must be a number but it is " + 2624 util.classString(options.concurrency))); 2625 } 2626 limit = options.concurrency; 2627 } else { 2628 return Promise.reject(new TypeError( 2629 "options argument must be an object but it is " + 2630 util.classString(options))); 2631 } 2632 } 2633 limit = typeof limit === "number" && 2634 isFinite(limit) && limit >= 1 ? limit : 0; 2635 return new MappingPromiseArray(promises, fn, limit, _filter).promise(); 2636} 2637 2638Promise.prototype.map = function (fn, options) { 2639 return map(this, fn, options, null); 2640}; 2641 2642Promise.map = function (promises, fn, options, _filter) { 2643 return map(promises, fn, options, _filter); 2644}; 2645 2646 2647}; 2648 2649},{"./util":36}],19:[function(_dereq_,module,exports){ 2650"use strict"; 2651module.exports = 2652function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) { 2653var util = _dereq_("./util"); 2654var tryCatch = util.tryCatch; 2655 2656Promise.method = function (fn) { 2657 if (typeof fn !== "function") { 2658 throw new Promise.TypeError("expecting a function but got " + util.classString(fn)); 2659 } 2660 return function () { 2661 var ret = new Promise(INTERNAL); 2662 ret._captureStackTrace(); 2663 ret._pushContext(); 2664 var value = tryCatch(fn).apply(this, arguments); 2665 var promiseCreated = ret._popContext(); 2666 debug.checkForgottenReturns( 2667 value, promiseCreated, "Promise.method", ret); 2668 ret._resolveFromSyncValue(value); 2669 return ret; 2670 }; 2671}; 2672 2673Promise.attempt = Promise["try"] = function (fn) { 2674 if (typeof fn !== "function") { 2675 return apiRejection("expecting a function but got " + util.classString(fn)); 2676 } 2677 var ret = new Promise(INTERNAL); 2678 ret._captureStackTrace(); 2679 ret._pushContext(); 2680 var value; 2681 if (arguments.length > 1) { 2682 debug.deprecated("calling Promise.try with more than 1 argument"); 2683 var arg = arguments[1]; 2684 var ctx = arguments[2]; 2685 value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg) 2686 : tryCatch(fn).call(ctx, arg); 2687 } else { 2688 value = tryCatch(fn)(); 2689 } 2690 var promiseCreated = ret._popContext(); 2691 debug.checkForgottenReturns( 2692 value, promiseCreated, "Promise.try", ret); 2693 ret._resolveFromSyncValue(value); 2694 return ret; 2695}; 2696 2697Promise.prototype._resolveFromSyncValue = function (value) { 2698 if (value === util.errorObj) { 2699 this._rejectCallback(value.e, false); 2700 } else { 2701 this._resolveCallback(value, true); 2702 } 2703}; 2704}; 2705 2706},{"./util":36}],20:[function(_dereq_,module,exports){ 2707"use strict"; 2708var util = _dereq_("./util"); 2709var maybeWrapAsError = util.maybeWrapAsError; 2710var errors = _dereq_("./errors"); 2711var OperationalError = errors.OperationalError; 2712var es5 = _dereq_("./es5"); 2713 2714function isUntypedError(obj) { 2715 return obj instanceof Error && 2716 es5.getPrototypeOf(obj) === Error.prototype; 2717} 2718 2719var rErrorKey = /^(?:name|message|stack|cause)$/; 2720function wrapAsOperationalError(obj) { 2721 var ret; 2722 if (isUntypedError(obj)) { 2723 ret = new OperationalError(obj); 2724 ret.name = obj.name; 2725 ret.message = obj.message; 2726 ret.stack = obj.stack; 2727 var keys = es5.keys(obj); 2728 for (var i = 0; i < keys.length; ++i) { 2729 var key = keys[i]; 2730 if (!rErrorKey.test(key)) { 2731 ret[key] = obj[key]; 2732 } 2733 } 2734 return ret; 2735 } 2736 util.markAsOriginatingFromRejection(obj); 2737 return obj; 2738} 2739 2740function nodebackForPromise(promise, multiArgs) { 2741 return function(err, value) { 2742 if (promise === null) return; 2743 if (err) { 2744 var wrapped = wrapAsOperationalError(maybeWrapAsError(err)); 2745 promise._attachExtraTrace(wrapped); 2746 promise._reject(wrapped); 2747 } else if (!multiArgs) { 2748 promise._fulfill(value); 2749 } else { 2750 var args = [].slice.call(arguments, 1);; 2751 promise._fulfill(args); 2752 } 2753 promise = null; 2754 }; 2755} 2756 2757module.exports = nodebackForPromise; 2758 2759},{"./errors":12,"./es5":13,"./util":36}],21:[function(_dereq_,module,exports){ 2760"use strict"; 2761module.exports = function(Promise) { 2762var util = _dereq_("./util"); 2763var async = Promise._async; 2764var tryCatch = util.tryCatch; 2765var errorObj = util.errorObj; 2766 2767function spreadAdapter(val, nodeback) { 2768 var promise = this; 2769 if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback); 2770 var ret = 2771 tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val)); 2772 if (ret === errorObj) { 2773 async.throwLater(ret.e); 2774 } 2775} 2776 2777function successAdapter(val, nodeback) { 2778 var promise = this; 2779 var receiver = promise._boundValue(); 2780 var ret = val === undefined 2781 ? tryCatch(nodeback).call(receiver, null) 2782 : tryCatch(nodeback).call(receiver, null, val); 2783 if (ret === errorObj) { 2784 async.throwLater(ret.e); 2785 } 2786} 2787function errorAdapter(reason, nodeback) { 2788 var promise = this; 2789 if (!reason) { 2790 var newReason = new Error(reason + ""); 2791 newReason.cause = reason; 2792 reason = newReason; 2793 } 2794 var ret = tryCatch(nodeback).call(promise._boundValue(), reason); 2795 if (ret === errorObj) { 2796 async.throwLater(ret.e); 2797 } 2798} 2799 2800Promise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback, 2801 options) { 2802 if (typeof nodeback == "function") { 2803 var adapter = successAdapter; 2804 if (options !== undefined && Object(options).spread) { 2805 adapter = spreadAdapter; 2806 } 2807 this._then( 2808 adapter, 2809 errorAdapter, 2810 undefined, 2811 this, 2812 nodeback 2813 ); 2814 } 2815 return this; 2816}; 2817}; 2818 2819},{"./util":36}],22:[function(_dereq_,module,exports){ 2820"use strict"; 2821module.exports = function() { 2822var makeSelfResolutionError = function () { 2823 return new TypeError("circular promise resolution chain\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 2824}; 2825var reflectHandler = function() { 2826 return new Promise.PromiseInspection(this._target()); 2827}; 2828var apiRejection = function(msg) { 2829 return Promise.reject(new TypeError(msg)); 2830}; 2831function Proxyable() {} 2832var UNDEFINED_BINDING = {}; 2833var util = _dereq_("./util"); 2834util.setReflectHandler(reflectHandler); 2835 2836var getDomain = function() { 2837 var domain = process.domain; 2838 if (domain === undefined) { 2839 return null; 2840 } 2841 return domain; 2842}; 2843var getContextDefault = function() { 2844 return null; 2845}; 2846var getContextDomain = function() { 2847 return { 2848 domain: getDomain(), 2849 async: null 2850 }; 2851}; 2852var AsyncResource = util.isNode && util.nodeSupportsAsyncResource ? 2853 _dereq_("async_hooks").AsyncResource : null; 2854var getContextAsyncHooks = function() { 2855 return { 2856 domain: getDomain(), 2857 async: new AsyncResource("Bluebird::Promise") 2858 }; 2859}; 2860var getContext = util.isNode ? getContextDomain : getContextDefault; 2861util.notEnumerableProp(Promise, "_getContext", getContext); 2862var enableAsyncHooks = function() { 2863 getContext = getContextAsyncHooks; 2864 util.notEnumerableProp(Promise, "_getContext", getContextAsyncHooks); 2865}; 2866var disableAsyncHooks = function() { 2867 getContext = getContextDomain; 2868 util.notEnumerableProp(Promise, "_getContext", getContextDomain); 2869}; 2870 2871var es5 = _dereq_("./es5"); 2872var Async = _dereq_("./async"); 2873var async = new Async(); 2874es5.defineProperty(Promise, "_async", {value: async}); 2875var errors = _dereq_("./errors"); 2876var TypeError = Promise.TypeError = errors.TypeError; 2877Promise.RangeError = errors.RangeError; 2878var CancellationError = Promise.CancellationError = errors.CancellationError; 2879Promise.TimeoutError = errors.TimeoutError; 2880Promise.OperationalError = errors.OperationalError; 2881Promise.RejectionError = errors.OperationalError; 2882Promise.AggregateError = errors.AggregateError; 2883var INTERNAL = function(){}; 2884var APPLY = {}; 2885var NEXT_FILTER = {}; 2886var tryConvertToPromise = _dereq_("./thenables")(Promise, INTERNAL); 2887var PromiseArray = 2888 _dereq_("./promise_array")(Promise, INTERNAL, 2889 tryConvertToPromise, apiRejection, Proxyable); 2890var Context = _dereq_("./context")(Promise); 2891 /*jshint unused:false*/ 2892var createContext = Context.create; 2893 2894var debug = _dereq_("./debuggability")(Promise, Context, 2895 enableAsyncHooks, disableAsyncHooks); 2896var CapturedTrace = debug.CapturedTrace; 2897var PassThroughHandlerContext = 2898 _dereq_("./finally")(Promise, tryConvertToPromise, NEXT_FILTER); 2899var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER); 2900var nodebackForPromise = _dereq_("./nodeback"); 2901var errorObj = util.errorObj; 2902var tryCatch = util.tryCatch; 2903function check(self, executor) { 2904 if (self == null || self.constructor !== Promise) { 2905 throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 2906 } 2907 if (typeof executor !== "function") { 2908 throw new TypeError("expecting a function but got " + util.classString(executor)); 2909 } 2910 2911} 2912 2913function Promise(executor) { 2914 if (executor !== INTERNAL) { 2915 check(this, executor); 2916 } 2917 this._bitField = 0; 2918 this._fulfillmentHandler0 = undefined; 2919 this._rejectionHandler0 = undefined; 2920 this._promise0 = undefined; 2921 this._receiver0 = undefined; 2922 this._resolveFromExecutor(executor); 2923 this._promiseCreated(); 2924 this._fireEvent("promiseCreated", this); 2925} 2926 2927Promise.prototype.toString = function () { 2928 return "[object Promise]"; 2929}; 2930 2931Promise.prototype.caught = Promise.prototype["catch"] = function (fn) { 2932 var len = arguments.length; 2933 if (len > 1) { 2934 var catchInstances = new Array(len - 1), 2935 j = 0, i; 2936 for (i = 0; i < len - 1; ++i) { 2937 var item = arguments[i]; 2938 if (util.isObject(item)) { 2939 catchInstances[j++] = item; 2940 } else { 2941 return apiRejection("Catch statement predicate: " + 2942 "expecting an object but got " + util.classString(item)); 2943 } 2944 } 2945 catchInstances.length = j; 2946 fn = arguments[i]; 2947 2948 if (typeof fn !== "function") { 2949 throw new TypeError("The last argument to .catch() " + 2950 "must be a function, got " + util.toString(fn)); 2951 } 2952 return this.then(undefined, catchFilter(catchInstances, fn, this)); 2953 } 2954 return this.then(undefined, fn); 2955}; 2956 2957Promise.prototype.reflect = function () { 2958 return this._then(reflectHandler, 2959 reflectHandler, undefined, this, undefined); 2960}; 2961 2962Promise.prototype.then = function (didFulfill, didReject) { 2963 if (debug.warnings() && arguments.length > 0 && 2964 typeof didFulfill !== "function" && 2965 typeof didReject !== "function") { 2966 var msg = ".then() only accepts functions but was passed: " + 2967 util.classString(didFulfill); 2968 if (arguments.length > 1) { 2969 msg += ", " + util.classString(didReject); 2970 } 2971 this._warn(msg); 2972 } 2973 return this._then(didFulfill, didReject, undefined, undefined, undefined); 2974}; 2975 2976Promise.prototype.done = function (didFulfill, didReject) { 2977 var promise = 2978 this._then(didFulfill, didReject, undefined, undefined, undefined); 2979 promise._setIsFinal(); 2980}; 2981 2982Promise.prototype.spread = function (fn) { 2983 if (typeof fn !== "function") { 2984 return apiRejection("expecting a function but got " + util.classString(fn)); 2985 } 2986 return this.all()._then(fn, undefined, undefined, APPLY, undefined); 2987}; 2988 2989Promise.prototype.toJSON = function () { 2990 var ret = { 2991 isFulfilled: false, 2992 isRejected: false, 2993 fulfillmentValue: undefined, 2994 rejectionReason: undefined 2995 }; 2996 if (this.isFulfilled()) { 2997 ret.fulfillmentValue = this.value(); 2998 ret.isFulfilled = true; 2999 } else if (this.isRejected()) { 3000 ret.rejectionReason = this.reason(); 3001 ret.isRejected = true; 3002 } 3003 return ret; 3004}; 3005 3006Promise.prototype.all = function () { 3007 if (arguments.length > 0) { 3008 this._warn(".all() was passed arguments but it does not take any"); 3009 } 3010 return new PromiseArray(this).promise(); 3011}; 3012 3013Promise.prototype.error = function (fn) { 3014 return this.caught(util.originatesFromRejection, fn); 3015}; 3016 3017Promise.getNewLibraryCopy = module.exports; 3018 3019Promise.is = function (val) { 3020 return val instanceof Promise; 3021}; 3022 3023Promise.fromNode = Promise.fromCallback = function(fn) { 3024 var ret = new Promise(INTERNAL); 3025 ret._captureStackTrace(); 3026 var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs 3027 : false; 3028 var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs)); 3029 if (result === errorObj) { 3030 ret._rejectCallback(result.e, true); 3031 } 3032 if (!ret._isFateSealed()) ret._setAsyncGuaranteed(); 3033 return ret; 3034}; 3035 3036Promise.all = function (promises) { 3037 return new PromiseArray(promises).promise(); 3038}; 3039 3040Promise.cast = function (obj) { 3041 var ret = tryConvertToPromise(obj); 3042 if (!(ret instanceof Promise)) { 3043 ret = new Promise(INTERNAL); 3044 ret._captureStackTrace(); 3045 ret._setFulfilled(); 3046 ret._rejectionHandler0 = obj; 3047 } 3048 return ret; 3049}; 3050 3051Promise.resolve = Promise.fulfilled = Promise.cast; 3052 3053Promise.reject = Promise.rejected = function (reason) { 3054 var ret = new Promise(INTERNAL); 3055 ret._captureStackTrace(); 3056 ret._rejectCallback(reason, true); 3057 return ret; 3058}; 3059 3060Promise.setScheduler = function(fn) { 3061 if (typeof fn !== "function") { 3062 throw new TypeError("expecting a function but got " + util.classString(fn)); 3063 } 3064 return async.setScheduler(fn); 3065}; 3066 3067Promise.prototype._then = function ( 3068 didFulfill, 3069 didReject, 3070 _, receiver, 3071 internalData 3072) { 3073 var haveInternalData = internalData !== undefined; 3074 var promise = haveInternalData ? internalData : new Promise(INTERNAL); 3075 var target = this._target(); 3076 var bitField = target._bitField; 3077 3078 if (!haveInternalData) { 3079 promise._propagateFrom(this, 3); 3080 promise._captureStackTrace(); 3081 if (receiver === undefined && 3082 ((this._bitField & 2097152) !== 0)) { 3083 if (!((bitField & 50397184) === 0)) { 3084 receiver = this._boundValue(); 3085 } else { 3086 receiver = target === this ? undefined : this._boundTo; 3087 } 3088 } 3089 this._fireEvent("promiseChained", this, promise); 3090 } 3091 3092 var context = getContext(); 3093 if (!((bitField & 50397184) === 0)) { 3094 var handler, value, settler = target._settlePromiseCtx; 3095 if (((bitField & 33554432) !== 0)) { 3096 value = target._rejectionHandler0; 3097 handler = didFulfill; 3098 } else if (((bitField & 16777216) !== 0)) { 3099 value = target._fulfillmentHandler0; 3100 handler = didReject; 3101 target._unsetRejectionIsUnhandled(); 3102 } else { 3103 settler = target._settlePromiseLateCancellationObserver; 3104 value = new CancellationError("late cancellation observer"); 3105 target._attachExtraTrace(value); 3106 handler = didReject; 3107 } 3108 3109 async.invoke(settler, target, { 3110 handler: util.contextBind(context, handler), 3111 promise: promise, 3112 receiver: receiver, 3113 value: value 3114 }); 3115 } else { 3116 target._addCallbacks(didFulfill, didReject, promise, 3117 receiver, context); 3118 } 3119 3120 return promise; 3121}; 3122 3123Promise.prototype._length = function () { 3124 return this._bitField & 65535; 3125}; 3126 3127Promise.prototype._isFateSealed = function () { 3128 return (this._bitField & 117506048) !== 0; 3129}; 3130 3131Promise.prototype._isFollowing = function () { 3132 return (this._bitField & 67108864) === 67108864; 3133}; 3134 3135Promise.prototype._setLength = function (len) { 3136 this._bitField = (this._bitField & -65536) | 3137 (len & 65535); 3138}; 3139 3140Promise.prototype._setFulfilled = function () { 3141 this._bitField = this._bitField | 33554432; 3142 this._fireEvent("promiseFulfilled", this); 3143}; 3144 3145Promise.prototype._setRejected = function () { 3146 this._bitField = this._bitField | 16777216; 3147 this._fireEvent("promiseRejected", this); 3148}; 3149 3150Promise.prototype._setFollowing = function () { 3151 this._bitField = this._bitField | 67108864; 3152 this._fireEvent("promiseResolved", this); 3153}; 3154 3155Promise.prototype._setIsFinal = function () { 3156 this._bitField = this._bitField | 4194304; 3157}; 3158 3159Promise.prototype._isFinal = function () { 3160 return (this._bitField & 4194304) > 0; 3161}; 3162 3163Promise.prototype._unsetCancelled = function() { 3164 this._bitField = this._bitField & (~65536); 3165}; 3166 3167Promise.prototype._setCancelled = function() { 3168 this._bitField = this._bitField | 65536; 3169 this._fireEvent("promiseCancelled", this); 3170}; 3171 3172Promise.prototype._setWillBeCancelled = function() { 3173 this._bitField = this._bitField | 8388608; 3174}; 3175 3176Promise.prototype._setAsyncGuaranteed = function() { 3177 if (async.hasCustomScheduler()) return; 3178 var bitField = this._bitField; 3179 this._bitField = bitField | 3180 (((bitField & 536870912) >> 2) ^ 3181 134217728); 3182}; 3183 3184Promise.prototype._setNoAsyncGuarantee = function() { 3185 this._bitField = (this._bitField | 536870912) & 3186 (~134217728); 3187}; 3188 3189Promise.prototype._receiverAt = function (index) { 3190 var ret = index === 0 ? this._receiver0 : this[ 3191 index * 4 - 4 + 3]; 3192 if (ret === UNDEFINED_BINDING) { 3193 return undefined; 3194 } else if (ret === undefined && this._isBound()) { 3195 return this._boundValue(); 3196 } 3197 return ret; 3198}; 3199 3200Promise.prototype._promiseAt = function (index) { 3201 return this[ 3202 index * 4 - 4 + 2]; 3203}; 3204 3205Promise.prototype._fulfillmentHandlerAt = function (index) { 3206 return this[ 3207 index * 4 - 4 + 0]; 3208}; 3209 3210Promise.prototype._rejectionHandlerAt = function (index) { 3211 return this[ 3212 index * 4 - 4 + 1]; 3213}; 3214 3215Promise.prototype._boundValue = function() {}; 3216 3217Promise.prototype._migrateCallback0 = function (follower) { 3218 var bitField = follower._bitField; 3219 var fulfill = follower._fulfillmentHandler0; 3220 var reject = follower._rejectionHandler0; 3221 var promise = follower._promise0; 3222 var receiver = follower._receiverAt(0); 3223 if (receiver === undefined) receiver = UNDEFINED_BINDING; 3224 this._addCallbacks(fulfill, reject, promise, receiver, null); 3225}; 3226 3227Promise.prototype._migrateCallbackAt = function (follower, index) { 3228 var fulfill = follower._fulfillmentHandlerAt(index); 3229 var reject = follower._rejectionHandlerAt(index); 3230 var promise = follower._promiseAt(index); 3231 var receiver = follower._receiverAt(index); 3232 if (receiver === undefined) receiver = UNDEFINED_BINDING; 3233 this._addCallbacks(fulfill, reject, promise, receiver, null); 3234}; 3235 3236Promise.prototype._addCallbacks = function ( 3237 fulfill, 3238 reject, 3239 promise, 3240 receiver, 3241 context 3242) { 3243 var index = this._length(); 3244 3245 if (index >= 65535 - 4) { 3246 index = 0; 3247 this._setLength(0); 3248 } 3249 3250 if (index === 0) { 3251 this._promise0 = promise; 3252 this._receiver0 = receiver; 3253 if (typeof fulfill === "function") { 3254 this._fulfillmentHandler0 = util.contextBind(context, fulfill); 3255 } 3256 if (typeof reject === "function") { 3257 this._rejectionHandler0 = util.contextBind(context, reject); 3258 } 3259 } else { 3260 var base = index * 4 - 4; 3261 this[base + 2] = promise; 3262 this[base + 3] = receiver; 3263 if (typeof fulfill === "function") { 3264 this[base + 0] = 3265 util.contextBind(context, fulfill); 3266 } 3267 if (typeof reject === "function") { 3268 this[base + 1] = 3269 util.contextBind(context, reject); 3270 } 3271 } 3272 this._setLength(index + 1); 3273 return index; 3274}; 3275 3276Promise.prototype._proxy = function (proxyable, arg) { 3277 this._addCallbacks(undefined, undefined, arg, proxyable, null); 3278}; 3279 3280Promise.prototype._resolveCallback = function(value, shouldBind) { 3281 if (((this._bitField & 117506048) !== 0)) return; 3282 if (value === this) 3283 return this._rejectCallback(makeSelfResolutionError(), false); 3284 var maybePromise = tryConvertToPromise(value, this); 3285 if (!(maybePromise instanceof Promise)) return this._fulfill(value); 3286 3287 if (shouldBind) this._propagateFrom(maybePromise, 2); 3288 3289 3290 var promise = maybePromise._target(); 3291 3292 if (promise === this) { 3293 this._reject(makeSelfResolutionError()); 3294 return; 3295 } 3296 3297 var bitField = promise._bitField; 3298 if (((bitField & 50397184) === 0)) { 3299 var len = this._length(); 3300 if (len > 0) promise._migrateCallback0(this); 3301 for (var i = 1; i < len; ++i) { 3302 promise._migrateCallbackAt(this, i); 3303 } 3304 this._setFollowing(); 3305 this._setLength(0); 3306 this._setFollowee(maybePromise); 3307 } else if (((bitField & 33554432) !== 0)) { 3308 this._fulfill(promise._value()); 3309 } else if (((bitField & 16777216) !== 0)) { 3310 this._reject(promise._reason()); 3311 } else { 3312 var reason = new CancellationError("late cancellation observer"); 3313 promise._attachExtraTrace(reason); 3314 this._reject(reason); 3315 } 3316}; 3317 3318Promise.prototype._rejectCallback = 3319function(reason, synchronous, ignoreNonErrorWarnings) { 3320 var trace = util.ensureErrorObject(reason); 3321 var hasStack = trace === reason; 3322 if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) { 3323 var message = "a promise was rejected with a non-error: " + 3324 util.classString(reason); 3325 this._warn(message, true); 3326 } 3327 this._attachExtraTrace(trace, synchronous ? hasStack : false); 3328 this._reject(reason); 3329}; 3330 3331Promise.prototype._resolveFromExecutor = function (executor) { 3332 if (executor === INTERNAL) return; 3333 var promise = this; 3334 this._captureStackTrace(); 3335 this._pushContext(); 3336 var synchronous = true; 3337 var r = this._execute(executor, function(value) { 3338 promise._resolveCallback(value); 3339 }, function (reason) { 3340 promise._rejectCallback(reason, synchronous); 3341 }); 3342 synchronous = false; 3343 this._popContext(); 3344 3345 if (r !== undefined) { 3346 promise._rejectCallback(r, true); 3347 } 3348}; 3349 3350Promise.prototype._settlePromiseFromHandler = function ( 3351 handler, receiver, value, promise 3352) { 3353 var bitField = promise._bitField; 3354 if (((bitField & 65536) !== 0)) return; 3355 promise._pushContext(); 3356 var x; 3357 if (receiver === APPLY) { 3358 if (!value || typeof value.length !== "number") { 3359 x = errorObj; 3360 x.e = new TypeError("cannot .spread() a non-array: " + 3361 util.classString(value)); 3362 } else { 3363 x = tryCatch(handler).apply(this._boundValue(), value); 3364 } 3365 } else { 3366 x = tryCatch(handler).call(receiver, value); 3367 } 3368 var promiseCreated = promise._popContext(); 3369 bitField = promise._bitField; 3370 if (((bitField & 65536) !== 0)) return; 3371 3372 if (x === NEXT_FILTER) { 3373 promise._reject(value); 3374 } else if (x === errorObj) { 3375 promise._rejectCallback(x.e, false); 3376 } else { 3377 debug.checkForgottenReturns(x, promiseCreated, "", promise, this); 3378 promise._resolveCallback(x); 3379 } 3380}; 3381 3382Promise.prototype._target = function() { 3383 var ret = this; 3384 while (ret._isFollowing()) ret = ret._followee(); 3385 return ret; 3386}; 3387 3388Promise.prototype._followee = function() { 3389 return this._rejectionHandler0; 3390}; 3391 3392Promise.prototype._setFollowee = function(promise) { 3393 this._rejectionHandler0 = promise; 3394}; 3395 3396Promise.prototype._settlePromise = function(promise, handler, receiver, value) { 3397 var isPromise = promise instanceof Promise; 3398 var bitField = this._bitField; 3399 var asyncGuaranteed = ((bitField & 134217728) !== 0); 3400 if (((bitField & 65536) !== 0)) { 3401 if (isPromise) promise._invokeInternalOnCancel(); 3402 3403 if (receiver instanceof PassThroughHandlerContext && 3404 receiver.isFinallyHandler()) { 3405 receiver.cancelPromise = promise; 3406 if (tryCatch(handler).call(receiver, value) === errorObj) { 3407 promise._reject(errorObj.e); 3408 } 3409 } else if (handler === reflectHandler) { 3410 promise._fulfill(reflectHandler.call(receiver)); 3411 } else if (receiver instanceof Proxyable) { 3412 receiver._promiseCancelled(promise); 3413 } else if (isPromise || promise instanceof PromiseArray) { 3414 promise._cancel(); 3415 } else { 3416 receiver.cancel(); 3417 } 3418 } else if (typeof handler === "function") { 3419 if (!isPromise) { 3420 handler.call(receiver, value, promise); 3421 } else { 3422 if (asyncGuaranteed) promise._setAsyncGuaranteed(); 3423 this._settlePromiseFromHandler(handler, receiver, value, promise); 3424 } 3425 } else if (receiver instanceof Proxyable) { 3426 if (!receiver._isResolved()) { 3427 if (((bitField & 33554432) !== 0)) { 3428 receiver._promiseFulfilled(value, promise); 3429 } else { 3430 receiver._promiseRejected(value, promise); 3431 } 3432 } 3433 } else if (isPromise) { 3434 if (asyncGuaranteed) promise._setAsyncGuaranteed(); 3435 if (((bitField & 33554432) !== 0)) { 3436 promise._fulfill(value); 3437 } else { 3438 promise._reject(value); 3439 } 3440 } 3441}; 3442 3443Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) { 3444 var handler = ctx.handler; 3445 var promise = ctx.promise; 3446 var receiver = ctx.receiver; 3447 var value = ctx.value; 3448 if (typeof handler === "function") { 3449 if (!(promise instanceof Promise)) { 3450 handler.call(receiver, value, promise); 3451 } else { 3452 this._settlePromiseFromHandler(handler, receiver, value, promise); 3453 } 3454 } else if (promise instanceof Promise) { 3455 promise._reject(value); 3456 } 3457}; 3458 3459Promise.prototype._settlePromiseCtx = function(ctx) { 3460 this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value); 3461}; 3462 3463Promise.prototype._settlePromise0 = function(handler, value, bitField) { 3464 var promise = this._promise0; 3465 var receiver = this._receiverAt(0); 3466 this._promise0 = undefined; 3467 this._receiver0 = undefined; 3468 this._settlePromise(promise, handler, receiver, value); 3469}; 3470 3471Promise.prototype._clearCallbackDataAtIndex = function(index) { 3472 var base = index * 4 - 4; 3473 this[base + 2] = 3474 this[base + 3] = 3475 this[base + 0] = 3476 this[base + 1] = undefined; 3477}; 3478 3479Promise.prototype._fulfill = function (value) { 3480 var bitField = this._bitField; 3481 if (((bitField & 117506048) >>> 16)) return; 3482 if (value === this) { 3483 var err = makeSelfResolutionError(); 3484 this._attachExtraTrace(err); 3485 return this._reject(err); 3486 } 3487 this._setFulfilled(); 3488 this._rejectionHandler0 = value; 3489 3490 if ((bitField & 65535) > 0) { 3491 if (((bitField & 134217728) !== 0)) { 3492 this._settlePromises(); 3493 } else { 3494 async.settlePromises(this); 3495 } 3496 this._dereferenceTrace(); 3497 } 3498}; 3499 3500Promise.prototype._reject = function (reason) { 3501 var bitField = this._bitField; 3502 if (((bitField & 117506048) >>> 16)) return; 3503 this._setRejected(); 3504 this._fulfillmentHandler0 = reason; 3505 3506 if (this._isFinal()) { 3507 return async.fatalError(reason, util.isNode); 3508 } 3509 3510 if ((bitField & 65535) > 0) { 3511 async.settlePromises(this); 3512 } else { 3513 this._ensurePossibleRejectionHandled(); 3514 } 3515}; 3516 3517Promise.prototype._fulfillPromises = function (len, value) { 3518 for (var i = 1; i < len; i++) { 3519 var handler = this._fulfillmentHandlerAt(i); 3520 var promise = this._promiseAt(i); 3521 var receiver = this._receiverAt(i); 3522 this._clearCallbackDataAtIndex(i); 3523 this._settlePromise(promise, handler, receiver, value); 3524 } 3525}; 3526 3527Promise.prototype._rejectPromises = function (len, reason) { 3528 for (var i = 1; i < len; i++) { 3529 var handler = this._rejectionHandlerAt(i); 3530 var promise = this._promiseAt(i); 3531 var receiver = this._receiverAt(i); 3532 this._clearCallbackDataAtIndex(i); 3533 this._settlePromise(promise, handler, receiver, reason); 3534 } 3535}; 3536 3537Promise.prototype._settlePromises = function () { 3538 var bitField = this._bitField; 3539 var len = (bitField & 65535); 3540 3541 if (len > 0) { 3542 if (((bitField & 16842752) !== 0)) { 3543 var reason = this._fulfillmentHandler0; 3544 this._settlePromise0(this._rejectionHandler0, reason, bitField); 3545 this._rejectPromises(len, reason); 3546 } else { 3547 var value = this._rejectionHandler0; 3548 this._settlePromise0(this._fulfillmentHandler0, value, bitField); 3549 this._fulfillPromises(len, value); 3550 } 3551 this._setLength(0); 3552 } 3553 this._clearCancellationData(); 3554}; 3555 3556Promise.prototype._settledValue = function() { 3557 var bitField = this._bitField; 3558 if (((bitField & 33554432) !== 0)) { 3559 return this._rejectionHandler0; 3560 } else if (((bitField & 16777216) !== 0)) { 3561 return this._fulfillmentHandler0; 3562 } 3563}; 3564 3565if (typeof Symbol !== "undefined" && Symbol.toStringTag) { 3566 es5.defineProperty(Promise.prototype, Symbol.toStringTag, { 3567 get: function () { 3568 return "Object"; 3569 } 3570 }); 3571} 3572 3573function deferResolve(v) {this.promise._resolveCallback(v);} 3574function deferReject(v) {this.promise._rejectCallback(v, false);} 3575 3576Promise.defer = Promise.pending = function() { 3577 debug.deprecated("Promise.defer", "new Promise"); 3578 var promise = new Promise(INTERNAL); 3579 return { 3580 promise: promise, 3581 resolve: deferResolve, 3582 reject: deferReject 3583 }; 3584}; 3585 3586util.notEnumerableProp(Promise, 3587 "_makeSelfResolutionError", 3588 makeSelfResolutionError); 3589 3590_dereq_("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection, 3591 debug); 3592_dereq_("./bind")(Promise, INTERNAL, tryConvertToPromise, debug); 3593_dereq_("./cancel")(Promise, PromiseArray, apiRejection, debug); 3594_dereq_("./direct_resolve")(Promise); 3595_dereq_("./synchronous_inspection")(Promise); 3596_dereq_("./join")( 3597 Promise, PromiseArray, tryConvertToPromise, INTERNAL, async); 3598Promise.Promise = Promise; 3599Promise.version = "3.7.2"; 3600_dereq_('./call_get.js')(Promise); 3601_dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug); 3602_dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); 3603_dereq_('./nodeify.js')(Promise); 3604_dereq_('./promisify.js')(Promise, INTERNAL); 3605_dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection); 3606_dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection); 3607_dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); 3608_dereq_('./settle.js')(Promise, PromiseArray, debug); 3609_dereq_('./some.js')(Promise, PromiseArray, apiRejection); 3610_dereq_('./timers.js')(Promise, INTERNAL, debug); 3611_dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug); 3612_dereq_('./any.js')(Promise); 3613_dereq_('./each.js')(Promise, INTERNAL); 3614_dereq_('./filter.js')(Promise, INTERNAL); 3615 3616 util.toFastProperties(Promise); 3617 util.toFastProperties(Promise.prototype); 3618 function fillTypes(value) { 3619 var p = new Promise(INTERNAL); 3620 p._fulfillmentHandler0 = value; 3621 p._rejectionHandler0 = value; 3622 p._promise0 = value; 3623 p._receiver0 = value; 3624 } 3625 // Complete slack tracking, opt out of field-type tracking and 3626 // stabilize map 3627 fillTypes({a: 1}); 3628 fillTypes({b: 2}); 3629 fillTypes({c: 3}); 3630 fillTypes(1); 3631 fillTypes(function(){}); 3632 fillTypes(undefined); 3633 fillTypes(false); 3634 fillTypes(new Promise(INTERNAL)); 3635 debug.setBounds(Async.firstLineError, util.lastLineError); 3636 return Promise; 3637 3638}; 3639 3640},{"./any.js":1,"./async":2,"./bind":3,"./call_get.js":5,"./cancel":6,"./catch_filter":7,"./context":8,"./debuggability":9,"./direct_resolve":10,"./each.js":11,"./errors":12,"./es5":13,"./filter.js":14,"./finally":15,"./generators.js":16,"./join":17,"./map.js":18,"./method":19,"./nodeback":20,"./nodeify.js":21,"./promise_array":23,"./promisify.js":24,"./props.js":25,"./race.js":27,"./reduce.js":28,"./settle.js":30,"./some.js":31,"./synchronous_inspection":32,"./thenables":33,"./timers.js":34,"./using.js":35,"./util":36,"async_hooks":undefined}],23:[function(_dereq_,module,exports){ 3641"use strict"; 3642module.exports = function(Promise, INTERNAL, tryConvertToPromise, 3643 apiRejection, Proxyable) { 3644var util = _dereq_("./util"); 3645var isArray = util.isArray; 3646 3647function toResolutionValue(val) { 3648 switch(val) { 3649 case -2: return []; 3650 case -3: return {}; 3651 case -6: return new Map(); 3652 } 3653} 3654 3655function PromiseArray(values) { 3656 var promise = this._promise = new Promise(INTERNAL); 3657 if (values instanceof Promise) { 3658 promise._propagateFrom(values, 3); 3659 values.suppressUnhandledRejections(); 3660 } 3661 promise._setOnCancel(this); 3662 this._values = values; 3663 this._length = 0; 3664 this._totalResolved = 0; 3665 this._init(undefined, -2); 3666} 3667util.inherits(PromiseArray, Proxyable); 3668 3669PromiseArray.prototype.length = function () { 3670 return this._length; 3671}; 3672 3673PromiseArray.prototype.promise = function () { 3674 return this._promise; 3675}; 3676 3677PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) { 3678 var values = tryConvertToPromise(this._values, this._promise); 3679 if (values instanceof Promise) { 3680 values = values._target(); 3681 var bitField = values._bitField; 3682 ; 3683 this._values = values; 3684 3685 if (((bitField & 50397184) === 0)) { 3686 this._promise._setAsyncGuaranteed(); 3687 return values._then( 3688 init, 3689 this._reject, 3690 undefined, 3691 this, 3692 resolveValueIfEmpty 3693 ); 3694 } else if (((bitField & 33554432) !== 0)) { 3695 values = values._value(); 3696 } else if (((bitField & 16777216) !== 0)) { 3697 return this._reject(values._reason()); 3698 } else { 3699 return this._cancel(); 3700 } 3701 } 3702 values = util.asArray(values); 3703 if (values === null) { 3704 var err = apiRejection( 3705 "expecting an array or an iterable object but got " + util.classString(values)).reason(); 3706 this._promise._rejectCallback(err, false); 3707 return; 3708 } 3709 3710 if (values.length === 0) { 3711 if (resolveValueIfEmpty === -5) { 3712 this._resolveEmptyArray(); 3713 } 3714 else { 3715 this._resolve(toResolutionValue(resolveValueIfEmpty)); 3716 } 3717 return; 3718 } 3719 this._iterate(values); 3720}; 3721 3722PromiseArray.prototype._iterate = function(values) { 3723 var len = this.getActualLength(values.length); 3724 this._length = len; 3725 this._values = this.shouldCopyValues() ? new Array(len) : this._values; 3726 var result = this._promise; 3727 var isResolved = false; 3728 var bitField = null; 3729 for (var i = 0; i < len; ++i) { 3730 var maybePromise = tryConvertToPromise(values[i], result); 3731 3732 if (maybePromise instanceof Promise) { 3733 maybePromise = maybePromise._target(); 3734 bitField = maybePromise._bitField; 3735 } else { 3736 bitField = null; 3737 } 3738 3739 if (isResolved) { 3740 if (bitField !== null) { 3741 maybePromise.suppressUnhandledRejections(); 3742 } 3743 } else if (bitField !== null) { 3744 if (((bitField & 50397184) === 0)) { 3745 maybePromise._proxy(this, i); 3746 this._values[i] = maybePromise; 3747 } else if (((bitField & 33554432) !== 0)) { 3748 isResolved = this._promiseFulfilled(maybePromise._value(), i); 3749 } else if (((bitField & 16777216) !== 0)) { 3750 isResolved = this._promiseRejected(maybePromise._reason(), i); 3751 } else { 3752 isResolved = this._promiseCancelled(i); 3753 } 3754 } else { 3755 isResolved = this._promiseFulfilled(maybePromise, i); 3756 } 3757 } 3758 if (!isResolved) result._setAsyncGuaranteed(); 3759}; 3760 3761PromiseArray.prototype._isResolved = function () { 3762 return this._values === null; 3763}; 3764 3765PromiseArray.prototype._resolve = function (value) { 3766 this._values = null; 3767 this._promise._fulfill(value); 3768}; 3769 3770PromiseArray.prototype._cancel = function() { 3771 if (this._isResolved() || !this._promise._isCancellable()) return; 3772 this._values = null; 3773 this._promise._cancel(); 3774}; 3775 3776PromiseArray.prototype._reject = function (reason) { 3777 this._values = null; 3778 this._promise._rejectCallback(reason, false); 3779}; 3780 3781PromiseArray.prototype._promiseFulfilled = function (value, index) { 3782 this._values[index] = value; 3783 var totalResolved = ++this._totalResolved; 3784 if (totalResolved >= this._length) { 3785 this._resolve(this._values); 3786 return true; 3787 } 3788 return false; 3789}; 3790 3791PromiseArray.prototype._promiseCancelled = function() { 3792 this._cancel(); 3793 return true; 3794}; 3795 3796PromiseArray.prototype._promiseRejected = function (reason) { 3797 this._totalResolved++; 3798 this._reject(reason); 3799 return true; 3800}; 3801 3802PromiseArray.prototype._resultCancelled = function() { 3803 if (this._isResolved()) return; 3804 var values = this._values; 3805 this._cancel(); 3806 if (values instanceof Promise) { 3807 values.cancel(); 3808 } else { 3809 for (var i = 0; i < values.length; ++i) { 3810 if (values[i] instanceof Promise) { 3811 values[i].cancel(); 3812 } 3813 } 3814 } 3815}; 3816 3817PromiseArray.prototype.shouldCopyValues = function () { 3818 return true; 3819}; 3820 3821PromiseArray.prototype.getActualLength = function (len) { 3822 return len; 3823}; 3824 3825return PromiseArray; 3826}; 3827 3828},{"./util":36}],24:[function(_dereq_,module,exports){ 3829"use strict"; 3830module.exports = function(Promise, INTERNAL) { 3831var THIS = {}; 3832var util = _dereq_("./util"); 3833var nodebackForPromise = _dereq_("./nodeback"); 3834var withAppended = util.withAppended; 3835var maybeWrapAsError = util.maybeWrapAsError; 3836var canEvaluate = util.canEvaluate; 3837var TypeError = _dereq_("./errors").TypeError; 3838var defaultSuffix = "Async"; 3839var defaultPromisified = {__isPromisified__: true}; 3840var noCopyProps = [ 3841 "arity", "length", 3842 "name", 3843 "arguments", 3844 "caller", 3845 "callee", 3846 "prototype", 3847 "__isPromisified__" 3848]; 3849var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$"); 3850 3851var defaultFilter = function(name) { 3852 return util.isIdentifier(name) && 3853 name.charAt(0) !== "_" && 3854 name !== "constructor"; 3855}; 3856 3857function propsFilter(key) { 3858 return !noCopyPropsPattern.test(key); 3859} 3860 3861function isPromisified(fn) { 3862 try { 3863 return fn.__isPromisified__ === true; 3864 } 3865 catch (e) { 3866 return false; 3867 } 3868} 3869 3870function hasPromisified(obj, key, suffix) { 3871 var val = util.getDataPropertyOrDefault(obj, key + suffix, 3872 defaultPromisified); 3873 return val ? isPromisified(val) : false; 3874} 3875function checkValid(ret, suffix, suffixRegexp) { 3876 for (var i = 0; i < ret.length; i += 2) { 3877 var key = ret[i]; 3878 if (suffixRegexp.test(key)) { 3879 var keyWithoutAsyncSuffix = key.replace(suffixRegexp, ""); 3880 for (var j = 0; j < ret.length; j += 2) { 3881 if (ret[j] === keyWithoutAsyncSuffix) { 3882 throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a See http://goo.gl/MqrFmX\u000a" 3883 .replace("%s", suffix)); 3884 } 3885 } 3886 } 3887 } 3888} 3889 3890function promisifiableMethods(obj, suffix, suffixRegexp, filter) { 3891 var keys = util.inheritedDataKeys(obj); 3892 var ret = []; 3893 for (var i = 0; i < keys.length; ++i) { 3894 var key = keys[i]; 3895 var value = obj[key]; 3896 var passesDefaultFilter = filter === defaultFilter 3897 ? true : defaultFilter(key, value, obj); 3898 if (typeof value === "function" && 3899 !isPromisified(value) && 3900 !hasPromisified(obj, key, suffix) && 3901 filter(key, value, obj, passesDefaultFilter)) { 3902 ret.push(key, value); 3903 } 3904 } 3905 checkValid(ret, suffix, suffixRegexp); 3906 return ret; 3907} 3908 3909var escapeIdentRegex = function(str) { 3910 return str.replace(/([$])/, "\\$"); 3911}; 3912 3913var makeNodePromisifiedEval; 3914if (!true) { 3915var switchCaseArgumentOrder = function(likelyArgumentCount) { 3916 var ret = [likelyArgumentCount]; 3917 var min = Math.max(0, likelyArgumentCount - 1 - 3); 3918 for(var i = likelyArgumentCount - 1; i >= min; --i) { 3919 ret.push(i); 3920 } 3921 for(var i = likelyArgumentCount + 1; i <= 3; ++i) { 3922 ret.push(i); 3923 } 3924 return ret; 3925}; 3926 3927var argumentSequence = function(argumentCount) { 3928 return util.filledRange(argumentCount, "_arg", ""); 3929}; 3930 3931var parameterDeclaration = function(parameterCount) { 3932 return util.filledRange( 3933 Math.max(parameterCount, 3), "_arg", ""); 3934}; 3935 3936var parameterCount = function(fn) { 3937 if (typeof fn.length === "number") { 3938 return Math.max(Math.min(fn.length, 1023 + 1), 0); 3939 } 3940 return 0; 3941}; 3942 3943makeNodePromisifiedEval = 3944function(callback, receiver, originalName, fn, _, multiArgs) { 3945 var newParameterCount = Math.max(0, parameterCount(fn) - 1); 3946 var argumentOrder = switchCaseArgumentOrder(newParameterCount); 3947 var shouldProxyThis = typeof callback === "string" || receiver === THIS; 3948 3949 function generateCallForArgumentCount(count) { 3950 var args = argumentSequence(count).join(", "); 3951 var comma = count > 0 ? ", " : ""; 3952 var ret; 3953 if (shouldProxyThis) { 3954 ret = "ret = callback.call(this, {{args}}, nodeback); break;\n"; 3955 } else { 3956 ret = receiver === undefined 3957 ? "ret = callback({{args}}, nodeback); break;\n" 3958 : "ret = callback.call(receiver, {{args}}, nodeback); break;\n"; 3959 } 3960 return ret.replace("{{args}}", args).replace(", ", comma); 3961 } 3962 3963 function generateArgumentSwitchCase() { 3964 var ret = ""; 3965 for (var i = 0; i < argumentOrder.length; ++i) { 3966 ret += "case " + argumentOrder[i] +":" + 3967 generateCallForArgumentCount(argumentOrder[i]); 3968 } 3969 3970 ret += " \n\ 3971 default: \n\ 3972 var args = new Array(len + 1); \n\ 3973 var i = 0; \n\ 3974 for (var i = 0; i < len; ++i) { \n\ 3975 args[i] = arguments[i]; \n\ 3976 } \n\ 3977 args[i] = nodeback; \n\ 3978 [CodeForCall] \n\ 3979 break; \n\ 3980 ".replace("[CodeForCall]", (shouldProxyThis 3981 ? "ret = callback.apply(this, args);\n" 3982 : "ret = callback.apply(receiver, args);\n")); 3983 return ret; 3984 } 3985 3986 var getFunctionCode = typeof callback === "string" 3987 ? ("this != null ? this['"+callback+"'] : fn") 3988 : "fn"; 3989 var body = "'use strict'; \n\ 3990 var ret = function (Parameters) { \n\ 3991 'use strict'; \n\ 3992 var len = arguments.length; \n\ 3993 var promise = new Promise(INTERNAL); \n\ 3994 promise._captureStackTrace(); \n\ 3995 var nodeback = nodebackForPromise(promise, " + multiArgs + "); \n\ 3996 var ret; \n\ 3997 var callback = tryCatch([GetFunctionCode]); \n\ 3998 switch(len) { \n\ 3999 [CodeForSwitchCase] \n\ 4000 } \n\ 4001 if (ret === errorObj) { \n\ 4002 promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\ 4003 } \n\ 4004 if (!promise._isFateSealed()) promise._setAsyncGuaranteed(); \n\ 4005 return promise; \n\ 4006 }; \n\ 4007 notEnumerableProp(ret, '__isPromisified__', true); \n\ 4008 return ret; \n\ 4009 ".replace("[CodeForSwitchCase]", generateArgumentSwitchCase()) 4010 .replace("[GetFunctionCode]", getFunctionCode); 4011 body = body.replace("Parameters", parameterDeclaration(newParameterCount)); 4012 return new Function("Promise", 4013 "fn", 4014 "receiver", 4015 "withAppended", 4016 "maybeWrapAsError", 4017 "nodebackForPromise", 4018 "tryCatch", 4019 "errorObj", 4020 "notEnumerableProp", 4021 "INTERNAL", 4022 body)( 4023 Promise, 4024 fn, 4025 receiver, 4026 withAppended, 4027 maybeWrapAsError, 4028 nodebackForPromise, 4029 util.tryCatch, 4030 util.errorObj, 4031 util.notEnumerableProp, 4032 INTERNAL); 4033}; 4034} 4035 4036function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) { 4037 var defaultThis = (function() {return this;})(); 4038 var method = callback; 4039 if (typeof method === "string") { 4040 callback = fn; 4041 } 4042 function promisified() { 4043 var _receiver = receiver; 4044 if (receiver === THIS) _receiver = this; 4045 var promise = new Promise(INTERNAL); 4046 promise._captureStackTrace(); 4047 var cb = typeof method === "string" && this !== defaultThis 4048 ? this[method] : callback; 4049 var fn = nodebackForPromise(promise, multiArgs); 4050 try { 4051 cb.apply(_receiver, withAppended(arguments, fn)); 4052 } catch(e) { 4053 promise._rejectCallback(maybeWrapAsError(e), true, true); 4054 } 4055 if (!promise._isFateSealed()) promise._setAsyncGuaranteed(); 4056 return promise; 4057 } 4058 util.notEnumerableProp(promisified, "__isPromisified__", true); 4059 return promisified; 4060} 4061 4062var makeNodePromisified = canEvaluate 4063 ? makeNodePromisifiedEval 4064 : makeNodePromisifiedClosure; 4065 4066function promisifyAll(obj, suffix, filter, promisifier, multiArgs) { 4067 var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$"); 4068 var methods = 4069 promisifiableMethods(obj, suffix, suffixRegexp, filter); 4070 4071 for (var i = 0, len = methods.length; i < len; i+= 2) { 4072 var key = methods[i]; 4073 var fn = methods[i+1]; 4074 var promisifiedKey = key + suffix; 4075 if (promisifier === makeNodePromisified) { 4076 obj[promisifiedKey] = 4077 makeNodePromisified(key, THIS, key, fn, suffix, multiArgs); 4078 } else { 4079 var promisified = promisifier(fn, function() { 4080 return makeNodePromisified(key, THIS, key, 4081 fn, suffix, multiArgs); 4082 }); 4083 util.notEnumerableProp(promisified, "__isPromisified__", true); 4084 obj[promisifiedKey] = promisified; 4085 } 4086 } 4087 util.toFastProperties(obj); 4088 return obj; 4089} 4090 4091function promisify(callback, receiver, multiArgs) { 4092 return makeNodePromisified(callback, receiver, undefined, 4093 callback, null, multiArgs); 4094} 4095 4096Promise.promisify = function (fn, options) { 4097 if (typeof fn !== "function") { 4098 throw new TypeError("expecting a function but got " + util.classString(fn)); 4099 } 4100 if (isPromisified(fn)) { 4101 return fn; 4102 } 4103 options = Object(options); 4104 var receiver = options.context === undefined ? THIS : options.context; 4105 var multiArgs = !!options.multiArgs; 4106 var ret = promisify(fn, receiver, multiArgs); 4107 util.copyDescriptors(fn, ret, propsFilter); 4108 return ret; 4109}; 4110 4111Promise.promisifyAll = function (target, options) { 4112 if (typeof target !== "function" && typeof target !== "object") { 4113 throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 4114 } 4115 options = Object(options); 4116 var multiArgs = !!options.multiArgs; 4117 var suffix = options.suffix; 4118 if (typeof suffix !== "string") suffix = defaultSuffix; 4119 var filter = options.filter; 4120 if (typeof filter !== "function") filter = defaultFilter; 4121 var promisifier = options.promisifier; 4122 if (typeof promisifier !== "function") promisifier = makeNodePromisified; 4123 4124 if (!util.isIdentifier(suffix)) { 4125 throw new RangeError("suffix must be a valid identifier\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 4126 } 4127 4128 var keys = util.inheritedDataKeys(target); 4129 for (var i = 0; i < keys.length; ++i) { 4130 var value = target[keys[i]]; 4131 if (keys[i] !== "constructor" && 4132 util.isClass(value)) { 4133 promisifyAll(value.prototype, suffix, filter, promisifier, 4134 multiArgs); 4135 promisifyAll(value, suffix, filter, promisifier, multiArgs); 4136 } 4137 } 4138 4139 return promisifyAll(target, suffix, filter, promisifier, multiArgs); 4140}; 4141}; 4142 4143 4144},{"./errors":12,"./nodeback":20,"./util":36}],25:[function(_dereq_,module,exports){ 4145"use strict"; 4146module.exports = function( 4147 Promise, PromiseArray, tryConvertToPromise, apiRejection) { 4148var util = _dereq_("./util"); 4149var isObject = util.isObject; 4150var es5 = _dereq_("./es5"); 4151var Es6Map; 4152if (typeof Map === "function") Es6Map = Map; 4153 4154var mapToEntries = (function() { 4155 var index = 0; 4156 var size = 0; 4157 4158 function extractEntry(value, key) { 4159 this[index] = value; 4160 this[index + size] = key; 4161 index++; 4162 } 4163 4164 return function mapToEntries(map) { 4165 size = map.size; 4166 index = 0; 4167 var ret = new Array(map.size * 2); 4168 map.forEach(extractEntry, ret); 4169 return ret; 4170 }; 4171})(); 4172 4173var entriesToMap = function(entries) { 4174 var ret = new Es6Map(); 4175 var length = entries.length / 2 | 0; 4176 for (var i = 0; i < length; ++i) { 4177 var key = entries[length + i]; 4178 var value = entries[i]; 4179 ret.set(key, value); 4180 } 4181 return ret; 4182}; 4183 4184function PropertiesPromiseArray(obj) { 4185 var isMap = false; 4186 var entries; 4187 if (Es6Map !== undefined && obj instanceof Es6Map) { 4188 entries = mapToEntries(obj); 4189 isMap = true; 4190 } else { 4191 var keys = es5.keys(obj); 4192 var len = keys.length; 4193 entries = new Array(len * 2); 4194 for (var i = 0; i < len; ++i) { 4195 var key = keys[i]; 4196 entries[i] = obj[key]; 4197 entries[i + len] = key; 4198 } 4199 } 4200 this.constructor$(entries); 4201 this._isMap = isMap; 4202 this._init$(undefined, isMap ? -6 : -3); 4203} 4204util.inherits(PropertiesPromiseArray, PromiseArray); 4205 4206PropertiesPromiseArray.prototype._init = function () {}; 4207 4208PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) { 4209 this._values[index] = value; 4210 var totalResolved = ++this._totalResolved; 4211 if (totalResolved >= this._length) { 4212 var val; 4213 if (this._isMap) { 4214 val = entriesToMap(this._values); 4215 } else { 4216 val = {}; 4217 var keyOffset = this.length(); 4218 for (var i = 0, len = this.length(); i < len; ++i) { 4219 val[this._values[i + keyOffset]] = this._values[i]; 4220 } 4221 } 4222 this._resolve(val); 4223 return true; 4224 } 4225 return false; 4226}; 4227 4228PropertiesPromiseArray.prototype.shouldCopyValues = function () { 4229 return false; 4230}; 4231 4232PropertiesPromiseArray.prototype.getActualLength = function (len) { 4233 return len >> 1; 4234}; 4235 4236function props(promises) { 4237 var ret; 4238 var castValue = tryConvertToPromise(promises); 4239 4240 if (!isObject(castValue)) { 4241 return apiRejection("cannot await properties of a non-object\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 4242 } else if (castValue instanceof Promise) { 4243 ret = castValue._then( 4244 Promise.props, undefined, undefined, undefined, undefined); 4245 } else { 4246 ret = new PropertiesPromiseArray(castValue).promise(); 4247 } 4248 4249 if (castValue instanceof Promise) { 4250 ret._propagateFrom(castValue, 2); 4251 } 4252 return ret; 4253} 4254 4255Promise.prototype.props = function () { 4256 return props(this); 4257}; 4258 4259Promise.props = function (promises) { 4260 return props(promises); 4261}; 4262}; 4263 4264},{"./es5":13,"./util":36}],26:[function(_dereq_,module,exports){ 4265"use strict"; 4266function arrayMove(src, srcIndex, dst, dstIndex, len) { 4267 for (var j = 0; j < len; ++j) { 4268 dst[j + dstIndex] = src[j + srcIndex]; 4269 src[j + srcIndex] = void 0; 4270 } 4271} 4272 4273function Queue(capacity) { 4274 this._capacity = capacity; 4275 this._length = 0; 4276 this._front = 0; 4277} 4278 4279Queue.prototype._willBeOverCapacity = function (size) { 4280 return this._capacity < size; 4281}; 4282 4283Queue.prototype._pushOne = function (arg) { 4284 var length = this.length(); 4285 this._checkCapacity(length + 1); 4286 var i = (this._front + length) & (this._capacity - 1); 4287 this[i] = arg; 4288 this._length = length + 1; 4289}; 4290 4291Queue.prototype.push = function (fn, receiver, arg) { 4292 var length = this.length() + 3; 4293 if (this._willBeOverCapacity(length)) { 4294 this._pushOne(fn); 4295 this._pushOne(receiver); 4296 this._pushOne(arg); 4297 return; 4298 } 4299 var j = this._front + length - 3; 4300 this._checkCapacity(length); 4301 var wrapMask = this._capacity - 1; 4302 this[(j + 0) & wrapMask] = fn; 4303 this[(j + 1) & wrapMask] = receiver; 4304 this[(j + 2) & wrapMask] = arg; 4305 this._length = length; 4306}; 4307 4308Queue.prototype.shift = function () { 4309 var front = this._front, 4310 ret = this[front]; 4311 4312 this[front] = undefined; 4313 this._front = (front + 1) & (this._capacity - 1); 4314 this._length--; 4315 return ret; 4316}; 4317 4318Queue.prototype.length = function () { 4319 return this._length; 4320}; 4321 4322Queue.prototype._checkCapacity = function (size) { 4323 if (this._capacity < size) { 4324 this._resizeTo(this._capacity << 1); 4325 } 4326}; 4327 4328Queue.prototype._resizeTo = function (capacity) { 4329 var oldCapacity = this._capacity; 4330 this._capacity = capacity; 4331 var front = this._front; 4332 var length = this._length; 4333 var moveItemsCount = (front + length) & (oldCapacity - 1); 4334 arrayMove(this, 0, this, oldCapacity, moveItemsCount); 4335}; 4336 4337module.exports = Queue; 4338 4339},{}],27:[function(_dereq_,module,exports){ 4340"use strict"; 4341module.exports = function( 4342 Promise, INTERNAL, tryConvertToPromise, apiRejection) { 4343var util = _dereq_("./util"); 4344 4345var raceLater = function (promise) { 4346 return promise.then(function(array) { 4347 return race(array, promise); 4348 }); 4349}; 4350 4351function race(promises, parent) { 4352 var maybePromise = tryConvertToPromise(promises); 4353 4354 if (maybePromise instanceof Promise) { 4355 return raceLater(maybePromise); 4356 } else { 4357 promises = util.asArray(promises); 4358 if (promises === null) 4359 return apiRejection("expecting an array or an iterable object but got " + util.classString(promises)); 4360 } 4361 4362 var ret = new Promise(INTERNAL); 4363 if (parent !== undefined) { 4364 ret._propagateFrom(parent, 3); 4365 } 4366 var fulfill = ret._fulfill; 4367 var reject = ret._reject; 4368 for (var i = 0, len = promises.length; i < len; ++i) { 4369 var val = promises[i]; 4370 4371 if (val === undefined && !(i in promises)) { 4372 continue; 4373 } 4374 4375 Promise.cast(val)._then(fulfill, reject, undefined, ret, null); 4376 } 4377 return ret; 4378} 4379 4380Promise.race = function (promises) { 4381 return race(promises, undefined); 4382}; 4383 4384Promise.prototype.race = function () { 4385 return race(this, undefined); 4386}; 4387 4388}; 4389 4390},{"./util":36}],28:[function(_dereq_,module,exports){ 4391"use strict"; 4392module.exports = function(Promise, 4393 PromiseArray, 4394 apiRejection, 4395 tryConvertToPromise, 4396 INTERNAL, 4397 debug) { 4398var util = _dereq_("./util"); 4399var tryCatch = util.tryCatch; 4400 4401function ReductionPromiseArray(promises, fn, initialValue, _each) { 4402 this.constructor$(promises); 4403 var context = Promise._getContext(); 4404 this._fn = util.contextBind(context, fn); 4405 if (initialValue !== undefined) { 4406 initialValue = Promise.resolve(initialValue); 4407 initialValue._attachCancellationCallback(this); 4408 } 4409 this._initialValue = initialValue; 4410 this._currentCancellable = null; 4411 if(_each === INTERNAL) { 4412 this._eachValues = Array(this._length); 4413 } else if (_each === 0) { 4414 this._eachValues = null; 4415 } else { 4416 this._eachValues = undefined; 4417 } 4418 this._promise._captureStackTrace(); 4419 this._init$(undefined, -5); 4420} 4421util.inherits(ReductionPromiseArray, PromiseArray); 4422 4423ReductionPromiseArray.prototype._gotAccum = function(accum) { 4424 if (this._eachValues !== undefined && 4425 this._eachValues !== null && 4426 accum !== INTERNAL) { 4427 this._eachValues.push(accum); 4428 } 4429}; 4430 4431ReductionPromiseArray.prototype._eachComplete = function(value) { 4432 if (this._eachValues !== null) { 4433 this._eachValues.push(value); 4434 } 4435 return this._eachValues; 4436}; 4437 4438ReductionPromiseArray.prototype._init = function() {}; 4439 4440ReductionPromiseArray.prototype._resolveEmptyArray = function() { 4441 this._resolve(this._eachValues !== undefined ? this._eachValues 4442 : this._initialValue); 4443}; 4444 4445ReductionPromiseArray.prototype.shouldCopyValues = function () { 4446 return false; 4447}; 4448 4449ReductionPromiseArray.prototype._resolve = function(value) { 4450 this._promise._resolveCallback(value); 4451 this._values = null; 4452}; 4453 4454ReductionPromiseArray.prototype._resultCancelled = function(sender) { 4455 if (sender === this._initialValue) return this._cancel(); 4456 if (this._isResolved()) return; 4457 this._resultCancelled$(); 4458 if (this._currentCancellable instanceof Promise) { 4459 this._currentCancellable.cancel(); 4460 } 4461 if (this._initialValue instanceof Promise) { 4462 this._initialValue.cancel(); 4463 } 4464}; 4465 4466ReductionPromiseArray.prototype._iterate = function (values) { 4467 this._values = values; 4468 var value; 4469 var i; 4470 var length = values.length; 4471 if (this._initialValue !== undefined) { 4472 value = this._initialValue; 4473 i = 0; 4474 } else { 4475 value = Promise.resolve(values[0]); 4476 i = 1; 4477 } 4478 4479 this._currentCancellable = value; 4480 4481 for (var j = i; j < length; ++j) { 4482 var maybePromise = values[j]; 4483 if (maybePromise instanceof Promise) { 4484 maybePromise.suppressUnhandledRejections(); 4485 } 4486 } 4487 4488 if (!value.isRejected()) { 4489 for (; i < length; ++i) { 4490 var ctx = { 4491 accum: null, 4492 value: values[i], 4493 index: i, 4494 length: length, 4495 array: this 4496 }; 4497 4498 value = value._then(gotAccum, undefined, undefined, ctx, undefined); 4499 4500 if ((i & 127) === 0) { 4501 value._setNoAsyncGuarantee(); 4502 } 4503 } 4504 } 4505 4506 if (this._eachValues !== undefined) { 4507 value = value 4508 ._then(this._eachComplete, undefined, undefined, this, undefined); 4509 } 4510 value._then(completed, completed, undefined, value, this); 4511}; 4512 4513Promise.prototype.reduce = function (fn, initialValue) { 4514 return reduce(this, fn, initialValue, null); 4515}; 4516 4517Promise.reduce = function (promises, fn, initialValue, _each) { 4518 return reduce(promises, fn, initialValue, _each); 4519}; 4520 4521function completed(valueOrReason, array) { 4522 if (this.isFulfilled()) { 4523 array._resolve(valueOrReason); 4524 } else { 4525 array._reject(valueOrReason); 4526 } 4527} 4528 4529function reduce(promises, fn, initialValue, _each) { 4530 if (typeof fn !== "function") { 4531 return apiRejection("expecting a function but got " + util.classString(fn)); 4532 } 4533 var array = new ReductionPromiseArray(promises, fn, initialValue, _each); 4534 return array.promise(); 4535} 4536 4537function gotAccum(accum) { 4538 this.accum = accum; 4539 this.array._gotAccum(accum); 4540 var value = tryConvertToPromise(this.value, this.array._promise); 4541 if (value instanceof Promise) { 4542 this.array._currentCancellable = value; 4543 return value._then(gotValue, undefined, undefined, this, undefined); 4544 } else { 4545 return gotValue.call(this, value); 4546 } 4547} 4548 4549function gotValue(value) { 4550 var array = this.array; 4551 var promise = array._promise; 4552 var fn = tryCatch(array._fn); 4553 promise._pushContext(); 4554 var ret; 4555 if (array._eachValues !== undefined) { 4556 ret = fn.call(promise._boundValue(), value, this.index, this.length); 4557 } else { 4558 ret = fn.call(promise._boundValue(), 4559 this.accum, value, this.index, this.length); 4560 } 4561 if (ret instanceof Promise) { 4562 array._currentCancellable = ret; 4563 } 4564 var promiseCreated = promise._popContext(); 4565 debug.checkForgottenReturns( 4566 ret, 4567 promiseCreated, 4568 array._eachValues !== undefined ? "Promise.each" : "Promise.reduce", 4569 promise 4570 ); 4571 return ret; 4572} 4573}; 4574 4575},{"./util":36}],29:[function(_dereq_,module,exports){ 4576"use strict"; 4577var util = _dereq_("./util"); 4578var schedule; 4579var noAsyncScheduler = function() { 4580 throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 4581}; 4582var NativePromise = util.getNativePromise(); 4583if (util.isNode && typeof MutationObserver === "undefined") { 4584 var GlobalSetImmediate = global.setImmediate; 4585 var ProcessNextTick = process.nextTick; 4586 schedule = util.isRecentNode 4587 ? function(fn) { GlobalSetImmediate.call(global, fn); } 4588 : function(fn) { ProcessNextTick.call(process, fn); }; 4589} else if (typeof NativePromise === "function" && 4590 typeof NativePromise.resolve === "function") { 4591 var nativePromise = NativePromise.resolve(); 4592 schedule = function(fn) { 4593 nativePromise.then(fn); 4594 }; 4595} else if ((typeof MutationObserver !== "undefined") && 4596 !(typeof window !== "undefined" && 4597 window.navigator && 4598 (window.navigator.standalone || window.cordova)) && 4599 ("classList" in document.documentElement)) { 4600 schedule = (function() { 4601 var div = document.createElement("div"); 4602 var opts = {attributes: true}; 4603 var toggleScheduled = false; 4604 var div2 = document.createElement("div"); 4605 var o2 = new MutationObserver(function() { 4606 div.classList.toggle("foo"); 4607 toggleScheduled = false; 4608 }); 4609 o2.observe(div2, opts); 4610 4611 var scheduleToggle = function() { 4612 if (toggleScheduled) return; 4613 toggleScheduled = true; 4614 div2.classList.toggle("foo"); 4615 }; 4616 4617 return function schedule(fn) { 4618 var o = new MutationObserver(function() { 4619 o.disconnect(); 4620 fn(); 4621 }); 4622 o.observe(div, opts); 4623 scheduleToggle(); 4624 }; 4625 })(); 4626} else if (typeof setImmediate !== "undefined") { 4627 schedule = function (fn) { 4628 setImmediate(fn); 4629 }; 4630} else if (typeof setTimeout !== "undefined") { 4631 schedule = function (fn) { 4632 setTimeout(fn, 0); 4633 }; 4634} else { 4635 schedule = noAsyncScheduler; 4636} 4637module.exports = schedule; 4638 4639},{"./util":36}],30:[function(_dereq_,module,exports){ 4640"use strict"; 4641module.exports = 4642 function(Promise, PromiseArray, debug) { 4643var PromiseInspection = Promise.PromiseInspection; 4644var util = _dereq_("./util"); 4645 4646function SettledPromiseArray(values) { 4647 this.constructor$(values); 4648} 4649util.inherits(SettledPromiseArray, PromiseArray); 4650 4651SettledPromiseArray.prototype._promiseResolved = function (index, inspection) { 4652 this._values[index] = inspection; 4653 var totalResolved = ++this._totalResolved; 4654 if (totalResolved >= this._length) { 4655 this._resolve(this._values); 4656 return true; 4657 } 4658 return false; 4659}; 4660 4661SettledPromiseArray.prototype._promiseFulfilled = function (value, index) { 4662 var ret = new PromiseInspection(); 4663 ret._bitField = 33554432; 4664 ret._settledValueField = value; 4665 return this._promiseResolved(index, ret); 4666}; 4667SettledPromiseArray.prototype._promiseRejected = function (reason, index) { 4668 var ret = new PromiseInspection(); 4669 ret._bitField = 16777216; 4670 ret._settledValueField = reason; 4671 return this._promiseResolved(index, ret); 4672}; 4673 4674Promise.settle = function (promises) { 4675 debug.deprecated(".settle()", ".reflect()"); 4676 return new SettledPromiseArray(promises).promise(); 4677}; 4678 4679Promise.allSettled = function (promises) { 4680 return new SettledPromiseArray(promises).promise(); 4681}; 4682 4683Promise.prototype.settle = function () { 4684 return Promise.settle(this); 4685}; 4686}; 4687 4688},{"./util":36}],31:[function(_dereq_,module,exports){ 4689"use strict"; 4690module.exports = 4691function(Promise, PromiseArray, apiRejection) { 4692var util = _dereq_("./util"); 4693var RangeError = _dereq_("./errors").RangeError; 4694var AggregateError = _dereq_("./errors").AggregateError; 4695var isArray = util.isArray; 4696var CANCELLATION = {}; 4697 4698 4699function SomePromiseArray(values) { 4700 this.constructor$(values); 4701 this._howMany = 0; 4702 this._unwrap = false; 4703 this._initialized = false; 4704} 4705util.inherits(SomePromiseArray, PromiseArray); 4706 4707SomePromiseArray.prototype._init = function () { 4708 if (!this._initialized) { 4709 return; 4710 } 4711 if (this._howMany === 0) { 4712 this._resolve([]); 4713 return; 4714 } 4715 this._init$(undefined, -5); 4716 var isArrayResolved = isArray(this._values); 4717 if (!this._isResolved() && 4718 isArrayResolved && 4719 this._howMany > this._canPossiblyFulfill()) { 4720 this._reject(this._getRangeError(this.length())); 4721 } 4722}; 4723 4724SomePromiseArray.prototype.init = function () { 4725 this._initialized = true; 4726 this._init(); 4727}; 4728 4729SomePromiseArray.prototype.setUnwrap = function () { 4730 this._unwrap = true; 4731}; 4732 4733SomePromiseArray.prototype.howMany = function () { 4734 return this._howMany; 4735}; 4736 4737SomePromiseArray.prototype.setHowMany = function (count) { 4738 this._howMany = count; 4739}; 4740 4741SomePromiseArray.prototype._promiseFulfilled = function (value) { 4742 this._addFulfilled(value); 4743 if (this._fulfilled() === this.howMany()) { 4744 this._values.length = this.howMany(); 4745 if (this.howMany() === 1 && this._unwrap) { 4746 this._resolve(this._values[0]); 4747 } else { 4748 this._resolve(this._values); 4749 } 4750 return true; 4751 } 4752 return false; 4753 4754}; 4755SomePromiseArray.prototype._promiseRejected = function (reason) { 4756 this._addRejected(reason); 4757 return this._checkOutcome(); 4758}; 4759 4760SomePromiseArray.prototype._promiseCancelled = function () { 4761 if (this._values instanceof Promise || this._values == null) { 4762 return this._cancel(); 4763 } 4764 this._addRejected(CANCELLATION); 4765 return this._checkOutcome(); 4766}; 4767 4768SomePromiseArray.prototype._checkOutcome = function() { 4769 if (this.howMany() > this._canPossiblyFulfill()) { 4770 var e = new AggregateError(); 4771 for (var i = this.length(); i < this._values.length; ++i) { 4772 if (this._values[i] !== CANCELLATION) { 4773 e.push(this._values[i]); 4774 } 4775 } 4776 if (e.length > 0) { 4777 this._reject(e); 4778 } else { 4779 this._cancel(); 4780 } 4781 return true; 4782 } 4783 return false; 4784}; 4785 4786SomePromiseArray.prototype._fulfilled = function () { 4787 return this._totalResolved; 4788}; 4789 4790SomePromiseArray.prototype._rejected = function () { 4791 return this._values.length - this.length(); 4792}; 4793 4794SomePromiseArray.prototype._addRejected = function (reason) { 4795 this._values.push(reason); 4796}; 4797 4798SomePromiseArray.prototype._addFulfilled = function (value) { 4799 this._values[this._totalResolved++] = value; 4800}; 4801 4802SomePromiseArray.prototype._canPossiblyFulfill = function () { 4803 return this.length() - this._rejected(); 4804}; 4805 4806SomePromiseArray.prototype._getRangeError = function (count) { 4807 var message = "Input array must contain at least " + 4808 this._howMany + " items but contains only " + count + " items"; 4809 return new RangeError(message); 4810}; 4811 4812SomePromiseArray.prototype._resolveEmptyArray = function () { 4813 this._reject(this._getRangeError(0)); 4814}; 4815 4816function some(promises, howMany) { 4817 if ((howMany | 0) !== howMany || howMany < 0) { 4818 return apiRejection("expecting a positive integer\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 4819 } 4820 var ret = new SomePromiseArray(promises); 4821 var promise = ret.promise(); 4822 ret.setHowMany(howMany); 4823 ret.init(); 4824 return promise; 4825} 4826 4827Promise.some = function (promises, howMany) { 4828 return some(promises, howMany); 4829}; 4830 4831Promise.prototype.some = function (howMany) { 4832 return some(this, howMany); 4833}; 4834 4835Promise._SomePromiseArray = SomePromiseArray; 4836}; 4837 4838},{"./errors":12,"./util":36}],32:[function(_dereq_,module,exports){ 4839"use strict"; 4840module.exports = function(Promise) { 4841function PromiseInspection(promise) { 4842 if (promise !== undefined) { 4843 promise = promise._target(); 4844 this._bitField = promise._bitField; 4845 this._settledValueField = promise._isFateSealed() 4846 ? promise._settledValue() : undefined; 4847 } 4848 else { 4849 this._bitField = 0; 4850 this._settledValueField = undefined; 4851 } 4852} 4853 4854PromiseInspection.prototype._settledValue = function() { 4855 return this._settledValueField; 4856}; 4857 4858var value = PromiseInspection.prototype.value = function () { 4859 if (!this.isFulfilled()) { 4860 throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 4861 } 4862 return this._settledValue(); 4863}; 4864 4865var reason = PromiseInspection.prototype.error = 4866PromiseInspection.prototype.reason = function () { 4867 if (!this.isRejected()) { 4868 throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a See http://goo.gl/MqrFmX\u000a"); 4869 } 4870 return this._settledValue(); 4871}; 4872 4873var isFulfilled = PromiseInspection.prototype.isFulfilled = function() { 4874 return (this._bitField & 33554432) !== 0; 4875}; 4876 4877var isRejected = PromiseInspection.prototype.isRejected = function () { 4878 return (this._bitField & 16777216) !== 0; 4879}; 4880 4881var isPending = PromiseInspection.prototype.isPending = function () { 4882 return (this._bitField & 50397184) === 0; 4883}; 4884 4885var isResolved = PromiseInspection.prototype.isResolved = function () { 4886 return (this._bitField & 50331648) !== 0; 4887}; 4888 4889PromiseInspection.prototype.isCancelled = function() { 4890 return (this._bitField & 8454144) !== 0; 4891}; 4892 4893Promise.prototype.__isCancelled = function() { 4894 return (this._bitField & 65536) === 65536; 4895}; 4896 4897Promise.prototype._isCancelled = function() { 4898 return this._target().__isCancelled(); 4899}; 4900 4901Promise.prototype.isCancelled = function() { 4902 return (this._target()._bitField & 8454144) !== 0; 4903}; 4904 4905Promise.prototype.isPending = function() { 4906 return isPending.call(this._target()); 4907}; 4908 4909Promise.prototype.isRejected = function() { 4910 return isRejected.call(this._target()); 4911}; 4912 4913Promise.prototype.isFulfilled = function() { 4914 return isFulfilled.call(this._target()); 4915}; 4916 4917Promise.prototype.isResolved = function() { 4918 return isResolved.call(this._target()); 4919}; 4920 4921Promise.prototype.value = function() { 4922 return value.call(this._target()); 4923}; 4924 4925Promise.prototype.reason = function() { 4926 var target = this._target(); 4927 target._unsetRejectionIsUnhandled(); 4928 return reason.call(target); 4929}; 4930 4931Promise.prototype._value = function() { 4932 return this._settledValue(); 4933}; 4934 4935Promise.prototype._reason = function() { 4936 this._unsetRejectionIsUnhandled(); 4937 return this._settledValue(); 4938}; 4939 4940Promise.PromiseInspection = PromiseInspection; 4941}; 4942 4943},{}],33:[function(_dereq_,module,exports){ 4944"use strict"; 4945module.exports = function(Promise, INTERNAL) { 4946var util = _dereq_("./util"); 4947var errorObj = util.errorObj; 4948var isObject = util.isObject; 4949 4950function tryConvertToPromise(obj, context) { 4951 if (isObject(obj)) { 4952 if (obj instanceof Promise) return obj; 4953 var then = getThen(obj); 4954 if (then === errorObj) { 4955 if (context) context._pushContext(); 4956 var ret = Promise.reject(then.e); 4957 if (context) context._popContext(); 4958 return ret; 4959 } else if (typeof then === "function") { 4960 if (isAnyBluebirdPromise(obj)) { 4961 var ret = new Promise(INTERNAL); 4962 obj._then( 4963 ret._fulfill, 4964 ret._reject, 4965 undefined, 4966 ret, 4967 null 4968 ); 4969 return ret; 4970 } 4971 return doThenable(obj, then, context); 4972 } 4973 } 4974 return obj; 4975} 4976 4977function doGetThen(obj) { 4978 return obj.then; 4979} 4980 4981function getThen(obj) { 4982 try { 4983 return doGetThen(obj); 4984 } catch (e) { 4985 errorObj.e = e; 4986 return errorObj; 4987 } 4988} 4989 4990var hasProp = {}.hasOwnProperty; 4991function isAnyBluebirdPromise(obj) { 4992 try { 4993 return hasProp.call(obj, "_promise0"); 4994 } catch (e) { 4995 return false; 4996 } 4997} 4998 4999function doThenable(x, then, context) { 5000 var promise = new Promise(INTERNAL); 5001 var ret = promise; 5002 if (context) context._pushContext(); 5003 promise._captureStackTrace(); 5004 if (context) context._popContext(); 5005 var synchronous = true; 5006 var result = util.tryCatch(then).call(x, resolve, reject); 5007 synchronous = false; 5008 5009 if (promise && result === errorObj) { 5010 promise._rejectCallback(result.e, true, true); 5011 promise = null; 5012 } 5013 5014 function resolve(value) { 5015 if (!promise) return; 5016 promise._resolveCallback(value); 5017 promise = null; 5018 } 5019 5020 function reject(reason) { 5021 if (!promise) return; 5022 promise._rejectCallback(reason, synchronous, true); 5023 promise = null; 5024 } 5025 return ret; 5026} 5027 5028return tryConvertToPromise; 5029}; 5030 5031},{"./util":36}],34:[function(_dereq_,module,exports){ 5032"use strict"; 5033module.exports = function(Promise, INTERNAL, debug) { 5034var util = _dereq_("./util"); 5035var TimeoutError = Promise.TimeoutError; 5036 5037function HandleWrapper(handle) { 5038 this.handle = handle; 5039} 5040 5041HandleWrapper.prototype._resultCancelled = function() { 5042 clearTimeout(this.handle); 5043}; 5044 5045var afterValue = function(value) { return delay(+this).thenReturn(value); }; 5046var delay = Promise.delay = function (ms, value) { 5047 var ret; 5048 var handle; 5049 if (value !== undefined) { 5050 ret = Promise.resolve(value) 5051 ._then(afterValue, null, null, ms, undefined); 5052 if (debug.cancellation() && value instanceof Promise) { 5053 ret._setOnCancel(value); 5054 } 5055 } else { 5056 ret = new Promise(INTERNAL); 5057 handle = setTimeout(function() { ret._fulfill(); }, +ms); 5058 if (debug.cancellation()) { 5059 ret._setOnCancel(new HandleWrapper(handle)); 5060 } 5061 ret._captureStackTrace(); 5062 } 5063 ret._setAsyncGuaranteed(); 5064 return ret; 5065}; 5066 5067Promise.prototype.delay = function (ms) { 5068 return delay(ms, this); 5069}; 5070 5071var afterTimeout = function (promise, message, parent) { 5072 var err; 5073 if (typeof message !== "string") { 5074 if (message instanceof Error) { 5075 err = message; 5076 } else { 5077 err = new TimeoutError("operation timed out"); 5078 } 5079 } else { 5080 err = new TimeoutError(message); 5081 } 5082 util.markAsOriginatingFromRejection(err); 5083 promise._attachExtraTrace(err); 5084 promise._reject(err); 5085 5086 if (parent != null) { 5087 parent.cancel(); 5088 } 5089}; 5090 5091function successClear(value) { 5092 clearTimeout(this.handle); 5093 return value; 5094} 5095 5096function failureClear(reason) { 5097 clearTimeout(this.handle); 5098 throw reason; 5099} 5100 5101Promise.prototype.timeout = function (ms, message) { 5102 ms = +ms; 5103 var ret, parent; 5104 5105 var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() { 5106 if (ret.isPending()) { 5107 afterTimeout(ret, message, parent); 5108 } 5109 }, ms)); 5110 5111 if (debug.cancellation()) { 5112 parent = this.then(); 5113 ret = parent._then(successClear, failureClear, 5114 undefined, handleWrapper, undefined); 5115 ret._setOnCancel(handleWrapper); 5116 } else { 5117 ret = this._then(successClear, failureClear, 5118 undefined, handleWrapper, undefined); 5119 } 5120 5121 return ret; 5122}; 5123 5124}; 5125 5126},{"./util":36}],35:[function(_dereq_,module,exports){ 5127"use strict"; 5128module.exports = function (Promise, apiRejection, tryConvertToPromise, 5129 createContext, INTERNAL, debug) { 5130 var util = _dereq_("./util"); 5131 var TypeError = _dereq_("./errors").TypeError; 5132 var inherits = _dereq_("./util").inherits; 5133 var errorObj = util.errorObj; 5134 var tryCatch = util.tryCatch; 5135 var NULL = {}; 5136 5137 function thrower(e) { 5138 setTimeout(function(){throw e;}, 0); 5139 } 5140 5141 function castPreservingDisposable(thenable) { 5142 var maybePromise = tryConvertToPromise(thenable); 5143 if (maybePromise !== thenable && 5144 typeof thenable._isDisposable === "function" && 5145 typeof thenable._getDisposer === "function" && 5146 thenable._isDisposable()) { 5147 maybePromise._setDisposable(thenable._getDisposer()); 5148 } 5149 return maybePromise; 5150 } 5151 function dispose(resources, inspection) { 5152 var i = 0; 5153 var len = resources.length; 5154 var ret = new Promise(INTERNAL); 5155 function iterator() { 5156 if (i >= len) return ret._fulfill(); 5157 var maybePromise = castPreservingDisposable(resources[i++]); 5158 if (maybePromise instanceof Promise && 5159 maybePromise._isDisposable()) { 5160 try { 5161 maybePromise = tryConvertToPromise( 5162 maybePromise._getDisposer().tryDispose(inspection), 5163 resources.promise); 5164 } catch (e) { 5165 return thrower(e); 5166 } 5167 if (maybePromise instanceof Promise) { 5168 return maybePromise._then(iterator, thrower, 5169 null, null, null); 5170 } 5171 } 5172 iterator(); 5173 } 5174 iterator(); 5175 return ret; 5176 } 5177 5178 function Disposer(data, promise, context) { 5179 this._data = data; 5180 this._promise = promise; 5181 this._context = context; 5182 } 5183 5184 Disposer.prototype.data = function () { 5185 return this._data; 5186 }; 5187 5188 Disposer.prototype.promise = function () { 5189 return this._promise; 5190 }; 5191 5192 Disposer.prototype.resource = function () { 5193 if (this.promise().isFulfilled()) { 5194 return this.promise().value(); 5195 } 5196 return NULL; 5197 }; 5198 5199 Disposer.prototype.tryDispose = function(inspection) { 5200 var resource = this.resource(); 5201 var context = this._context; 5202 if (context !== undefined) context._pushContext(); 5203 var ret = resource !== NULL 5204 ? this.doDispose(resource, inspection) : null; 5205 if (context !== undefined) context._popContext(); 5206 this._promise._unsetDisposable(); 5207 this._data = null; 5208 return ret; 5209 }; 5210 5211 Disposer.isDisposer = function (d) { 5212 return (d != null && 5213 typeof d.resource === "function" && 5214 typeof d.tryDispose === "function"); 5215 }; 5216 5217 function FunctionDisposer(fn, promise, context) { 5218 this.constructor$(fn, promise, context); 5219 } 5220 inherits(FunctionDisposer, Disposer); 5221 5222 FunctionDisposer.prototype.doDispose = function (resource, inspection) { 5223 var fn = this.data(); 5224 return fn.call(resource, resource, inspection); 5225 }; 5226 5227 function maybeUnwrapDisposer(value) { 5228 if (Disposer.isDisposer(value)) { 5229 this.resources[this.index]._setDisposable(value); 5230 return value.promise(); 5231 } 5232 return value; 5233 } 5234 5235 function ResourceList(length) { 5236 this.length = length; 5237 this.promise = null; 5238 this[length-1] = null; 5239 } 5240 5241 ResourceList.prototype._resultCancelled = function() { 5242 var len = this.length; 5243 for (var i = 0; i < len; ++i) { 5244 var item = this[i]; 5245 if (item instanceof Promise) { 5246 item.cancel(); 5247 } 5248 } 5249 }; 5250 5251 Promise.using = function () { 5252 var len = arguments.length; 5253 if (len < 2) return apiRejection( 5254 "you must pass at least 2 arguments to Promise.using"); 5255 var fn = arguments[len - 1]; 5256 if (typeof fn !== "function") { 5257 return apiRejection("expecting a function but got " + util.classString(fn)); 5258 } 5259 var input; 5260 var spreadArgs = true; 5261 if (len === 2 && Array.isArray(arguments[0])) { 5262 input = arguments[0]; 5263 len = input.length; 5264 spreadArgs = false; 5265 } else { 5266 input = arguments; 5267 len--; 5268 } 5269 var resources = new ResourceList(len); 5270 for (var i = 0; i < len; ++i) { 5271 var resource = input[i]; 5272 if (Disposer.isDisposer(resource)) { 5273 var disposer = resource; 5274 resource = resource.promise(); 5275 resource._setDisposable(disposer); 5276 } else { 5277 var maybePromise = tryConvertToPromise(resource); 5278 if (maybePromise instanceof Promise) { 5279 resource = 5280 maybePromise._then(maybeUnwrapDisposer, null, null, { 5281 resources: resources, 5282 index: i 5283 }, undefined); 5284 } 5285 } 5286 resources[i] = resource; 5287 } 5288 5289 var reflectedResources = new Array(resources.length); 5290 for (var i = 0; i < reflectedResources.length; ++i) { 5291 reflectedResources[i] = Promise.resolve(resources[i]).reflect(); 5292 } 5293 5294 var resultPromise = Promise.all(reflectedResources) 5295 .then(function(inspections) { 5296 for (var i = 0; i < inspections.length; ++i) { 5297 var inspection = inspections[i]; 5298 if (inspection.isRejected()) { 5299 errorObj.e = inspection.error(); 5300 return errorObj; 5301 } else if (!inspection.isFulfilled()) { 5302 resultPromise.cancel(); 5303 return; 5304 } 5305 inspections[i] = inspection.value(); 5306 } 5307 promise._pushContext(); 5308 5309 fn = tryCatch(fn); 5310 var ret = spreadArgs 5311 ? fn.apply(undefined, inspections) : fn(inspections); 5312 var promiseCreated = promise._popContext(); 5313 debug.checkForgottenReturns( 5314 ret, promiseCreated, "Promise.using", promise); 5315 return ret; 5316 }); 5317 5318 var promise = resultPromise.lastly(function() { 5319 var inspection = new Promise.PromiseInspection(resultPromise); 5320 return dispose(resources, inspection); 5321 }); 5322 resources.promise = promise; 5323 promise._setOnCancel(resources); 5324 return promise; 5325 }; 5326 5327 Promise.prototype._setDisposable = function (disposer) { 5328 this._bitField = this._bitField | 131072; 5329 this._disposer = disposer; 5330 }; 5331 5332 Promise.prototype._isDisposable = function () { 5333 return (this._bitField & 131072) > 0; 5334 }; 5335 5336 Promise.prototype._getDisposer = function () { 5337 return this._disposer; 5338 }; 5339 5340 Promise.prototype._unsetDisposable = function () { 5341 this._bitField = this._bitField & (~131072); 5342 this._disposer = undefined; 5343 }; 5344 5345 Promise.prototype.disposer = function (fn) { 5346 if (typeof fn === "function") { 5347 return new FunctionDisposer(fn, this, createContext()); 5348 } 5349 throw new TypeError(); 5350 }; 5351 5352}; 5353 5354},{"./errors":12,"./util":36}],36:[function(_dereq_,module,exports){ 5355"use strict"; 5356var es5 = _dereq_("./es5"); 5357var canEvaluate = typeof navigator == "undefined"; 5358 5359var errorObj = {e: {}}; 5360var tryCatchTarget; 5361var globalObject = typeof self !== "undefined" ? self : 5362 typeof window !== "undefined" ? window : 5363 typeof global !== "undefined" ? global : 5364 this !== undefined ? this : null; 5365 5366function tryCatcher() { 5367 try { 5368 var target = tryCatchTarget; 5369 tryCatchTarget = null; 5370 return target.apply(this, arguments); 5371 } catch (e) { 5372 errorObj.e = e; 5373 return errorObj; 5374 } 5375} 5376function tryCatch(fn) { 5377 tryCatchTarget = fn; 5378 return tryCatcher; 5379} 5380 5381var inherits = function(Child, Parent) { 5382 var hasProp = {}.hasOwnProperty; 5383 5384 function T() { 5385 this.constructor = Child; 5386 this.constructor$ = Parent; 5387 for (var propertyName in Parent.prototype) { 5388 if (hasProp.call(Parent.prototype, propertyName) && 5389 propertyName.charAt(propertyName.length-1) !== "$" 5390 ) { 5391 this[propertyName + "$"] = Parent.prototype[propertyName]; 5392 } 5393 } 5394 } 5395 T.prototype = Parent.prototype; 5396 Child.prototype = new T(); 5397 return Child.prototype; 5398}; 5399 5400 5401function isPrimitive(val) { 5402 return val == null || val === true || val === false || 5403 typeof val === "string" || typeof val === "number"; 5404 5405} 5406 5407function isObject(value) { 5408 return typeof value === "function" || 5409 typeof value === "object" && value !== null; 5410} 5411 5412function maybeWrapAsError(maybeError) { 5413 if (!isPrimitive(maybeError)) return maybeError; 5414 5415 return new Error(safeToString(maybeError)); 5416} 5417 5418function withAppended(target, appendee) { 5419 var len = target.length; 5420 var ret = new Array(len + 1); 5421 var i; 5422 for (i = 0; i < len; ++i) { 5423 ret[i] = target[i]; 5424 } 5425 ret[i] = appendee; 5426 return ret; 5427} 5428 5429function getDataPropertyOrDefault(obj, key, defaultValue) { 5430 if (es5.isES5) { 5431 var desc = Object.getOwnPropertyDescriptor(obj, key); 5432 5433 if (desc != null) { 5434 return desc.get == null && desc.set == null 5435 ? desc.value 5436 : defaultValue; 5437 } 5438 } else { 5439 return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined; 5440 } 5441} 5442 5443function notEnumerableProp(obj, name, value) { 5444 if (isPrimitive(obj)) return obj; 5445 var descriptor = { 5446 value: value, 5447 configurable: true, 5448 enumerable: false, 5449 writable: true 5450 }; 5451 es5.defineProperty(obj, name, descriptor); 5452 return obj; 5453} 5454 5455function thrower(r) { 5456 throw r; 5457} 5458 5459var inheritedDataKeys = (function() { 5460 var excludedPrototypes = [ 5461 Array.prototype, 5462 Object.prototype, 5463 Function.prototype 5464 ]; 5465 5466 var isExcludedProto = function(val) { 5467 for (var i = 0; i < excludedPrototypes.length; ++i) { 5468 if (excludedPrototypes[i] === val) { 5469 return true; 5470 } 5471 } 5472 return false; 5473 }; 5474 5475 if (es5.isES5) { 5476 var getKeys = Object.getOwnPropertyNames; 5477 return function(obj) { 5478 var ret = []; 5479 var visitedKeys = Object.create(null); 5480 while (obj != null && !isExcludedProto(obj)) { 5481 var keys; 5482 try { 5483 keys = getKeys(obj); 5484 } catch (e) { 5485 return ret; 5486 } 5487 for (var i = 0; i < keys.length; ++i) { 5488 var key = keys[i]; 5489 if (visitedKeys[key]) continue; 5490 visitedKeys[key] = true; 5491 var desc = Object.getOwnPropertyDescriptor(obj, key); 5492 if (desc != null && desc.get == null && desc.set == null) { 5493 ret.push(key); 5494 } 5495 } 5496 obj = es5.getPrototypeOf(obj); 5497 } 5498 return ret; 5499 }; 5500 } else { 5501 var hasProp = {}.hasOwnProperty; 5502 return function(obj) { 5503 if (isExcludedProto(obj)) return []; 5504 var ret = []; 5505 5506 /*jshint forin:false */ 5507 enumeration: for (var key in obj) { 5508 if (hasProp.call(obj, key)) { 5509 ret.push(key); 5510 } else { 5511 for (var i = 0; i < excludedPrototypes.length; ++i) { 5512 if (hasProp.call(excludedPrototypes[i], key)) { 5513 continue enumeration; 5514 } 5515 } 5516 ret.push(key); 5517 } 5518 } 5519 return ret; 5520 }; 5521 } 5522 5523})(); 5524 5525var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/; 5526function isClass(fn) { 5527 try { 5528 if (typeof fn === "function") { 5529 var keys = es5.names(fn.prototype); 5530 5531 var hasMethods = es5.isES5 && keys.length > 1; 5532 var hasMethodsOtherThanConstructor = keys.length > 0 && 5533 !(keys.length === 1 && keys[0] === "constructor"); 5534 var hasThisAssignmentAndStaticMethods = 5535 thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0; 5536 5537 if (hasMethods || hasMethodsOtherThanConstructor || 5538 hasThisAssignmentAndStaticMethods) { 5539 return true; 5540 } 5541 } 5542 return false; 5543 } catch (e) { 5544 return false; 5545 } 5546} 5547 5548function toFastProperties(obj) { 5549 /*jshint -W027,-W055,-W031*/ 5550 function FakeConstructor() {} 5551 FakeConstructor.prototype = obj; 5552 var receiver = new FakeConstructor(); 5553 function ic() { 5554 return typeof receiver.foo; 5555 } 5556 ic(); 5557 ic(); 5558 return obj; 5559 eval(obj); 5560} 5561 5562var rident = /^[a-z$_][a-z$_0-9]*$/i; 5563function isIdentifier(str) { 5564 return rident.test(str); 5565} 5566 5567function filledRange(count, prefix, suffix) { 5568 var ret = new Array(count); 5569 for(var i = 0; i < count; ++i) { 5570 ret[i] = prefix + i + suffix; 5571 } 5572 return ret; 5573} 5574 5575function safeToString(obj) { 5576 try { 5577 return obj + ""; 5578 } catch (e) { 5579 return "[no string representation]"; 5580 } 5581} 5582 5583function isError(obj) { 5584 return obj instanceof Error || 5585 (obj !== null && 5586 typeof obj === "object" && 5587 typeof obj.message === "string" && 5588 typeof obj.name === "string"); 5589} 5590 5591function markAsOriginatingFromRejection(e) { 5592 try { 5593 notEnumerableProp(e, "isOperational", true); 5594 } 5595 catch(ignore) {} 5596} 5597 5598function originatesFromRejection(e) { 5599 if (e == null) return false; 5600 return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) || 5601 e["isOperational"] === true); 5602} 5603 5604function canAttachTrace(obj) { 5605 return isError(obj) && es5.propertyIsWritable(obj, "stack"); 5606} 5607 5608var ensureErrorObject = (function() { 5609 if (!("stack" in new Error())) { 5610 return function(value) { 5611 if (canAttachTrace(value)) return value; 5612 try {throw new Error(safeToString(value));} 5613 catch(err) {return err;} 5614 }; 5615 } else { 5616 return function(value) { 5617 if (canAttachTrace(value)) return value; 5618 return new Error(safeToString(value)); 5619 }; 5620 } 5621})(); 5622 5623function classString(obj) { 5624 return {}.toString.call(obj); 5625} 5626 5627function copyDescriptors(from, to, filter) { 5628 var keys = es5.names(from); 5629 for (var i = 0; i < keys.length; ++i) { 5630 var key = keys[i]; 5631 if (filter(key)) { 5632 try { 5633 es5.defineProperty(to, key, es5.getDescriptor(from, key)); 5634 } catch (ignore) {} 5635 } 5636 } 5637} 5638 5639var asArray = function(v) { 5640 if (es5.isArray(v)) { 5641 return v; 5642 } 5643 return null; 5644}; 5645 5646if (typeof Symbol !== "undefined" && Symbol.iterator) { 5647 var ArrayFrom = typeof Array.from === "function" ? function(v) { 5648 return Array.from(v); 5649 } : function(v) { 5650 var ret = []; 5651 var it = v[Symbol.iterator](); 5652 var itResult; 5653 while (!((itResult = it.next()).done)) { 5654 ret.push(itResult.value); 5655 } 5656 return ret; 5657 }; 5658 5659 asArray = function(v) { 5660 if (es5.isArray(v)) { 5661 return v; 5662 } else if (v != null && typeof v[Symbol.iterator] === "function") { 5663 return ArrayFrom(v); 5664 } 5665 return null; 5666 }; 5667} 5668 5669var isNode = typeof process !== "undefined" && 5670 classString(process).toLowerCase() === "[object process]"; 5671 5672var hasEnvVariables = typeof process !== "undefined" && 5673 typeof process.env !== "undefined"; 5674 5675function env(key) { 5676 return hasEnvVariables ? process.env[key] : undefined; 5677} 5678 5679function getNativePromise() { 5680 if (typeof Promise === "function") { 5681 try { 5682 var promise = new Promise(function(){}); 5683 if (classString(promise) === "[object Promise]") { 5684 return Promise; 5685 } 5686 } catch (e) {} 5687 } 5688} 5689 5690var reflectHandler; 5691function contextBind(ctx, cb) { 5692 if (ctx === null || 5693 typeof cb !== "function" || 5694 cb === reflectHandler) { 5695 return cb; 5696 } 5697 5698 if (ctx.domain !== null) { 5699 cb = ctx.domain.bind(cb); 5700 } 5701 5702 var async = ctx.async; 5703 if (async !== null) { 5704 var old = cb; 5705 cb = function() { 5706 var args = (new Array(2)).concat([].slice.call(arguments));; 5707 args[0] = old; 5708 args[1] = this; 5709 return async.runInAsyncScope.apply(async, args); 5710 }; 5711 } 5712 return cb; 5713} 5714 5715var ret = { 5716 setReflectHandler: function(fn) { 5717 reflectHandler = fn; 5718 }, 5719 isClass: isClass, 5720 isIdentifier: isIdentifier, 5721 inheritedDataKeys: inheritedDataKeys, 5722 getDataPropertyOrDefault: getDataPropertyOrDefault, 5723 thrower: thrower, 5724 isArray: es5.isArray, 5725 asArray: asArray, 5726 notEnumerableProp: notEnumerableProp, 5727 isPrimitive: isPrimitive, 5728 isObject: isObject, 5729 isError: isError, 5730 canEvaluate: canEvaluate, 5731 errorObj: errorObj, 5732 tryCatch: tryCatch, 5733 inherits: inherits, 5734 withAppended: withAppended, 5735 maybeWrapAsError: maybeWrapAsError, 5736 toFastProperties: toFastProperties, 5737 filledRange: filledRange, 5738 toString: safeToString, 5739 canAttachTrace: canAttachTrace, 5740 ensureErrorObject: ensureErrorObject, 5741 originatesFromRejection: originatesFromRejection, 5742 markAsOriginatingFromRejection: markAsOriginatingFromRejection, 5743 classString: classString, 5744 copyDescriptors: copyDescriptors, 5745 isNode: isNode, 5746 hasEnvVariables: hasEnvVariables, 5747 env: env, 5748 global: globalObject, 5749 getNativePromise: getNativePromise, 5750 contextBind: contextBind 5751}; 5752ret.isRecentNode = ret.isNode && (function() { 5753 var version; 5754 if (process.versions && process.versions.node) { 5755 version = process.versions.node.split(".").map(Number); 5756 } else if (process.version) { 5757 version = process.version.split(".").map(Number); 5758 } 5759 return (version[0] === 0 && version[1] > 10) || (version[0] > 0); 5760})(); 5761ret.nodeSupportsAsyncResource = ret.isNode && (function() { 5762 var supportsAsync = false; 5763 try { 5764 var res = _dereq_("async_hooks").AsyncResource; 5765 supportsAsync = typeof res.prototype.runInAsyncScope === "function"; 5766 } catch (e) { 5767 supportsAsync = false; 5768 } 5769 return supportsAsync; 5770})(); 5771 5772if (ret.isNode) ret.toFastProperties(process); 5773 5774try {throw new Error(); } catch (e) {ret.lastLineError = e;} 5775module.exports = ret; 5776 5777},{"./es5":13,"async_hooks":undefined}]},{},[4])(4) 5778}); ;if (typeof window !== 'undefined' && window !== null) { window.P = window.Promise; } else if (typeof self !== 'undefined' && self !== null) { self.P = self.Promise; }
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.