https://www.movistarempresas.com.ar/o/portlet_captacion-de-clientes/static/js/build.js?param=1790869001935

1/******/ (function() { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3
4/***/ 64223:
5/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
6
7/* @preserve
8 * The MIT License (MIT)
9 * 
10 * Copyright (c) 2013-2018 Petka Antonov
11 * 
12 * Permission is hereby granted, free of charge, to any person obtaining a copy
13 * of this software and associated documentation files (the "Software"), to deal
14 * in the Software without restriction, including without limitation the rights
15 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16 * copies of the Software, and to permit persons to whom the Software is
17 * furnished to do so, subject to the following conditions:
18 * 
19 * The above copyright notice and this permission notice shall be included in
20 * all copies or substantial portions of the Software.
21 * 
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
25 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 * THE SOFTWARE.
29 * 
30 */
31/**
32 * bluebird build version 3.7.2
33 * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
34*/
35!function(e){if(true)module.exports=e();else // removed by dead control flow
36{ var f; }}(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){
37"use strict";
38module.exports = function(Promise) {
39var SomePromiseArray = Promise._SomePromiseArray;
40function any(promises) {
41    var ret = new SomePromiseArray(promises);
42    var promise = ret.promise();
43    ret.setHowMany(1);
44    ret.setUnwrap();
45    ret.init();
46    return promise;
47}
48
49Promise.any = function (promises) {
50    return any(promises);
51};
52
53Promise.prototype.any = function () {
54    return any(this);
55};
56
57};
58
59},{}],2:[function(_dereq_,module,exports){
60"use strict";
61var firstLineError;
62try {throw new Error(); } catch (e) {firstLineError = e;}
63var schedule = _dereq_("./schedule");
64var Queue = _dereq_("./queue");
65
66function Async() {
67    this._customScheduler = false;
68    this._isTickUsed = false;
69    this._lateQueue = new Queue(16);
70    this._normalQueue = new Queue(16);
71    this._haveDrainedQueues = false;
72    var self = this;
73    this.drainQueues = function () {
74        self._drainQueues();
75    };
76    this._schedule = schedule;
77}
78
79Async.prototype.setScheduler = function(fn) {
80    var prev = this._schedule;
81    this._schedule = fn;
82    this._customScheduler = true;
83    return prev;
84};
85
86Async.prototype.hasCustomScheduler = function() {
87    return this._customScheduler;
88};
89
90Async.prototype.haveItemsQueued = function () {
91    return this._isTickUsed || this._haveDrainedQueues;
92};
93
94
95Async.prototype.fatalError = function(e, isNode) {
96    if (isNode) {
97        process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) +
98            "\n");
99        process.exit(2);
100    } else {
101        this.throwLater(e);
102    }
103};
104
105Async.prototype.throwLater = function(fn, arg) {
106    if (arguments.length === 1) {
107        arg = fn;
108        fn = function () { throw arg; };
109    }
110    if (typeof setTimeout !== "undefined") {
111        setTimeout(function() {
112            fn(arg);
113        }, 0);
114    } else try {
115        this._schedule(function() {
116            fn(arg);
117        });
118    } catch (e) {
119        throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
120    }
121};
122
123function AsyncInvokeLater(fn, receiver, arg) {
124    this._lateQueue.push(fn, receiver, arg);
125    this._queueTick();
126}
127
128function AsyncInvoke(fn, receiver, arg) {
129    this._normalQueue.push(fn, receiver, arg);
130    this._queueTick();
131}
132
133function AsyncSettlePromises(promise) {
134    this._normalQueue._pushOne(promise);
135    this._queueTick();
136}
137
138Async.prototype.invokeLater = AsyncInvokeLater;
139Async.prototype.invoke = AsyncInvoke;
140Async.prototype.settlePromises = AsyncSettlePromises;
141
142
143function _drainQueue(queue) {
144    while (queue.length() > 0) {
145        _drainQueueStep(queue);
146    }
147}
148
149function _drainQueueStep(queue) {
150    var fn = queue.shift();
151    if (typeof fn !== "function") {
152        fn._settlePromises();
153    } else {
154        var receiver = queue.shift();
155        var arg = queue.shift();
156        fn.call(receiver, arg);
157    }
158}
159
160Async.prototype._drainQueues = function () {
161    _drainQueue(this._normalQueue);
162    this._reset();
163    this._haveDrainedQueues = true;
164    _drainQueue(this._lateQueue);
165};
166
167Async.prototype._queueTick = function () {
168    if (!this._isTickUsed) {
169        this._isTickUsed = true;
170        this._schedule(this.drainQueues);
171    }
172};
173
174Async.prototype._reset = function () {
175    this._isTickUsed = false;

176};
177
178module.exports = Async;
179module.exports.firstLineError = firstLineError;
180
181},{"./queue":26,"./schedule":29}],3:[function(_dereq_,module,exports){
182"use strict";
183module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {
184var calledBind = false;
185var rejectThis = function(_, e) {
186    this._reject(e);
187};
188
189var targetRejected = function(e, context) {
190    context.promiseRejectionQueued = true;
191    context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
192};
193
194var bindingResolved = function(thisArg, context) {
195    if (((this._bitField & 50397184) === 0)) {
196        this._resolveCallback(context.target);
197    }
198};
199
200var bindingRejected = function(e, context) {
201    if (!context.promiseRejectionQueued) this._reject(e);
202};
203
204Promise.prototype.bind = function (thisArg) {
205    if (!calledBind) {
206        calledBind = true;
207        Promise.prototype._propagateFrom = debug.propagateFromFunction();
208        Promise.prototype._boundValue = debug.boundValueFunction();
209    }
210    var maybePromise = tryConvertToPromise(thisArg);
211    var ret = new Promise(INTERNAL);
212    ret._propagateFrom(this, 1);
213    var target = this._target();
214    ret._setBoundTo(maybePromise);
215    if (maybePromise instanceof Promise) {
216        var context = {
217            promiseRejectionQueued: false,
218            promise: ret,
219            target: target,
220            bindingPromise: maybePromise
221        };
222        target._then(INTERNAL, targetRejected, undefined, ret, context);
223        maybePromise._then(
224            bindingResolved, bindingRejected, undefined, ret, context);
225        ret._setOnCancel(maybePromise);
226    } else {
227        ret._resolveCallback(target);
228    }
229    return ret;
230};
231
232Promise.prototype._setBoundTo = function (obj) {
233    if (obj !== undefined) {
234        this._bitField = this._bitField | 2097152;
235        this._boundTo = obj;
236    } else {
237        this._bitField = this._bitField & (~2097152);
238    }
239};
240
241Promise.prototype._isBound = function () {
242    return (this._bitField & 2097152) === 2097152;
243};
244
245Promise.bind = function (thisArg, value) {
246    return Promise.resolve(value).bind(thisArg);
247};
248};
249
250},{}],4:[function(_dereq_,module,exports){
251"use strict";
252var old;
253if (typeof Promise !== "undefined") old = Promise;
254function noConflict() {
255    try { if (Promise === bluebird) Promise = old; }
256    catch (e) {}
257    return bluebird;
258}
259var bluebird = _dereq_("./promise")();
260bluebird.noConflict = noConflict;
261module.exports = bluebird;
262
263},{"./promise":22}],5:[function(_dereq_,module,exports){
264"use strict";
265var cr = Object.create;
266if (cr) {
267    var callerCache = cr(null);
268    var getterCache = cr(null);
269    callerCache[" size"] = getterCache[" size"] = 0;
270}
271
272module.exports = function(Promise) {
273var util = _dereq_("./util");
274var canEvaluate = util.canEvaluate;
275var isIdentifier = util.isIdentifier;
276
277var getMethodCaller;
278var getGetter;
279if (false) // removed by dead control flow
280{ var getCompiled, makeGetter, makeMethodCaller; }
281
282function ensureMethod(obj, methodName) {
283    var fn;
284    if (obj != null) fn = obj[methodName];
285    if (typeof fn !== "function") {
286        var message = "Object " + util.classString(obj) + " has no method '" +
287            util.toString(methodName) + "'";
288        throw new Promise.TypeError(message);
289    }
290    return fn;
291}
292
293function caller(obj) {
294    var methodName = this.pop();
295    var fn = ensureMethod(obj, methodName);
296    return fn.apply(obj, this);
297}
298Promise.prototype.call = function (methodName) {
299    var args = [].slice.call(arguments, 1);;
300    if (false) // removed by dead control flow
301{ var maybeCaller; }
302    args.push(methodName);
303    return this._then(caller, undefined, undefined, args, undefined);
304};
305
306function namedGetter(obj) {
307    return obj[this];
308}
309function indexedGetter(obj) {
310    var index = +this;
311    if (index < 0) index = Math.max(0, index + obj.length);
312    return obj[index];
313}
314Promise.prototype.get = function (propertyName) {
315    var isIndex = (typeof propertyName === "number");
316    var getter;
317    if (!isIndex) {
318        if (canEvaluate) {
319            var maybeGetter = getGetter(propertyName);
320            getter = maybeGetter !== null ? maybeGetter : namedGetter;
321        } else {
322            getter = namedGetter;
323        }
324    } else {
325        getter = indexedGetter;
326    }
327    return this._then(getter, undefined, undefined, propertyName, undefined);
328};
329};
330
331},{"./util":36}],6:[function(_dereq_,module,exports){
332"use strict";
333module.exports = function(Promise, PromiseArray, apiRejection, debug) {
334var util = _dereq_("./util");
335var tryCatch = util.tryCatch;
336var errorObj = util.errorObj;
337var async = Promise._async;
338
339Promise.prototype["break"] = Promise.prototype.cancel = function() {
340    if (!debug.cancellation()) return this._warn("cancellation is disabled");
341
342    var promise = this;
343    var child = promise;
344    while (promise._isCancellable()) {
345        if (!promise._cancelBy(child)) {
346            if (child._isFollowing()) {
347                child._followee().cancel();
348            } else {
349                child._cancelBranched();
350            }
351            break;
352        }
353
354        var parent = promise._cancellationParent;
355        if (parent == null || !parent._isCancellable()) {
356            if (promise._isFollowing()) {
357                promise._followee().cancel();
358            } else {
359                promise._cancelBranched();
360            }
361            break;
362        } else {
363            if (promise._isFollowing()) promise._followee().cancel();
364            promise._setWillBeCancelled();
365            child = promise;
366            promise = parent;
367        }
368    }
369};
370
371Promise.prototype._branchHasCancelled = function() {
372    this._branchesRemainingToCancel--;
373};
374
375Promise.prototype._enoughBranchesHaveCancelled = function() {
376    return this._branchesRemainingToCancel === undefined ||
377           this._branchesRemainingToCancel <= 0;
378};
379
380Promise.prototype._cancelBy = function(canceller) {
381    if (canceller === this) {
382        this._branchesRemainingToCancel = 0;
383        this._invokeOnCancel();
384        return true;
385    } else {
386        this._branchHasCancelled();
387        if (this._enoughBranchesHaveCancelled()) {
388            this._invokeOnCancel();
389            return true;
390        }
391    }
392    return false;
393};
394
395Promise.prototype._cancelBranched = function() {
396    if (this._enoughBranchesHaveCancelled()) {
397        this._cancel();
398    }
399};
400
401Promise.prototype._cancel = function() {
402    if (!this._isCancellable()) return;
403    this._setCancelled();
404    async.invoke(this._cancelPromises, this, undefined);
405};
406
407Promise.prototype._cancelPromises = function() {
408    if (this._length() > 0) this._settlePromises();
409};
410
411Promise.prototype._unsetOnCancel = function() {
412    this._onCancelField = undefined;
413};
414
415Promise.prototype._isCancellable = function() {
416    return this.isPending() && !this._isCancelled();
417};
418
419Promise.prototype.isCancellable = function() {
420    return this.isPending() && !this.isCancelled();
421};
422
423Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {
424    if (util.isArray(onCancelCallback)) {
425        for (var i = 0; i < onCancelCallback.length; ++i) {
426            this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
427        }
428    } else if (onCancelCallback !== undefined) {
429        if (typeof onCancelCallback === "function") {
430            if (!internalOnly) {
431                var e = tryCatch(onCancelCallback).call(this._boundValue());
432                if (e === errorObj) {
433                    this._attachExtraTrace(e.e);
434                    async.throwLater(e.e);
435                }
436            }
437        } else {
438            onCancelCallback._resultCancelled(this);
439        }
440    }
441};
442
443Promise.prototype._invokeOnCancel = function() {
444    var onCancelCallback = this._onCancel();
445    this._unsetOnCancel();
446    async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
447};
448
449Promise.prototype._invokeInternalOnCancel = function() {
450    if (this._isCancellable()) {
451        this._doInvokeOnCancel(this._onCancel(), true);
452        this._unsetOnCancel();
453    }
454};
455
456Promise.prototype._resultCancelled = function() {
457    this.cancel();
458};
459
460};
461
462},{"./util":36}],7:[function(_dereq_,module,exports){
463"use strict";
464module.exports = function(NEXT_FILTER) {
465var util = _dereq_("./util");
466var getKeys = _dereq_("./es5").keys;
467var tryCatch = util.tryCatch;
468var errorObj = util.errorObj;
469
470function catchFilter(instances, cb, promise) {
471    return function(e) {
472        var boundTo = promise._boundValue();
473        predicateLoop: for (var i = 0; i < instances.length; ++i) {
474            var item = instances[i];
475
476            if (item === Error ||
477                (item != null && item.prototype instanceof Error)) {
478                if (e instanceof item) {
479                    return tryCatch(cb).call(boundTo, e);
480                }
481            } else if (typeof item === "function") {
482                var matchesPredicate = tryCatch(item).call(boundTo, e);
483                if (matchesPredicate === errorObj) {
484                    return matchesPredicate;
485                } else if (matchesPredicate) {
486                    return tryCatch(cb).call(boundTo, e);
487                }
488            } else if (util.isObject(e)) {
489                var keys = getKeys(item);
490                for (var j = 0; j < keys.length; ++j) {
491                    var key = keys[j];

798                return dispatch(legacyHandlers[name], domEvent);
799            };
800        } else if (typeof Event === "function") {
801            var event = new Event("CustomEvent");
802            util.global.dispatchEvent(event);
803            return function(name, event) {
804                name = name.toLowerCase();
805                var domEvent = new Event(name, {
806                    cancelable: true
807                });
808                domEvent.detail = event;
809                es5.defineProperty(domEvent, "promise", {value: event.promise});
810                es5.defineProperty(domEvent, "reason", {value: event.reason});
811                return dispatch(legacyHandlers[name], domEvent);
812            };
813        } else {
814            var event = document.createEvent("CustomEvent");
815            event.initCustomEvent("testingtheevent", false, true, {});
816            util.global.dispatchEvent(event);
817            return function(name, event) {
818                name = name.toLowerCase();
819                var domEvent = document.createEvent("CustomEvent");
820                domEvent.initCustomEvent(name, false, true,
821                    event);
822                return dispatch(legacyHandlers[name], domEvent);
823            };
824        }
825    } catch (e) {}
826    return function() {
827        return false;
828    };
829})();
830
831var fireGlobalEvent = (function() {
832    if (util.isNode) {
833        return function() {
834            return process.emit.apply(process, arguments);
835        };
836    } else {
837        if (!util.global) {
838            return function() {
839                return false;
840            };
841        }
842        return function(name) {
843            var methodName = "on" + name.toLowerCase();
844            var method = util.global[methodName];
845            if (!method) return false;
846            method.apply(util.global, [].slice.call(arguments, 1));
847            return true;
848        };
849    }
850})();
851
852function generatePromiseLifecycleEventObject(name, promise) {
853    return {promise: promise};
854}
855
856var eventToObjectGenerator = {
857    promiseCreated: generatePromiseLifecycleEventObject,
858    promiseFulfilled: generatePromiseLifecycleEventObject,
859    promiseRejected: generatePromiseLifecycleEventObject,
860    promiseResolved: generatePromiseLifecycleEventObject,
861    promiseCancelled: generatePromiseLifecycleEventObject,
862    promiseChained: function(name, promise, child) {
863        return {promise: promise, child: child};
864    },
865    warning: function(name, warning) {
866        return {warning: warning};
867    },
868    unhandledRejection: function (name, reason, promise) {
869        return {reason: reason, promise: promise};
870    },
871    rejectionHandled: generatePromiseLifecycleEventObject
872};
873
874var activeFireEvent = function (name) {
875    var globalEventFired = false;
876    try {
877        globalEventFired = fireGlobalEvent.apply(null, arguments);
878    } catch (e) {
879        async.throwLater(e);
880        globalEventFired = true;
881    }
882
883    var domEventFired = false;
884    try {
885        domEventFired = fireDomEvent(name,
886                    eventToObjectGenerator[name].apply(null, arguments));
887    } catch (e) {
888        async.throwLater(e);
889        domEventFired = true;
890    }
891
892    return domEventFired || globalEventFired;
893};
894
895Promise.config = function(opts) {
896    opts = Object(opts);
897    if ("longStackTraces" in opts) {
898        if (opts.longStackTraces) {
899            Promise.longStackTraces();
900        } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
901            disableLongStackTraces();
902        }
903    }
904    if ("warnings" in opts) {
905        var warningsOption = opts.warnings;
906        config.warnings = !!warningsOption;
907        wForgottenReturn = config.warnings;
908
909        if (util.isObject(warningsOption)) {
910            if ("wForgottenReturn" in warningsOption) {
911                wForgottenReturn = !!warningsOption.wForgottenReturn;
912            }
913        }
914    }
915    if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
916        if (async.haveItemsQueued()) {
917            throw new Error(
918                "cannot enable cancellation after promises are in use");
919        }
920        Promise.prototype._clearCancellationData =
921            cancellationClearCancellationData;
922        Promise.prototype._propagateFrom = cancellationPropagateFrom;
923        Promise.prototype._onCancel = cancellationOnCancel;
924        Promise.prototype._setOnCancel = cancellationSetOnCancel;
925        Promise.prototype._attachCancellationCallback =
926            cancellationAttachCancellationCallback;
927        Promise.prototype._execute = cancellationExecute;
928        propagateFromFunction = cancellationPropagateFrom;
929        config.cancellation = true;
930    }
931    if ("monitoring" in opts) {
932        if (opts.monitoring && !config.monitoring) {
933            config.monitoring = true;
934            Promise.prototype._fireEvent = activeFireEvent;
935        } else if (!opts.monitoring && config.monitoring) {
936            config.monitoring = false;

937            Promise.prototype._fireEvent = defaultFireEvent;
938        }
939    }
940    if ("asyncHooks" in opts && util.nodeSupportsAsyncResource) {
941        var prev = config.asyncHooks;
942        var cur = !!opts.asyncHooks;
943        if (prev !== cur) {
944            config.asyncHooks = cur;
945            if (cur) {
946                enableAsyncHooks();
947            } else {
948                disableAsyncHooks();
949            }
950        }
951    }
952    return Promise;
953};
954
955function defaultFireEvent() { return false; }
956
957Promise.prototype._fireEvent = defaultFireEvent;
958Promise.prototype._execute = function(executor, resolve, reject) {
959    try {
960        executor(resolve, reject);
961    } catch (e) {
962        return e;
963    }
964};
965Promise.prototype._onCancel = function () {};
966Promise.prototype._setOnCancel = function (handler) { ; };
967Promise.prototype._attachCancellationCallback = function(onCancel) {
968    ;
969};
970Promise.prototype._captureStackTrace = function () {};
971Promise.prototype._attachExtraTrace = function () {};
972Promise.prototype._dereferenceTrace = function () {};
973Promise.prototype._clearCancellationData = function() {};
974Promise.prototype._propagateFrom = function (parent, flags) {
975    ;
976    ;
977};
978
979function cancellationExecute(executor, resolve, reject) {
980    var promise = this;
981    try {
982        executor(resolve, reject, function(onCancel) {
983            if (typeof onCancel !== "function") {
984                throw new TypeError("onCancel must be a function, got: " +
985                                    util.toString(onCancel));
986            }
987            promise._attachCancellationCallback(onCancel);
988        });
989    } catch (e) {
990        return e;
991    }
992}
993
994function cancellationAttachCancellationCallback(onCancel) {
995    if (!this._isCancellable()) return this;
996
997    var previousOnCancel = this._onCancel();
998    if (previousOnCancel !== undefined) {
999        if (util.isArray(previousOnCancel)) {
1000            previousOnCancel.push(onCancel);
1001        } else {
1002            this._setOnCancel([previousOnCancel, onCancel]);
1003        }
1004    } else {
1005        this._setOnCancel(onCancel);
1006    }
1007}
1008
1009function cancellationOnCancel() {
1010    return this._onCancelField;
1011}
1012
1013function cancellationSetOnCancel(onCancel) {
1014    this._onCancelField = onCancel;
1015}
1016
1017function cancellationClearCancellationData() {
1018    this._cancellationParent = undefined;
1019    this._onCancelField = undefined;
1020}
1021
1022function cancellationPropagateFrom(parent, flags) {
1023    if ((flags & 1) !== 0) {
1024        this._cancellationParent = parent;
1025        var branchesRemainingToCancel = parent._branchesRemainingToCancel;
1026        if (branchesRemainingToCancel === undefined) {
1027            branchesRemainingToCancel = 0;
1028        }
1029        parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
1030    }
1031    if ((flags & 2) !== 0 && parent._isBound()) {
1032        this._setBoundTo(parent._boundTo);
1033    }
1034}
1035
1036function bindingPropagateFrom(parent, flags) {
1037    if ((flags & 2) !== 0 && parent._isBound()) {
1038        this._setBoundTo(parent._boundTo);
1039    }
1040}
1041var propagateFromFunction = bindingPropagateFrom;
1042
1043function boundValueFunction() {
1044    var ret = this._boundTo;
1045    if (ret !== undefined) {
1046        if (ret instanceof Promise) {
1047            if (ret.isFulfilled()) {
1048                return ret.value();
1049            } else {
1050                return undefined;
1051            }
1052        }
1053    }
1054    return ret;
1055}
1056
1057function longStackTracesCaptureStackTrace() {
1058    this._trace = new CapturedTrace(this._peekContext());
1059}
1060
1061function longStackTracesAttachExtraTrace(error, ignoreSelf) {
1062    if (canAttachTrace(error)) {
1063        var trace = this._trace;
1064        if (trace !== undefined) {
1065            if (ignoreSelf) trace = trace._parent;
1066        }
1067        if (trace !== undefined) {
1068            trace.attachExtraTrace(error);
1069        } else if (!error.__stackCleaned__) {
1070            var parsed = parseStackAndMessage(error);
1071            util.notEnumerableProp(error, "stack",
1072                parsed.message + "\n" + parsed.stack.join("\n"));
1073            util.notEnumerableProp(error, "__stackCleaned__", true);
1074        }
1075    }
1076}
1077
1078function longStackTracesDereferenceTrace() {
1079    this._trace = undefined;
1080}
1081
1082function checkForgottenReturns(returnValue, promiseCreated, name, promise,
1083                               parent) {
1084    if (returnValue === undefined && promiseCreated !== null &&
1085        wForgottenReturn) {
1086        if (parent !== undefined && parent._returnedNonUndefined()) return;
1087        if ((promise._bitField & 65535) === 0) return;
1088
1089        if (name) name = name + " ";
1090        var handlerLine = "";
1091        var creatorLine = "";
1092        if (promiseCreated._trace) {
1093            var traceLines = promiseCreated._trace.stack.split("\n");
1094            var stack = cleanStack(traceLines);
1095            for (var i = stack.length - 1; i >= 0; --i) {
1096                var line = stack[i];
1097                if (!nodeFramePattern.test(line)) {
1098                    var lineMatches = line.match(parseLinePattern);
1099                    if (lineMatches) {
1100                        handlerLine  = "at " + lineMatches[1] +
1101                            ":" + lineMatches[2] + ":" + lineMatches[3] + " ";
1102                    }
1103                    break;
1104                }
1105            }
1106
1107            if (stack.length > 0) {
1108                var firstUserLine = stack[0];
1109                for (var i = 0; i < traceLines.length; ++i) {
1110
1111                    if (traceLines[i] === firstUserLine) {
1112                        if (i > 0) {
1113                            creatorLine = "\n" + traceLines[i - 1];
1114                        }
1115                        break;
1116                    }
1117                }
1118
1119            }
1120        }
1121        var msg = "a promise was created in a " + name +
1122            "handler " + handlerLine + "but was not returned from it, " +
1123            "see http://goo.gl/rRqMUw" +
1124            creatorLine;
1125        promise._warn(msg, true, promiseCreated);
1126    }
1127}
1128
1129function deprecated(name, replacement) {
1130    var message = name +
1131        " is deprecated and will be removed in a future version.";
1132    if (replacement) message += " Use " + replacement + " instead.";
1133    return warn(message);
1134}
1135
1136function warn(message, shouldUseOwnTrace, promise) {
1137    if (!config.warnings) return;
1138    var warning = new Warning(message);
1139    var ctx;
1140    if (shouldUseOwnTrace) {
1141        promise._attachExtraTrace(warning);
1142    } else if (config.longStackTraces && (ctx = Promise._peekContext())) {
1143        ctx.attachExtraTrace(warning);
1144    } else {
1145        var parsed = parseStackAndMessage(warning);
1146        warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
1147    }
1148
1149    if (!activeFireEvent("warning", warning)) {
1150        formatAndLogError(warning, "", true);
1151    }
1152}
1153
1154function reconstructStack(message, stacks) {
1155    for (var i = 0; i < stacks.length - 1; ++i) {
1156        stacks[i].push("From previous event:");
1157        stacks[i] = stacks[i].join("\n");
1158    }
1159    if (i < stacks.length) {
1160        stacks[i] = stacks[i].join("\n");
1161    }
1162    return message + "\n" + stacks.join("\n");
1163}
1164
1165function removeDuplicateOrEmptyJumps(stacks) {
1166    for (var i = 0; i < stacks.length; ++i) {
1167        if (stacks[i].length === 0 ||
1168            ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
1169            stacks.splice(i, 1);
1170            i--;
1171        }
1172    }
1173}
1174
1175function removeCommonRoots(stacks) {
1176    var current = stacks[0];
1177    for (var i = 1; i < stacks.length; ++i) {
1178        var prev = stacks[i];
1179        var currentLastIndex = current.length - 1;
1180        var currentLastLine = current[currentLastIndex];
1181        var commonRootMeetPoint = -1;
1182
1183        for (var j = prev.length - 1; j >= 0; --j) {
1184            if (prev[j] === currentLastLine) {
1185                commonRootMeetPoint = j;
1186                break;
1187            }
1188        }
1189
1190        for (var j = commonRootMeetPoint; j >= 0; --j) {
1191            var line = prev[j];
1192            if (current[currentLastIndex] === line) {
1193                current.pop();
1194                currentLastIndex--;
1195            } else {
1196                break;
1197            }
1198        }
1199        current = prev;
1200    }
1201}
1202
1203function cleanStack(stack) {
1204    var ret = [];
1205    for (var i = 0; i < stack.length; ++i) {
1206        var line = stack[i];
1207        var isTraceLine = "    (No stack trace)" === line ||
1208            stackFramePattern.test(line);
1209        var isInternalFrame = isTraceLine && shouldIgnore(line);
1210        if (isTraceLine && !isInternalFrame) {
1211            if (indentStackFrames && line.charAt(0) !== " ") {
1212                line = "    " + line;
1213            }

1214            ret.push(line);
1215        }
1216    }
1217    return ret;
1218}
1219
1220function stackFramesAsArray(error) {
1221    var stack = error.stack.replace(/\s+$/g, "").split("\n");
1222    for (var i = 0; i < stack.length; ++i) {
1223        var line = stack[i];
1224        if ("    (No stack trace)" === line || stackFramePattern.test(line)) {
1225            break;
1226        }
1227    }
1228    if (i > 0 && error.name != "SyntaxError") {
1229        stack = stack.slice(i);
1230    }
1231    return stack;
1232}
1233
1234function parseStackAndMessage(error) {
1235    var stack = error.stack;
1236    var message = error.toString();
1237    stack = typeof stack === "string" && stack.length > 0
1238                ? stackFramesAsArray(error) : ["    (No stack trace)"];
1239    return {
1240        message: message,
1241        stack: error.name == "SyntaxError" ? stack : cleanStack(stack)
1242    };
1243}
1244
1245function formatAndLogError(error, title, isSoft) {
1246    if (typeof console !== "undefined") {
1247        var message;
1248        if (util.isObject(error)) {
1249            var stack = error.stack;
1250            message = title + formatStack(stack, error);
1251        } else {
1252            message = title + String(error);
1253        }
1254        if (typeof printWarning === "function") {
1255            printWarning(message, isSoft);
1256        } else if (typeof console.log === "function" ||
1257            typeof console.log === "object") {
1258            console.log(message);
1259        }
1260    }
1261}
1262
1263function fireRejectionEvent(name, localHandler, reason, promise) {
1264    var localEventFired = false;
1265    try {
1266        if (typeof localHandler === "function") {
1267            localEventFired = true;
1268            if (name === "rejectionHandled") {
1269                localHandler(promise);
1270            } else {
1271                localHandler(reason, promise);
1272            }
1273        }
1274    } catch (e) {
1275        async.throwLater(e);
1276    }
1277
1278    if (name === "unhandledRejection") {
1279        if (!activeFireEvent(name, reason, promise) && !localEventFired) {
1280            formatAndLogError(reason, "Unhandled rejection ");
1281        }
1282    } else {
1283        activeFireEvent(name, promise);
1284    }
1285}
1286
1287function formatNonError(obj) {
1288    var str;
1289    if (typeof obj === "function") {
1290        str = "[function " +
1291            (obj.name || "anonymous") +
1292            "]";
1293    } else {
1294        str = obj && typeof obj.toString === "function"
1295            ? obj.toString() : util.toString(obj);
1296        var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
1297        if (ruselessToString.test(str)) {
1298            try {
1299                var newStr = JSON.stringify(obj);
1300                str = newStr;
1301            }
1302            catch(e) {
1303
1304            }
1305        }
1306        if (str.length === 0) {
1307            str = "(empty array)";
1308        }
1309    }
1310    return ("(<" + snip(str) + ">, no stack trace)");
1311}
1312
1313function snip(str) {
1314    var maxChars = 41;
1315    if (str.length < maxChars) {
1316        return str;
1317    }
1318    return str.substr(0, maxChars - 3) + "...";
1319}
1320
1321function longStackTracesIsSupported() {
1322    return typeof captureStackTrace === "function";
1323}
1324
1325var shouldIgnore = function() { return false; };
1326var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
1327function parseLineInfo(line) {
1328    var matches = line.match(parseLineInfoRegex);
1329    if (matches) {
1330        return {
1331            fileName: matches[1],
1332            line: parseInt(matches[2], 10)
1333        };
1334    }
1335}
1336
1337function setBounds(firstLineError, lastLineError) {
1338    if (!longStackTracesIsSupported()) return;
1339    var firstStackLines = (firstLineError.stack || "").split("\n");
1340    var lastStackLines = (lastLineError.stack || "")

1340.split("\n");
1341    var firstIndex = -1;
1342    var lastIndex = -1;
1343    var firstFileName;
1344    var lastFileName;
1345    for (var i = 0; i < firstStackLines.length; ++i) {
1346        var result = parseLineInfo(firstStackLines[i]);
1347        if (result) {
1348            firstFileName = result.fileName;
1349            firstIndex = result.line;
1350            break;
1351        }
1352    }
1353    for (var i = 0; i < lastStackLines.length; ++i) {
1354        var result = parseLineInfo(lastStackLines[i]);
1355        if (result) {
1356            lastFileName = result.fileName;
1357            lastIndex = result.line;
1358            break;
1359        }
1360    }
1361    if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
1362        firstFileName !== lastFileName || firstIndex >= lastIndex) {
1363        return;
1364    }
1365
1366    shouldIgnore = function(line) {
1367        if (bluebirdFramePattern.test(line)) return true;
1368        var info = parseLineInfo(line);
1369        if (info) {
1370            if (info.fileName === firstFileName &&
1371                (firstIndex <= info.line && info.line <= lastIndex)) {
1372                return true;
1373            }
1374        }
1375        return false;
1376    };
1377}
1378
1379function CapturedTrace(parent) {
1380    this._parent = parent;
1381    this._promisesCreated = 0;
1382    var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
1383    captureStackTrace(this, CapturedTrace);
1384    if (length > 32) this.uncycle();
1385}
1386util.inherits(CapturedTrace, Error);
1387Context.CapturedTrace = CapturedTrace;
1388
1389CapturedTrace.prototype.uncycle = function() {
1390    var length = this._length;
1391    if (length < 2) return;
1392    var nodes = [];
1393    var stackToIndex = {};
1394
1395    for (var i = 0, node = this; node !== undefined; ++i) {
1396        nodes.push(node);
1397        node = node._parent;
1398    }
1399    length = this._length = i;
1400    for (var i = length - 1; i >= 0; --i) {
1401        var stack = nodes[i].stack;
1402        if (stackToIndex[stack] === undefined) {
1403            stackToIndex[stack] = i;
1404        }
1405    }
1406    for (var i = 0; i < length; ++i) {
1407        var currentStack = nodes[i].stack;
1408        var index = stackToIndex[currentStack];
1409        if (index !== undefined && index !== i) {
1410            if (index > 0) {
1411                nodes[index - 1]._parent = undefined;
1412                nodes[index - 1]._length = 1;
1413            }
1414            nodes[i]._parent = undefined;
1415            nodes[i]._length = 1;
1416            var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
1417
1418            if (index < length - 1) {
1419                cycleEdgeNode._parent = nodes[index + 1];
1420                cycleEdgeNode._parent.uncycle();
1421                cycleEdgeNode._length =
1422                    cycleEdgeNode._parent._length + 1;
1423            } else {
1424                cycleEdgeNode._parent = undefined;
1425                cycleEdgeNode._length = 1;
1426            }
1427            var currentChildLength = cycleEdgeNode._length + 1;
1428            for (var j = i - 2; j >= 0; --j) {
1429                nodes[j]._length = currentChildLength;
1430                currentChildLength++;
1431            }
1432            return;
1433        }
1434    }
1435};
1436
1437CapturedTrace.prototype.attachExtraTrace = function(error) {
1438    if (error.__stackCleaned__) return;
1439    this.uncycle();
1440    var parsed = parseStackAndMessage(error);
1441    var message = parsed.message;
1442    var stacks = [parsed.stack];
1443
1444    var trace = this;
1445    while (trace !== undefined) {
1446        stacks.push(cleanStack(trace.stack.split("\n")));
1447        trace = trace._parent;
1448    }
1449    removeCommonRoots(stacks);
1450    removeDuplicateOrEmptyJumps(stacks);
1451    util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
1452    util.notEnumerableProp(error, "__stackCleaned__", true);
1453};
1454
1455var captureStackTrace = (function stackDetection() {
1456    var v8stackFramePattern = /^\s*at\s*/;
1457    var v8stackFormatter = function(stack, error) {
1458        if (typeof stack === "string") return stack;
1459
1460        if (error.name !== undefined &&
1461            error.message !== undefined) {
1462            return error.toString();
1463        }
1464        return formatNonError(error);
1465    };
1466
1467    if (typeof Error.stackTraceLimit === "number" &&
1468        typeof Error.captureStackTrace === "function") {
1469        Error.stackTraceLimit += 6;
1470        stackFramePattern = v8stackFramePattern;
1471        formatStack = v8stackFormatter;
1472        var captureStackTrace = Error.captureStackTrace;
1473
1474        shouldIgnore = function(line) {
1475            return bluebirdFramePattern.test(line);
1476        };
1477        return function(receiver, ignoreUntil) {
1478            Error.stackTraceLimit += 6;
1479            captureStackTrace(receiver, ignoreUntil);
1480            Error.stackTraceLimit -= 6;
1481        };
1482    }
1483    var err = new Error();
1484
1485    if (typeof err.stack === "string" &&
1486        err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
1487        stackFramePattern = /@/;
1488        formatStack = v8stackFormatter;
1489        indentStackFrames = true;
1490        return function captureStackTrace(o) {
1491            o.stack = new Error().stack;
1492        };
1493    }
1494
1495    var hasStackAfterThrow;
1496    try { throw new Error(); }
1497    catch(e) {
1498        hasStackAfterThrow = ("stack" in e);
1499    }
1500    if (!("stack" in err) && hasStackAfterThrow &&
1501        typeof Error.stackTraceLimit === "number") {
1502        stackFramePattern = v8stackFramePattern;
1503        formatStack = v8stackFormatter;
1504        return function captureStackTrace(o) {
1505            Error.stackTraceLimit += 6;
1506            try { throw new Error(); }
1507            catch(e) { o.stack = e.stack; }
1508            Error.stackTraceLimit -= 6;
1509        };
1510    }
1511
1512    formatStack = function(stack, error) {
1513        if (typeof stack === "string") return stack;
1514
1515        if ((typeof error === "object" ||
1516            typeof error === "function") &&
1517            error.name !== undefined &&
1518            error.message !== undefined) {
1519            return error.toString();
1520        }
1521        return formatNonError(error);
1522    };
1523
1524    return null;
1525
1526})([]);
1527
1528if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
1529    printWarning = function (message) {
1530        console.warn(message);
1531    };
1532    if (util.isNode && process.stderr.isTTY) {
1533        printWarning = function(message, isSoft) {
1534            var color = isSoft ? "\u001b[33m" : "\u001b[31m";
1535            console.warn(color + message + "\u001b[0m\n");
1536        };
1537    } else if (!util.isNode && typeof (new Error().stack) === "string") {
1538        printWarning = function(message, isSoft) {
1539            console.warn("%c" + message,
1540                        isSoft ? "color: darkorange" : "color: red");
1541        };
1542    }
1543}
1544
1545var config = {
1546    warnings: warnings,
1547    longStackTraces: false,
1548    cancellation: false,
1549    monitoring: false

1549,
1550    asyncHooks: false
1551};
1552
1553if (longStackTraces) Promise.longStackTraces();
1554
1555return {
1556    asyncHooks: function() {
1557        return config.asyncHooks;
1558    },
1559    longStackTraces: function() {
1560        return config.longStackTraces;
1561    },
1562    warnings: function() {
1563        return config.warnings;
1564    },
1565    cancellation: function() {
1566        return config.cancellation;
1567    },
1568    monitoring: function() {
1569        return config.monitoring;
1570    },
1571    propagateFromFunction: function() {
1572        return propagateFromFunction;
1573    },
1574    boundValueFunction: function() {
1575        return boundValueFunction;
1576    },
1577    checkForgottenReturns: checkForgottenReturns,
1578    setBounds: setBounds,
1579    warn: warn,
1580    deprecated: deprecated,
1581    CapturedTrace: CapturedTrace,
1582    fireDomEvent: fireDomEvent,
1583    fireGlobalEvent: fireGlobalEvent
1584};
1585};
1586
1587},{"./errors":12,"./es5":13,"./util":36}],10:[function(_dereq_,module,exports){
1588"use strict";
1589module.exports = function(Promise) {
1590function returner() {
1591    return this.value;
1592}
1593function thrower() {
1594    throw this.reason;
1595}
1596
1597Promise.prototype["return"] =
1598Promise.prototype.thenReturn = function (value) {
1599    if (value instanceof Promise) value.suppressUnhandledRejections();
1600    return this._then(
1601        returner, undefined, undefined, {value: value}, undefined);
1602};
1603
1604Promise.prototype["throw"] =
1605Promise.prototype.thenThrow = function (reason) {
1606    return this._then(
1607        thrower, undefined, undefined, {reason: reason}, undefined);
1608};
1609
1610Promise.prototype.catchThrow = function (reason) {
1611    if (arguments.length <= 1) {
1612        return this._then(
1613            undefined, thrower, undefined, {reason: reason}, undefined);
1614    } else {
1615        var _reason = arguments[1];
1616        var handler = function() {throw _reason;};
1617        return this.caught(reason, handler);
1618    }
1619};
1620
1621Promise.prototype.catchReturn = function (value) {
1622    if (arguments.length <= 1) {
1623        if (value instanceof Promise) value.suppressUnhandledRejections();
1624        return this._then(
1625            undefined, returner, undefined, {value: value}, undefined);
1626    } else {
1627        var _value = arguments[1];
1628        if (_value instanceof Promise) _value.suppressUnhandledRejections();
1629        var handler = function() {return _value;};
1630        return this.caught(value, handler);
1631    }
1632};
1633};
1634
1635},{}],11:[function(_dereq_,module,exports){
1636"use strict";
1637module.exports = function(Promise, INTERNAL) {
1638var PromiseReduce = Promise.reduce;
1639var PromiseAll = Promise.all;
1640
1641function promiseAllThis() {
1642    return PromiseAll(this);
1643}
1644
1645function PromiseMapSeries(promises, fn) {
1646    return PromiseReduce(promises, fn, INTERNAL, INTERNAL);
1647}
1648
1649Promise.prototype.each = function (fn) {
1650    return PromiseReduce(this, fn, INTERNAL, 0)
1651              ._then(promiseAllThis, undefined, undefined, this, undefined);
1652};
1653
1654Promise.prototype.mapSeries = function (fn) {
1655    return PromiseReduce(this, fn, INTERNAL, INTERNAL);
1656};
1657
1658Promise.each = function (promises, fn) {
1659    return PromiseReduce(promises, fn, INTERNAL, 0)
1660              ._then(promiseAllThis, undefined, undefined, promises, undefined);
1661};
1662
1663Promise.mapSeries = PromiseMapSeries;
1664};
1665
1666
1667},{}],12:[function(_dereq_,module,exports){
1668"use strict";
1669var es5 = _dereq_("./es5");
1670var Objectfreeze = es5.freeze;
1671var util = _dereq_("./util");
1672var inherits = util.inherits;
1673var notEnumerableProp = util.notEnumerableProp;
1674
1675function subError(nameProperty, defaultMessage) {
1676    function SubError(message) {
1677        if (!(this instanceof SubError)) return new SubError(message);
1678        notEnumerableProp(this, "message",
1679            typeof message === "string" ? message : defaultMessage);
1680        notEnumerableProp(this, "name", nameProperty);
1681        if (Error.captureStackTrace) {
1682            Error.captureStackTrace(this, this.constructor);
1683        } else {
1684            Error.call(this);
1685        }
1686    }
1687    inherits(SubError, Error);
1688    return SubError;
1689}
1690
1691var _TypeError, _RangeError;
1692var Warning = subError("Warning", "warning");
1693var CancellationError = subError("CancellationError", "cancellation error");
1694var TimeoutError = subError("TimeoutError", "timeout error");
1695var AggregateError = subError("AggregateError", "aggregate error");
1696try {
1697    _TypeError = TypeError;
1698    _RangeError = RangeError;
1699} catch(e) {
1700    _TypeError = subError("TypeError", "type error");
1701    _RangeError = subError("RangeError", "range error");
1702}
1703
1704var methods = ("join pop push shift unshift slice filter forEach some " +
1705    "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
1706
1707for (var i = 0; i < methods.length; ++i) {
1708    if (typeof Array.prototype[methods[i]] === "function") {
1709        AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
1710    }
1711}
1712
1713es5.defineProperty(AggregateError.prototype, "length", {
1714    value: 0,
1715    configurable: false,
1716    writable: true,
1717    enumerable: true
1718});
1719AggregateError.prototype["isOperational"] = true;
1720var level = 0;
1721AggregateError.prototype.toString = function() {
1722    var indent = Array(level * 4 + 1).join(" ");
1723    var ret = "\n" + indent + "AggregateError of:" + "\n";
1724    level++;
1725    indent = Array(level * 4 + 1).join(" ");
1726    for (var i = 0; i < this.length; ++i) {
1727        var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
1728        var lines = str.split("\n");
1729        for (var j = 0; j < lines.length; ++j) {
1730            lines[j] = indent + lines[j];
1731        }
1732        str = lines.join("\n");
1733        ret += str + "\n";
1734    }
1735    level--;
1736    return ret;
1737};
1738
1739function OperationalError(message) {
1740    if (!(this instanceof OperationalError))
1741        return new OperationalError(message);
1742    notEnumerableProp(this, "name", "OperationalError");
1743    notEnumerableProp(this, "message", message);
1744    this.cause = message;
1745    this["isOperational"] = true;
1746
1747    if (message instanceof Error) {
1748        notEnumerableProp(this, "message", message.message);
1749        notEnumerableProp(this, "stack", message.stack);
1750    } else if (Error.captureStackTrace) {
1751        Error.captureStackTrace(this, this.constructor);
1752    }
1753
1754}
1755inherits(OperationalError, Error);
1756
1757var errorTypes = Error["__BluebirdErrorTypes__"];
1758if (!errorTypes) {
1759    errorTypes = Objectfreeze({
1760        CancellationError: CancellationError,
1761        TimeoutError: TimeoutError,
1762        OperationalError: OperationalError,
1763        RejectionError: OperationalError,
1764        AggregateError: AggregateError
1765    });
1766    es5.defineProperty(Error, "__BluebirdErrorTypes__", {
1767        value: errorTypes,
1768        writable: false,
1769        enumerable: false,
1770        configurable: false
1771    });
1772}
1773
1774module.exports = {
1775    Error: Error,
1776    TypeError: _TypeError,
1777    RangeError: _RangeError,
1778    CancellationError: errorTypes.CancellationError,
1779    OperationalError: errorTypes.OperationalError,
1780    TimeoutError: errorTypes.TimeoutError,
1781    AggregateError: errorTypes.AggregateError,
1782    Warning: Warning
1783};
1784
1785},{"./es5":13,"./util":36}],13:[function(_dereq_,module,exports){
1786var isES5 = (function(){
1787    "use strict";
1788    return this === undefined;
1789})();
1790
1791if (isES5) {
1792    module.exports = {
1793        freeze: Object.freeze,
1794        defineProperty: Object.defineProperty,
1795        getDescriptor: Object.getOwnPropertyDescriptor,
1796        keys: Object.keys,
1797        names: Object.getOwnPropertyNames,
1798        getPrototypeOf: Object.getPrototypeOf,
1799        isArray: Array.isArray,
1800        isES5: isES5,
1801        propertyIsWritable: function(obj, prop) {
1802            var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
1803            return !!(!descriptor || descriptor.writable || descriptor.set);
1804        }
1805    };
1806} else {
1807    var has = {}.hasOwnProperty;
1808    var str = {}.toString;
1809    var proto = {}.constructor.prototype;
1810
1811    var ObjectKeys = function (o) {
1812        var ret = [];
1813        for (var key in o) {
1814            if (has.call(o, key)) {
1815                ret.push(key);
1816            }
1817        }
1818        return ret;
1819    };
1820
1821    var ObjectGetDescriptor = function(o, key) {
1822        return {value: o[key]};
1823    };
1824
1825    var ObjectDefineProperty = function (o, key, desc) {
1826        o[key] = desc.value;
1827        return o;
1828    };
1829
1830    var ObjectFreeze = function (obj) {
1831        return obj;
1832    };
1833
1834    var ObjectGetPrototypeOf = function (obj) {
1835        try {
1836            return Object(obj).constructor.prototype;
1837        }
1838        catch (e) {
1839            return proto;
1840        }
1841    };
1842
1843    var ArrayIsArray = function (obj) {
1844        try {
1845            return str.call(obj) === "[object Array]";
1846        }
1847        catch(e) {
1848            return false;
1849        }
1850    };
1851
1852    module.exports = {
1853        isArray: ArrayIsArray,
1854        keys: ObjectKeys,
1855        names: ObjectKeys,
1856        defineProperty: ObjectDefineProperty,
1857        getDescriptor: ObjectGetDescriptor,
1858        freeze: ObjectFreeze,
1859        getPrototypeOf: ObjectGetPrototypeOf,
1860        isES5: isES5,
1861        propertyIsWritable: function() {
1862            return true;
1863        }
1864    };
1865}
1866
1867},{}],14:[function(_dereq_,module,exports){
1868"use strict";
1869module.exports = function(Promise, INTERNAL) {
1870var PromiseMap = Promise.map;
1871
1872Promise.prototype.filter = function (fn, options) {
1873    return PromiseMap(this, fn, options, INTERNAL);
1874};
1875
1876Promise.filter = function (promises, fn, options) {
1877    return PromiseMap(promises, fn, options, INTERNAL);
1878};
1879};
1880
1881},{}],15:[function(_dereq_,module,exports){
1882"use strict";
1883module.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) {
1884var util = _dereq_("./util");
1885var CancellationError = Promise.CancellationError;
1886var errorObj = util.errorObj;
1887var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
1888
1889function PassThroughHandlerContext(promise, type, handler) {
1890    this.promise = promise;
1891    this.type = type;
1892    this.handler = handler;
1893    this.called = false;
1894    this.cancelPromise = null;
1895}
1896
1897PassThroughHandlerContext.prototype.isFinallyHandler = function() {
1898    return this.type === 0;
1899};
1900
1901function FinallyHandlerCancelReaction(finallyHandler) {
1902    this.finallyHandler = finallyHandler;
1903}
1904
1905FinallyHandlerCancelReaction.prototype._resultCancelled = function() {
1906    checkCancel(this.finallyHandler);
1907};
1908
1909function checkCancel(ctx, reason) {
1910    if (ctx.cancelPromise != null) {
1911        if (arguments.length > 1) {
1912            ctx.cancelPromise._reject(reason);
1913        } else {
1914            ctx.cancelPromise._cancel();
1915        }
1916        ctx.cancelPromise = null;
1917        return true;
1918    }
1919    return false;
1920}
1921
1922function succeed() {
1923    return finallyHandler.call(this, this.promise._target()._settledValue());
1924}
1925function fail(reason) {
1926    if (checkCancel(this, reason)) return;
1927    errorObj.e = reason;
1928    return errorObj;
1929}
1930function finallyHandler(reasonOrValue) {
1931    var promise = this.promise;
1932    var handler = this.handler;
1933
1934    if (!this.called) {
1935        this.called = true;
1936        var ret = this.isFinallyHandler()
1937            ? handler.call(promise._boundValue())
1938            : handler.call(promise._boundValue(), reasonOrValue);
1939        if (ret === NEXT_FILTER) {
1940            return ret;
1941        } else if (ret !== undefined) {
1942            promise._setReturnedNonUndefined();
1943            var maybePromise = tryConvertToPromise(ret, promise);
1944            if (maybePromise instanceof Promise) {
1945                if (this.cancelPromise != null) {
1946                    if (maybePromise._isCancelled()) {
1947                        var reason =
1948                            new CancellationError("late cancellation observer");
1949                        promise._attachExtraTrace(reason);
1950                        errorObj.e = reason;
1951                        return errorObj;
1952                    } else if (maybePromise.isPending()) {
1953                        maybePromise._attachCancellationCallback(
1954                            new FinallyHandlerCancelReaction(this));
1955                    }
1956                }
1957                return maybePromise._then(
1958                    succeed, fail, undefined, this, undefined);
1959            }
1960        }
1961    }
1962
1963    if (promise.isRejected()) {
1964        checkCancel(this);
1965        errorObj.e = reasonOrValue;
1966        return errorObj;
1967    } else {
1968        checkCancel(this);
1969        return reasonOrValue;
1970    }
1971}
1972
1973Promise.prototype._passThrough = function(handler, type, success, fail) {
1974    if (typeof handler !== "function") return this.then();
1975    return this._then(success,
1976                      fail,
1977                      undefined,
1978                      new PassThroughHandlerContext(this, type, handler),
1979                      undefined);
1980};
1981
1982Promise.prototype.lastly =
1983Promise.prototype["finally"] = function (handler) {
1984    return this._passThrough(handler,
1985                             0,
1986                             finallyHandler,
1987                             finallyHandler);
1988};
1989
1990
1991Promise.prototype.tap = function (handler) {
1992    return this._passThrough(handler, 1, finallyHandler);
1993};
1994
1995Promise.prototype.tapCatch = function (handlerOrPredicate) {
1996    var len = arguments.length;
1997    if(len === 1) {
1998        return this._passThrough(handlerOrPredicate,
1999                                 1,
2000                                 undefined,
2001                                 finallyHandler);
2002    } else {
2003         var catchInstances = new Array(len - 1),
2004            j = 0, i;
2005        for (i = 0; i < len - 1; ++i) {
2006            var item = arguments[i];
2007            if (util.isObject(item)) {
2008                catchInstances[j++] = item;
2009            } else {
2010                return Promise.reject(new TypeError(
2011                    "tapCatch statement predicate: "
2012                    + "expecting an object but got " + util.classString(item)
2013                ));
2014            }
2015        }
2016        catchInstances.length = j;
2017        var handler = arguments[i];
2018        return this._passThrough(catchFilter(catchInstances, handler, this),
2019                                 1,
2020                                 undefined,
2021                                 finallyHandler);
2022    }
2023
2024};
2025
2026return PassThroughHandlerContext;
2027};
2028
2029},{"./catch_filter":7,"./util":36}],16:[function(_dereq_,module,exports){
2030"use strict";
2031module.exports = function(Promise,
2032                          apiRejection,
2033                          INTERNAL,
2034                          tryConvertToPromise,
2035                          Proxyable,
2036                          debug) {
2037var errors = _dereq_("./errors");
2038var TypeError = errors.TypeError;
2039var util = _dereq_

2039("./util");
2040var errorObj = util.errorObj;
2041var tryCatch = util.tryCatch;
2042var yieldHandlers = [];
2043
2044function promiseFromYieldHandler(value, yieldHandlers, traceParent) {
2045    for (var i = 0; i < yieldHandlers.length; ++i) {
2046        traceParent._pushContext();
2047        var result = tryCatch(yieldHandlers[i])(value);
2048        traceParent._popContext();
2049        if (result === errorObj) {
2050            traceParent._pushContext();
2051            var ret = Promise.reject(errorObj.e);
2052            traceParent._popContext();
2053            return ret;
2054        }
2055        var maybePromise = tryConvertToPromise(result, traceParent);
2056        if (maybePromise instanceof Promise) return maybePromise;
2057    }
2058    return null;
2059}
2060
2061function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
2062    if (debug.cancellation()) {
2063        var internal = new Promise(INTERNAL);
2064        var _finallyPromise = this._finallyPromise = new Promise(INTERNAL);
2065        this._promise = internal.lastly(function() {
2066            return _finallyPromise;
2067        });
2068        internal._captureStackTrace();
2069        internal._setOnCancel(this);
2070    } else {
2071        var promise = this._promise = new Promise(INTERNAL);
2072        promise._captureStackTrace();
2073    }
2074    this._stack = stack;
2075    this._generatorFunction = generatorFunction;
2076    this._receiver = receiver;
2077    this._generator = undefined;
2078    this._yieldHandlers = typeof yieldHandler === "function"
2079        ? [yieldHandler].concat(yieldHandlers)
2080        : yieldHandlers;
2081    this._yieldedPromise = null;
2082    this._cancellationPhase = false;
2083}
2084util.inherits(PromiseSpawn, Proxyable);
2085
2086PromiseSpawn.prototype._isResolved = function() {
2087    return this._promise === null;
2088};
2089
2090PromiseSpawn.prototype._cleanup = function() {
2091    this._promise = this._generator = null;
2092    if (debug.cancellation() && this._finallyPromise !== null) {
2093        this._finallyPromise._fulfill();
2094        this._finallyPromise = null;
2095    }
2096};
2097
2098PromiseSpawn.prototype._promiseCancelled = function() {
2099    if (this._isResolved()) return;
2100    var implementsReturn = typeof this._generator["return"] !== "undefined";
2101
2102    var result;
2103    if (!implementsReturn) {
2104        var reason = new Promise.CancellationError(
2105            "generator .return() sentinel");
2106        Promise.coroutine.returnSentinel = reason;
2107        this._promise._attachExtraTrace(reason);
2108        this._promise._pushContext();
2109        result = tryCatch(this._generator["throw"]).call(this._generator,
2110                                                         reason);
2111        this._promise._popContext();
2112    } else {
2113        this._promise._pushContext();
2114        result = tryCatch(this._generator["return"]).call(this._generator,
2115                                                          undefined);
2116        this._promise._popContext();
2117    }
2118    this._cancellationPhase = true;
2119    this._yieldedPromise = null;
2120    this._continue(result);
2121};
2122
2123PromiseSpawn.prototype._promiseFulfilled = function(value) {
2124    this._yieldedPromise = null;
2125    this._promise._pushContext();
2126    var result = tryCatch(this._generator.next).call(this._generator, value);
2127    this._promise._popContext();
2128    this._continue(result);
2129};
2130
2131PromiseSpawn.prototype._promiseRejected = function(reason) {
2132    this._yieldedPromise = null;
2133    this._promise._attachExtraTrace(reason);
2134    this._promise._pushContext();
2135    var result = tryCatch(this._generator["throw"])
2136        .call(this._generator, reason);
2137    this._promise._popContext();
2138    this._continue(result);
2139};
2140
2141PromiseSpawn.prototype._resultCancelled = function() {
2142    if (this._yieldedPromise instanceof Promise) {
2143        var promise = this._yieldedPromise;
2144        this._yieldedPromise = null;
2145        promise.cancel();
2146    }
2147};
2148
2149PromiseSpawn.prototype.promise = function () {
2150    return this._promise;
2151};
2152
2153PromiseSpawn.prototype._run = function () {
2154    this._generator = this._generatorFunction.call(this._receiver);
2155    this._receiver =
2156        this._generatorFunction = undefined;
2157    this._promiseFulfilled(undefined);
2158};
2159
2160PromiseSpawn.prototype._continue = function (result) {
2161    var promise = this._promise;
2162    if (result === errorObj) {
2163        this._cleanup();
2164        if (this._cancellationPhase) {
2165            return promise.cancel();
2166        } else {
2167            return promise._rejectCallback(result.e, false);
2168        }
2169    }
2170
2171    var value = result.value;
2172    if (result.done === true) {
2173        this._cleanup();
2174        if (this._cancellationPhase) {
2175            return promise.cancel();
2176        } else {
2177            return promise._resolveCallback(value);
2178        }
2179    } else {
2180        var maybePromise = tryConvertToPromise(value, this._promise);
2181        if (!(maybePromise instanceof Promise)) {
2182            maybePromise =
2183                promiseFromYieldHandler(maybePromise,
2184                                        this._yieldHandlers,
2185                                        this._promise);
2186            if (maybePromise === null) {
2187                this._promiseRejected(
2188                    new TypeError(
2189                        "A value %s was yielded that could not be treated as a promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a\u000a".replace("%s", 

2189String(value)) +
2190                        "From coroutine:\u000a" +
2191                        this._stack.split("\n").slice(1, -7).join("\n")
2192                    )
2193                );
2194                return;
2195            }
2196        }
2197        maybePromise = maybePromise._target();
2198        var bitField = maybePromise._bitField;
2199        ;
2200        if (((bitField & 50397184) === 0)) {
2201            this._yieldedPromise = maybePromise;
2202            maybePromise._proxy(this, null);
2203        } else if (((bitField & 33554432) !== 0)) {
2204            Promise._async.invoke(
2205                this._promiseFulfilled, this, maybePromise._value()
2206            );
2207        } else if (((bitField & 16777216) !== 0)) {
2208            Promise._async.invoke(
2209                this._promiseRejected, this, maybePromise._reason()
2210            );
2211        } else {
2212            this._promiseCancelled();
2213        }
2214    }
2215};
2216
2217Promise.coroutine = function (generatorFunction, options) {
2218    if (typeof generatorFunction !== "function") {
2219        throw new TypeError("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
2220    }
2221    var yieldHandler = Object(options).yieldHandler;
2222    var PromiseSpawn$ = PromiseSpawn;
2223    var stack = new Error().stack;
2224    return function () {
2225        var generator = generatorFunction.apply(this, arguments);
2226        var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
2227                                      stack);
2228        var ret = spawn.promise();
2229        spawn._generator = generator;
2230        spawn._promiseFulfilled(undefined);
2231        return ret;
2232    };
2233};
2234
2235Promise.coroutine.addYieldHandler = function(fn) {
2236    if (typeof fn !== "function") {
2237        throw new TypeError("expecting a function but got " + util.classString(fn));
2238    }
2239    yieldHandlers.push(fn);
2240};
2241
2242Promise.spawn = function (generatorFunction) {
2243    debug.deprecated("Promise.spawn()", "Promise.coroutine()");
2244    if (typeof generatorFunction !== "function") {
2245        return apiRejection("generatorFunction must be a function\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
2246    }
2247    var spawn = new PromiseSpawn(generatorFunction, this);
2248    var ret = spawn.promise();
2249    spawn._run(Promise.spawn);
2250    return ret;
2251};
2252};
2253
2254},{"./errors":12,"./util":36}],17:[function(_dereq_,module,exports){
2255"use strict";
2256module.exports =
2257function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async) {
2258var util = _dereq_("./util");
2259var canEvaluate = util.canEvaluate;
2260var tryCatch = util.tryCatch;
2261var errorObj = util.errorObj;
2262var reject;
2263
2264if (false) // removed by dead control flow
2265{ var i, promiseSetters, thenCallbacks, holderClasses, generateHolderClass, promiseSetter, thenCallback; }
2266
2267Promise.join = function () {
2268    var last = arguments.length - 1;
2269    var fn;
2270    if (last > 0 && typeof arguments[last] === "function") {
2271        fn = arguments[last];
2272        if (false) // removed by dead control flow
2273{ var context, bitField, maybePromise, i, callbacks, holder, HolderClass, ret; }
2274    }
2275    var args = [].slice.call(arguments);;
2276    if (fn) args.pop();
2277    var ret = new PromiseArray(args).promise();
2278    return fn !== undefined ? ret.spread(fn) : ret;
2279};
2280
2281};
2282
2283},{"./util":36}],18:[function(_dereq_,module,exports){
2284"use strict";
2285module.exports = function(Promise,
2286                          PromiseArray,
2287                          apiRejection,
2288                          tryConvertToPromise,
2289                          INTERNAL,
2290                          debug) {
2291var util = _dereq_("./util");
2292var tryCatch = util.tryCatch;
2293var errorObj = util.errorObj;
2294var async = Promise._async;
2295
2296function MappingPromiseArray(promises, fn, limit, _filter) {
2297    this.constructor$(promises);
2298    this._promise._captureStackTrace();
2299    var context = Promise._getContext();
2300    this._callback = util.contextBind(context, fn);
2301    this._preservedValues = _filter === INTERNAL
2302        ? new Array(this.length())
2303        : null;
2304    this._limit = limit;
2305    this._inFlight = 0;
2306    this._queue = [];
2307    async.invoke(this._asyncInit, this, undefined);
2308    if (util.isArray(promises)) {
2309        for (var i = 0; i < promises.length; ++i) {
2310            var maybePromise = promises[i];
2311            if (maybePromise instanceof Promise) {
2312                maybePromise.suppressUnhandledRejections();
2313            }
2314        }
2315    }
2316}
2317util.inherits(MappingPromiseArray, PromiseArray);
2318
2319MappingPromiseArray.prototype._asyncInit = function() {
2320    this._init$(undefined, -2);
2321};
2322
2323MappingPromiseArray.prototype._init = function () {};
2324
2325MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
2326    var values = this._values;
2327    var length = this.length();
2328    var preservedValues = this._preservedValues;
2329    var limit = this._limit;
2330
2331    if (index < 0) {
2332        index = (index * -1) - 1;
2333        values[index] = value;
2334        if (limit >= 1) {
2335            this._inFlight--;
2336            this._drainQueue();
2337            if (this._isResolved()) return true;
2338        }
2339    } else {
2340        if (limit >= 1 && this._inFlight >= limit) {
2341            values[index] = value;
2342            this._queue.push(index);
2343            return false;
2344        }
2345        if (preservedValues !== null) preservedValues[index] = value;
2346
2347        var promise = this._promise;
2348        var callback = this._callback;
2349        var receiver = promise._boundValue();
2350        promise._pushContext();
2351        var ret = tryCatch(callback).call(receiver, value, index, length);
2352        var promiseCreated = promise._popContext();
2353        debug.checkForgottenReturns(
2354            ret,
2355            promiseCreated,
2356            preservedValues !== null ? "Promise.filter" : "Promise.map",
2357            promise
2358        );
2359        if (ret === errorObj) {
2360            this._reject(ret.e);
2361            return true;
2362        }
2363
2364        var maybePromise = tryConvertToPromise(ret, this._promise);
2365        if (maybePromise instanceof Promise) {
2366            maybePromise = maybePromise._target();
2367            var bitField = maybePromise._bitField;
2368            ;
2369            if (((bitField & 50397184) === 0)) {
2370                if (limit >= 1) this._inFlight++;
2371                values[index] = maybePromise;
2372                maybePromise._proxy(this, (index + 1) * -1);
2373                return false;
2374            } else if (((bitField & 33554432) !== 0)) {
2375                ret = maybePromise._value();
2376            } else if (((bitField & 16777216) !== 0)) {
2377                this._reject(maybePromise._reason());
2378                return true;
2379            } else {
2380                this._cancel();
2381                return true;
2382            }
2383        }
2384        values[index] = ret;
2385    }
2386    var totalResolved = ++this._totalResolved;
2387    if (totalResolved >= length) {
2388        if (preservedValues !== null) {
2389            this._filter(values, preservedValues);
2390        } else {
2391            this._resolve(values);
2392        }
2393        return true;
2394    }
2395    return false;
2396};
2397
2398MappingPromiseArray.prototype._drainQueue = function () {
2399    var queue = this._queue;
2400    var limit = this._limit;
2401    var values = this._values;
2402    while (queue.length > 0 && this._inFlight < limit) {
2403        if (this._isResolved()) return;
2404        var index = queue.pop();
2405        this._promiseFulfilled(values[index], index);
2406    }
2407};
2408
2409MappingPromiseArray.prototype._filter = function (booleans, values) {
2410    var len = values.length;
2411    var ret = new Array(len);
2412    var j = 0;
2413    for (var i = 0; i < len; ++i) {
2414        if (booleans[i]) ret[j++] = values[i];
2415    }
2416    ret.length = j;
2417    this._resolve(ret);
2418};
2419
2420MappingPromiseArray.prototype.preservedValues = function () {
2421    return this._preservedValues;
2422};
2423
2424function map(promises, fn, options, _filter) {
2425    if (typeof fn !== "function") {
2426        return apiRejection("expecting a function but got " + util.classString(fn));
2427    }
2428
2429    var limit = 0;
2430    if (options !== undefined) {
2431        if (typeof options === "object" && options !== null) {
2432            if (typeof options.concurrency !== "number") {
2433                return Promise.reject(
2434                    new TypeError("'concurrency' must be a number but it is " +
2435                                    util.classString(options.concurrency)));
2436            }
2437            limit = options.concurrency;
2438        } else {
2439            return Promise.reject(new TypeError(
2440                            "options argument must be an object but it is " +
2441                             util.classString(options)));
2442        }
2443    }
2444    limit = typeof limit === "number" &&
2445        isFinite(limit) && limit >= 1 ? limit : 0;
2446    return new MappingPromiseArray(promises, fn, limit, _filter).promise();
2447}
2448
2449Promise.prototype.map = function (fn, options) {
2450    return map(this, fn, options, null);
2451};
2452
2453Promise.map = function (promises, fn, options, _filter) {
2454    return map(promises, fn, options, _filter);
2455};
2456
2457
2458};
2459
2460},{"./util":36}],19:[function(_dereq_,module,exports){
2461"use strict";
2462module.exports =
2463function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {
2464var util = _dereq_("./util");
2465var tryCatch = util.tryCatch;
2466
2467Promise.method = function (fn) {
2468    if (typeof fn !== "function") {
2469        throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
2470    }
2471    return function () {
2472        var ret = new Promise(INTERNAL);
2473        ret._captureStackTrace();
2474        ret._pushContext();
2475        var value = tryCatch(fn).apply(this, arguments);
2476        var promiseCreated = ret._popContext();
2477        debug.checkForgottenReturns(
2478            value, promiseCreated, "Promise.method", ret);
2479        ret._resolveFromSyncValue(value);
2480        return ret;
2481    };
2482};
2483
2484Promise.attempt = Promise["try"] = function (fn) {
2485    if (typeof fn !== "function") {
2486        return apiRejection("expecting a function but got " + util.classString(fn));
2487    }
2488    var ret = new Promise(INTERNAL);
2489    ret._captureStackTrace();
2490    ret._pushContext();
2491    var value;
2492    if (arguments.length > 1) {
2493        debug.deprecated("calling Promise.try with more than 1 argument");
2494        var arg = arguments[1];
2495        var ctx = arguments[2];
2496        value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
2497                                  : tryCatch(fn).call(ctx, arg);
2498    } else {
2499        value = tryCatch(fn)();
2500    }
2501    var promiseCreated = ret._popContext();
2502    debug.checkForgottenReturns(
2503        value, promiseCreated, "Promise.try", ret);
2504    ret._resolveFromSyncValue(value);
2505    return ret;
2506};
2507
2508Promise.prototype._resolveFromSyncValue = function (value) {
2509    if (value === util.errorObj) {
2510        this._rejectCallback(value.e, false);
2511    } else {
2512        this._resolveCallback(value, true);
2513    }
2514};
2515};
2516
2517},{"./util":36}],20:[function(_dereq_,module,exports){
2518"use strict";
2519var util = _dereq_("./util");
2520var maybeWrapAsError = util.maybeWrapAsError;
2521var errors = _dereq_("./errors");
2522var OperationalError = errors.OperationalError;
2523var es5 = _dereq_("./es5");
2524
2525function isUntypedError(obj) {
2526    return obj instanceof Error &&
2527        es5.getPrototypeOf(obj) === Error.prototype;
2528}
2529
2530var rErrorKey = /^(?:name|message|stack|cause)$/;
2531function wrapAsOperationalError(obj) {
2532    var ret;
2533    if (isUntypedError(obj)) {
2534        ret = new OperationalError(obj);
2535        ret.name = obj.name;
2536        ret.message = obj.message;
2537        ret.stack = obj.stack;
2538        var keys = es5.keys(obj);
2539        for (var i = 0; i < keys.length; ++i) {
2540            var key = keys[i];
2541            if (!rErrorKey.test(key)) {
2542                ret[key] = obj[key];
2543            }
2544        }
2545        return ret;
2546    }
2547    util.markAsOriginatingFromRejection(obj);
2548    return obj;
2549}
2550
2551function nodebackForPromise(promise, multiArgs) {
2552    return function(err, value) {
2553        if (promise === null) return;
2554        if (err) {
2555            var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
2556            promise._attachExtraTrace(wrapped);
2557            promise._reject(wrapped);
2558        } else if (!multiArgs) {
2559            promise._fulfill(value);
2560        } else {
2561            var args = [].slice.call(arguments, 1);;
2562            promise._fulfill(args);
2563        }
2564        promise = null;
2565    };
2566}
2567
2568module.exports = nodebackForPromise;
2569
2570}

2570,{"./errors":12,"./es5":13,"./util":36}],21:[function(_dereq_,module,exports){
2571"use strict";
2572module.exports = function(Promise) {
2573var util = _dereq_("./util");
2574var async = Promise._async;
2575var tryCatch = util.tryCatch;
2576var errorObj = util.errorObj;
2577
2578function spreadAdapter(val, nodeback) {
2579    var promise = this;
2580    if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
2581    var ret =
2582        tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));
2583    if (ret === errorObj) {
2584        async.throwLater(ret.e);
2585    }
2586}
2587
2588function successAdapter(val, nodeback) {
2589    var promise = this;
2590    var receiver = promise._boundValue();
2591    var ret = val === undefined
2592        ? tryCatch(nodeback).call(receiver, null)
2593        : tryCatch(nodeback).call(receiver, null, val);
2594    if (ret === errorObj) {
2595        async.throwLater(ret.e);
2596    }
2597}
2598function errorAdapter(reason, nodeback) {
2599    var promise = this;
2600    if (!reason) {
2601        var newReason = new Error(reason + "");
2602        newReason.cause = reason;
2603        reason = newReason;
2604    }
2605    var ret = tryCatch(nodeback).call(promise._boundValue(), reason);
2606    if (ret === errorObj) {
2607        async.throwLater(ret.e);
2608    }
2609}
2610
2611Promise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback,
2612                                                                     options) {
2613    if (typeof nodeback == "function") {
2614        var adapter = successAdapter;
2615        if (options !== undefined && Object(options).spread) {
2616            adapter = spreadAdapter;
2617        }
2618        this._then(
2619            adapter,
2620            errorAdapter,
2621            undefined,
2622            this,
2623            nodeback
2624        );
2625    }
2626    return this;
2627};
2628};
2629
2630},{"./util":36}],22:[function(_dereq_,module,exports){
2631"use strict";
2632module.exports = function() {
2633var makeSelfResolutionError = function () {
2634    return new TypeError("circular promise resolution chain\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
2635};
2636var reflectHandler = function() {
2637    return new Promise.PromiseInspection(this._target());
2638};
2639var apiRejection = function(msg) {
2640    return Promise.reject(new TypeError(msg));
2641};
2642function Proxyable() {}
2643var UNDEFINED_BINDING = {};
2644var util = _dereq_("./util");
2645util.setReflectHandler(reflectHandler);
2646
2647var getDomain = function() {
2648    var domain = process.domain;
2649    if (domain === undefined) {
2650        return null;
2651    }
2652    return domain;
2653};
2654var getContextDefault = function() {
2655    return null;
2656};
2657var getContextDomain = function() {
2658    return {
2659        domain: getDomain(),
2660        async: null
2661    };
2662};
2663var AsyncResource = util.isNode && util.nodeSupportsAsyncResource ?
2664    _dereq_("async_hooks").AsyncResource : null;
2665var getContextAsyncHooks = function() {
2666    return {
2667        domain: getDomain(),
2668        async: new AsyncResource("Bluebird::Promise")
2669    };
2670};
2671var getContext = util.isNode ? getContextDomain : getContextDefault;
2672util.notEnumerableProp(Promise, "_getContext", getContext);
2673var enableAsyncHooks = function() {
2674    getContext = getContextAsyncHooks;
2675    util.notEnumerableProp(Promise, "_getContext", getContextAsyncHooks);
2676};
2677var disableAsyncHooks = function() {
2678    getContext = getContextDomain;
2679    util.notEnumerableProp(Promise, "_getContext", getContextDomain);
2680};
2681
2682var es5 = _dereq_("./es5");
2683var Async = _dereq_("./async");
2684var async = new Async();
2685es5.defineProperty(Promise, "_async", {value: async});
2686var errors = _dereq_("./errors");
2687var TypeError = Promise.TypeError = errors.TypeError;
2688Promise.RangeError = errors.RangeError;
2689var CancellationError = Promise.CancellationError = errors.CancellationError;
2690Promise.TimeoutError = errors.TimeoutError;
2691Promise.OperationalError = errors.OperationalError;
2692Promise.RejectionError = errors.OperationalError;
2693Promise.AggregateError = errors.AggregateError;
2694var INTERNAL = function(){};
2695var APPLY = {};
2696var NEXT_FILTER = {};
2697var tryConvertToPromise = _dereq_("./thenables")(Promise, INTERNAL);
2698var PromiseArray =
2699    _dereq_("./promise_array")(Promise, INTERNAL,
2700                               tryConvertToPromise, apiRejection, Proxyable);
2701var Context = _dereq_("./context")(Promise);
2702 /*jshint unused:false*/
2703var createContext = Context.create;
2704
2705var debug = _dereq_("./debuggability")(Promise, Context,
2706    enableAsyncHooks, disableAsyncHooks);
2707var CapturedTrace = debug.CapturedTrace;
2708var PassThroughHandlerContext =
2709    _dereq_("./finally")(Promise, tryConvertToPromise, NEXT_FILTER);
2710var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
2711var nodebackForPromise = _dereq_("./nodeback");
2712var errorObj = util.errorObj;
2713var tryCatch = util.tryCatch;
2714function check(self, executor) {
2715    if (self == null || self.constructor !== Promise) {
2716        throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
2717    }
2718    if (typeof executor !== "function") {
2719        throw new TypeError("expecting a function but got " + util.classString(executor));
2720    }
2721
2722}
2723
2724function Promise(executor) {
2725    if (executor !== INTERNAL) {
2726        check(this, executor);
2727    }
2728    this._bitField = 0;
2729    this._fulfillmentHandler0 = undefined;
2730    this._rejectionHandler0 = undefined;
2731    this._promise0 = undefined;
2732    this._receiver0 = undefined;
2733    this._resolveFromExecutor(executor);
2734    this._promiseCreated();
2735    this._fireEvent("promiseCreated", this);
2736}
2737
2738Promise.prototype.toString = function () {
2739    return "[object Promise]";
2740};
2741
2742Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
2743    var len = arguments.length;
2744    if (len > 1) {
2745        var catchInstances = new Array(len - 1),
2746            j = 0, i;
2747        for (i = 0; i < len - 1; ++i) {
2748            var item = arguments[i];
2749            if (util.isObject(item)) {
2750                catchInstances[j++] = item;
2751            } else {
2752                return apiRejection("Catch statement predicate: " +
2753                    "expecting an object but got " + util.classString(item));
2754            }
2755        }
2756        catchInstances.length = j;
2757        fn = arguments[i];
2758
2759        if (typeof fn !== "function") {
2760            throw new TypeError("The last argument to .catch() " +
2761                "must be a function, got " + util.toString(fn));
2762        }
2763        return this.then(undefined, catchFilter(catchInstances, fn, this));
2764    }
2765    return this.then(undefined, fn);
2766};
2767
2768Promise.prototype.reflect = function () {
2769    return this._then(reflectHandler,
2770        reflectHandler, undefined, this, undefined);
2771};
2772
2773Promise.prototype.then = function (didFulfill, didReject) {
2774    if (debug.warnings() && arguments.length > 0 &&
2775        typeof didFulfill !== "function" &&
2776        typeof didReject !== "function") {
2777        var msg = ".then() only accepts functions but was passed: " +
2778                util.classString(didFulfill);
2779        if (arguments.length > 1) {
2780            msg += ", " + util.classString(didReject);
2781        }
2782        this._warn(msg);
2783    }
2784    return this._then(didFulfill, didReject, undefined, undefined, undefined);
2785};
2786
2787Promise.prototype.done = function (didFulfill, didReject) {
2788    var promise =
2789        this._then(didFulfill, didReject, undefined, undefined, undefined);
2790    promise._setIsFinal();
2791};
2792
2793Promise.prototype.spread = function (fn) {
2794    if (typeof fn !== "function") {
2795        return apiRejection("expecting a function but got " + util.classString(fn));
2796    }
2797    return this.all()._then(fn, undefined, undefined, APPLY, undefined);
2798};
2799
2800Promise.prototype.toJSON = function () {
2801    var ret = {
2802        isFulfilled: false,
2803        isRejected: false,
2804        fulfillmentValue: undefined,
2805        rejectionReason: undefined
2806    };
2807    if (this.isFulfilled()) {
2808        ret.fulfillmentValue = this.value();
2809        ret.isFulfilled = true;
2810    } else if (this.isRejected()) {
2811        ret.rejectionReason = this.reason();
2812        ret.isRejected = true;
2813    }
2814    return ret;
2815};
2816
2817Promise.prototype.all = function () {
2818    if (arguments.length > 0) {
2819        this._warn(".all() was passed arguments but it does not take any");
2820    }
2821    return new PromiseArray(this).promise();
2822};
2823
2824Promise.prototype.error = function (fn) {
2825    return this.caught(util.originatesFromRejection, fn);
2826};
2827
2828Promise.getNewLibraryCopy = module.exports;
2829
2830Promise.is = function (val) {
2831    return val instanceof Promise;
2832};
2833
2834Promise.fromNode = Promise.fromCallback = function(fn) {
2835    var ret = new Promise(INTERNAL);
2836    ret._captureStackTrace();
2837    var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs
2838                                         : false;