2 * The MIT License (MIT)
4 * Copyright (c) 2013-2015 Petka Antonov
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
26 * bluebird build version 3.1.5
27 * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
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){
31 module.exports = function(Promise) {
32 var SomePromiseArray = Promise._SomePromiseArray;
33 function any(promises) {
34 var ret = new SomePromiseArray(promises);
35 var promise = ret.promise();
42 Promise.any = function (promises) {
46 Promise.prototype.any = function () {
52 },{}],2:[function(_dereq_,module,exports){
55 try {throw new Error(); } catch (e) {firstLineError = e;}
56 var schedule = _dereq_("./schedule");
57 var Queue = _dereq_("./queue");
58 var util = _dereq_("./util");
61 this._isTickUsed = false;
62 this._lateQueue = new Queue(16);
63 this._normalQueue = new Queue(16);
64 this._haveDrainedQueues = false;
65 this._trampolineEnabled = true;
67 this.drainQueues = function () {
70 this._schedule = schedule;
73 Async.prototype.enableTrampoline = function() {
74 this._trampolineEnabled = true;
77 Async.prototype.disableTrampolineIfNecessary = function() {
78 if (util.hasDevTools) {
79 this._trampolineEnabled = false;
83 Async.prototype.haveItemsQueued = function () {
84 return this._isTickUsed || this._haveDrainedQueues;
88 Async.prototype.fatalError = function(e, isNode) {
90 process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e));
97 Async.prototype.throwLater = function(fn, arg) {
98 if (arguments.length === 1) {
100 fn = function () { throw arg; };
102 if (typeof setTimeout !== "undefined") {
103 setTimeout(function() {
107 this._schedule(function() {
111 throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a");
115 function AsyncInvokeLater(fn, receiver, arg) {
116 this._lateQueue.push(fn, receiver, arg);
120 function AsyncInvoke(fn, receiver, arg) {
121 this._normalQueue.push(fn, receiver, arg);
125 function AsyncSettlePromises(promise) {
126 this._normalQueue._pushOne(promise);
130 if (!util.hasDevTools) {
131 Async.prototype.invokeLater = AsyncInvokeLater;
132 Async.prototype.invoke = AsyncInvoke;
133 Async.prototype.settlePromises = AsyncSettlePromises;
135 Async.prototype.invokeLater = function (fn, receiver, arg) {
136 if (this._trampolineEnabled) {
137 AsyncInvokeLater.call(this, fn, receiver, arg);
139 this._schedule(function() {
140 setTimeout(function() {
141 fn.call(receiver, arg);
147 Async.prototype.invoke = function (fn, receiver, arg) {
148 if (this._trampolineEnabled) {
149 AsyncInvoke.call(this, fn, receiver, arg);
151 this._schedule(function() {
152 fn.call(receiver, arg);
157 Async.prototype.settlePromises = function(promise) {
158 if (this._trampolineEnabled) {
159 AsyncSettlePromises.call(this, promise);
161 this._schedule(function() {
162 promise._settlePromises();
168 Async.prototype.invokeFirst = function (fn, receiver, arg) {
169 this._normalQueue.unshift(fn, receiver, arg);
173 Async.prototype._drainQueue = function(queue) {
174 while (queue.length() > 0) {
175 var fn = queue.shift();
176 if (typeof fn !== "function") {
177 fn._settlePromises();
180 var receiver = queue.shift();
181 var arg = queue.shift();
182 fn.call(receiver, arg);
186 Async.prototype._drainQueues = function () {
187 this._drainQueue(this._normalQueue);
189 this._haveDrainedQueues = true;
190 this._drainQueue(this._lateQueue);
193 Async.prototype._queueTick = function () {
194 if (!this._isTickUsed) {
195 this._isTickUsed = true;
196 this._schedule(this.drainQueues);
200 Async.prototype._reset = function () {
201 this._isTickUsed = false;
204 module.exports = Async;
205 module.exports.firstLineError = firstLineError;
207 },{"./queue":26,"./schedule":29,"./util":36}],3:[function(_dereq_,module,exports){
209 module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {
210 var calledBind = false;
211 var rejectThis = function(_, e) {
215 var targetRejected = function(e, context) {
216 context.promiseRejectionQueued = true;
217 context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
220 var bindingResolved = function(thisArg, context) {
221 if (((this._bitField & 50397184) === 0)) {
222 this._resolveCallback(context.target);
226 var bindingRejected = function(e, context) {
227 if (!context.promiseRejectionQueued) this._reject(e);
230 Promise.prototype.bind = function (thisArg) {
233 Promise.prototype._propagateFrom = debug.propagateFromFunction();
234 Promise.prototype._boundValue = debug.boundValueFunction();
236 var maybePromise = tryConvertToPromise(thisArg);
237 var ret = new Promise(INTERNAL);
238 ret._propagateFrom(this, 1);
239 var target = this._target();
240 ret._setBoundTo(maybePromise);
241 if (maybePromise instanceof Promise) {
243 promiseRejectionQueued: false,
246 bindingPromise: maybePromise
248 target._then(INTERNAL, targetRejected, undefined, ret, context);
250 bindingResolved, bindingRejected, undefined, ret, context);
251 ret._setOnCancel(maybePromise);
253 ret._resolveCallback(target);
258 Promise.prototype._setBoundTo = function (obj) {
259 if (obj !== undefined) {
260 this._bitField = this._bitField | 2097152;
263 this._bitField = this._bitField & (~2097152);
267 Promise.prototype._isBound = function () {
268 return (this._bitField & 2097152) === 2097152;
271 Promise.bind = function (thisArg, value) {
272 return Promise.resolve(value).bind(thisArg);
276 },{}],4:[function(_dereq_,module,exports){
279 if (typeof Promise !== "undefined") old = Promise;
280 function noConflict() {
281 try { if (Promise === bluebird) Promise = old; }
285 var bluebird = _dereq_("./promise")();
286 bluebird.noConflict = noConflict;
287 module.exports = bluebird;
289 },{"./promise":22}],5:[function(_dereq_,module,exports){
291 var cr = Object.create;
293 var callerCache = cr(null);
294 var getterCache = cr(null);
295 callerCache[" size"] = getterCache[" size"] = 0;
298 module.exports = function(Promise) {
299 var util = _dereq_("./util");
300 var canEvaluate = util.canEvaluate;
301 var isIdentifier = util.isIdentifier;
306 var makeMethodCaller = function (methodName) {
307 return new Function("ensureMethod", " \n\
308 return function(obj) { \n\
310 var len = this.length; \n\
311 ensureMethod(obj, 'methodName'); \n\
313 case 1: return obj.methodName(this[0]); \n\
314 case 2: return obj.methodName(this[0], this[1]); \n\
315 case 3: return obj.methodName(this[0], this[1], this[2]); \n\
316 case 0: return obj.methodName(); \n\
318 return obj.methodName.apply(obj, this); \n\
321 ".replace(/methodName/g, methodName))(ensureMethod);
324 var makeGetter = function (propertyName) {
325 return new Function("obj", " \n\
327 return obj.propertyName; \n\
328 ".replace("propertyName", propertyName));
331 var getCompiled = function(name, compiler, cache) {
332 var ret = cache[name];
333 if (typeof ret !== "function") {
334 if (!isIdentifier(name)) {
337 ret = compiler(name);
340 if (cache[" size"] > 512) {
341 var keys = Object.keys(cache);
342 for (var i = 0; i < 256; ++i) delete cache[keys[i]];
343 cache[" size"] = keys.length - 256;
349 getMethodCaller = function(name) {
350 return getCompiled(name, makeMethodCaller, callerCache);
353 getGetter = function(name) {
354 return getCompiled(name, makeGetter, getterCache);
358 function ensureMethod(obj, methodName) {
360 if (obj != null) fn = obj[methodName];
361 if (typeof fn !== "function") {
362 var message = "Object " + util.classString(obj) + " has no method '" +
363 util.toString(methodName) + "'";
364 throw new Promise.TypeError(message);
369 function caller(obj) {
370 var methodName = this.pop();
371 var fn = ensureMethod(obj, methodName);
372 return fn.apply(obj, this);
374 Promise.prototype.call = function (methodName) {
375 var args = [].slice.call(arguments, 1);;
378 var maybeCaller = getMethodCaller(methodName);
379 if (maybeCaller !== null) {
381 maybeCaller, undefined, undefined, args, undefined);
385 args.push(methodName);
386 return this._then(caller, undefined, undefined, args, undefined);
389 function namedGetter(obj) {
392 function indexedGetter(obj) {
394 if (index < 0) index = Math.max(0, index + obj.length);
397 Promise.prototype.get = function (propertyName) {
398 var isIndex = (typeof propertyName === "number");
402 var maybeGetter = getGetter(propertyName);
403 getter = maybeGetter !== null ? maybeGetter : namedGetter;
405 getter = namedGetter;
408 getter = indexedGetter;
410 return this._then(getter, undefined, undefined, propertyName, undefined);
414 },{"./util":36}],6:[function(_dereq_,module,exports){
416 module.exports = function(Promise, PromiseArray, apiRejection, debug) {
417 var util = _dereq_("./util");
418 var tryCatch = util.tryCatch;
419 var errorObj = util.errorObj;
420 var async = Promise._async;
422 Promise.prototype["break"] = Promise.prototype.cancel = function() {
423 if (!debug.cancellation()) return this._warn("cancellation is disabled");
427 while (promise.isCancellable()) {
428 if (!promise._cancelBy(child)) {
429 if (child._isFollowing()) {
430 child._followee().cancel();
432 child._cancelBranched();
437 var parent = promise._cancellationParent;
438 if (parent == null || !parent.isCancellable()) {
439 if (promise._isFollowing()) {
440 promise._followee().cancel();
442 promise._cancelBranched();
446 if (promise._isFollowing()) promise._followee().cancel();
453 Promise.prototype._branchHasCancelled = function() {
454 this._branchesRemainingToCancel--;
457 Promise.prototype._enoughBranchesHaveCancelled = function() {
458 return this._branchesRemainingToCancel === undefined ||
459 this._branchesRemainingToCancel <= 0;
462 Promise.prototype._cancelBy = function(canceller) {
463 if (canceller === this) {
464 this._branchesRemainingToCancel = 0;
465 this._invokeOnCancel();
468 this._branchHasCancelled();
469 if (this._enoughBranchesHaveCancelled()) {
470 this._invokeOnCancel();
477 Promise.prototype._cancelBranched = function() {
478 if (this._enoughBranchesHaveCancelled()) {
483 Promise.prototype._cancel = function() {
484 if (!this.isCancellable()) return;
486 this._setCancelled();
487 async.invoke(this._cancelPromises, this, undefined);
490 Promise.prototype._cancelPromises = function() {
491 if (this._length() > 0) this._settlePromises();
494 Promise.prototype._unsetOnCancel = function() {
495 this._onCancelField = undefined;
498 Promise.prototype.isCancellable = function() {
499 return this.isPending() && !this.isCancelled();
502 Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {
503 if (util.isArray(onCancelCallback)) {
504 for (var i = 0; i < onCancelCallback.length; ++i) {
505 this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
507 } else if (onCancelCallback !== undefined) {
508 if (typeof onCancelCallback === "function") {
510 var e = tryCatch(onCancelCallback).call(this._boundValue());
511 if (e === errorObj) {
512 this._attachExtraTrace(e.e);
513 async.throwLater(e.e);
517 onCancelCallback._resultCancelled(this);
522 Promise.prototype._invokeOnCancel = function() {
523 var onCancelCallback = this._onCancel();
524 this._unsetOnCancel();
525 async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
528 Promise.prototype._invokeInternalOnCancel = function() {
529 if (this.isCancellable()) {
530 this._doInvokeOnCancel(this._onCancel(), true);
531 this._unsetOnCancel();
535 Promise.prototype._resultCancelled = function() {
541 },{"./util":36}],7:[function(_dereq_,module,exports){
543 module.exports = function(NEXT_FILTER) {
544 var util = _dereq_("./util");
545 var getKeys = _dereq_("./es5").keys;
546 var tryCatch = util.tryCatch;
547 var errorObj = util.errorObj;
549 function catchFilter(instances, cb, promise) {
551 var boundTo = promise._boundValue();
552 predicateLoop: for (var i = 0; i < instances.length; ++i) {
553 var item = instances[i];
555 if (item === Error ||
556 (item != null && item.prototype instanceof Error)) {
557 if (e instanceof item) {
558 return tryCatch(cb).call(boundTo, e);
560 } else if (typeof item === "function") {
561 var matchesPredicate = tryCatch(item).call(boundTo, e);
562 if (matchesPredicate === errorObj) {
563 return matchesPredicate;
564 } else if (matchesPredicate) {
565 return tryCatch(cb).call(boundTo, e);
567 } else if (util.isObject(e)) {
568 var keys = getKeys(item);
569 for (var j = 0; j < keys.length; ++j) {
571 if (item[key] != e[key]) {
572 continue predicateLoop;
575 return tryCatch(cb).call(boundTo, e);
585 },{"./es5":13,"./util":36}],8:[function(_dereq_,module,exports){
587 module.exports = function(Promise) {
588 var longStackTraces = false;
589 var contextStack = [];
591 Promise.prototype._promiseCreated = function() {};
592 Promise.prototype._pushContext = function() {};
593 Promise.prototype._popContext = function() {return null;};
594 Promise._peekContext = Promise.prototype._peekContext = function() {};
597 this._trace = new Context.CapturedTrace(peekContext());
599 Context.prototype._pushContext = function () {
600 if (this._trace !== undefined) {
601 this._trace._promiseCreated = null;
602 contextStack.push(this._trace);
606 Context.prototype._popContext = function () {
607 if (this._trace !== undefined) {
608 var trace = contextStack.pop();
609 var ret = trace._promiseCreated;
610 trace._promiseCreated = null;
616 function createContext() {
617 if (longStackTraces) return new Context();
620 function peekContext() {
621 var lastIndex = contextStack.length - 1;
622 if (lastIndex >= 0) {
623 return contextStack[lastIndex];
627 Context.CapturedTrace = null;
628 Context.create = createContext;
629 Context.deactivateLongStackTraces = function() {};
630 Context.activateLongStackTraces = function() {
631 var Promise_pushContext = Promise.prototype._pushContext;
632 var Promise_popContext = Promise.prototype._popContext;
633 var Promise_PeekContext = Promise._peekContext;
634 var Promise_peekContext = Promise.prototype._peekContext;
635 var Promise_promiseCreated = Promise.prototype._promiseCreated;
636 Context.deactivateLongStackTraces = function() {
637 Promise.prototype._pushContext = Promise_pushContext;
638 Promise.prototype._popContext = Promise_popContext;
639 Promise._peekContext = Promise_PeekContext;
640 Promise.prototype._peekContext = Promise_peekContext;
641 Promise.prototype._promiseCreated = Promise_promiseCreated;
642 longStackTraces = false;
644 longStackTraces = true;
645 Promise.prototype._pushContext = Context.prototype._pushContext;
646 Promise.prototype._popContext = Context.prototype._popContext;
647 Promise._peekContext = Promise.prototype._peekContext = peekContext;
648 Promise.prototype._promiseCreated = function() {
649 var ctx = this._peekContext();
650 if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
656 },{}],9:[function(_dereq_,module,exports){
658 module.exports = function(Promise, Context) {
659 var getDomain = Promise._getDomain;
660 var async = Promise._async;
661 var Warning = _dereq_("./errors").Warning;
662 var util = _dereq_("./util");
663 var canAttachTrace = util.canAttachTrace;
664 var unhandledRejectionHandled;
665 var possiblyUnhandledRejection;
666 var bluebirdFramePattern =
667 /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
668 var stackFramePattern = null;
669 var formatStack = null;
670 var indentStackFrames = false;
672 var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 &&
674 util.env("BLUEBIRD_DEBUG") ||
675 util.env("NODE_ENV") === "development"));
677 var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 &&
678 (debugging || util.env("BLUEBIRD_WARNINGS")));
680 var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 &&
681 (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));
683 var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 &&
684 (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));
686 Promise.prototype.suppressUnhandledRejections = function() {
687 var target = this._target();
688 target._bitField = ((target._bitField & (~1048576)) |
692 Promise.prototype._ensurePossibleRejectionHandled = function () {
693 if ((this._bitField & 524288) !== 0) return;
694 this._setRejectionIsUnhandled();
695 async.invokeLater(this._notifyUnhandledRejection, this, undefined);
698 Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
699 fireRejectionEvent("rejectionHandled",
700 unhandledRejectionHandled, undefined, this);
703 Promise.prototype._setReturnedNonUndefined = function() {
704 this._bitField = this._bitField | 268435456;
707 Promise.prototype._returnedNonUndefined = function() {
708 return (this._bitField & 268435456) !== 0;
711 Promise.prototype._notifyUnhandledRejection = function () {
712 if (this._isRejectionUnhandled()) {
713 var reason = this._settledValue();
714 this._setUnhandledRejectionIsNotified();
715 fireRejectionEvent("unhandledRejection",
716 possiblyUnhandledRejection, reason, this);
720 Promise.prototype._setUnhandledRejectionIsNotified = function () {
721 this._bitField = this._bitField | 262144;
724 Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
725 this._bitField = this._bitField & (~262144);
728 Promise.prototype._isUnhandledRejectionNotified = function () {
729 return (this._bitField & 262144) > 0;
732 Promise.prototype._setRejectionIsUnhandled = function () {
733 this._bitField = this._bitField | 1048576;
736 Promise.prototype._unsetRejectionIsUnhandled = function () {
737 this._bitField = this._bitField & (~1048576);
738 if (this._isUnhandledRejectionNotified()) {
739 this._unsetUnhandledRejectionIsNotified();
740 this._notifyUnhandledRejectionIsHandled();
744 Promise.prototype._isRejectionUnhandled = function () {
745 return (this._bitField & 1048576) > 0;
748 Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) {
749 return warn(message, shouldUseOwnTrace, promise || this);
752 Promise.onPossiblyUnhandledRejection = function (fn) {
753 var domain = getDomain();
754 possiblyUnhandledRejection =
755 typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
759 Promise.onUnhandledRejectionHandled = function (fn) {
760 var domain = getDomain();
761 unhandledRejectionHandled =
762 typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
766 var disableLongStackTraces = function() {};
767 Promise.longStackTraces = function () {
768 if (async.haveItemsQueued() && !config.longStackTraces) {
769 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a");
771 if (!config.longStackTraces && longStackTracesIsSupported()) {
772 var Promise_captureStackTrace = Promise.prototype._captureStackTrace;
773 var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;
774 config.longStackTraces = true;
775 disableLongStackTraces = function() {
776 if (async.haveItemsQueued() && !config.longStackTraces) {
777 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a");
779 Promise.prototype._captureStackTrace = Promise_captureStackTrace;
780 Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;
781 Context.deactivateLongStackTraces();
782 async.enableTrampoline();
783 config.longStackTraces = false;
785 Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
786 Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
787 Context.activateLongStackTraces();
788 async.disableTrampolineIfNecessary();
792 Promise.hasLongStackTraces = function () {
793 return config.longStackTraces && longStackTracesIsSupported();
796 Promise.config = function(opts) {
798 if ("longStackTraces" in opts) {
799 if (opts.longStackTraces) {
800 Promise.longStackTraces();
801 } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
802 disableLongStackTraces();
805 if ("warnings" in opts) {
806 var warningsOption = opts.warnings;
807 config.warnings = !!warningsOption;
808 wForgottenReturn = config.warnings;
810 if (util.isObject(warningsOption)) {
811 if ("wForgottenReturn" in warningsOption) {
812 wForgottenReturn = !!warningsOption.wForgottenReturn;
816 if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
817 if (async.haveItemsQueued()) {
819 "cannot enable cancellation after promises are in use");
821 Promise.prototype._clearCancellationData =
822 cancellationClearCancellationData;
823 Promise.prototype._propagateFrom = cancellationPropagateFrom;
824 Promise.prototype._onCancel = cancellationOnCancel;
825 Promise.prototype._setOnCancel = cancellationSetOnCancel;
826 Promise.prototype._attachCancellationCallback =
827 cancellationAttachCancellationCallback;
828 Promise.prototype._execute = cancellationExecute;
829 propagateFromFunction = cancellationPropagateFrom;
830 config.cancellation = true;
834 Promise.prototype._execute = function(executor, resolve, reject) {
836 executor(resolve, reject);
841 Promise.prototype._onCancel = function () {};
842 Promise.prototype._setOnCancel = function (handler) { ; };
843 Promise.prototype._attachCancellationCallback = function(onCancel) {
846 Promise.prototype._captureStackTrace = function () {};
847 Promise.prototype._attachExtraTrace = function () {};
848 Promise.prototype._clearCancellationData = function() {};
849 Promise.prototype._propagateFrom = function (parent, flags) {
854 function cancellationExecute(executor, resolve, reject) {
857 executor(resolve, reject, function(onCancel) {
858 if (typeof onCancel !== "function") {
859 throw new TypeError("onCancel must be a function, got: " +
860 util.toString(onCancel));
862 promise._attachCancellationCallback(onCancel);
869 function cancellationAttachCancellationCallback(onCancel) {
870 if (!this.isCancellable()) return this;
872 var previousOnCancel = this._onCancel();
873 if (previousOnCancel !== undefined) {
874 if (util.isArray(previousOnCancel)) {
875 previousOnCancel.push(onCancel);
877 this._setOnCancel([previousOnCancel, onCancel]);
880 this._setOnCancel(onCancel);
884 function cancellationOnCancel() {
885 return this._onCancelField;
888 function cancellationSetOnCancel(onCancel) {
889 this._onCancelField = onCancel;
892 function cancellationClearCancellationData() {
893 this._cancellationParent = undefined;
894 this._onCancelField = undefined;
897 function cancellationPropagateFrom(parent, flags) {
898 if ((flags & 1) !== 0) {
899 this._cancellationParent = parent;
900 var branchesRemainingToCancel = parent._branchesRemainingToCancel;
901 if (branchesRemainingToCancel === undefined) {
902 branchesRemainingToCancel = 0;
904 parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
906 if ((flags & 2) !== 0 && parent._isBound()) {
907 this._setBoundTo(parent._boundTo);
911 function bindingPropagateFrom(parent, flags) {
912 if ((flags & 2) !== 0 && parent._isBound()) {
913 this._setBoundTo(parent._boundTo);
916 var propagateFromFunction = bindingPropagateFrom;
918 function boundValueFunction() {
919 var ret = this._boundTo;
920 if (ret !== undefined) {
921 if (ret instanceof Promise) {
922 if (ret.isFulfilled()) {
932 function longStackTracesCaptureStackTrace() {
933 this._trace = new CapturedTrace(this._peekContext());
936 function longStackTracesAttachExtraTrace(error, ignoreSelf) {
937 if (canAttachTrace(error)) {
938 var trace = this._trace;
939 if (trace !== undefined) {
940 if (ignoreSelf) trace = trace._parent;
942 if (trace !== undefined) {
943 trace.attachExtraTrace(error);
944 } else if (!error.__stackCleaned__) {
945 var parsed = parseStackAndMessage(error);
946 util.notEnumerableProp(error, "stack",
947 parsed.message + "\n" + parsed.stack.join("\n"));
948 util.notEnumerableProp(error, "__stackCleaned__", true);
953 function checkForgottenReturns(returnValue, promiseCreated, name, promise,
955 if (returnValue === undefined && promiseCreated !== null &&
957 if (parent !== undefined && parent._returnedNonUndefined()) return;
959 if (name) name = name + " ";
960 var msg = "a promise was created in a " + name +
961 "handler but was not returned from it";
962 promise._warn(msg, true, promiseCreated);
966 function deprecated(name, replacement) {
968 " is deprecated and will be removed in a future version.";
969 if (replacement) message += " Use " + replacement + " instead.";
970 return warn(message);
973 function warn(message, shouldUseOwnTrace, promise) {
974 if (!config.warnings) return;
975 var warning = new Warning(message);
977 if (shouldUseOwnTrace) {
978 promise._attachExtraTrace(warning);
979 } else if (config.longStackTraces && (ctx = Promise._peekContext())) {
980 ctx.attachExtraTrace(warning);
982 var parsed = parseStackAndMessage(warning);
983 warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
985 formatAndLogError(warning, "", true);
988 function reconstructStack(message, stacks) {
989 for (var i = 0; i < stacks.length - 1; ++i) {
990 stacks[i].push("From previous event:");
991 stacks[i] = stacks[i].join("\n");
993 if (i < stacks.length) {
994 stacks[i] = stacks[i].join("\n");
996 return message + "\n" + stacks.join("\n");
999 function removeDuplicateOrEmptyJumps(stacks) {
1000 for (var i = 0; i < stacks.length; ++i) {
1001 if (stacks[i].length === 0 ||
1002 ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
1003 stacks.splice(i, 1);
1009 function removeCommonRoots(stacks) {
1010 var current = stacks[0];
1011 for (var i = 1; i < stacks.length; ++i) {
1012 var prev = stacks[i];
1013 var currentLastIndex = current.length - 1;
1014 var currentLastLine = current[currentLastIndex];
1015 var commonRootMeetPoint = -1;
1017 for (var j = prev.length - 1; j >= 0; --j) {
1018 if (prev[j] === currentLastLine) {
1019 commonRootMeetPoint = j;
1024 for (var j = commonRootMeetPoint; j >= 0; --j) {
1026 if (current[currentLastIndex] === line) {
1037 function cleanStack(stack) {
1039 for (var i = 0; i < stack.length; ++i) {
1040 var line = stack[i];
1041 var isTraceLine = " (No stack trace)" === line ||
1042 stackFramePattern.test(line);
1043 var isInternalFrame = isTraceLine && shouldIgnore(line);
1044 if (isTraceLine && !isInternalFrame) {
1045 if (indentStackFrames && line.charAt(0) !== " ") {
1054 function stackFramesAsArray(error) {
1055 var stack = error.stack.replace(/\s+$/g, "").split("\n");
1056 for (var i = 0; i < stack.length; ++i) {
1057 var line = stack[i];
1058 if (" (No stack trace)" === line || stackFramePattern.test(line)) {
1063 stack = stack.slice(i);
1068 function parseStackAndMessage(error) {
1069 var stack = error.stack;
1070 var message = error.toString();
1071 stack = typeof stack === "string" && stack.length > 0
1072 ? stackFramesAsArray(error) : [" (No stack trace)"];
1075 stack: cleanStack(stack)
1079 function formatAndLogError(error, title, isSoft) {
1080 if (typeof console !== "undefined") {
1082 if (util.isObject(error)) {
1083 var stack = error.stack;
1084 message = title + formatStack(stack, error);
1086 message = title + String(error);
1088 if (typeof printWarning === "function") {
1089 printWarning(message, isSoft);
1090 } else if (typeof console.log === "function" ||
1091 typeof console.log === "object") {
1092 console.log(message);
1097 function fireRejectionEvent(name, localHandler, reason, promise) {
1098 var localEventFired = false;
1100 if (typeof localHandler === "function") {
1101 localEventFired = true;
1102 if (name === "rejectionHandled") {
1103 localHandler(promise);
1105 localHandler(reason, promise);
1109 async.throwLater(e);
1112 var globalEventFired = false;
1114 globalEventFired = fireGlobalEvent(name, reason, promise);
1116 globalEventFired = true;
1117 async.throwLater(e);
1120 var domEventFired = false;
1123 domEventFired = fireDomEvent(name.toLowerCase(), {
1128 domEventFired = true;
1129 async.throwLater(e);
1133 if (!globalEventFired && !localEventFired && !domEventFired &&
1134 name === "unhandledRejection") {
1135 formatAndLogError(reason, "Unhandled rejection ");
1139 function formatNonError(obj) {
1141 if (typeof obj === "function") {
1142 str = "[function " +
1143 (obj.name || "anonymous") +
1146 str = obj && typeof obj.toString === "function"
1147 ? obj.toString() : util.toString(obj);
1148 var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
1149 if (ruselessToString.test(str)) {
1151 var newStr = JSON.stringify(obj);
1158 if (str.length === 0) {
1159 str = "(empty array)";
1162 return ("(<" + snip(str) + ">, no stack trace)");
1165 function snip(str) {
1167 if (str.length < maxChars) {
1170 return str.substr(0, maxChars - 3) + "...";
1173 function longStackTracesIsSupported() {
1174 return typeof captureStackTrace === "function";
1177 var shouldIgnore = function() { return false; };
1178 var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
1179 function parseLineInfo(line) {
1180 var matches = line.match(parseLineInfoRegex);
1183 fileName: matches[1],
1184 line: parseInt(matches[2], 10)
1189 function setBounds(firstLineError, lastLineError) {
1190 if (!longStackTracesIsSupported()) return;
1191 var firstStackLines = firstLineError.stack.split("\n");
1192 var lastStackLines = lastLineError.stack.split("\n");
1193 var firstIndex = -1;
1197 for (var i = 0; i < firstStackLines.length; ++i) {
1198 var result = parseLineInfo(firstStackLines[i]);
1200 firstFileName = result.fileName;
1201 firstIndex = result.line;
1205 for (var i = 0; i < lastStackLines.length; ++i) {
1206 var result = parseLineInfo(lastStackLines[i]);
1208 lastFileName = result.fileName;
1209 lastIndex = result.line;
1213 if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
1214 firstFileName !== lastFileName || firstIndex >= lastIndex) {
1218 shouldIgnore = function(line) {
1219 if (bluebirdFramePattern.test(line)) return true;
1220 var info = parseLineInfo(line);
1222 if (info.fileName === firstFileName &&
1223 (firstIndex <= info.line && info.line <= lastIndex)) {
1231 function CapturedTrace(parent) {
1232 this._parent = parent;
1233 this._promisesCreated = 0;
1234 var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
1235 captureStackTrace(this, CapturedTrace);
1236 if (length > 32) this.uncycle();
1238 util.inherits(CapturedTrace, Error);
1239 Context.CapturedTrace = CapturedTrace;
1241 CapturedTrace.prototype.uncycle = function() {
1242 var length = this._length;
1243 if (length < 2) return;
1245 var stackToIndex = {};
1247 for (var i = 0, node = this; node !== undefined; ++i) {
1249 node = node._parent;
1251 length = this._length = i;
1252 for (var i = length - 1; i >= 0; --i) {
1253 var stack = nodes[i].stack;
1254 if (stackToIndex[stack] === undefined) {
1255 stackToIndex[stack] = i;
1258 for (var i = 0; i < length; ++i) {
1259 var currentStack = nodes[i].stack;
1260 var index = stackToIndex[currentStack];
1261 if (index !== undefined && index !== i) {
1263 nodes[index - 1]._parent = undefined;
1264 nodes[index - 1]._length = 1;
1266 nodes[i]._parent = undefined;
1267 nodes[i]._length = 1;
1268 var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
1270 if (index < length - 1) {
1271 cycleEdgeNode._parent = nodes[index + 1];
1272 cycleEdgeNode._parent.uncycle();
1273 cycleEdgeNode._length =
1274 cycleEdgeNode._parent._length + 1;
1276 cycleEdgeNode._parent = undefined;
1277 cycleEdgeNode._length = 1;
1279 var currentChildLength = cycleEdgeNode._length + 1;
1280 for (var j = i - 2; j >= 0; --j) {
1281 nodes[j]._length = currentChildLength;
1282 currentChildLength++;
1289 CapturedTrace.prototype.attachExtraTrace = function(error) {
1290 if (error.__stackCleaned__) return;
1292 var parsed = parseStackAndMessage(error);
1293 var message = parsed.message;
1294 var stacks = [parsed.stack];
1297 while (trace !== undefined) {
1298 stacks.push(cleanStack(trace.stack.split("\n")));
1299 trace = trace._parent;
1301 removeCommonRoots(stacks);
1302 removeDuplicateOrEmptyJumps(stacks);
1303 util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
1304 util.notEnumerableProp(error, "__stackCleaned__", true);
1307 var captureStackTrace = (function stackDetection() {
1308 var v8stackFramePattern = /^\s*at\s*/;
1309 var v8stackFormatter = function(stack, error) {
1310 if (typeof stack === "string") return stack;
1312 if (error.name !== undefined &&
1313 error.message !== undefined) {
1314 return error.toString();
1316 return formatNonError(error);
1319 if (typeof Error.stackTraceLimit === "number" &&
1320 typeof Error.captureStackTrace === "function") {
1321 Error.stackTraceLimit += 6;
1322 stackFramePattern = v8stackFramePattern;
1323 formatStack = v8stackFormatter;
1324 var captureStackTrace = Error.captureStackTrace;
1326 shouldIgnore = function(line) {
1327 return bluebirdFramePattern.test(line);
1329 return function(receiver, ignoreUntil) {
1330 Error.stackTraceLimit += 6;
1331 captureStackTrace(receiver, ignoreUntil);
1332 Error.stackTraceLimit -= 6;
1335 var err = new Error();
1337 if (typeof err.stack === "string" &&
1338 err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
1339 stackFramePattern = /@/;
1340 formatStack = v8stackFormatter;
1341 indentStackFrames = true;
1342 return function captureStackTrace(o) {
1343 o.stack = new Error().stack;
1347 var hasStackAfterThrow;
1348 try { throw new Error(); }
1350 hasStackAfterThrow = ("stack" in e);
1352 if (!("stack" in err) && hasStackAfterThrow &&
1353 typeof Error.stackTraceLimit === "number") {
1354 stackFramePattern = v8stackFramePattern;
1355 formatStack = v8stackFormatter;
1356 return function captureStackTrace(o) {
1357 Error.stackTraceLimit += 6;
1358 try { throw new Error(); }
1359 catch(e) { o.stack = e.stack; }
1360 Error.stackTraceLimit -= 6;
1364 formatStack = function(stack, error) {
1365 if (typeof stack === "string") return stack;
1367 if ((typeof error === "object" ||
1368 typeof error === "function") &&
1369 error.name !== undefined &&
1370 error.message !== undefined) {
1371 return error.toString();
1373 return formatNonError(error);
1381 var fireGlobalEvent = (function() {
1383 return function(name, reason, promise) {
1384 if (name === "rejectionHandled") {
1385 return process.emit(name, promise);
1387 return process.emit(name, reason, promise);
1391 var globalObject = typeof self !== "undefined" ? self :
1392 typeof window !== "undefined" ? window :
1393 typeof global !== "undefined" ? global :
1394 this !== undefined ? this : null;
1396 if (!globalObject) {
1403 var event = document.createEvent("CustomEvent");
1404 event.initCustomEvent("testingtheevent", false, true, {});
1405 globalObject.dispatchEvent(event);
1406 fireDomEvent = function(type, detail) {
1407 var event = document.createEvent("CustomEvent");
1408 event.initCustomEvent(type, false, true, detail);
1409 return !globalObject.dispatchEvent(event);
1413 var toWindowMethodNameMap = {};
1414 toWindowMethodNameMap["unhandledRejection"] = ("on" +
1415 "unhandledRejection").toLowerCase();
1416 toWindowMethodNameMap["rejectionHandled"] = ("on" +
1417 "rejectionHandled").toLowerCase();
1419 return function(name, reason, promise) {
1420 var methodName = toWindowMethodNameMap[name];
1421 var method = globalObject[methodName];
1422 if (!method) return false;
1423 if (name === "rejectionHandled") {
1424 method.call(globalObject, promise);
1426 method.call(globalObject, reason, promise);
1433 if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
1434 printWarning = function (message) {
1435 console.warn(message);
1437 if (util.isNode && process.stderr.isTTY) {
1438 printWarning = function(message, isSoft) {
1439 var color = isSoft ? "\u001b[33m" : "\u001b[31m";
1440 console.warn(color + message + "\u001b[0m\n");
1442 } else if (!util.isNode && typeof (new Error().stack) === "string") {
1443 printWarning = function(message, isSoft) {
1444 console.warn("%c" + message,
1445 isSoft ? "color: darkorange" : "color: red");
1452 longStackTraces: false,
1456 if (longStackTraces) Promise.longStackTraces();
1459 longStackTraces: function() {
1460 return config.longStackTraces;
1462 warnings: function() {
1463 return config.warnings;
1465 cancellation: function() {
1466 return config.cancellation;
1468 propagateFromFunction: function() {
1469 return propagateFromFunction;
1471 boundValueFunction: function() {
1472 return boundValueFunction;
1474 checkForgottenReturns: checkForgottenReturns,
1475 setBounds: setBounds,
1477 deprecated: deprecated,
1478 CapturedTrace: CapturedTrace
1482 },{"./errors":12,"./util":36}],10:[function(_dereq_,module,exports){
1484 module.exports = function(Promise) {
1485 function returner() {
1488 function thrower() {
1492 Promise.prototype["return"] =
1493 Promise.prototype.thenReturn = function (value) {
1494 if (value instanceof Promise) value.suppressUnhandledRejections();
1496 returner, undefined, undefined, {value: value}, undefined);
1499 Promise.prototype["throw"] =
1500 Promise.prototype.thenThrow = function (reason) {
1502 thrower, undefined, undefined, {reason: reason}, undefined);
1505 Promise.prototype.catchThrow = function (reason) {
1506 if (arguments.length <= 1) {
1508 undefined, thrower, undefined, {reason: reason}, undefined);
1510 var _reason = arguments[1];
1511 var handler = function() {throw _reason;};
1512 return this.caught(reason, handler);
1516 Promise.prototype.catchReturn = function (value) {
1517 if (arguments.length <= 1) {
1518 if (value instanceof Promise) value.suppressUnhandledRejections();
1520 undefined, returner, undefined, {value: value}, undefined);
1522 var _value = arguments[1];
1523 if (_value instanceof Promise) _value.suppressUnhandledRejections();
1524 var handler = function() {return _value;};
1525 return this.caught(value, handler);
1530 },{}],11:[function(_dereq_,module,exports){
1532 module.exports = function(Promise, INTERNAL) {
1533 var PromiseReduce = Promise.reduce;
1534 var PromiseAll = Promise.all;
1536 function promiseAllThis() {
1537 return PromiseAll(this);
1540 function PromiseMapSeries(promises, fn) {
1541 return PromiseReduce(promises, fn, INTERNAL, INTERNAL);
1544 Promise.prototype.each = function (fn) {
1545 return this.mapSeries(fn)
1546 ._then(promiseAllThis, undefined, undefined, this, undefined);
1549 Promise.prototype.mapSeries = function (fn) {
1550 return PromiseReduce(this, fn, INTERNAL, INTERNAL);
1553 Promise.each = function (promises, fn) {
1554 return PromiseMapSeries(promises, fn)
1555 ._then(promiseAllThis, undefined, undefined, promises, undefined);
1558 Promise.mapSeries = PromiseMapSeries;
1561 },{}],12:[function(_dereq_,module,exports){
1563 var es5 = _dereq_("./es5");
1564 var Objectfreeze = es5.freeze;
1565 var util = _dereq_("./util");
1566 var inherits = util.inherits;
1567 var notEnumerableProp = util.notEnumerableProp;
1569 function subError(nameProperty, defaultMessage) {
1570 function SubError(message) {
1571 if (!(this instanceof SubError)) return new SubError(message);
1572 notEnumerableProp(this, "message",
1573 typeof message === "string" ? message : defaultMessage);
1574 notEnumerableProp(this, "name", nameProperty);
1575 if (Error.captureStackTrace) {
1576 Error.captureStackTrace(this, this.constructor);
1581 inherits(SubError, Error);
1585 var _TypeError, _RangeError;
1586 var Warning = subError("Warning", "warning");
1587 var CancellationError = subError("CancellationError", "cancellation error");
1588 var TimeoutError = subError("TimeoutError", "timeout error");
1589 var AggregateError = subError("AggregateError", "aggregate error");
1591 _TypeError = TypeError;
1592 _RangeError = RangeError;
1594 _TypeError = subError("TypeError", "type error");
1595 _RangeError = subError("RangeError", "range error");
1598 var methods = ("join pop push shift unshift slice filter forEach some " +
1599 "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
1601 for (var i = 0; i < methods.length; ++i) {
1602 if (typeof Array.prototype[methods[i]] === "function") {
1603 AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
1607 es5.defineProperty(AggregateError.prototype, "length", {
1609 configurable: false,
1613 AggregateError.prototype["isOperational"] = true;
1615 AggregateError.prototype.toString = function() {
1616 var indent = Array(level * 4 + 1).join(" ");
1617 var ret = "\n" + indent + "AggregateError of:" + "\n";
1619 indent = Array(level * 4 + 1).join(" ");
1620 for (var i = 0; i < this.length; ++i) {
1621 var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
1622 var lines = str.split("\n");
1623 for (var j = 0; j < lines.length; ++j) {
1624 lines[j] = indent + lines[j];
1626 str = lines.join("\n");
1633 function OperationalError(message) {
1634 if (!(this instanceof OperationalError))
1635 return new OperationalError(message);
1636 notEnumerableProp(this, "name", "OperationalError");
1637 notEnumerableProp(this, "message", message);
1638 this.cause = message;
1639 this["isOperational"] = true;
1641 if (message instanceof Error) {
1642 notEnumerableProp(this, "message", message.message);
1643 notEnumerableProp(this, "stack", message.stack);
1644 } else if (Error.captureStackTrace) {
1645 Error.captureStackTrace(this, this.constructor);
1649 inherits(OperationalError, Error);
1651 var errorTypes = Error["__BluebirdErrorTypes__"];
1653 errorTypes = Objectfreeze({
1654 CancellationError: CancellationError,
1655 TimeoutError: TimeoutError,
1656 OperationalError: OperationalError,
1657 RejectionError: OperationalError,
1658 AggregateError: AggregateError
1660 notEnumerableProp(Error, "__BluebirdErrorTypes__", errorTypes);
1665 TypeError: _TypeError,
1666 RangeError: _RangeError,
1667 CancellationError: errorTypes.CancellationError,
1668 OperationalError: errorTypes.OperationalError,
1669 TimeoutError: errorTypes.TimeoutError,
1670 AggregateError: errorTypes.AggregateError,
1674 },{"./es5":13,"./util":36}],13:[function(_dereq_,module,exports){
1675 var isES5 = (function(){
1677 return this === undefined;
1682 freeze: Object.freeze,
1683 defineProperty: Object.defineProperty,
1684 getDescriptor: Object.getOwnPropertyDescriptor,
1686 names: Object.getOwnPropertyNames,
1687 getPrototypeOf: Object.getPrototypeOf,
1688 isArray: Array.isArray,
1690 propertyIsWritable: function(obj, prop) {
1691 var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
1692 return !!(!descriptor || descriptor.writable || descriptor.set);
1696 var has = {}.hasOwnProperty;
1697 var str = {}.toString;
1698 var proto = {}.constructor.prototype;
1700 var ObjectKeys = function (o) {
1702 for (var key in o) {
1703 if (has.call(o, key)) {
1710 var ObjectGetDescriptor = function(o, key) {
1711 return {value: o[key]};
1714 var ObjectDefineProperty = function (o, key, desc) {
1715 o[key] = desc.value;
1719 var ObjectFreeze = function (obj) {
1723 var ObjectGetPrototypeOf = function (obj) {
1725 return Object(obj).constructor.prototype;
1732 var ArrayIsArray = function (obj) {
1734 return str.call(obj) === "[object Array]";
1742 isArray: ArrayIsArray,
1745 defineProperty: ObjectDefineProperty,
1746 getDescriptor: ObjectGetDescriptor,
1747 freeze: ObjectFreeze,
1748 getPrototypeOf: ObjectGetPrototypeOf,
1750 propertyIsWritable: function() {
1756 },{}],14:[function(_dereq_,module,exports){
1758 module.exports = function(Promise, INTERNAL) {
1759 var PromiseMap = Promise.map;
1761 Promise.prototype.filter = function (fn, options) {
1762 return PromiseMap(this, fn, options, INTERNAL);
1765 Promise.filter = function (promises, fn, options) {
1766 return PromiseMap(promises, fn, options, INTERNAL);
1770 },{}],15:[function(_dereq_,module,exports){
1772 module.exports = function(Promise, tryConvertToPromise) {
1773 var util = _dereq_("./util");
1774 var CancellationError = Promise.CancellationError;
1775 var errorObj = util.errorObj;
1777 function PassThroughHandlerContext(promise, type, handler) {
1778 this.promise = promise;
1780 this.handler = handler;
1781 this.called = false;
1782 this.cancelPromise = null;
1785 function FinallyHandlerCancelReaction(finallyHandler) {
1786 this.finallyHandler = finallyHandler;
1789 FinallyHandlerCancelReaction.prototype._resultCancelled = function() {
1790 checkCancel(this.finallyHandler);
1793 function checkCancel(ctx, reason) {
1794 if (ctx.cancelPromise != null) {
1795 if (arguments.length > 1) {
1796 ctx.cancelPromise._reject(reason);
1798 ctx.cancelPromise._cancel();
1800 ctx.cancelPromise = null;
1806 function succeed() {
1807 return finallyHandler.call(this, this.promise._target()._settledValue());
1809 function fail(reason) {
1810 if (checkCancel(this, reason)) return;
1811 errorObj.e = reason;
1814 function finallyHandler(reasonOrValue) {
1815 var promise = this.promise;
1816 var handler = this.handler;
1820 var ret = this.type === 0
1821 ? handler.call(promise._boundValue())
1822 : handler.call(promise._boundValue(), reasonOrValue);
1823 if (ret !== undefined) {
1824 promise._setReturnedNonUndefined();
1825 var maybePromise = tryConvertToPromise(ret, promise);
1826 if (maybePromise instanceof Promise) {
1827 if (this.cancelPromise != null) {
1828 if (maybePromise.isCancelled()) {
1830 new CancellationError("late cancellation observer");
1831 promise._attachExtraTrace(reason);
1832 errorObj.e = reason;
1834 } else if (maybePromise.isPending()) {
1835 maybePromise._attachCancellationCallback(
1836 new FinallyHandlerCancelReaction(this));
1839 return maybePromise._then(
1840 succeed, fail, undefined, this, undefined);
1845 if (promise.isRejected()) {
1847 errorObj.e = reasonOrValue;
1851 return reasonOrValue;
1855 Promise.prototype._passThrough = function(handler, type, success, fail) {
1856 if (typeof handler !== "function") return this.then();
1857 return this._then(success,
1860 new PassThroughHandlerContext(this, type, handler),
1864 Promise.prototype.lastly =
1865 Promise.prototype["finally"] = function (handler) {
1866 return this._passThrough(handler,
1872 Promise.prototype.tap = function (handler) {
1873 return this._passThrough(handler, 1, finallyHandler);
1876 return PassThroughHandlerContext;
1879 },{"./util":36}],16:[function(_dereq_,module,exports){
1881 module.exports = function(Promise,
1884 tryConvertToPromise,
1887 var errors = _dereq_("./errors");
1888 var TypeError = errors.TypeError;
1889 var util = _dereq_("./util");
1890 var errorObj = util.errorObj;
1891 var tryCatch = util.tryCatch;
1892 var yieldHandlers = [];
1894 function promiseFromYieldHandler(value, yieldHandlers, traceParent) {
1895 for (var i = 0; i < yieldHandlers.length; ++i) {
1896 traceParent._pushContext();
1897 var result = tryCatch(yieldHandlers[i])(value);
1898 traceParent._popContext();
1899 if (result === errorObj) {
1900 traceParent._pushContext();
1901 var ret = Promise.reject(errorObj.e);
1902 traceParent._popContext();
1905 var maybePromise = tryConvertToPromise(result, traceParent);
1906 if (maybePromise instanceof Promise) return maybePromise;
1911 function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
1912 var promise = this._promise = new Promise(INTERNAL);
1913 promise._captureStackTrace();
1914 promise._setOnCancel(this);
1915 this._stack = stack;
1916 this._generatorFunction = generatorFunction;
1917 this._receiver = receiver;
1918 this._generator = undefined;
1919 this._yieldHandlers = typeof yieldHandler === "function"
1920 ? [yieldHandler].concat(yieldHandlers)
1922 this._yieldedPromise = null;
1924 util.inherits(PromiseSpawn, Proxyable);
1926 PromiseSpawn.prototype._isResolved = function() {
1927 return this._promise === null;
1930 PromiseSpawn.prototype._cleanup = function() {
1931 this._promise = this._generator = null;
1934 PromiseSpawn.prototype._promiseCancelled = function() {
1935 if (this._isResolved()) return;
1936 var implementsReturn = typeof this._generator["return"] !== "undefined";
1939 if (!implementsReturn) {
1940 var reason = new Promise.CancellationError(
1941 "generator .return() sentinel");
1942 Promise.coroutine.returnSentinel = reason;
1943 this._promise._attachExtraTrace(reason);
1944 this._promise._pushContext();
1945 result = tryCatch(this._generator["throw"]).call(this._generator,
1947 this._promise._popContext();
1948 if (result === errorObj && result.e === reason) {
1952 this._promise._pushContext();
1953 result = tryCatch(this._generator["return"]).call(this._generator,
1955 this._promise._popContext();
1957 var promise = this._promise;
1959 if (result === errorObj) {
1960 promise._rejectCallback(result.e, false);
1966 PromiseSpawn.prototype._promiseFulfilled = function(value) {
1967 this._yieldedPromise = null;
1968 this._promise._pushContext();
1969 var result = tryCatch(this._generator.next).call(this._generator, value);
1970 this._promise._popContext();
1971 this._continue(result);
1974 PromiseSpawn.prototype._promiseRejected = function(reason) {
1975 this._yieldedPromise = null;
1976 this._promise._attachExtraTrace(reason);
1977 this._promise._pushContext();
1978 var result = tryCatch(this._generator["throw"])
1979 .call(this._generator, reason);
1980 this._promise._popContext();
1981 this._continue(result);
1984 PromiseSpawn.prototype._resultCancelled = function() {
1985 if (this._yieldedPromise instanceof Promise) {
1986 var promise = this._yieldedPromise;
1987 this._yieldedPromise = null;
1992 PromiseSpawn.prototype.promise = function () {
1993 return this._promise;
1996 PromiseSpawn.prototype._run = function () {
1997 this._generator = this._generatorFunction.call(this._receiver);
1999 this._generatorFunction = undefined;
2000 this._promiseFulfilled(undefined);
2003 PromiseSpawn.prototype._continue = function (result) {
2004 var promise = this._promise;
2005 if (result === errorObj) {
2007 return promise._rejectCallback(result.e, false);
2010 var value = result.value;
2011 if (result.done === true) {
2013 return promise._resolveCallback(value);
2015 var maybePromise = tryConvertToPromise(value, this._promise);
2016 if (!(maybePromise instanceof Promise)) {
2018 promiseFromYieldHandler(maybePromise,
2019 this._yieldHandlers,
2021 if (maybePromise === null) {
2022 this._promiseRejected(
2024 "A value %s was yielded that could not be treated as a promise\u000a\u000a See http://goo.gl/MqrFmX\u000a\u000a".replace("%s", value) +
2025 "From coroutine:\u000a" +
2026 this._stack.split("\n").slice(1, -7).join("\n")
2032 maybePromise = maybePromise._target();
2033 var bitField = maybePromise._bitField;
2035 if (((bitField & 50397184) === 0)) {
2036 this._yieldedPromise = maybePromise;
2037 maybePromise._proxy(this, null);
2038 } else if (((bitField & 33554432) !== 0)) {
2039 this._promiseFulfilled(maybePromise._value());
2040 } else if (((bitField & 16777216) !== 0)) {
2041 this._promiseRejected(maybePromise._reason());
2043 this._promiseCancelled();
2048 Promise.coroutine = function (generatorFunction, options) {
2049 if (typeof generatorFunction !== "function") {
2050 throw new TypeError("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a");
2052 var yieldHandler = Object(options).yieldHandler;
2053 var PromiseSpawn$ = PromiseSpawn;
2054 var stack = new Error().stack;
2055 return function () {
2056 var generator = generatorFunction.apply(this, arguments);
2057 var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
2059 var ret = spawn.promise();
2060 spawn._generator = generator;
2061 spawn._promiseFulfilled(undefined);
2066 Promise.coroutine.addYieldHandler = function(fn) {
2067 if (typeof fn !== "function") {
2068 throw new TypeError("expecting a function but got " + util.classString(fn));
2070 yieldHandlers.push(fn);
2073 Promise.spawn = function (generatorFunction) {
2074 debug.deprecated("Promise.spawn()", "Promise.coroutine()");
2075 if (typeof generatorFunction !== "function") {
2076 return apiRejection("generatorFunction must be a function\u000a\u000a See http://goo.gl/MqrFmX\u000a");
2078 var spawn = new PromiseSpawn(generatorFunction, this);
2079 var ret = spawn.promise();
2080 spawn._run(Promise.spawn);
2085 },{"./errors":12,"./util":36}],17:[function(_dereq_,module,exports){
2088 function(Promise, PromiseArray, tryConvertToPromise, INTERNAL) {
2089 var util = _dereq_("./util");
2090 var canEvaluate = util.canEvaluate;
2091 var tryCatch = util.tryCatch;
2092 var errorObj = util.errorObj;
2097 var thenCallback = function(i) {
2098 return new Function("value", "holder", " \n\
2100 holder.pIndex = value; \n\
2101 holder.checkFulfillment(this); \n\
2102 ".replace(/Index/g, i));
2105 var promiseSetter = function(i) {
2106 return new Function("promise", "holder", " \n\
2108 holder.pIndex = promise; \n\
2109 ".replace(/Index/g, i));
2112 var generateHolderClass = function(total) {
2113 var props = new Array(total);
2114 for (var i = 0; i < props.length; ++i) {
2115 props[i] = "this.p" + (i+1);
2117 var assignment = props.join(" = ") + " = null;";
2118 var cancellationCode= "var promise;\n" + props.map(function(prop) {
2120 promise = " + prop + "; \n\
2121 if (promise instanceof Promise) { \n\
2122 promise.cancel(); \n\
2126 var passedArguments = props.join(", ");
2127 var name = "Holder$" + total;
2130 var code = "return function(tryCatch, errorObj, Promise) { \n\
2132 function [TheName](fn) { \n\
2137 [TheName].prototype.checkFulfillment = function(promise) { \n\
2138 var now = ++this.now; \n\
2139 if (now === [TheTotal]) { \n\
2140 promise._pushContext(); \n\
2141 var callback = this.fn; \n\
2142 var ret = tryCatch(callback)([ThePassedArguments]); \n\
2143 promise._popContext(); \n\
2144 if (ret === errorObj) { \n\
2145 promise._rejectCallback(ret.e, false); \n\
2147 promise._resolveCallback(ret); \n\
2152 [TheName].prototype._resultCancelled = function() { \n\
2153 [CancellationCode] \n\
2156 return [TheName]; \n\
2157 }(tryCatch, errorObj, Promise); \n\
2160 code = code.replace(/\[TheName\]/g, name)
2161 .replace(/\[TheTotal\]/g, total)
2162 .replace(/\[ThePassedArguments\]/g, passedArguments)
2163 .replace(/\[TheProperties\]/g, assignment)
2164 .replace(/\[CancellationCode\]/g, cancellationCode);
2166 return new Function("tryCatch", "errorObj", "Promise", code)
2167 (tryCatch, errorObj, Promise);
2170 var holderClasses = [];
2171 var thenCallbacks = [];
2172 var promiseSetters = [];
2174 for (var i = 0; i < 8; ++i) {
2175 holderClasses.push(generateHolderClass(i + 1));
2176 thenCallbacks.push(thenCallback(i + 1));
2177 promiseSetters.push(promiseSetter(i + 1));
2180 reject = function (reason) {
2181 this._reject(reason);
2185 Promise.join = function () {
2186 var last = arguments.length - 1;
2188 if (last > 0 && typeof arguments[last] === "function") {
2189 fn = arguments[last];
2191 if (last <= 8 && canEvaluate) {
2192 var ret = new Promise(INTERNAL);
2193 ret._captureStackTrace();
2194 var HolderClass = holderClasses[last - 1];
2195 var holder = new HolderClass(fn);
2196 var callbacks = thenCallbacks;
2198 for (var i = 0; i < last; ++i) {
2199 var maybePromise = tryConvertToPromise(arguments[i], ret);
2200 if (maybePromise instanceof Promise) {
2201 maybePromise = maybePromise._target();
2202 var bitField = maybePromise._bitField;
2204 if (((bitField & 50397184) === 0)) {
2205 maybePromise._then(callbacks[i], reject,
2206 undefined, ret, holder);
2207 promiseSetters[i](maybePromise, holder);
2208 } else if (((bitField & 33554432) !== 0)) {
2209 callbacks[i].call(ret,
2210 maybePromise._value(), holder);
2211 } else if (((bitField & 16777216) !== 0)) {
2212 ret._reject(maybePromise._reason());
2217 callbacks[i].call(ret, maybePromise, holder);
2220 if (!ret._isFateSealed()) {
2221 ret._setAsyncGuaranteed();
2222 ret._setOnCancel(holder);
2228 var args = [].slice.call(arguments);;
2230 var ret = new PromiseArray(args).promise();
2231 return fn !== undefined ? ret.spread(fn) : ret;
2236 },{"./util":36}],18:[function(_dereq_,module,exports){
2238 module.exports = function(Promise,
2241 tryConvertToPromise,
2244 var getDomain = Promise._getDomain;
2245 var util = _dereq_("./util");
2246 var tryCatch = util.tryCatch;
2247 var errorObj = util.errorObj;
2248 var EMPTY_ARRAY = [];
2250 function MappingPromiseArray(promises, fn, limit, _filter) {
2251 this.constructor$(promises);
2252 this._promise._captureStackTrace();
2253 var domain = getDomain();
2254 this._callback = domain === null ? fn : domain.bind(fn);
2255 this._preservedValues = _filter === INTERNAL
2256 ? new Array(this.length())
2258 this._limit = limit;
2260 this._queue = limit >= 1 ? [] : EMPTY_ARRAY;
2261 this._init$(undefined, -2);
2263 util.inherits(MappingPromiseArray, PromiseArray);
2265 MappingPromiseArray.prototype._init = function () {};
2267 MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
2268 var values = this._values;
2269 var length = this.length();
2270 var preservedValues = this._preservedValues;
2271 var limit = this._limit;
2274 index = (index * -1) - 1;
2275 values[index] = value;
2279 if (this._isResolved()) return true;
2282 if (limit >= 1 && this._inFlight >= limit) {
2283 values[index] = value;
2284 this._queue.push(index);
2287 if (preservedValues !== null) preservedValues[index] = value;
2289 var promise = this._promise;
2290 var callback = this._callback;
2291 var receiver = promise._boundValue();
2292 promise._pushContext();
2293 var ret = tryCatch(callback).call(receiver, value, index, length);
2294 var promiseCreated = promise._popContext();
2295 debug.checkForgottenReturns(
2298 preservedValues !== null ? "Promise.filter" : "Promise.map",
2301 if (ret === errorObj) {
2302 this._reject(ret.e);
2306 var maybePromise = tryConvertToPromise(ret, this._promise);
2307 if (maybePromise instanceof Promise) {
2308 maybePromise = maybePromise._target();
2309 var bitField = maybePromise._bitField;
2311 if (((bitField & 50397184) === 0)) {
2312 if (limit >= 1) this._inFlight++;
2313 values[index] = maybePromise;
2314 maybePromise._proxy(this, (index + 1) * -1);
2316 } else if (((bitField & 33554432) !== 0)) {
2317 ret = maybePromise._value();
2318 } else if (((bitField & 16777216) !== 0)) {
2319 this._reject(maybePromise._reason());
2326 values[index] = ret;
2328 var totalResolved = ++this._totalResolved;
2329 if (totalResolved >= length) {
2330 if (preservedValues !== null) {
2331 this._filter(values, preservedValues);
2333 this._resolve(values);
2340 MappingPromiseArray.prototype._drainQueue = function () {
2341 var queue = this._queue;
2342 var limit = this._limit;
2343 var values = this._values;
2344 while (queue.length > 0 && this._inFlight < limit) {
2345 if (this._isResolved()) return;
2346 var index = queue.pop();
2347 this._promiseFulfilled(values[index], index);
2351 MappingPromiseArray.prototype._filter = function (booleans, values) {
2352 var len = values.length;
2353 var ret = new Array(len);
2355 for (var i = 0; i < len; ++i) {
2356 if (booleans[i]) ret[j++] = values[i];
2362 MappingPromiseArray.prototype.preservedValues = function () {
2363 return this._preservedValues;
2366 function map(promises, fn, options, _filter) {
2367 if (typeof fn !== "function") {
2368 return apiRejection("expecting a function but got " + util.classString(fn));
2370 var limit = typeof options === "object" && options !== null
2371 ? options.concurrency
2373 limit = typeof limit === "number" &&
2374 isFinite(limit) && limit >= 1 ? limit : 0;
2375 return new MappingPromiseArray(promises, fn, limit, _filter).promise();
2378 Promise.prototype.map = function (fn, options) {
2379 return map(this, fn, options, null);
2382 Promise.map = function (promises, fn, options, _filter) {
2383 return map(promises, fn, options, _filter);
2389 },{"./util":36}],19:[function(_dereq_,module,exports){
2392 function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {
2393 var util = _dereq_("./util");
2394 var tryCatch = util.tryCatch;
2396 Promise.method = function (fn) {
2397 if (typeof fn !== "function") {
2398 throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
2400 return function () {
2401 var ret = new Promise(INTERNAL);
2402 ret._captureStackTrace();
2404 var value = tryCatch(fn).apply(this, arguments);
2405 var promiseCreated = ret._popContext();
2406 debug.checkForgottenReturns(
2407 value, promiseCreated, "Promise.method", ret);
2408 ret._resolveFromSyncValue(value);
2413 Promise.attempt = Promise["try"] = function (fn) {
2414 if (typeof fn !== "function") {
2415 return apiRejection("expecting a function but got " + util.classString(fn));
2417 var ret = new Promise(INTERNAL);
2418 ret._captureStackTrace();
2421 if (arguments.length > 1) {
2422 debug.deprecated("calling Promise.try with more than 1 argument");
2423 var arg = arguments[1];
2424 var ctx = arguments[2];
2425 value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
2426 : tryCatch(fn).call(ctx, arg);
2428 value = tryCatch(fn)();
2430 var promiseCreated = ret._popContext();
2431 debug.checkForgottenReturns(
2432 value, promiseCreated, "Promise.try", ret);
2433 ret._resolveFromSyncValue(value);
2437 Promise.prototype._resolveFromSyncValue = function (value) {
2438 if (value === util.errorObj) {
2439 this._rejectCallback(value.e, false);
2441 this._resolveCallback(value, true);
2446 },{"./util":36}],20:[function(_dereq_,module,exports){
2448 var util = _dereq_("./util");
2449 var maybeWrapAsError = util.maybeWrapAsError;
2450 var errors = _dereq_("./errors");
2451 var OperationalError = errors.OperationalError;
2452 var es5 = _dereq_("./es5");
2454 function isUntypedError(obj) {
2455 return obj instanceof Error &&
2456 es5.getPrototypeOf(obj) === Error.prototype;
2459 var rErrorKey = /^(?:name|message|stack|cause)$/;
2460 function wrapAsOperationalError(obj) {
2462 if (isUntypedError(obj)) {
2463 ret = new OperationalError(obj);
2464 ret.name = obj.name;
2465 ret.message = obj.message;
2466 ret.stack = obj.stack;
2467 var keys = es5.keys(obj);
2468 for (var i = 0; i < keys.length; ++i) {
2470 if (!rErrorKey.test(key)) {
2471 ret[key] = obj[key];
2476 util.markAsOriginatingFromRejection(obj);
2480 function nodebackForPromise(promise, multiArgs) {
2481 return function(err, value) {
2482 if (promise === null) return;
2484 var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
2485 promise._attachExtraTrace(wrapped);
2486 promise._reject(wrapped);
2487 } else if (!multiArgs) {
2488 promise._fulfill(value);
2490 var args = [].slice.call(arguments, 1);;
2491 promise._fulfill(args);
2497 module.exports = nodebackForPromise;
2499 },{"./errors":12,"./es5":13,"./util":36}],21:[function(_dereq_,module,exports){
2501 module.exports = function(Promise) {
2502 var util = _dereq_("./util");
2503 var async = Promise._async;
2504 var tryCatch = util.tryCatch;
2505 var errorObj = util.errorObj;
2507 function spreadAdapter(val, nodeback) {
2509 if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
2511 tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));
2512 if (ret === errorObj) {
2513 async.throwLater(ret.e);
2517 function successAdapter(val, nodeback) {
2519 var receiver = promise._boundValue();
2520 var ret = val === undefined
2521 ? tryCatch(nodeback).call(receiver, null)
2522 : tryCatch(nodeback).call(receiver, null, val);
2523 if (ret === errorObj) {
2524 async.throwLater(ret.e);
2527 function errorAdapter(reason, nodeback) {
2530 var newReason = new Error(reason + "");
2531 newReason.cause = reason;
2534 var ret = tryCatch(nodeback).call(promise._boundValue(), reason);
2535 if (ret === errorObj) {
2536 async.throwLater(ret.e);
2540 Promise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback,
2542 if (typeof nodeback == "function") {
2543 var adapter = successAdapter;
2544 if (options !== undefined && Object(options).spread) {
2545 adapter = spreadAdapter;
2559 },{"./util":36}],22:[function(_dereq_,module,exports){
2561 module.exports = function() {
2562 var makeSelfResolutionError = function () {
2563 return new TypeError("circular promise resolution chain\u000a\u000a See http://goo.gl/MqrFmX\u000a");
2565 var reflectHandler = function() {
2566 return new Promise.PromiseInspection(this._target());
2568 var apiRejection = function(msg) {
2569 return Promise.reject(new TypeError(msg));
2571 function Proxyable() {}
2572 var UNDEFINED_BINDING = {};
2573 var util = _dereq_("./util");
2577 getDomain = function() {
2578 var ret = process.domain;
2579 if (ret === undefined) ret = null;
2583 getDomain = function() {
2587 util.notEnumerableProp(Promise, "_getDomain", getDomain);
2589 var es5 = _dereq_("./es5");
2590 var Async = _dereq_("./async");
2591 var async = new Async();
2592 es5.defineProperty(Promise, "_async", {value: async});
2593 var errors = _dereq_("./errors");
2594 var TypeError = Promise.TypeError = errors.TypeError;
2595 Promise.RangeError = errors.RangeError;
2596 var CancellationError = Promise.CancellationError = errors.CancellationError;
2597 Promise.TimeoutError = errors.TimeoutError;
2598 Promise.OperationalError = errors.OperationalError;
2599 Promise.RejectionError = errors.OperationalError;
2600 Promise.AggregateError = errors.AggregateError;
2601 var INTERNAL = function(){};
2603 var NEXT_FILTER = {};
2604 var tryConvertToPromise = _dereq_("./thenables")(Promise, INTERNAL);
2606 _dereq_("./promise_array")(Promise, INTERNAL,
2607 tryConvertToPromise, apiRejection, Proxyable);
2608 var Context = _dereq_("./context")(Promise);
2609 /*jshint unused:false*/
2610 var createContext = Context.create;
2611 var debug = _dereq_("./debuggability")(Promise, Context);
2612 var CapturedTrace = debug.CapturedTrace;
2613 var PassThroughHandlerContext =
2614 _dereq_("./finally")(Promise, tryConvertToPromise);
2615 var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
2616 var nodebackForPromise = _dereq_("./nodeback");
2617 var errorObj = util.errorObj;
2618 var tryCatch = util.tryCatch;
2619 function check(self, executor) {
2620 if (typeof executor !== "function") {
2621 throw new TypeError("expecting a function but got " + util.classString(executor));
2623 if (self.constructor !== Promise) {
2624 throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a See http://goo.gl/MqrFmX\u000a");
2628 function Promise(executor) {
2630 this._fulfillmentHandler0 = undefined;
2631 this._rejectionHandler0 = undefined;
2632 this._promise0 = undefined;
2633 this._receiver0 = undefined;
2634 if (executor !== INTERNAL) {
2635 check(this, executor);
2636 this._resolveFromExecutor(executor);
2638 this._promiseCreated();
2641 Promise.prototype.toString = function () {
2642 return "[object Promise]";
2645 Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
2646 var len = arguments.length;
2648 var catchInstances = new Array(len - 1),
2650 for (i = 0; i < len - 1; ++i) {
2651 var item = arguments[i];
2652 if (util.isObject(item)) {
2653 catchInstances[j++] = item;
2655 return apiRejection("expecting an object but got " + util.classString(item));
2658 catchInstances.length = j;
2660 return this.then(undefined, catchFilter(catchInstances, fn, this));
2662 return this.then(undefined, fn);
2665 Promise.prototype.reflect = function () {
2666 return this._then(reflectHandler,
2667 reflectHandler, undefined, this, undefined);
2670 Promise.prototype.then = function (didFulfill, didReject) {
2671 if (debug.warnings() && arguments.length > 0 &&
2672 typeof didFulfill !== "function" &&
2673 typeof didReject !== "function") {
2674 var msg = ".then() only accepts functions but was passed: " +
2675 util.classString(didFulfill);
2676 if (arguments.length > 1) {
2677 msg += ", " + util.classString(didReject);
2681 return this._then(didFulfill, didReject, undefined, undefined, undefined);
2684 Promise.prototype.done = function (didFulfill, didReject) {
2686 this._then(didFulfill, didReject, undefined, undefined, undefined);
2687 promise._setIsFinal();
2690 Promise.prototype.spread = function (fn) {
2691 if (typeof fn !== "function") {
2692 return apiRejection("expecting a function but got " + util.classString(fn));
2694 return this.all()._then(fn, undefined, undefined, APPLY, undefined);
2697 Promise.prototype.toJSON = function () {
2701 fulfillmentValue: undefined,
2702 rejectionReason: undefined
2704 if (this.isFulfilled()) {
2705 ret.fulfillmentValue = this.value();
2706 ret.isFulfilled = true;
2707 } else if (this.isRejected()) {
2708 ret.rejectionReason = this.reason();
2709 ret.isRejected = true;
2714 Promise.prototype.all = function () {
2715 if (arguments.length > 0) {
2716 this._warn(".all() was passed arguments but it does not take any");
2718 return new PromiseArray(this).promise();
2721 Promise.prototype.error = function (fn) {
2722 return this.caught(util.originatesFromRejection, fn);
2725 Promise.is = function (val) {
2726 return val instanceof Promise;
2729 Promise.fromNode = Promise.fromCallback = function(fn) {
2730 var ret = new Promise(INTERNAL);
2731 ret._captureStackTrace();
2732 var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs
2734 var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));
2735 if (result === errorObj) {
2736 ret._rejectCallback(result.e, true);
2738 if (!ret._isFateSealed()) ret._setAsyncGuaranteed();
2742 Promise.all = function (promises) {
2743 return new PromiseArray(promises).promise();
2746 Promise.cast = function (obj) {
2747 var ret = tryConvertToPromise(obj);
2748 if (!(ret instanceof Promise)) {
2749 ret = new Promise(INTERNAL);
2750 ret._captureStackTrace();
2751 ret._setFulfilled();
2752 ret._rejectionHandler0 = obj;
2757 Promise.resolve = Promise.fulfilled = Promise.cast;
2759 Promise.reject = Promise.rejected = function (reason) {
2760 var ret = new Promise(INTERNAL);
2761 ret._captureStackTrace();
2762 ret._rejectCallback(reason, true);
2766 Promise.setScheduler = function(fn) {
2767 if (typeof fn !== "function") {
2768 throw new TypeError("expecting a function but got " + util.classString(fn));
2770 var prev = async._schedule;
2771 async._schedule = fn;
2775 Promise.prototype._then = function (
2781 var haveInternalData = internalData !== undefined;
2782 var promise = haveInternalData ? internalData : new Promise(INTERNAL);
2783 var target = this._target();
2784 var bitField = target._bitField;
2786 if (!haveInternalData) {
2787 promise._propagateFrom(this, 3);
2788 promise._captureStackTrace();
2789 if (receiver === undefined &&
2790 ((this._bitField & 2097152) !== 0)) {
2791 if (!((bitField & 50397184) === 0)) {
2792 receiver = this._boundValue();
2794 receiver = target === this ? undefined : this._boundTo;
2799 var domain = getDomain();
2800 if (!((bitField & 50397184) === 0)) {
2801 var handler, value, settler = target._settlePromiseCtx;
2802 if (((bitField & 33554432) !== 0)) {
2803 value = target._rejectionHandler0;
2804 handler = didFulfill;
2805 } else if (((bitField & 16777216) !== 0)) {
2806 value = target._fulfillmentHandler0;
2807 handler = didReject;
2808 target._unsetRejectionIsUnhandled();
2810 settler = target._settlePromiseLateCancellationObserver;
2811 value = new CancellationError("late cancellation observer");
2812 target._attachExtraTrace(value);
2813 handler = didReject;
2816 async.invoke(settler, target, {
2817 handler: domain === null ? handler
2818 : (typeof handler === "function" && domain.bind(handler)),
2824 target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
2830 Promise.prototype._length = function () {
2831 return this._bitField & 65535;
2834 Promise.prototype._isFateSealed = function () {
2835 return (this._bitField & 117506048) !== 0;
2838 Promise.prototype._isFollowing = function () {
2839 return (this._bitField & 67108864) === 67108864;
2842 Promise.prototype._setLength = function (len) {
2843 this._bitField = (this._bitField & -65536) |
2847 Promise.prototype._setFulfilled = function () {
2848 this._bitField = this._bitField | 33554432;
2851 Promise.prototype._setRejected = function () {
2852 this._bitField = this._bitField | 16777216;
2855 Promise.prototype._setFollowing = function () {
2856 this._bitField = this._bitField | 67108864;
2859 Promise.prototype._setIsFinal = function () {
2860 this._bitField = this._bitField | 4194304;
2863 Promise.prototype._isFinal = function () {
2864 return (this._bitField & 4194304) > 0;
2867 Promise.prototype._unsetCancelled = function() {
2868 this._bitField = this._bitField & (~65536);
2871 Promise.prototype._setCancelled = function() {
2872 this._bitField = this._bitField | 65536;
2875 Promise.prototype._setAsyncGuaranteed = function() {
2876 this._bitField = this._bitField | 134217728;
2879 Promise.prototype._receiverAt = function (index) {
2880 var ret = index === 0 ? this._receiver0 : this[
2882 if (ret === UNDEFINED_BINDING) {
2884 } else if (ret === undefined && this._isBound()) {
2885 return this._boundValue();
2890 Promise.prototype._promiseAt = function (index) {
2895 Promise.prototype._fulfillmentHandlerAt = function (index) {
2900 Promise.prototype._rejectionHandlerAt = function (index) {
2905 Promise.prototype._boundValue = function() {};
2907 Promise.prototype._migrateCallback0 = function (follower) {
2908 var bitField = follower._bitField;
2909 var fulfill = follower._fulfillmentHandler0;
2910 var reject = follower._rejectionHandler0;
2911 var promise = follower._promise0;
2912 var receiver = follower._receiverAt(0);
2913 if (receiver === undefined) receiver = UNDEFINED_BINDING;
2914 this._addCallbacks(fulfill, reject, promise, receiver, null);
2917 Promise.prototype._migrateCallbackAt = function (follower, index) {
2918 var fulfill = follower._fulfillmentHandlerAt(index);
2919 var reject = follower._rejectionHandlerAt(index);
2920 var promise = follower._promiseAt(index);
2921 var receiver = follower._receiverAt(index);
2922 if (receiver === undefined) receiver = UNDEFINED_BINDING;
2923 this._addCallbacks(fulfill, reject, promise, receiver, null);
2926 Promise.prototype._addCallbacks = function (
2933 var index = this._length();
2935 if (index >= 65535 - 4) {
2941 this._promise0 = promise;
2942 this._receiver0 = receiver;
2943 if (typeof fulfill === "function") {
2944 this._fulfillmentHandler0 =
2945 domain === null ? fulfill : domain.bind(fulfill);
2947 if (typeof reject === "function") {
2948 this._rejectionHandler0 =
2949 domain === null ? reject : domain.bind(reject);
2952 var base = index * 4 - 4;
2953 this[base + 2] = promise;
2954 this[base + 3] = receiver;
2955 if (typeof fulfill === "function") {
2957 domain === null ? fulfill : domain.bind(fulfill);
2959 if (typeof reject === "function") {
2961 domain === null ? reject : domain.bind(reject);
2964 this._setLength(index + 1);
2968 Promise.prototype._proxy = function (proxyable, arg) {
2969 this._addCallbacks(undefined, undefined, arg, proxyable, null);
2972 Promise.prototype._resolveCallback = function(value, shouldBind) {
2973 if (((this._bitField & 117506048) !== 0)) return;
2975 return this._rejectCallback(makeSelfResolutionError(), false);
2976 var maybePromise = tryConvertToPromise(value, this);
2977 if (!(maybePromise instanceof Promise)) return this._fulfill(value);
2979 if (shouldBind) this._propagateFrom(maybePromise, 2);
2981 var promise = maybePromise._target();
2982 var bitField = promise._bitField;
2983 if (((bitField & 50397184) === 0)) {
2984 var len = this._length();
2985 if (len > 0) promise._migrateCallback0(this);
2986 for (var i = 1; i < len; ++i) {
2987 promise._migrateCallbackAt(this, i);
2989 this._setFollowing();
2991 this._setFollowee(promise);
2992 } else if (((bitField & 33554432) !== 0)) {
2993 this._fulfill(promise._value());
2994 } else if (((bitField & 16777216) !== 0)) {
2995 this._reject(promise._reason());
2997 var reason = new CancellationError("late cancellation observer");
2998 promise._attachExtraTrace(reason);
2999 this._reject(reason);
3003 Promise.prototype._rejectCallback =
3004 function(reason, synchronous, ignoreNonErrorWarnings) {
3005 var trace = util.ensureErrorObject(reason);
3006 var hasStack = trace === reason;
3007 if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {
3008 var message = "a promise was rejected with a non-error: " +
3009 util.classString(reason);
3010 this._warn(message, true);
3012 this._attachExtraTrace(trace, synchronous ? hasStack : false);
3013 this._reject(reason);
3016 Promise.prototype._resolveFromExecutor = function (executor) {
3018 this._captureStackTrace();
3019 this._pushContext();
3020 var synchronous = true;
3021 var r = this._execute(executor, function(value) {
3022 promise._resolveCallback(value);
3023 }, function (reason) {
3024 promise._rejectCallback(reason, synchronous);
3026 synchronous = false;
3029 if (r !== undefined) {
3030 promise._rejectCallback(r, true);
3034 Promise.prototype._settlePromiseFromHandler = function (
3035 handler, receiver, value, promise
3037 var bitField = promise._bitField;
3038 if (((bitField & 65536) !== 0)) return;
3039 promise._pushContext();
3041 if (receiver === APPLY) {
3042 if (!value || typeof value.length !== "number") {
3044 x.e = new TypeError("cannot .spread() a non-array: " +
3045 util.classString(value));
3047 x = tryCatch(handler).apply(this._boundValue(), value);
3050 x = tryCatch(handler).call(receiver, value);
3052 var promiseCreated = promise._popContext();
3053 bitField = promise._bitField;
3054 if (((bitField & 65536) !== 0)) return;
3056 if (x === NEXT_FILTER) {
3057 promise._reject(value);
3058 } else if (x === errorObj || x === promise) {
3059 var err = x === promise ? makeSelfResolutionError() : x.e;
3060 promise._rejectCallback(err, false);
3062 debug.checkForgottenReturns(x, promiseCreated, "", promise, this);
3063 promise._resolveCallback(x);
3067 Promise.prototype._target = function() {
3069 while (ret._isFollowing()) ret = ret._followee();
3073 Promise.prototype._followee = function() {
3074 return this._rejectionHandler0;
3077 Promise.prototype._setFollowee = function(promise) {
3078 this._rejectionHandler0 = promise;
3081 Promise.prototype._settlePromise = function(promise, handler, receiver, value) {
3082 var isPromise = promise instanceof Promise;
3083 var bitField = this._bitField;
3084 var asyncGuaranteed = ((bitField & 134217728) !== 0);
3085 if (((bitField & 65536) !== 0)) {
3086 if (isPromise) promise._invokeInternalOnCancel();
3088 if (receiver instanceof PassThroughHandlerContext) {
3089 receiver.cancelPromise = promise;
3090 if (tryCatch(handler).call(receiver, value) === errorObj) {
3091 promise._reject(errorObj.e);
3093 } else if (handler === reflectHandler) {
3094 promise._fulfill(reflectHandler.call(receiver));
3095 } else if (receiver instanceof Proxyable) {
3096 receiver._promiseCancelled(promise);
3097 } else if (isPromise || promise instanceof PromiseArray) {
3102 } else if (typeof handler === "function") {
3104 handler.call(receiver, value, promise);
3106 if (asyncGuaranteed) promise._setAsyncGuaranteed();
3107 this._settlePromiseFromHandler(handler, receiver, value, promise);
3109 } else if (receiver instanceof Proxyable) {
3110 if (!receiver._isResolved()) {
3111 if (((bitField & 33554432) !== 0)) {
3112 receiver._promiseFulfilled(value, promise);
3114 receiver._promiseRejected(value, promise);
3117 } else if (isPromise) {
3118 if (asyncGuaranteed) promise._setAsyncGuaranteed();
3119 if (((bitField & 33554432) !== 0)) {
3120 promise._fulfill(value);
3122 promise._reject(value);
3127 Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) {
3128 var handler = ctx.handler;
3129 var promise = ctx.promise;
3130 var receiver = ctx.receiver;
3131 var value = ctx.value;
3132 if (typeof handler === "function") {
3133 if (!(promise instanceof Promise)) {
3134 handler.call(receiver, value, promise);
3136 this._settlePromiseFromHandler(handler, receiver, value, promise);
3138 } else if (promise instanceof Promise) {
3139 promise._reject(value);
3143 Promise.prototype._settlePromiseCtx = function(ctx) {
3144 this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
3147 Promise.prototype._settlePromise0 = function(handler, value, bitField) {
3148 var promise = this._promise0;
3149 var receiver = this._receiverAt(0);
3150 this._promise0 = undefined;
3151 this._receiver0 = undefined;
3152 this._settlePromise(promise, handler, receiver, value);
3155 Promise.prototype._clearCallbackDataAtIndex = function(index) {
3156 var base = index * 4 - 4;
3160 this[base + 1] = undefined;
3163 Promise.prototype._fulfill = function (value) {
3164 var bitField = this._bitField;
3165 if (((bitField & 117506048) >>> 16)) return;
3166 if (value === this) {
3167 var err = makeSelfResolutionError();
3168 this._attachExtraTrace(err);
3169 return this._reject(err);
3171 this._setFulfilled();
3172 this._rejectionHandler0 = value;
3174 if ((bitField & 65535) > 0) {
3175 if (((bitField & 134217728) !== 0)) {
3176 this._settlePromises();
3178 async.settlePromises(this);
3183 Promise.prototype._reject = function (reason) {
3184 var bitField = this._bitField;
3185 if (((bitField & 117506048) >>> 16)) return;
3186 this._setRejected();
3187 this._fulfillmentHandler0 = reason;
3189 if (this._isFinal()) {
3190 return async.fatalError(reason, util.isNode);
3193 if ((bitField & 65535) > 0) {
3194 if (((bitField & 134217728) !== 0)) {
3195 this._settlePromises();
3197 async.settlePromises(this);
3200 this._ensurePossibleRejectionHandled();
3204 Promise.prototype._fulfillPromises = function (len, value) {
3205 for (var i = 1; i < len; i++) {
3206 var handler = this._fulfillmentHandlerAt(i);
3207 var promise = this._promiseAt(i);
3208 var receiver = this._receiverAt(i);
3209 this._clearCallbackDataAtIndex(i);
3210 this._settlePromise(promise, handler, receiver, value);
3214 Promise.prototype._rejectPromises = function (len, reason) {
3215 for (var i = 1; i < len; i++) {
3216 var handler = this._rejectionHandlerAt(i);
3217 var promise = this._promiseAt(i);
3218 var receiver = this._receiverAt(i);
3219 this._clearCallbackDataAtIndex(i);
3220 this._settlePromise(promise, handler, receiver, reason);
3224 Promise.prototype._settlePromises = function () {
3225 var bitField = this._bitField;
3226 var len = (bitField & 65535);
3229 if (((bitField & 16842752) !== 0)) {
3230 var reason = this._fulfillmentHandler0;
3231 this._settlePromise0(this._rejectionHandler0, reason, bitField);
3232 this._rejectPromises(len, reason);
3234 var value = this._rejectionHandler0;
3235 this._settlePromise0(this._fulfillmentHandler0, value, bitField);
3236 this._fulfillPromises(len, value);
3240 this._clearCancellationData();
3243 Promise.prototype._settledValue = function() {
3244 var bitField = this._bitField;
3245 if (((bitField & 33554432) !== 0)) {
3246 return this._rejectionHandler0;
3247 } else if (((bitField & 16777216) !== 0)) {
3248 return this._fulfillmentHandler0;
3252 function deferResolve(v) {this.promise._resolveCallback(v);}
3253 function deferReject(v) {this.promise._rejectCallback(v, false);}
3255 Promise.defer = Promise.pending = function() {
3256 debug.deprecated("Promise.defer", "new Promise");
3257 var promise = new Promise(INTERNAL);
3260 resolve: deferResolve,
3265 util.notEnumerableProp(Promise,
3266 "_makeSelfResolutionError",
3267 makeSelfResolutionError);
3269 _dereq_("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection,
3271 _dereq_("./bind")(Promise, INTERNAL, tryConvertToPromise, debug);
3272 _dereq_("./cancel")(Promise, PromiseArray, apiRejection, debug);
3273 _dereq_("./direct_resolve")(Promise);
3274 _dereq_("./synchronous_inspection")(Promise);
3276 Promise, PromiseArray, tryConvertToPromise, INTERNAL, debug);
3277 Promise.Promise = Promise;
3278 _dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
3279 _dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug);
3280 _dereq_('./timers.js')(Promise, INTERNAL, debug);
3281 _dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug);
3282 _dereq_('./nodeify.js')(Promise);
3283 _dereq_('./call_get.js')(Promise);
3284 _dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);
3285 _dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);
3286 _dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);
3287 _dereq_('./settle.js')(Promise, PromiseArray, debug);
3288 _dereq_('./some.js')(Promise, PromiseArray, apiRejection);
3289 _dereq_('./promisify.js')(Promise, INTERNAL);
3290 _dereq_('./any.js')(Promise);
3291 _dereq_('./each.js')(Promise, INTERNAL);
3292 _dereq_('./filter.js')(Promise, INTERNAL);
3294 util.toFastProperties(Promise);
3295 util.toFastProperties(Promise.prototype);
3296 function fillTypes(value) {
3297 var p = new Promise(INTERNAL);
3298 p._fulfillmentHandler0 = value;
3299 p._rejectionHandler0 = value;
3300 p._promise0 = value;
3301 p._receiver0 = value;
3303 // Complete slack tracking, opt out of field-type tracking and
3309 fillTypes(function(){});
3310 fillTypes(undefined);
3312 fillTypes(new Promise(INTERNAL));
3313 debug.setBounds(Async.firstLineError, util.lastLineError);
3318 },{"./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}],23:[function(_dereq_,module,exports){
3320 module.exports = function(Promise, INTERNAL, tryConvertToPromise,
3321 apiRejection, Proxyable) {
3322 var util = _dereq_("./util");
3323 var isArray = util.isArray;
3325 function toResolutionValue(val) {
3332 function PromiseArray(values) {
3333 var promise = this._promise = new Promise(INTERNAL);
3334 if (values instanceof Promise) {
3335 promise._propagateFrom(values, 3);
3337 promise._setOnCancel(this);
3338 this._values = values;
3340 this._totalResolved = 0;
3341 this._init(undefined, -2);
3343 util.inherits(PromiseArray, Proxyable);
3345 PromiseArray.prototype.length = function () {
3346 return this._length;
3349 PromiseArray.prototype.promise = function () {
3350 return this._promise;
3353 PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
3354 var values = tryConvertToPromise(this._values, this._promise);
3355 if (values instanceof Promise) {
3356 values = values._target();
3357 var bitField = values._bitField;
3359 this._values = values;
3361 if (((bitField & 50397184) === 0)) {
3362 this._promise._setAsyncGuaranteed();
3363 return values._then(
3370 } else if (((bitField & 33554432) !== 0)) {
3371 values = values._value();
3372 } else if (((bitField & 16777216) !== 0)) {
3373 return this._reject(values._reason());
3375 return this._cancel();
3378 values = util.asArray(values);
3379 if (values === null) {
3380 var err = apiRejection(
3381 "expecting an array or an iterable object but got " + util.classString(values)).reason();
3382 this._promise._rejectCallback(err, false);
3386 if (values.length === 0) {
3387 if (resolveValueIfEmpty === -5) {
3388 this._resolveEmptyArray();
3391 this._resolve(toResolutionValue(resolveValueIfEmpty));
3395 this._iterate(values);
3398 PromiseArray.prototype._iterate = function(values) {
3399 var len = this.getActualLength(values.length);
3401 this._values = this.shouldCopyValues() ? new Array(len) : this._values;
3402 var result = this._promise;
3403 var isResolved = false;
3404 var bitField = null;
3405 for (var i = 0; i < len; ++i) {
3406 var maybePromise = tryConvertToPromise(values[i], result);
3408 if (maybePromise instanceof Promise) {
3409 maybePromise = maybePromise._target();
3410 bitField = maybePromise._bitField;
3416 if (bitField !== null) {
3417 maybePromise.suppressUnhandledRejections();
3419 } else if (bitField !== null) {
3420 if (((bitField & 50397184) === 0)) {
3421 maybePromise._proxy(this, i);
3422 this._values[i] = maybePromise;
3423 } else if (((bitField & 33554432) !== 0)) {
3424 isResolved = this._promiseFulfilled(maybePromise._value(), i);
3425 } else if (((bitField & 16777216) !== 0)) {
3426 isResolved = this._promiseRejected(maybePromise._reason(), i);
3428 isResolved = this._promiseCancelled(i);
3431 isResolved = this._promiseFulfilled(maybePromise, i);
3434 if (!isResolved) result._setAsyncGuaranteed();
3437 PromiseArray.prototype._isResolved = function () {
3438 return this._values === null;
3441 PromiseArray.prototype._resolve = function (value) {
3442 this._values = null;
3443 this._promise._fulfill(value);
3446 PromiseArray.prototype._cancel = function() {
3447 if (this._isResolved() || !this._promise.isCancellable()) return;
3448 this._values = null;
3449 this._promise._cancel();
3452 PromiseArray.prototype._reject = function (reason) {
3453 this._values = null;
3454 this._promise._rejectCallback(reason, false);
3457 PromiseArray.prototype._promiseFulfilled = function (value, index) {
3458 this._values[index] = value;
3459 var totalResolved = ++this._totalResolved;
3460 if (totalResolved >= this._length) {
3461 this._resolve(this._values);
3467 PromiseArray.prototype._promiseCancelled = function() {
3472 PromiseArray.prototype._promiseRejected = function (reason) {
3473 this._totalResolved++;
3474 this._reject(reason);
3478 PromiseArray.prototype._resultCancelled = function() {
3479 if (this._isResolved()) return;
3480 var values = this._values;
3482 if (values instanceof Promise) {
3485 for (var i = 0; i < values.length; ++i) {
3486 if (values[i] instanceof Promise) {
3493 PromiseArray.prototype.shouldCopyValues = function () {
3497 PromiseArray.prototype.getActualLength = function (len) {
3501 return PromiseArray;
3504 },{"./util":36}],24:[function(_dereq_,module,exports){
3506 module.exports = function(Promise, INTERNAL) {
3508 var util = _dereq_("./util");
3509 var nodebackForPromise = _dereq_("./nodeback");
3510 var withAppended = util.withAppended;
3511 var maybeWrapAsError = util.maybeWrapAsError;
3512 var canEvaluate = util.canEvaluate;
3513 var TypeError = _dereq_("./errors").TypeError;
3514 var defaultSuffix = "Async";
3515 var defaultPromisified = {__isPromisified__: true};
3525 var noCopyPropsPattern = new RegExp("^(?:" + noCopyProps.join("|") + ")$");
3527 var defaultFilter = function(name) {
3528 return util.isIdentifier(name) &&
3529 name.charAt(0) !== "_" &&
3530 name !== "constructor";
3533 function propsFilter(key) {
3534 return !noCopyPropsPattern.test(key);
3537 function isPromisified(fn) {
3539 return fn.__isPromisified__ === true;
3546 function hasPromisified(obj, key, suffix) {
3547 var val = util.getDataPropertyOrDefault(obj, key + suffix,
3548 defaultPromisified);
3549 return val ? isPromisified(val) : false;
3551 function checkValid(ret, suffix, suffixRegexp) {
3552 for (var i = 0; i < ret.length; i += 2) {
3554 if (suffixRegexp.test(key)) {
3555 var keyWithoutAsyncSuffix = key.replace(suffixRegexp, "");
3556 for (var j = 0; j < ret.length; j += 2) {
3557 if (ret[j] === keyWithoutAsyncSuffix) {
3558 throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a See http://goo.gl/MqrFmX\u000a"
3559 .replace("%s", suffix));
3566 function promisifiableMethods(obj, suffix, suffixRegexp, filter) {
3567 var keys = util.inheritedDataKeys(obj);
3569 for (var i = 0; i < keys.length; ++i) {
3571 var value = obj[key];
3572 var passesDefaultFilter = filter === defaultFilter
3573 ? true : defaultFilter(key, value, obj);
3574 if (typeof value === "function" &&
3575 !isPromisified(value) &&
3576 !hasPromisified(obj, key, suffix) &&
3577 filter(key, value, obj, passesDefaultFilter)) {
3578 ret.push(key, value);
3581 checkValid(ret, suffix, suffixRegexp);
3585 var escapeIdentRegex = function(str) {
3586 return str.replace(/([$])/, "\\$");
3589 var makeNodePromisifiedEval;
3591 var switchCaseArgumentOrder = function(likelyArgumentCount) {
3592 var ret = [likelyArgumentCount];
3593 var min = Math.max(0, likelyArgumentCount - 1 - 3);
3594 for(var i = likelyArgumentCount - 1; i >= min; --i) {
3597 for(var i = likelyArgumentCount + 1; i <= 3; ++i) {
3603 var argumentSequence = function(argumentCount) {
3604 return util.filledRange(argumentCount, "_arg", "");
3607 var parameterDeclaration = function(parameterCount) {
3608 return util.filledRange(
3609 Math.max(parameterCount, 3), "_arg", "");
3612 var parameterCount = function(fn) {
3613 if (typeof fn.length === "number") {
3614 return Math.max(Math.min(fn.length, 1023 + 1), 0);
3619 makeNodePromisifiedEval =
3620 function(callback, receiver, originalName, fn, _, multiArgs) {
3621 var newParameterCount = Math.max(0, parameterCount(fn) - 1);
3622 var argumentOrder = switchCaseArgumentOrder(newParameterCount);
3623 var shouldProxyThis = typeof callback === "string" || receiver === THIS;
3625 function generateCallForArgumentCount(count) {
3626 var args = argumentSequence(count).join(", ");
3627 var comma = count > 0 ? ", " : "";
3629 if (shouldProxyThis) {
3630 ret = "ret = callback.call(this, {{args}}, nodeback); break;\n";
3632 ret = receiver === undefined
3633 ? "ret = callback({{args}}, nodeback); break;\n"
3634 : "ret = callback.call(receiver, {{args}}, nodeback); break;\n";
3636 return ret.replace("{{args}}", args).replace(", ", comma);
3639 function generateArgumentSwitchCase() {
3641 for (var i = 0; i < argumentOrder.length; ++i) {
3642 ret += "case " + argumentOrder[i] +":" +
3643 generateCallForArgumentCount(argumentOrder[i]);
3648 var args = new Array(len + 1); \n\
3650 for (var i = 0; i < len; ++i) { \n\
3651 args[i] = arguments[i]; \n\
3653 args[i] = nodeback; \n\
3656 ".replace("[CodeForCall]", (shouldProxyThis
3657 ? "ret = callback.apply(this, args);\n"
3658 : "ret = callback.apply(receiver, args);\n"));
3662 var getFunctionCode = typeof callback === "string"
3663 ? ("this != null ? this['"+callback+"'] : fn")
3665 var body = "'use strict'; \n\
3666 var ret = function (Parameters) { \n\
3668 var len = arguments.length; \n\
3669 var promise = new Promise(INTERNAL); \n\
3670 promise._captureStackTrace(); \n\
3671 var nodeback = nodebackForPromise(promise, " + multiArgs + "); \n\
3673 var callback = tryCatch([GetFunctionCode]); \n\
3675 [CodeForSwitchCase] \n\
3677 if (ret === errorObj) { \n\
3678 promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\
3680 if (!promise._isFateSealed()) promise._setAsyncGuaranteed(); \n\
3683 notEnumerableProp(ret, '__isPromisified__', true); \n\
3685 ".replace("[CodeForSwitchCase]", generateArgumentSwitchCase())
3686 .replace("[GetFunctionCode]", getFunctionCode);
3687 body = body.replace("Parameters", parameterDeclaration(newParameterCount));
3688 return new Function("Promise",
3693 "nodebackForPromise",
3696 "notEnumerableProp",
3707 util.notEnumerableProp,
3712 function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {
3713 var defaultThis = (function() {return this;})();
3714 var method = callback;
3715 if (typeof method === "string") {
3718 function promisified() {
3719 var _receiver = receiver;
3720 if (receiver === THIS) _receiver = this;
3721 var promise = new Promise(INTERNAL);
3722 promise._captureStackTrace();
3723 var cb = typeof method === "string" && this !== defaultThis
3724 ? this[method] : callback;
3725 var fn = nodebackForPromise(promise, multiArgs);
3727 cb.apply(_receiver, withAppended(arguments, fn));
3729 promise._rejectCallback(maybeWrapAsError(e), true, true);
3731 if (!promise._isFateSealed()) promise._setAsyncGuaranteed();
3734 util.notEnumerableProp(promisified, "__isPromisified__", true);
3738 var makeNodePromisified = canEvaluate
3739 ? makeNodePromisifiedEval
3740 : makeNodePromisifiedClosure;
3742 function promisifyAll(obj, suffix, filter, promisifier, multiArgs) {
3743 var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$");
3745 promisifiableMethods(obj, suffix, suffixRegexp, filter);
3747 for (var i = 0, len = methods.length; i < len; i+= 2) {
3748 var key = methods[i];
3749 var fn = methods[i+1];
3750 var promisifiedKey = key + suffix;
3751 if (promisifier === makeNodePromisified) {
3752 obj[promisifiedKey] =
3753 makeNodePromisified(key, THIS, key, fn, suffix, multiArgs);
3755 var promisified = promisifier(fn, function() {
3756 return makeNodePromisified(key, THIS, key,
3757 fn, suffix, multiArgs);
3759 util.notEnumerableProp(promisified, "__isPromisified__", true);
3760 obj[promisifiedKey] = promisified;
3763 util.toFastProperties(obj);
3767 function promisify(callback, receiver, multiArgs) {
3768 return makeNodePromisified(callback, receiver, undefined,
3769 callback, null, multiArgs);
3772 Promise.promisify = function (fn, options) {
3773 if (typeof fn !== "function") {
3774 throw new TypeError("expecting a function but got " + util.classString(fn));
3776 if (isPromisified(fn)) {
3779 options = Object(options);
3780 var receiver = options.context === undefined ? THIS : options.context;
3781 var multiArgs = !!options.multiArgs;
3782 var ret = promisify(fn, receiver, multiArgs);
3783 util.copyDescriptors(fn, ret, propsFilter);
3787 Promise.promisifyAll = function (target, options) {
3788 if (typeof target !== "function" && typeof target !== "object") {
3789 throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a See http://goo.gl/MqrFmX\u000a");
3791 options = Object(options);
3792 var multiArgs = !!options.multiArgs;
3793 var suffix = options.suffix;
3794 if (typeof suffix !== "string") suffix = defaultSuffix;
3795 var filter = options.filter;
3796 if (typeof filter !== "function") filter = defaultFilter;
3797 var promisifier = options.promisifier;
3798 if (typeof promisifier !== "function") promisifier = makeNodePromisified;
3800 if (!util.isIdentifier(suffix)) {
3801 throw new RangeError("suffix must be a valid identifier\u000a\u000a See http://goo.gl/MqrFmX\u000a");
3804 var keys = util.inheritedDataKeys(target);
3805 for (var i = 0; i < keys.length; ++i) {
3806 var value = target[keys[i]];
3807 if (keys[i] !== "constructor" &&
3808 util.isClass(value)) {
3809 promisifyAll(value.prototype, suffix, filter, promisifier,
3811 promisifyAll(value, suffix, filter, promisifier, multiArgs);
3815 return promisifyAll(target, suffix, filter, promisifier, multiArgs);
3820 },{"./errors":12,"./nodeback":20,"./util":36}],25:[function(_dereq_,module,exports){
3822 module.exports = function(
3823 Promise, PromiseArray, tryConvertToPromise, apiRejection) {
3824 var util = _dereq_("./util");
3825 var isObject = util.isObject;
3826 var es5 = _dereq_("./es5");
3828 if (typeof Map === "function") Es6Map = Map;
3830 var mapToEntries = (function() {
3834 function extractEntry(value, key) {
3835 this[index] = value;
3836 this[index + size] = key;
3840 return function mapToEntries(map) {
3843 var ret = new Array(map.size * 2);
3844 map.forEach(extractEntry, ret);
3849 var entriesToMap = function(entries) {
3850 var ret = new Es6Map();
3851 var length = entries.length / 2 | 0;
3852 for (var i = 0; i < length; ++i) {
3853 var key = entries[length + i];
3854 var value = entries[i];
3855 ret.set(key, value);
3860 function PropertiesPromiseArray(obj) {
3863 if (Es6Map !== undefined && obj instanceof Es6Map) {
3864 entries = mapToEntries(obj);
3867 var keys = es5.keys(obj);
3868 var len = keys.length;
3869 entries = new Array(len * 2);
3870 for (var i = 0; i < len; ++i) {
3872 entries[i] = obj[key];
3873 entries[i + len] = key;
3876 this.constructor$(entries);
3877 this._isMap = isMap;
3878 this._init$(undefined, -3);
3880 util.inherits(PropertiesPromiseArray, PromiseArray);
3882 PropertiesPromiseArray.prototype._init = function () {};
3884 PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {
3885 this._values[index] = value;
3886 var totalResolved = ++this._totalResolved;
3887 if (totalResolved >= this._length) {
3890 val = entriesToMap(this._values);
3893 var keyOffset = this.length();
3894 for (var i = 0, len = this.length(); i < len; ++i) {
3895 val[this._values[i + keyOffset]] = this._values[i];
3904 PropertiesPromiseArray.prototype.shouldCopyValues = function () {
3908 PropertiesPromiseArray.prototype.getActualLength = function (len) {
3912 function props(promises) {
3914 var castValue = tryConvertToPromise(promises);
3916 if (!isObject(castValue)) {
3917 return apiRejection("cannot await properties of a non-object\u000a\u000a See http://goo.gl/MqrFmX\u000a");
3918 } else if (castValue instanceof Promise) {
3919 ret = castValue._then(
3920 Promise.props, undefined, undefined, undefined, undefined);
3922 ret = new PropertiesPromiseArray(castValue).promise();
3925 if (castValue instanceof Promise) {
3926 ret._propagateFrom(castValue, 2);
3931 Promise.prototype.props = function () {
3935 Promise.props = function (promises) {
3936 return props(promises);
3940 },{"./es5":13,"./util":36}],26:[function(_dereq_,module,exports){
3942 function arrayMove(src, srcIndex, dst, dstIndex, len) {
3943 for (var j = 0; j < len; ++j) {
3944 dst[j + dstIndex] = src[j + srcIndex];
3945 src[j + srcIndex] = void 0;
3949 function Queue(capacity) {
3950 this._capacity = capacity;
3955 Queue.prototype._willBeOverCapacity = function (size) {
3956 return this._capacity < size;
3959 Queue.prototype._pushOne = function (arg) {
3960 var length = this.length();
3961 this._checkCapacity(length + 1);
3962 var i = (this._front + length) & (this._capacity - 1);
3964 this._length = length + 1;
3967 Queue.prototype._unshiftOne = function(value) {
3968 var capacity = this._capacity;
3969 this._checkCapacity(this.length() + 1);
3970 var front = this._front;
3971 var i = (((( front - 1 ) &
3972 ( capacity - 1) ) ^ capacity ) - capacity );
3975 this._length = this.length() + 1;
3978 Queue.prototype.unshift = function(fn, receiver, arg) {
3979 this._unshiftOne(arg);
3980 this._unshiftOne(receiver);
3981 this._unshiftOne(fn);
3984 Queue.prototype.push = function (fn, receiver, arg) {
3985 var length = this.length() + 3;
3986 if (this._willBeOverCapacity(length)) {
3988 this._pushOne(receiver);
3992 var j = this._front + length - 3;
3993 this._checkCapacity(length);
3994 var wrapMask = this._capacity - 1;
3995 this[(j + 0) & wrapMask] = fn;
3996 this[(j + 1) & wrapMask] = receiver;
3997 this[(j + 2) & wrapMask] = arg;
3998 this._length = length;
4001 Queue.prototype.shift = function () {
4002 var front = this._front,
4005 this[front] = undefined;
4006 this._front = (front + 1) & (this._capacity - 1);
4011 Queue.prototype.length = function () {
4012 return this._length;
4015 Queue.prototype._checkCapacity = function (size) {
4016 if (this._capacity < size) {
4017 this._resizeTo(this._capacity << 1);
4021 Queue.prototype._resizeTo = function (capacity) {
4022 var oldCapacity = this._capacity;
4023 this._capacity = capacity;
4024 var front = this._front;
4025 var length = this._length;
4026 var moveItemsCount = (front + length) & (oldCapacity - 1);
4027 arrayMove(this, 0, this, oldCapacity, moveItemsCount);
4030 module.exports = Queue;
4032 },{}],27:[function(_dereq_,module,exports){
4034 module.exports = function(
4035 Promise, INTERNAL, tryConvertToPromise, apiRejection) {
4036 var util = _dereq_("./util");
4038 var raceLater = function (promise) {
4039 return promise.then(function(array) {
4040 return race(array, promise);
4044 function race(promises, parent) {
4045 var maybePromise = tryConvertToPromise(promises);
4047 if (maybePromise instanceof Promise) {
4048 return raceLater(maybePromise);
4050 promises = util.asArray(promises);
4051 if (promises === null)
4052 return apiRejection("expecting an array or an iterable object but got " + util.classString(promises));
4055 var ret = new Promise(INTERNAL);
4056 if (parent !== undefined) {
4057 ret._propagateFrom(parent, 3);
4059 var fulfill = ret._fulfill;
4060 var reject = ret._reject;
4061 for (var i = 0, len = promises.length; i < len; ++i) {
4062 var val = promises[i];
4064 if (val === undefined && !(i in promises)) {
4068 Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
4073 Promise.race = function (promises) {
4074 return race(promises, undefined);
4077 Promise.prototype.race = function () {
4078 return race(this, undefined);
4083 },{"./util":36}],28:[function(_dereq_,module,exports){
4085 module.exports = function(Promise,
4088 tryConvertToPromise,
4091 var getDomain = Promise._getDomain;
4092 var util = _dereq_("./util");
4093 var tryCatch = util.tryCatch;
4095 function ReductionPromiseArray(promises, fn, initialValue, _each) {
4096 this.constructor$(promises);
4097 var domain = getDomain();
4098 this._fn = domain === null ? fn : domain.bind(fn);
4099 if (initialValue !== undefined) {
4100 initialValue = Promise.resolve(initialValue);
4101 initialValue._attachCancellationCallback(this);
4103 this._initialValue = initialValue;
4104 this._currentCancellable = null;
4105 this._eachValues = _each === INTERNAL ? [] : undefined;
4106 this._promise._captureStackTrace();
4107 this._init$(undefined, -5);
4109 util.inherits(ReductionPromiseArray, PromiseArray);
4111 ReductionPromiseArray.prototype._gotAccum = function(accum) {
4112 if (this._eachValues !== undefined && accum !== INTERNAL) {
4113 this._eachValues.push(accum);
4117 ReductionPromiseArray.prototype._eachComplete = function(value) {
4118 this._eachValues.push(value);
4119 return this._eachValues;
4122 ReductionPromiseArray.prototype._init = function() {};
4124 ReductionPromiseArray.prototype._resolveEmptyArray = function() {
4125 this._resolve(this._eachValues !== undefined ? this._eachValues
4126 : this._initialValue);
4129 ReductionPromiseArray.prototype.shouldCopyValues = function () {
4133 ReductionPromiseArray.prototype._resolve = function(value) {
4134 this._promise._resolveCallback(value);
4135 this._values = null;
4138 ReductionPromiseArray.prototype._resultCancelled = function(sender) {
4139 if (sender === this._initialValue) return this._cancel();
4140 if (this._isResolved()) return;
4141 this._resultCancelled$();
4142 if (this._currentCancellable instanceof Promise) {
4143 this._currentCancellable.cancel();
4145 if (this._initialValue instanceof Promise) {
4146 this._initialValue.cancel();
4150 ReductionPromiseArray.prototype._iterate = function (values) {
4151 this._values = values;
4154 var length = values.length;
4155 if (this._initialValue !== undefined) {
4156 value = this._initialValue;
4159 value = Promise.resolve(values[0]);
4163 this._currentCancellable = value;
4165 if (!value.isRejected()) {
4166 for (; i < length; ++i) {
4174 value = value._then(gotAccum, undefined, undefined, ctx, undefined);
4178 if (this._eachValues !== undefined) {
4180 ._then(this._eachComplete, undefined, undefined, this, undefined);
4182 value._then(completed, completed, undefined, value, this);
4185 Promise.prototype.reduce = function (fn, initialValue) {
4186 return reduce(this, fn, initialValue, null);
4189 Promise.reduce = function (promises, fn, initialValue, _each) {
4190 return reduce(promises, fn, initialValue, _each);
4193 function completed(valueOrReason, array) {
4194 if (this.isFulfilled()) {
4195 array._resolve(valueOrReason);
4197 array._reject(valueOrReason);
4201 function reduce(promises, fn, initialValue, _each) {
4202 if (typeof fn !== "function") {
4203 return apiRejection("expecting a function but got " + util.classString(fn));
4205 var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
4206 return array.promise();
4209 function gotAccum(accum) {
4211 this.array._gotAccum(accum);
4212 var value = tryConvertToPromise(this.value, this.array._promise);
4213 if (value instanceof Promise) {
4214 this.array._currentCancellable = value;
4215 return value._then(gotValue, undefined, undefined, this, undefined);
4217 return gotValue.call(this, value);
4221 function gotValue(value) {
4222 var array = this.array;
4223 var promise = array._promise;
4224 var fn = tryCatch(array._fn);
4225 promise._pushContext();
4227 if (array._eachValues !== undefined) {
4228 ret = fn.call(promise._boundValue(), value, this.index, this.length);
4230 ret = fn.call(promise._boundValue(),
4231 this.accum, value, this.index, this.length);
4233 if (ret instanceof Promise) {
4234 array._currentCancellable = ret;
4236 var promiseCreated = promise._popContext();
4237 debug.checkForgottenReturns(
4240 array._eachValues !== undefined ? "Promise.each" : "Promise.reduce",
4247 },{"./util":36}],29:[function(_dereq_,module,exports){
4249 var util = _dereq_("./util");
4251 var noAsyncScheduler = function() {
4252 throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/MqrFmX\u000a");
4254 if (util.isNode && typeof MutationObserver === "undefined") {
4255 var GlobalSetImmediate = global.setImmediate;
4256 var ProcessNextTick = process.nextTick;
4257 schedule = util.isRecentNode
4258 ? function(fn) { GlobalSetImmediate.call(global, fn); }
4259 : function(fn) { ProcessNextTick.call(process, fn); };
4260 } else if ((typeof MutationObserver !== "undefined") &&
4261 !(typeof window !== "undefined" &&
4263 window.navigator.standalone)) {
4264 schedule = (function() {
4265 var div = document.createElement("div");
4266 var opts = {attributes: true};
4267 var toggleScheduled = false;
4268 var div2 = document.createElement("div");
4269 var o2 = new MutationObserver(function() {
4270 div.classList.toggle("foo");
4271 toggleScheduled = false;
4273 o2.observe(div2, opts);
4275 var scheduleToggle = function() {
4276 if (toggleScheduled) return;
4277 toggleScheduled = true;
4278 div2.classList.toggle("foo");
4281 return function schedule(fn) {
4282 var o = new MutationObserver(function() {
4286 o.observe(div, opts);
4290 } else if (typeof setImmediate !== "undefined") {
4291 schedule = function (fn) {
4294 } else if (typeof setTimeout !== "undefined") {
4295 schedule = function (fn) {
4299 schedule = noAsyncScheduler;
4301 module.exports = schedule;
4303 },{"./util":36}],30:[function(_dereq_,module,exports){
4306 function(Promise, PromiseArray, debug) {
4307 var PromiseInspection = Promise.PromiseInspection;
4308 var util = _dereq_("./util");
4310 function SettledPromiseArray(values) {
4311 this.constructor$(values);
4313 util.inherits(SettledPromiseArray, PromiseArray);
4315 SettledPromiseArray.prototype._promiseResolved = function (index, inspection) {
4316 this._values[index] = inspection;
4317 var totalResolved = ++this._totalResolved;
4318 if (totalResolved >= this._length) {
4319 this._resolve(this._values);
4325 SettledPromiseArray.prototype._promiseFulfilled = function (value, index) {
4326 var ret = new PromiseInspection();
4327 ret._bitField = 33554432;
4328 ret._settledValueField = value;
4329 return this._promiseResolved(index, ret);
4331 SettledPromiseArray.prototype._promiseRejected = function (reason, index) {
4332 var ret = new PromiseInspection();
4333 ret._bitField = 16777216;
4334 ret._settledValueField = reason;
4335 return this._promiseResolved(index, ret);
4338 Promise.settle = function (promises) {
4339 debug.deprecated(".settle()", ".reflect()");
4340 return new SettledPromiseArray(promises).promise();
4343 Promise.prototype.settle = function () {
4344 return Promise.settle(this);
4348 },{"./util":36}],31:[function(_dereq_,module,exports){
4351 function(Promise, PromiseArray, apiRejection) {
4352 var util = _dereq_("./util");
4353 var RangeError = _dereq_("./errors").RangeError;
4354 var AggregateError = _dereq_("./errors").AggregateError;
4355 var isArray = util.isArray;
4356 var CANCELLATION = {};
4359 function SomePromiseArray(values) {
4360 this.constructor$(values);
4362 this._unwrap = false;
4363 this._initialized = false;
4365 util.inherits(SomePromiseArray, PromiseArray);
4367 SomePromiseArray.prototype._init = function () {
4368 if (!this._initialized) {
4371 if (this._howMany === 0) {
4375 this._init$(undefined, -5);
4376 var isArrayResolved = isArray(this._values);
4377 if (!this._isResolved() &&
4379 this._howMany > this._canPossiblyFulfill()) {
4380 this._reject(this._getRangeError(this.length()));
4384 SomePromiseArray.prototype.init = function () {
4385 this._initialized = true;
4389 SomePromiseArray.prototype.setUnwrap = function () {
4390 this._unwrap = true;
4393 SomePromiseArray.prototype.howMany = function () {
4394 return this._howMany;
4397 SomePromiseArray.prototype.setHowMany = function (count) {
4398 this._howMany = count;
4401 SomePromiseArray.prototype._promiseFulfilled = function (value) {
4402 this._addFulfilled(value);
4403 if (this._fulfilled() === this.howMany()) {
4404 this._values.length = this.howMany();
4405 if (this.howMany() === 1 && this._unwrap) {
4406 this._resolve(this._values[0]);
4408 this._resolve(this._values);
4415 SomePromiseArray.prototype._promiseRejected = function (reason) {
4416 this._addRejected(reason);
4417 return this._checkOutcome();
4420 SomePromiseArray.prototype._promiseCancelled = function () {
4421 if (this._values instanceof Promise || this._values == null) {
4422 return this._cancel();
4424 this._addRejected(CANCELLATION);
4425 return this._checkOutcome();
4428 SomePromiseArray.prototype._checkOutcome = function() {
4429 if (this.howMany() > this._canPossiblyFulfill()) {
4430 var e = new AggregateError();
4431 for (var i = this.length(); i < this._values.length; ++i) {
4432 if (this._values[i] !== CANCELLATION) {
4433 e.push(this._values[i]);
4446 SomePromiseArray.prototype._fulfilled = function () {
4447 return this._totalResolved;
4450 SomePromiseArray.prototype._rejected = function () {
4451 return this._values.length - this.length();
4454 SomePromiseArray.prototype._addRejected = function (reason) {
4455 this._values.push(reason);
4458 SomePromiseArray.prototype._addFulfilled = function (value) {
4459 this._values[this._totalResolved++] = value;
4462 SomePromiseArray.prototype._canPossiblyFulfill = function () {
4463 return this.length() - this._rejected();
4466 SomePromiseArray.prototype._getRangeError = function (count) {
4467 var message = "Input array must contain at least " +
4468 this._howMany + " items but contains only " + count + " items";
4469 return new RangeError(message);
4472 SomePromiseArray.prototype._resolveEmptyArray = function () {
4473 this._reject(this._getRangeError(0));
4476 function some(promises, howMany) {
4477 if ((howMany | 0) !== howMany || howMany < 0) {
4478 return apiRejection("expecting a positive integer\u000a\u000a See http://goo.gl/MqrFmX\u000a");
4480 var ret = new SomePromiseArray(promises);
4481 var promise = ret.promise();
4482 ret.setHowMany(howMany);
4487 Promise.some = function (promises, howMany) {
4488 return some(promises, howMany);
4491 Promise.prototype.some = function (howMany) {
4492 return some(this, howMany);
4495 Promise._SomePromiseArray = SomePromiseArray;
4498 },{"./errors":12,"./util":36}],32:[function(_dereq_,module,exports){
4500 module.exports = function(Promise) {
4501 function PromiseInspection(promise) {
4502 if (promise !== undefined) {
4503 promise = promise._target();
4504 this._bitField = promise._bitField;
4505 this._settledValueField = promise._isFateSealed()
4506 ? promise._settledValue() : undefined;
4510 this._settledValueField = undefined;
4514 PromiseInspection.prototype._settledValue = function() {
4515 return this._settledValueField;
4518 var value = PromiseInspection.prototype.value = function () {
4519 if (!this.isFulfilled()) {
4520 throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a See http://goo.gl/MqrFmX\u000a");
4522 return this._settledValue();
4525 var reason = PromiseInspection.prototype.error =
4526 PromiseInspection.prototype.reason = function () {
4527 if (!this.isRejected()) {
4528 throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a See http://goo.gl/MqrFmX\u000a");
4530 return this._settledValue();
4533 var isFulfilled = PromiseInspection.prototype.isFulfilled = function() {
4534 return (this._bitField & 33554432) !== 0;
4537 var isRejected = PromiseInspection.prototype.isRejected = function () {
4538 return (this._bitField & 16777216) !== 0;
4541 var isPending = PromiseInspection.prototype.isPending = function () {
4542 return (this._bitField & 50397184) === 0;
4545 var isResolved = PromiseInspection.prototype.isResolved = function () {
4546 return (this._bitField & 50331648) !== 0;
4549 PromiseInspection.prototype.isCancelled =
4550 Promise.prototype._isCancelled = function() {
4551 return (this._bitField & 65536) === 65536;
4554 Promise.prototype.isCancelled = function() {
4555 return this._target()._isCancelled();
4558 Promise.prototype.isPending = function() {
4559 return isPending.call(this._target());
4562 Promise.prototype.isRejected = function() {
4563 return isRejected.call(this._target());
4566 Promise.prototype.isFulfilled = function() {
4567 return isFulfilled.call(this._target());
4570 Promise.prototype.isResolved = function() {
4571 return isResolved.call(this._target());
4574 Promise.prototype.value = function() {
4575 return value.call(this._target());
4578 Promise.prototype.reason = function() {
4579 var target = this._target();
4580 target._unsetRejectionIsUnhandled();
4581 return reason.call(target);
4584 Promise.prototype._value = function() {
4585 return this._settledValue();
4588 Promise.prototype._reason = function() {
4589 this._unsetRejectionIsUnhandled();
4590 return this._settledValue();
4593 Promise.PromiseInspection = PromiseInspection;
4596 },{}],33:[function(_dereq_,module,exports){
4598 module.exports = function(Promise, INTERNAL) {
4599 var util = _dereq_("./util");
4600 var errorObj = util.errorObj;
4601 var isObject = util.isObject;
4603 function tryConvertToPromise(obj, context) {
4604 if (isObject(obj)) {
4605 if (obj instanceof Promise) return obj;
4606 var then = getThen(obj);
4607 if (then === errorObj) {
4608 if (context) context._pushContext();
4609 var ret = Promise.reject(then.e);
4610 if (context) context._popContext();
4612 } else if (typeof then === "function") {
4613 if (isAnyBluebirdPromise(obj)) {
4614 var ret = new Promise(INTERNAL);
4624 return doThenable(obj, then, context);
4630 function doGetThen(obj) {
4634 function getThen(obj) {
4636 return doGetThen(obj);
4643 var hasProp = {}.hasOwnProperty;
4644 function isAnyBluebirdPromise(obj) {
4645 return hasProp.call(obj, "_promise0");
4648 function doThenable(x, then, context) {
4649 var promise = new Promise(INTERNAL);
4651 if (context) context._pushContext();
4652 promise._captureStackTrace();
4653 if (context) context._popContext();
4654 var synchronous = true;
4655 var result = util.tryCatch(then).call(x, resolve, reject);
4656 synchronous = false;
4658 if (promise && result === errorObj) {
4659 promise._rejectCallback(result.e, true, true);
4663 function resolve(value) {
4664 if (!promise) return;
4665 promise._resolveCallback(value);
4669 function reject(reason) {
4670 if (!promise) return;
4671 promise._rejectCallback(reason, synchronous, true);
4677 return tryConvertToPromise;
4680 },{"./util":36}],34:[function(_dereq_,module,exports){
4682 module.exports = function(Promise, INTERNAL, debug) {
4683 var util = _dereq_("./util");
4684 var TimeoutError = Promise.TimeoutError;
4686 var afterTimeout = function (promise, message, parent) {
4687 if (!promise.isPending()) return;
4689 if (typeof message !== "string") {
4690 if (message instanceof Error) {
4693 err = new TimeoutError("operation timed out");
4696 err = new TimeoutError(message);
4698 util.markAsOriginatingFromRejection(err);
4699 promise._attachExtraTrace(err);
4700 promise._reject(err);
4701 if (debug.cancellation()) {
4706 var afterValue = function(value) { return delay(+this).thenReturn(value); };
4707 var delay = Promise.delay = function (ms, value) {
4709 if (value !== undefined) {
4710 ret = Promise.resolve(value)
4711 ._then(afterValue, null, null, ms, undefined);
4713 ret = new Promise(INTERNAL);
4714 setTimeout(function() { ret._fulfill(); }, +ms);
4716 ret._setAsyncGuaranteed();
4720 Promise.prototype.delay = function (ms) {
4721 return delay(ms, this);
4724 function successClear(value) {
4726 if (handle instanceof Number) handle = +handle;
4727 clearTimeout(handle);
4731 function failureClear(reason) {
4733 if (handle instanceof Number) handle = +handle;
4734 clearTimeout(handle);
4739 Promise.prototype.timeout = function (ms, message) {
4741 var parent = this.then();
4742 var ret = parent.then();
4743 var handle = setTimeout(function timeoutTimeout() {
4744 afterTimeout(ret, message, parent);
4746 if (debug.cancellation()) {
4748 _resultCancelled: function() {
4749 clearTimeout(handle);
4753 return ret._then(successClear, failureClear, undefined, handle, undefined);
4758 },{"./util":36}],35:[function(_dereq_,module,exports){
4760 module.exports = function (Promise, apiRejection, tryConvertToPromise,
4761 createContext, INTERNAL, debug) {
4762 var util = _dereq_("./util");
4763 var TypeError = _dereq_("./errors").TypeError;
4764 var inherits = _dereq_("./util").inherits;
4765 var errorObj = util.errorObj;
4766 var tryCatch = util.tryCatch;
4768 function thrower(e) {
4769 setTimeout(function(){throw e;}, 0);
4772 function castPreservingDisposable(thenable) {
4773 var maybePromise = tryConvertToPromise(thenable);
4774 if (maybePromise !== thenable &&
4775 typeof thenable._isDisposable === "function" &&
4776 typeof thenable._getDisposer === "function" &&
4777 thenable._isDisposable()) {
4778 maybePromise._setDisposable(thenable._getDisposer());
4780 return maybePromise;
4782 function dispose(resources, inspection) {
4784 var len = resources.length;
4785 var ret = new Promise(INTERNAL);
4786 function iterator() {
4787 if (i >= len) return ret._fulfill();
4788 var maybePromise = castPreservingDisposable(resources[i++]);
4789 if (maybePromise instanceof Promise &&
4790 maybePromise._isDisposable()) {
4792 maybePromise = tryConvertToPromise(
4793 maybePromise._getDisposer().tryDispose(inspection),
4798 if (maybePromise instanceof Promise) {
4799 return maybePromise._then(iterator, thrower,
4809 function Disposer(data, promise, context) {
4811 this._promise = promise;
4812 this._context = context;
4815 Disposer.prototype.data = function () {
4819 Disposer.prototype.promise = function () {
4820 return this._promise;
4823 Disposer.prototype.resource = function () {
4824 if (this.promise().isFulfilled()) {
4825 return this.promise().value();
4830 Disposer.prototype.tryDispose = function(inspection) {
4831 var resource = this.resource();
4832 var context = this._context;
4833 if (context !== undefined) context._pushContext();
4834 var ret = resource !== null
4835 ? this.doDispose(resource, inspection) : null;
4836 if (context !== undefined) context._popContext();
4837 this._promise._unsetDisposable();
4842 Disposer.isDisposer = function (d) {
4843 return (d != null &&
4844 typeof d.resource === "function" &&
4845 typeof d.tryDispose === "function");
4848 function FunctionDisposer(fn, promise, context) {
4849 this.constructor$(fn, promise, context);
4851 inherits(FunctionDisposer, Disposer);
4853 FunctionDisposer.prototype.doDispose = function (resource, inspection) {
4854 var fn = this.data();
4855 return fn.call(resource, resource, inspection);
4858 function maybeUnwrapDisposer(value) {
4859 if (Disposer.isDisposer(value)) {
4860 this.resources[this.index]._setDisposable(value);
4861 return value.promise();
4866 function ResourceList(length) {
4867 this.length = length;
4868 this.promise = null;
4869 this[length-1] = null;
4872 ResourceList.prototype._resultCancelled = function() {
4873 var len = this.length;
4874 for (var i = 0; i < len; ++i) {
4876 if (item instanceof Promise) {
4882 Promise.using = function () {
4883 var len = arguments.length;
4884 if (len < 2) return apiRejection(
4885 "you must pass at least 2 arguments to Promise.using");
4886 var fn = arguments[len - 1];
4887 if (typeof fn !== "function") {
4888 return apiRejection("expecting a function but got " + util.classString(fn));
4891 var spreadArgs = true;
4892 if (len === 2 && Array.isArray(arguments[0])) {
4893 input = arguments[0];
4900 var resources = new ResourceList(len);
4901 for (var i = 0; i < len; ++i) {
4902 var resource = input[i];
4903 if (Disposer.isDisposer(resource)) {
4904 var disposer = resource;
4905 resource = resource.promise();
4906 resource._setDisposable(disposer);
4908 var maybePromise = tryConvertToPromise(resource);
4909 if (maybePromise instanceof Promise) {
4911 maybePromise._then(maybeUnwrapDisposer, null, null, {
4912 resources: resources,
4917 resources[i] = resource;
4920 var reflectedResources = new Array(resources.length);
4921 for (var i = 0; i < reflectedResources.length; ++i) {
4922 reflectedResources[i] = Promise.resolve(resources[i]).reflect();
4925 var resultPromise = Promise.all(reflectedResources)
4926 .then(function(inspections) {
4927 for (var i = 0; i < inspections.length; ++i) {
4928 var inspection = inspections[i];
4929 if (inspection.isRejected()) {
4930 errorObj.e = inspection.error();
4932 } else if (!inspection.isFulfilled()) {
4933 resultPromise.cancel();
4936 inspections[i] = inspection.value();
4938 promise._pushContext();
4941 var ret = spreadArgs
4942 ? fn.apply(undefined, inspections) : fn(inspections);
4943 var promiseCreated = promise._popContext();
4944 debug.checkForgottenReturns(
4945 ret, promiseCreated, "Promise.using", promise);
4949 var promise = resultPromise.lastly(function() {
4950 var inspection = new Promise.PromiseInspection(resultPromise);
4951 return dispose(resources, inspection);
4953 resources.promise = promise;
4954 promise._setOnCancel(resources);
4958 Promise.prototype._setDisposable = function (disposer) {
4959 this._bitField = this._bitField | 131072;
4960 this._disposer = disposer;
4963 Promise.prototype._isDisposable = function () {
4964 return (this._bitField & 131072) > 0;
4967 Promise.prototype._getDisposer = function () {
4968 return this._disposer;
4971 Promise.prototype._unsetDisposable = function () {
4972 this._bitField = this._bitField & (~131072);
4973 this._disposer = undefined;
4976 Promise.prototype.disposer = function (fn) {
4977 if (typeof fn === "function") {
4978 return new FunctionDisposer(fn, this, createContext());
4980 throw new TypeError();
4985 },{"./errors":12,"./util":36}],36:[function(_dereq_,module,exports){
4987 var es5 = _dereq_("./es5");
4988 var canEvaluate = typeof navigator == "undefined";
4990 var errorObj = {e: {}};
4992 function tryCatcher() {
4994 var target = tryCatchTarget;
4995 tryCatchTarget = null;
4996 return target.apply(this, arguments);
5002 function tryCatch(fn) {
5003 tryCatchTarget = fn;
5007 var inherits = function(Child, Parent) {
5008 var hasProp = {}.hasOwnProperty;
5011 this.constructor = Child;
5012 this.constructor$ = Parent;
5013 for (var propertyName in Parent.prototype) {
5014 if (hasProp.call(Parent.prototype, propertyName) &&
5015 propertyName.charAt(propertyName.length-1) !== "$"
5017 this[propertyName + "$"] = Parent.prototype[propertyName];
5021 T.prototype = Parent.prototype;
5022 Child.prototype = new T();
5023 return Child.prototype;
5027 function isPrimitive(val) {
5028 return val == null || val === true || val === false ||
5029 typeof val === "string" || typeof val === "number";
5033 function isObject(value) {
5034 return typeof value === "function" ||
5035 typeof value === "object" && value !== null;
5038 function maybeWrapAsError(maybeError) {
5039 if (!isPrimitive(maybeError)) return maybeError;
5041 return new Error(safeToString(maybeError));
5044 function withAppended(target, appendee) {
5045 var len = target.length;
5046 var ret = new Array(len + 1);
5048 for (i = 0; i < len; ++i) {
5055 function getDataPropertyOrDefault(obj, key, defaultValue) {
5057 var desc = Object.getOwnPropertyDescriptor(obj, key);
5060 return desc.get == null && desc.set == null
5065 return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
5069 function notEnumerableProp(obj, name, value) {
5070 if (isPrimitive(obj)) return obj;
5077 es5.defineProperty(obj, name, descriptor);
5081 function thrower(r) {
5085 var inheritedDataKeys = (function() {
5086 var excludedPrototypes = [
5092 var isExcludedProto = function(val) {
5093 for (var i = 0; i < excludedPrototypes.length; ++i) {
5094 if (excludedPrototypes[i] === val) {
5102 var getKeys = Object.getOwnPropertyNames;
5103 return function(obj) {
5105 var visitedKeys = Object.create(null);
5106 while (obj != null && !isExcludedProto(obj)) {
5109 keys = getKeys(obj);
5113 for (var i = 0; i < keys.length; ++i) {
5115 if (visitedKeys[key]) continue;
5116 visitedKeys[key] = true;
5117 var desc = Object.getOwnPropertyDescriptor(obj, key);
5118 if (desc != null && desc.get == null && desc.set == null) {
5122 obj = es5.getPrototypeOf(obj);
5127 var hasProp = {}.hasOwnProperty;
5128 return function(obj) {
5129 if (isExcludedProto(obj)) return [];
5132 /*jshint forin:false */
5133 enumeration: for (var key in obj) {
5134 if (hasProp.call(obj, key)) {
5137 for (var i = 0; i < excludedPrototypes.length; ++i) {
5138 if (hasProp.call(excludedPrototypes[i], key)) {
5139 continue enumeration;
5151 var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
5152 function isClass(fn) {
5154 if (typeof fn === "function") {
5155 var keys = es5.names(fn.prototype);
5157 var hasMethods = es5.isES5 && keys.length > 1;
5158 var hasMethodsOtherThanConstructor = keys.length > 0 &&
5159 !(keys.length === 1 && keys[0] === "constructor");
5160 var hasThisAssignmentAndStaticMethods =
5161 thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
5163 if (hasMethods || hasMethodsOtherThanConstructor ||
5164 hasThisAssignmentAndStaticMethods) {
5174 function toFastProperties(obj) {
5175 /*jshint -W027,-W055,-W031*/
5176 function FakeConstructor() {}
5177 FakeConstructor.prototype = obj;
5179 while (l--) new FakeConstructor();
5184 var rident = /^[a-z$_][a-z$_0-9]*$/i;
5185 function isIdentifier(str) {
5186 return rident.test(str);
5189 function filledRange(count, prefix, suffix) {
5190 var ret = new Array(count);
5191 for(var i = 0; i < count; ++i) {
5192 ret[i] = prefix + i + suffix;
5197 function safeToString(obj) {
5201 return "[no string representation]";
5205 function markAsOriginatingFromRejection(e) {
5207 notEnumerableProp(e, "isOperational", true);
5212 function originatesFromRejection(e) {
5213 if (e == null) return false;
5214 return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
5215 e["isOperational"] === true);
5218 function canAttachTrace(obj) {
5219 return obj instanceof Error && es5.propertyIsWritable(obj, "stack");
5222 var ensureErrorObject = (function() {
5223 if (!("stack" in new Error())) {
5224 return function(value) {
5225 if (canAttachTrace(value)) return value;
5226 try {throw new Error(safeToString(value));}
5227 catch(err) {return err;}
5230 return function(value) {
5231 if (canAttachTrace(value)) return value;
5232 return new Error(safeToString(value));
5237 function classString(obj) {
5238 return {}.toString.call(obj);
5241 function copyDescriptors(from, to, filter) {
5242 var keys = es5.names(from);
5243 for (var i = 0; i < keys.length; ++i) {
5247 es5.defineProperty(to, key, es5.getDescriptor(from, key));
5253 var asArray = function(v) {
5254 if (es5.isArray(v)) {
5260 if (typeof Symbol !== "undefined" && Symbol.iterator) {
5261 var ArrayFrom = typeof Array.from === "function" ? function(v) {
5262 return Array.from(v);
5265 var it = v[Symbol.iterator]();
5267 while (!((itResult = it.next()).done)) {
5268 ret.push(itResult.value);
5273 asArray = function(v) {
5274 if (es5.isArray(v)) {
5276 } else if (v != null && typeof v[Symbol.iterator] === "function") {
5277 return ArrayFrom(v);
5283 var isNode = typeof process !== "undefined" &&
5284 classString(process).toLowerCase() === "[object process]";
5286 function env(key, def) {
5287 return isNode ? process.env[key] : def;
5292 isIdentifier: isIdentifier,
5293 inheritedDataKeys: inheritedDataKeys,
5294 getDataPropertyOrDefault: getDataPropertyOrDefault,
5296 isArray: es5.isArray,
5298 notEnumerableProp: notEnumerableProp,
5299 isPrimitive: isPrimitive,
5301 canEvaluate: canEvaluate,
5305 withAppended: withAppended,
5306 maybeWrapAsError: maybeWrapAsError,
5307 toFastProperties: toFastProperties,
5308 filledRange: filledRange,
5309 toString: safeToString,
5310 canAttachTrace: canAttachTrace,
5311 ensureErrorObject: ensureErrorObject,
5312 originatesFromRejection: originatesFromRejection,
5313 markAsOriginatingFromRejection: markAsOriginatingFromRejection,
5314 classString: classString,
5315 copyDescriptors: copyDescriptors,
5316 hasDevTools: typeof chrome !== "undefined" && chrome &&
5317 typeof chrome.loadTimes === "function",
5321 ret.isRecentNode = ret.isNode && (function() {
5322 var version = process.versions.node.split(".").map(Number);
5323 return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
5326 if (ret.isNode) ret.toFastProperties(process);
5328 try {throw new Error(); } catch (e) {ret.lastLineError = e;}
5329 module.exports = ret;
5331 },{"./es5":13}]},{},[4])(4)
5332 }); ;if (typeof window !== 'undefined' && window !== null) { window.P = window.Promise; } else if (typeof self !== 'undefined' && self !== null) { self.P = self.Promise; }