commit cd2898ece37aac74c645df718137097adb8bc019
parent 900a957318071a9bab481cec1452f8ebb908a607
Author: Dan Stillman <dstillman@zotero.org>
Date: Mon, 8 Jun 2015 02:38:56 -0400
Update Bluebird to v2.9.27
Diffstat:
| M | resource/bluebird.js | | | 960 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------- |
1 file changed, 698 insertions(+), 262 deletions(-)
diff --git a/resource/bluebird.js b/resource/bluebird.js
@@ -23,8 +23,8 @@
*
*/
/**
- * bluebird build version 2.9.6
- * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, progress, cancel, using, filter, any, each, timers
+ * bluebird build version 2.9.27
+ * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, cancel, using, filter, any, each, timers
*/
!function(e){
//
@@ -134,12 +134,13 @@ var firstLineError;
try {throw new Error(); } catch (e) {firstLineError = e;}
var schedule = _dereq_("./schedule.js");
var Queue = _dereq_("./queue.js");
-var _process = typeof process !== "undefined" ? process : undefined;
+var util = _dereq_("./util.js");
function Async() {
this._isTickUsed = false;
this._lateQueue = new Queue(16);
this._normalQueue = new Queue(16);
+ this._trampolineEnabled = true;
var self = this;
this.drainQueues = function () {
self._drainQueues();
@@ -148,17 +149,23 @@ function Async() {
schedule.isStatic ? schedule(this.drainQueues) : schedule;
}
-Async.prototype.haveItemsQueued = function () {
- return this._normalQueue.length() > 0;
+Async.prototype.disableTrampolineIfNecessary = function() {
+ if (util.hasDevTools) {
+ this._trampolineEnabled = false;
+ }
};
-Async.prototype._withDomain = function(fn) {
- if (_process !== undefined &&
- _process.domain != null &&
- !fn.domain) {
- fn = _process.domain.bind(fn);
+Async.prototype.enableTrampoline = function() {
+ if (!this._trampolineEnabled) {
+ this._trampolineEnabled = true;
+ this._schedule = function(fn) {
+ setTimeout(fn, 0);
+ };
}
- return fn;
+};
+
+Async.prototype.haveItemsQueued = function () {
+ return this._normalQueue.length() > 0;
};
Async.prototype.throwLater = function(fn, arg) {
@@ -166,7 +173,8 @@ Async.prototype.throwLater = function(fn, arg) {
arg = fn;
fn = function () { throw arg; };
}
- fn = this._withDomain(fn);
+ var domain = this._getDomain();
+ if (domain !== undefined) fn = domain.bind(fn);
if (typeof setTimeout !== "undefined") {
setTimeout(function() {
fn(arg);
@@ -180,26 +188,116 @@ Async.prototype.throwLater = function(fn, arg) {
}
};
-Async.prototype.invokeLater = function (fn, receiver, arg) {
- fn = this._withDomain(fn);
+Async.prototype._getDomain = function() {};
+
+if (!true) {
+if (util.isNode) {
+ var EventsModule = _dereq_("events");
+
+ var domainGetter = function() {
+ var domain = process.domain;
+ if (domain === null) return undefined;
+ return domain;
+ };
+
+ if (EventsModule.usingDomains) {
+ Async.prototype._getDomain = domainGetter;
+ } else {
+ var descriptor =
+ Object.getOwnPropertyDescriptor(EventsModule, "usingDomains");
+
+ if (descriptor) {
+ if (!descriptor.configurable) {
+ process.on("domainsActivated", function() {
+ Async.prototype._getDomain = domainGetter;
+ });
+ } else {
+ var usingDomains = false;
+ Object.defineProperty(EventsModule, "usingDomains", {
+ configurable: false,
+ enumerable: true,
+ get: function() {
+ return usingDomains;
+ },
+ set: function(value) {
+ if (usingDomains || !value) return;
+ usingDomains = true;
+ Async.prototype._getDomain = domainGetter;
+ util.toFastProperties(process);
+ process.emit("domainsActivated");
+ }
+ });
+ }
+ }
+ }
+}
+}
+
+function AsyncInvokeLater(fn, receiver, arg) {
+ var domain = this._getDomain();
+ if (domain !== undefined) fn = domain.bind(fn);
this._lateQueue.push(fn, receiver, arg);
this._queueTick();
-};
+}
-Async.prototype.invokeFirst = function (fn, receiver, arg) {
- fn = this._withDomain(fn);
- this._normalQueue.unshift(fn, receiver, arg);
+function AsyncInvoke(fn, receiver, arg) {
+ var domain = this._getDomain();
+ if (domain !== undefined) fn = domain.bind(fn);
+ this._normalQueue.push(fn, receiver, arg);
this._queueTick();
-};
+}
-Async.prototype.invoke = function (fn, receiver, arg) {
- fn = this._withDomain(fn);
- this._normalQueue.push(fn, receiver, arg);
+function AsyncSettlePromises(promise) {
+ var domain = this._getDomain();
+ if (domain !== undefined) {
+ var fn = domain.bind(promise._settlePromises);
+ this._normalQueue.push(fn, promise, undefined);
+ } else {
+ this._normalQueue._pushOne(promise);
+ }
this._queueTick();
-};
+}
-Async.prototype.settlePromises = function(promise) {
- this._normalQueue._pushOne(promise);
+if (!util.hasDevTools) {
+ Async.prototype.invokeLater = AsyncInvokeLater;
+ Async.prototype.invoke = AsyncInvoke;
+ Async.prototype.settlePromises = AsyncSettlePromises;
+} else {
+ Async.prototype.invokeLater = function (fn, receiver, arg) {
+ if (this._trampolineEnabled) {
+ AsyncInvokeLater.call(this, fn, receiver, arg);
+ } else {
+ setTimeout(function() {
+ fn.call(receiver, arg);
+ }, 100);
+ }
+ };
+
+ Async.prototype.invoke = function (fn, receiver, arg) {
+ if (this._trampolineEnabled) {
+ AsyncInvoke.call(this, fn, receiver, arg);
+ } else {
+ setTimeout(function() {
+ fn.call(receiver, arg);
+ }, 0);
+ }
+ };
+
+ Async.prototype.settlePromises = function(promise) {
+ if (this._trampolineEnabled) {
+ AsyncSettlePromises.call(this, promise);
+ } else {
+ setTimeout(function() {
+ promise._settlePromises();
+ }, 0);
+ }
+ };
+}
+
+Async.prototype.invokeFirst = function (fn, receiver, arg) {
+ var domain = this._getDomain();
+ if (domain !== undefined) fn = domain.bind(fn);
+ this._normalQueue.unshift(fn, receiver, arg);
this._queueTick();
};
@@ -236,76 +334,78 @@ Async.prototype._reset = function () {
module.exports = new Async();
module.exports.firstLineError = firstLineError;
-},{"./queue.js":28,"./schedule.js":31}],3:[function(_dereq_,module,exports){
+},{"./queue.js":28,"./schedule.js":31,"./util.js":38,"events":39}],3:[function(_dereq_,module,exports){
"use strict";
module.exports = function(Promise, INTERNAL, tryConvertToPromise) {
-function returnThis() { return this.value; }
-function throwThis() { throw this.reason; }
-function awaitBindingThenResolve(value) {
- return this._then(returnThis, null, null, {value: value}, undefined);
-}
-function awaitBindingThenReject(reason) {
- return this._then(throwThis, throwThis, null, {reason: reason}, undefined);
-}
-function setBinding(binding) { this._setBoundTo(binding); }
-Promise.prototype.bind = function (thisArg) {
- var maybePromise = tryConvertToPromise(thisArg);
- if (maybePromise instanceof Promise) {
- if (maybePromise.isFulfilled()) {
- thisArg = maybePromise.value();
- } else if (maybePromise.isRejected()) {
- return Promise.reject(maybePromise.reason());
- } else {
- var ret = this.then();
- var parent = ret;
- ret = ret._then(awaitBindingThenResolve,
- awaitBindingThenReject,
- null, maybePromise, undefined);
- maybePromise._then(setBinding, ret._reject, null, ret, null);
- if (!ret._cancellable()) ret._setPendingCancellationParent(parent);
- return ret;
- }
- }
- var ret = this.then();
- ret._setBoundTo(thisArg);
- return ret;
+var rejectThis = function(_, e) {
+ this._reject(e);
};
-Promise.bind = function (thisArg, value) {
- return Promise.resolve(value).bind(thisArg);
+var targetRejected = function(e, context) {
+ context.promiseRejectionQueued = true;
+ context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
};
-Promise.prototype._setPendingCancellationParent = function(parent) {
- this._settledValue = parent;
-};
-
-Promise.prototype._pendingCancellationParent = function() {
- if (this.isPending() && this._settledValue !== undefined) {
- var ret = this._settledValue;
- ret.cancellable();
- this._settledValue = undefined;
- return ret;
+var bindingResolved = function(thisArg, context) {
+ this._setBoundTo(thisArg);
+ if (this._isPending()) {
+ this._resolveCallback(context.target);
}
};
-Promise.prototype._setIsMigratingBinding = function () {
- this._bitField = this._bitField | 8388608;
+var bindingRejected = function(e, context) {
+ if (!context.promiseRejectionQueued) this._reject(e);
};
-Promise.prototype._unsetIsMigratingBinding = function () {
- this._bitField = this._bitField & (~8388608);
-};
-
-Promise.prototype._isMigratingBinding = function () {
- return (this._bitField & 8388608) === 8388608;
+Promise.prototype.bind = function (thisArg) {
+ var maybePromise = tryConvertToPromise(thisArg);
+ var ret = new Promise(INTERNAL);
+ ret._propagateFrom(this, 1);
+ var target = this._target();
+ if (maybePromise instanceof Promise) {
+ var context = {
+ promiseRejectionQueued: false,
+ promise: ret,
+ target: target,
+ bindingPromise: maybePromise
+ };
+ target._then(INTERNAL, targetRejected, ret._progress, ret, context);
+ maybePromise._then(
+ bindingResolved, bindingRejected, ret._progress, ret, context);
+ } else {
+ ret._setBoundTo(thisArg);
+ ret._resolveCallback(target);
+ }
+ return ret;
};
Promise.prototype._setBoundTo = function (obj) {
- this._boundTo = obj;
+ if (obj !== undefined) {
+ this._bitField = this._bitField | 131072;
+ this._boundTo = obj;
+ } else {
+ this._bitField = this._bitField & (~131072);
+ }
};
Promise.prototype._isBound = function () {
- return this._boundTo !== undefined;
+ return (this._bitField & 131072) === 131072;
+};
+
+Promise.bind = function (thisArg, value) {
+ var maybePromise = tryConvertToPromise(thisArg);
+ var ret = new Promise(INTERNAL);
+
+ if (maybePromise instanceof Promise) {
+ maybePromise._then(function(thisArg) {
+ ret._setBoundTo(thisArg);
+ ret._resolveCallback(value);
+ }, ret._reject, ret._progress, ret, null);
+ } else {
+ ret._setBoundTo(thisArg);
+ ret._resolveCallback(value);
+ }
+ return ret;
};
};
@@ -475,8 +575,9 @@ Promise.prototype.cancel = function (reason) {
Promise.prototype.cancellable = function () {
if (this._cancellable()) return this;
+ async.enableTrampoline();
this._setCancellable();
- this._cancellationParent = this._pendingCancellationParent();
+ this._cancellationParent = undefined;
return this;
};
@@ -506,6 +607,7 @@ var bluebirdFramePattern =
var stackFramePattern = null;
var formatStack = null;
var indentStackFrames = false;
+var warn;
function CapturedTrace(parent) {
this._parent = parent;
@@ -585,8 +687,8 @@ CapturedTrace.prototype.attachExtraTrace = function(error) {
}
removeCommonRoots(stacks);
removeDuplicateOrEmptyJumps(stacks);
- error.stack = reconstructStack(message, stacks);
- error.__stackCleaned__ = true;
+ util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
+ util.notEnumerableProp(error, "__stackCleaned__", true);
};
function reconstructStack(message, stacks) {
@@ -681,7 +783,7 @@ CapturedTrace.parseStackAndMessage = function(error) {
};
CapturedTrace.formatAndLogError = function(error, title) {
- if (typeof console === "object") {
+ if (typeof console !== "undefined") {
var message;
if (typeof error === "object" || typeof error === "function") {
var stack = error.stack;
@@ -689,9 +791,8 @@ CapturedTrace.formatAndLogError = function(error, title) {
} else {
message = title + String(error);
}
- if (typeof console.warn === "function" ||
- typeof console.warn === "object") {
- console.warn(message);
+ if (typeof warn === "function") {
+ warn(message);
} else if (typeof console.log === "function" ||
typeof console.log === "object") {
console.log(message);
@@ -746,7 +847,7 @@ function(name, localHandler, reason, promise) {
if (!globalEventFired && !localEventFired && !domEventFired &&
name === "unhandledRejection") {
- CapturedTrace.formatAndLogError(reason, "Possibly unhandled ");
+ CapturedTrace.formatAndLogError(reason, "Unhandled rejection ");
}
};
@@ -972,6 +1073,21 @@ var fireGlobalEvent = (function() {
}
})();
+if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
+ warn = function (message) {
+ console.warn(message);
+ };
+ if (util.isNode && process.stderr.isTTY) {
+ warn = function(message) {
+ process.stderr.write("\u001b[31m" + message + "\u001b[39m\n");
+ };
+ } else if (!util.isNode && typeof (new Error().stack) === "string") {
+ warn = function(message) {
+ console.warn("%c" + message, "color: red");
+ };
+ }
+}
+
return CapturedTrace;
};
@@ -1096,6 +1212,10 @@ var debugging = false || (util.isNode &&
(!!process.env["BLUEBIRD_DEBUG"] ||
process.env["NODE_ENV"] === "development"));
+if (debugging) {
+ async.disableTrampolineIfNecessary();
+}
+
Promise.prototype._ensurePossibleRejectionHandled = function () {
this._setRejectionIsUnhandled();
async.invokeLater(this._notifyUnhandledRejection, this, undefined);
@@ -1175,8 +1295,9 @@ Promise.prototype._attachExtraTrace = function (error, ignoreSelf) {
trace.attachExtraTrace(error);
} else if (!error.__stackCleaned__) {
var parsed = CapturedTrace.parseStackAndMessage(error);
- error.stack = parsed.stack.join("\n");
- error.__stackCleaned__ = true;
+ util.notEnumerableProp(error, "stack",
+ parsed.message + "\n" + parsed.stack.join("\n"));
+ util.notEnumerableProp(error, "__stackCleaned__", true);
}
}
};
@@ -1208,6 +1329,9 @@ Promise.longStackTraces = function () {
throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/DT1qyG\u000a");
}
debugging = CapturedTrace.isSupported();
+ if (debugging) {
+ async.disableTrampolineIfNecessary();
+ }
};
Promise.hasLongStackTraces = function () {
@@ -1237,6 +1361,10 @@ var returner = function () {
var thrower = function () {
throw this;
};
+var returnUndefined = function() {};
+var throwUndefined = function() {
+ throw undefined;
+};
var wrapper = function (value, action) {
if (action === 1) {
@@ -1253,6 +1381,8 @@ var wrapper = function (value, action) {
Promise.prototype["return"] =
Promise.prototype.thenReturn = function (value) {
+ if (value === undefined) return this.then(returnUndefined);
+
if (wrapsPrimitiveReceiver && isPrimitive(value)) {
return this._then(
wrapper(value, 2),
@@ -1267,6 +1397,8 @@ Promise.prototype.thenReturn = function (value) {
Promise.prototype["throw"] =
Promise.prototype.thenThrow = function (reason) {
+ if (reason === undefined) return this.then(throwUndefined);
+
if (wrapsPrimitiveReceiver && isPrimitive(reason)) {
return this._then(
wrapper(reason, 1),
@@ -1296,7 +1428,8 @@ Promise.each = function (promises, fn) {
},{}],13:[function(_dereq_,module,exports){
"use strict";
-var Objectfreeze = _dereq_("./es5.js").freeze;
+var es5 = _dereq_("./es5.js");
+var Objectfreeze = es5.freeze;
var util = _dereq_("./util.js");
var inherits = util.inherits;
var notEnumerableProp = util.notEnumerableProp;
@@ -1339,7 +1472,12 @@ for (var i = 0; i < methods.length; ++i) {
}
}
-AggregateError.prototype.length = 0;
+es5.defineProperty(AggregateError.prototype, "length", {
+ value: 0,
+ configurable: false,
+ writable: true,
+ enumerable: true
+});
AggregateError.prototype["isOperational"] = true;
var level = 0;
AggregateError.prototype.toString = function() {
@@ -1411,7 +1549,9 @@ if (isES5) {
module.exports = {
freeze: Object.freeze,
defineProperty: Object.defineProperty,
+ getDescriptor: Object.getOwnPropertyDescriptor,
keys: Object.keys,
+ names: Object.getOwnPropertyNames,
getPrototypeOf: Object.getPrototypeOf,
isArray: Array.isArray,
isES5: isES5,
@@ -1435,6 +1575,10 @@ if (isES5) {
return ret;
};
+ var ObjectGetDescriptor = function(o, key) {
+ return {value: o[key]};
+ };
+
var ObjectDefineProperty = function (o, key, desc) {
o[key] = desc.value;
return o;
@@ -1465,7 +1609,9 @@ if (isES5) {
module.exports = {
isArray: ArrayIsArray,
keys: ObjectKeys,
+ names: ObjectKeys,
defineProperty: ObjectDefineProperty,
+ getDescriptor: ObjectGetDescriptor,
freeze: ObjectFreeze,
getPrototypeOf: ObjectGetPrototypeOf,
isES5: isES5,
@@ -1844,6 +1990,7 @@ module.exports = function(Promise,
apiRejection,
tryConvertToPromise,
INTERNAL) {
+var async = _dereq_("./async.js");
var util = _dereq_("./util.js");
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;
@@ -1852,7 +1999,6 @@ var EMPTY_ARRAY = [];
function MappingPromiseArray(promises, fn, limit, _filter) {
this.constructor$(promises);
- this._promise._setIsSpreadable();
this._promise._captureStackTrace();
this._callback = fn;
this._preservedValues = _filter === INTERNAL
@@ -1861,9 +2007,10 @@ function MappingPromiseArray(promises, fn, limit, _filter) {
this._limit = limit;
this._inFlight = 0;
this._queue = limit >= 1 ? [] : EMPTY_ARRAY;
- this._init$(undefined, -2);
+ async.invoke(init, this, undefined);
}
util.inherits(MappingPromiseArray, PromiseArray);
+function init() {this._init$(undefined, -2);}
MappingPromiseArray.prototype._init = function () {};
@@ -1969,7 +2116,7 @@ Promise.map = function (promises, fn, options, _filter) {
};
-},{"./util.js":38}],20:[function(_dereq_,module,exports){
+},{"./async.js":2,"./util.js":38}],20:[function(_dereq_,module,exports){
"use strict";
module.exports =
function(Promise, INTERNAL, tryConvertToPromise, apiRejection) {
@@ -2056,6 +2203,7 @@ function errorAdapter(reason, nodeback) {
}
}
+Promise.prototype.asCallback =
Promise.prototype.nodeify = function (nodeback, options) {
if (typeof nodeback == "function") {
var adapter = successAdapter;
@@ -2205,7 +2353,6 @@ function Promise(resolver) {
this._promise0 = undefined;
this._receiver0 = undefined;
this._settledValue = undefined;
- this._boundTo = undefined;
if (resolver !== INTERNAL) this._resolveFromResolver(resolver);
}
@@ -2262,11 +2409,7 @@ Promise.prototype.done = function (didFulfill, didReject, didProgress) {
};
Promise.prototype.spread = function (didFulfill, didReject) {
- var followee = this._target();
- var target = followee._isSpreadable()
- ? (followee === this ? this : this.then())
- : this.all();
- return target._then(didFulfill, didReject, undefined, APPLY, undefined);
+ return this.all()._then(didFulfill, didReject, undefined, APPLY, undefined);
};
Promise.prototype.isCancellable = function () {
@@ -2292,9 +2435,7 @@ Promise.prototype.toJSON = function () {
};
Promise.prototype.all = function () {
- var ret = new PromiseArray(this).promise();
- ret._setIsSpreadable();
- return ret;
+ return new PromiseArray(this).promise();
};
Promise.prototype.error = function (fn) {
@@ -2315,9 +2456,7 @@ Promise.fromNode = function(fn) {
};
Promise.all = function (promises) {
- var ret = new PromiseArray(promises).promise();
- ret._setIsSpreadable();
- return ret;
+ return new PromiseArray(promises).promise();
};
Promise.defer = Promise.pending = function () {
@@ -2368,13 +2507,8 @@ Promise.prototype._then = function (
var target = this._target();
if (target !== this) {
- if (!haveInternalData) {
- ret._setIsMigrated();
- if (receiver === undefined) {
- ret._setIsMigratingBinding();
- receiver = this;
- }
- }
+ if (receiver === undefined) receiver = this._boundTo;
+ if (!haveInternalData) ret._setIsMigrated();
}
var callbackIndex =
@@ -2442,14 +2576,6 @@ Promise.prototype._unsetCancellable = function () {
this._bitField = this._bitField & (~67108864);
};
-Promise.prototype._isSpreadable = function () {
- return (this._bitField & 131072) > 0;
-};
-
-Promise.prototype._setIsSpreadable = function () {
- this._bitField = this._bitField | 131072;
-};
-
Promise.prototype._setIsMigrated = function () {
this._bitField = this._bitField | 4194304;
};
@@ -2467,7 +2593,7 @@ Promise.prototype._receiverAt = function (index) {
? this._receiver0
: this[
index * 5 - 5 + 4];
- if (this._isBound() && ret === undefined) {
+ if (ret === undefined && this._isBound()) {
return this._boundTo;
}
return ret;
@@ -2497,13 +2623,7 @@ Promise.prototype._migrateCallbacks = function (follower, index) {
var progress = follower._progressHandlerAt(index);
var promise = follower._promiseAt(index);
var receiver = follower._receiverAt(index);
- if (promise instanceof Promise) {
- promise._setIsMigrated();
- if (receiver === undefined) {
- receiver = follower;
- promise._setIsMigratingBinding();
- }
- }
+ if (promise instanceof Promise) promise._setIsMigrated();
this._addCallbacks(fulfill, reject, progress, promise, receiver);
};
@@ -2597,10 +2717,9 @@ function(reason, synchronous, shouldNotMarkOriginatingFromRejection) {
util.markAsOriginatingFromRejection(reason);
}
var trace = util.ensureErrorObject(reason);
- var hasStack = util.canAttachTrace(reason) &&
- typeof trace.stack === "string" && trace.stack.length > 0;
+ var hasStack = trace === reason;
this._attachExtraTrace(trace, synchronous ? hasStack : false);
- this._reject(reason, trace === reason ? undefined : trace);
+ this._reject(reason, hasStack ? undefined : trace);
};
Promise.prototype._resolveFromResolver = function (resolver) {
@@ -2672,7 +2791,7 @@ Promise.prototype._propagateFrom = function (parent, flags) {
this._setCancellable();
this._cancellationParent = parent;
}
- if ((flags & 4) > 0) {
+ if ((flags & 4) > 0 && parent._isBound()) {
this._setBoundTo(parent._boundTo);
}
};
@@ -2703,10 +2822,7 @@ Promise.prototype._settlePromiseAt = function (index) {
this._isCarryingStackTrace() ? this._getCarriedStackTrace() : undefined;
var value = this._settledValue;
var receiver = this._receiverAt(index);
- if (isPromise && promise._isMigratingBinding()) {
- promise._unsetIsMigratingBinding();
- receiver = receiver._boundTo;
- }
+
this._clearCallbackDataAtIndex(index);
@@ -2835,37 +2951,54 @@ Promise.prototype._settlePromises = function () {
};
Promise._makeSelfResolutionError = makeSelfResolutionError;
+_dereq_("./progress.js")(Promise, PromiseArray);
_dereq_("./method.js")(Promise, INTERNAL, tryConvertToPromise, apiRejection);
_dereq_("./bind.js")(Promise, INTERNAL, tryConvertToPromise);
_dereq_("./finally.js")(Promise, NEXT_FILTER, tryConvertToPromise);
_dereq_("./direct_resolve.js")(Promise);
_dereq_("./synchronous_inspection.js")(Promise);
_dereq_("./join.js")(Promise, PromiseArray, tryConvertToPromise, INTERNAL);
-
-util.toFastProperties(Promise);
-util.toFastProperties(Promise.prototype);
Promise.Promise = Promise;
-CapturedTrace.setBounds(async.firstLineError, util.lastLineError);
_dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL);
+_dereq_('./cancel.js')(Promise);
_dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext);
_dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise);
_dereq_('./nodeify.js')(Promise);
-_dereq_('./cancel.js')(Promise);
-_dereq_('./promisify.js')(Promise, INTERNAL);
+_dereq_('./call_get.js')(Promise);
_dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);
_dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);
_dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL);
_dereq_('./settle.js')(Promise, PromiseArray);
-_dereq_('./call_get.js')(Promise);
_dereq_('./some.js')(Promise, PromiseArray, apiRejection);
-_dereq_('./progress.js')(Promise, PromiseArray);
+_dereq_('./promisify.js')(Promise, INTERNAL);
_dereq_('./any.js')(Promise);
_dereq_('./each.js')(Promise, INTERNAL);
_dereq_('./timers.js')(Promise, INTERNAL);
_dereq_('./filter.js')(Promise, INTERNAL);
-
-Promise.prototype = Promise.prototype;
-return Promise;
+
+ util.toFastProperties(Promise);
+ util.toFastProperties(Promise.prototype);
+ function fillTypes(value) {
+ var p = new Promise(INTERNAL);
+ p._fulfillmentHandler0 = value;
+ p._rejectionHandler0 = value;
+ p._progressHandler0 = value;
+ p._promise0 = value;
+ p._receiver0 = value;
+ p._settledValue = value;
+ }
+ // Complete slack tracking, opt out of field-type tracking and
+ // stabilize map
+ fillTypes({a: 1});
+ fillTypes({b: 2});
+ fillTypes({c: 3});
+ fillTypes(1);
+ fillTypes(function(){});
+ fillTypes(undefined);
+ fillTypes(false);
+ fillTypes(new Promise(INTERNAL));
+ CapturedTrace.setBounds(async.firstLineError, util.lastLineError);
+ return Promise;
};
@@ -2906,7 +3039,6 @@ PromiseArray.prototype.promise = function () {
PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
var values = tryConvertToPromise(this._values, this._promise);
if (values instanceof Promise) {
- values._setBoundTo(this._promise._boundTo);
values = values._target();
this._values = values;
if (values._isFulfilled()) {
@@ -3151,12 +3283,18 @@ var maybeWrapAsError = util.maybeWrapAsError;
var canEvaluate = util.canEvaluate;
var TypeError = _dereq_("./errors").TypeError;
var defaultSuffix = "Async";
+var defaultPromisified = {__isPromisified__: true};
+var noCopyPropsPattern =
+ /^(?:length|name|arguments|caller|callee|prototype|__isPromisified__)$/;
var defaultFilter = function(name, func) {
return util.isIdentifier(name) &&
name.charAt(0) !== "_" &&
!util.isClass(func);
};
-var defaultPromisified = {__isPromisified__: true};
+
+function propsFilter(key) {
+ return !noCopyPropsPattern.test(key);
+}
function isPromisified(fn) {
try {
@@ -3214,22 +3352,23 @@ var makeNodePromisifiedEval;
if (!true) {
var switchCaseArgumentOrder = function(likelyArgumentCount) {
var ret = [likelyArgumentCount];
- var min = Math.max(0, likelyArgumentCount - 1 - 5);
+ var min = Math.max(0, likelyArgumentCount - 1 - 3);
for(var i = likelyArgumentCount - 1; i >= min; --i) {
ret.push(i);
}
- for(var i = likelyArgumentCount + 1; i <= 5; ++i) {
+ for(var i = likelyArgumentCount + 1; i <= 3; ++i) {
ret.push(i);
}
return ret;
};
var argumentSequence = function(argumentCount) {
- return util.filledRange(argumentCount, "arguments[", "]");
+ return util.filledRange(argumentCount, "_arg", "");
};
var parameterDeclaration = function(parameterCount) {
- return util.filledRange(parameterCount, "_arg", "");
+ return util.filledRange(
+ Math.max(parameterCount, 3), "_arg", "");
};
var parameterCount = function(fn) {
@@ -3239,71 +3378,32 @@ var parameterCount = function(fn) {
return 0;
};
-var generatePropertyAccess = function(key) {
- if (util.isIdentifier(key)) {
- return "." + key;
- }
- else return "['" + key.replace(/(['\\])/g, "\\$1") + "']";
-};
-
makeNodePromisifiedEval =
-function(callback, receiver, originalName, fn, suffix) {
+function(callback, receiver, originalName, fn) {
var newParameterCount = Math.max(0, parameterCount(fn) - 1);
var argumentOrder = switchCaseArgumentOrder(newParameterCount);
- var callbackName =
- (typeof originalName === "string" && util.isIdentifier(originalName)
- ? originalName + suffix
- : "promisified");
+ var shouldProxyThis = typeof callback === "string" || receiver === THIS;
function generateCallForArgumentCount(count) {
var args = argumentSequence(count).join(", ");
var comma = count > 0 ? ", " : "";
var ret;
- if (typeof callback === "string") {
- ret = " \n\
- this.method({{args}}, fn); \n\
- break; \n\
- ".replace(".method", generatePropertyAccess(callback));
- } else if (receiver === THIS) {
- ret = " \n\
- callback.call(this, {{args}}, fn); \n\
- break; \n\
- ";
- } else if (receiver !== undefined) {
- ret = " \n\
- callback.call(receiver, {{args}}, fn); \n\
- break; \n\
- ";
+ if (shouldProxyThis) {
+ ret = "ret = callback.call(this, {{args}}, nodeback); break;\n";
} else {
- ret = " \n\
- callback({{args}}, fn); \n\
- break; \n\
- ";
+ ret = receiver === undefined
+ ? "ret = callback({{args}}, nodeback); break;\n"
+ : "ret = callback.call(receiver, {{args}}, nodeback); break;\n";
}
return ret.replace("{{args}}", args).replace(", ", comma);
}
function generateArgumentSwitchCase() {
var ret = "";
- for(var i = 0; i < argumentOrder.length; ++i) {
+ for (var i = 0; i < argumentOrder.length; ++i) {
ret += "case " + argumentOrder[i] +":" +
generateCallForArgumentCount(argumentOrder[i]);
}
- var codeForCall;
- if (typeof callback === "string") {
- codeForCall = " \n\
- this.property.apply(this, args); \n\
- "
- .replace(".property", generatePropertyAccess(callback));
- } else if (receiver === THIS) {
- codeForCall = " \n\
- callback.apply(this, args); \n\
- ";
- } else {
- codeForCall = " \n\
- callback.apply(receiver, args); \n\
- ";
- }
ret += " \n\
default: \n\
@@ -3312,72 +3412,81 @@ function(callback, receiver, originalName, fn, suffix) {
for (var i = 0; i < len; ++i) { \n\
args[i] = arguments[i]; \n\
} \n\
- args[i] = fn; \n\
+ args[i] = nodeback; \n\
[CodeForCall] \n\
break; \n\
- ".replace("[CodeForCall]", codeForCall);
+ ".replace("[CodeForCall]", (shouldProxyThis
+ ? "ret = callback.apply(this, args);\n"
+ : "ret = callback.apply(receiver, args);\n"));
return ret;
}
+ var getFunctionCode = typeof callback === "string"
+ ? ("this != null ? this['"+callback+"'] : fn")
+ : "fn";
+
return new Function("Promise",
- "callback",
+ "fn",
"receiver",
"withAppended",
"maybeWrapAsError",
"nodebackForPromise",
- "INTERNAL"," \n\
- var ret = function (Parameters) { \n\
+ "tryCatch",
+ "errorObj",
+ "INTERNAL","'use strict'; \n\
+ var ret = function (Parameters) { \n\
'use strict'; \n\
var len = arguments.length; \n\
var promise = new Promise(INTERNAL); \n\
promise._captureStackTrace(); \n\
- promise._setIsSpreadable(); \n\
- var fn = nodebackForPromise(promise); \n\
- try { \n\
- switch(len) { \n\
- [CodeForSwitchCase] \n\
- } \n\
- } catch (e) { \n\
- var wrapped = maybeWrapAsError(e); \n\
- promise._attachExtraTrace(wrapped); \n\
- promise._reject(wrapped); \n\
+ var nodeback = nodebackForPromise(promise); \n\
+ var ret; \n\
+ var callback = tryCatch([GetFunctionCode]); \n\
+ switch(len) { \n\
+ [CodeForSwitchCase] \n\
+ } \n\
+ if (ret === errorObj) { \n\
+ promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\
} \n\
return promise; \n\
}; \n\
ret.__isPromisified__ = true; \n\
return ret; \n\
"
- .replace("FunctionName", callbackName)
.replace("Parameters", parameterDeclaration(newParameterCount))
- .replace("[CodeForSwitchCase]", generateArgumentSwitchCase()))(
+ .replace("[CodeForSwitchCase]", generateArgumentSwitchCase())
+ .replace("[GetFunctionCode]", getFunctionCode))(
Promise,
- callback,
+ fn,
receiver,
withAppended,
maybeWrapAsError,
nodebackForPromise,
+ util.tryCatch,
+ util.errorObj,
INTERNAL
);
};
}
-function makeNodePromisifiedClosure(callback, receiver) {
+function makeNodePromisifiedClosure(callback, receiver, _, fn) {
+ var defaultThis = (function() {return this;})();
+ var method = callback;
+ if (typeof method === "string") {
+ callback = fn;
+ }
function promisified() {
var _receiver = receiver;
if (receiver === THIS) _receiver = this;
- if (typeof callback === "string") {
- callback = _receiver[callback];
- }
var promise = new Promise(INTERNAL);
promise._captureStackTrace();
- promise._setIsSpreadable();
+ var cb = typeof method === "string" && this !== defaultThis
+ ? this[method] : callback;
var fn = nodebackForPromise(promise);
try {
- callback.apply(_receiver, withAppended(arguments, fn));
+ cb.apply(_receiver, withAppended(arguments, fn));
} catch(e) {
- var wrapped = maybeWrapAsError(e);
- promise._attachExtraTrace(wrapped);
- promise._reject(wrapped);
+ promise._rejectCallback(maybeWrapAsError(e), true, true);
}
return promise;
}
@@ -3419,7 +3528,9 @@ Promise.promisify = function (fn, receiver) {
if (isPromisified(fn)) {
return fn;
}
- return promisify(fn, arguments.length < 2 ? THIS : receiver);
+ var ret = promisify(fn, arguments.length < 2 ? THIS : receiver);
+ util.copyDescriptors(fn, ret, propsFilter);
+ return ret;
};
Promise.promisifyAll = function (target, options) {
@@ -3438,7 +3549,7 @@ Promise.promisifyAll = function (target, options) {
throw new RangeError("suffix must be a valid identifier\u000a\u000a See http://goo.gl/8FZo5V\u000a");
}
- var keys = util.inheritedDataKeys(target, {includeHidden: true});
+ var keys = util.inheritedDataKeys(target);
for (var i = 0; i < keys.length; ++i) {
var value = target[keys[i]];
if (keys[i] !== "constructor" &&
@@ -3682,6 +3793,7 @@ module.exports = function(Promise,
apiRejection,
tryConvertToPromise,
INTERNAL) {
+var async = _dereq_("./async.js");
var util = _dereq_("./util.js");
var tryCatch = util.tryCatch;
var errorObj = util.errorObj;
@@ -3711,7 +3823,10 @@ function ReductionPromiseArray(promises, fn, accum, _each) {
if (!(isPromise || this._zerothIsAccum)) this._gotAccum = true;
this._callback = fn;
this._accum = accum;
- if (!rejected) this._init$(undefined, -5);
+ if (!rejected) async.invoke(init, this, undefined);
+}
+function init() {
+ this._init$(undefined, -5);
}
util.inherits(ReductionPromiseArray, PromiseArray);
@@ -3819,15 +3934,20 @@ Promise.reduce = function (promises, fn, initialValue, _each) {
};
};
-},{"./util.js":38}],31:[function(_dereq_,module,exports){
+},{"./async.js":2,"./util.js":38}],31:[function(_dereq_,module,exports){
"use strict";
var schedule;
-if (_dereq_("./util.js").isNode) {
- var version = process.version.split(".").map(Number);
- schedule = (version[0] === 0 && version[1] > 10) || (version[0] > 0)
- ? global.setImmediate : process.nextTick;
-}
-else if (typeof MutationObserver !== "undefined") {
+var util = _dereq_("./util");
+var noAsyncScheduler = function() {
+ throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/m3OTXk\u000a");
+};
+if (util.isNode && typeof MutationObserver === "undefined") {
+ var GlobalSetImmediate = global.setImmediate;
+ var ProcessNextTick = process.nextTick;
+ schedule = util.isRecentNode
+ ? function(fn) { GlobalSetImmediate.call(global, fn); }
+ : function(fn) { ProcessNextTick.call(process, fn); };
+} else if (typeof MutationObserver !== "undefined") {
schedule = function(fn) {
var div = document.createElement("div");
var observer = new MutationObserver(fn);
@@ -3835,20 +3955,20 @@ else if (typeof MutationObserver !== "undefined") {
return function() { div.classList.toggle("foo"); };
};
schedule.isStatic = true;
-}
-else if (typeof setTimeout !== "undefined") {
+} else if (typeof setImmediate !== "undefined") {
schedule = function (fn) {
- setTimeout(fn, 0);
+ setImmediate(fn);
};
-}
-else {
- schedule = function() {
- throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/m3OTXk\u000a");
+} else if (typeof setTimeout !== "undefined") {
+ schedule = function (fn) {
+ setTimeout(fn, 0);
};
+} else {
+ schedule = noAsyncScheduler;
}
module.exports = schedule;
-},{"./util.js":38}],32:[function(_dereq_,module,exports){
+},{"./util":38}],32:[function(_dereq_,module,exports){
"use strict";
module.exports =
function(Promise, PromiseArray) {
@@ -3857,7 +3977,6 @@ var util = _dereq_("./util.js");
function SettledPromiseArray(values) {
this.constructor$(values);
- this._promise._setIsSpreadable();
}
util.inherits(SettledPromiseArray, PromiseArray);
@@ -3913,7 +4032,6 @@ SomePromiseArray.prototype._init = function () {
if (!this._initialized) {
return;
}
- this._promise._setIsSpreadable();
if (this._howMany === 0) {
this._resolve([]);
return;
@@ -4524,9 +4642,6 @@ var inherits = function(Child, Parent) {
return Child.prototype;
};
-function asString(val) {
- return typeof val === "string" ? val : ("" + val);
-}
function isPrimitive(val) {
return val == null || val === true || val === false ||
@@ -4541,7 +4656,7 @@ function isObject(value) {
function maybeWrapAsError(maybeError) {
if (!isPrimitive(maybeError)) return maybeError;
- return new Error(asString(maybeError));
+ return new Error(safeToString(maybeError));
}
function withAppended(target, appendee) {
@@ -4591,13 +4706,12 @@ function thrower(r) {
var inheritedDataKeys = (function() {
if (es5.isES5) {
- return function(obj, opts) {
+ var oProto = Object.prototype;
+ var getKeys = Object.getOwnPropertyNames;
+ return function(obj) {
var ret = [];
var visitedKeys = Object.create(null);
- var getKeys = Object(opts).includeHidden
- ? Object.getOwnPropertyNames
- : Object.keys;
- while (obj != null) {
+ while (obj != null && obj !== oProto) {
var keys;
try {
keys = getKeys(obj);
@@ -4633,7 +4747,8 @@ var inheritedDataKeys = (function() {
function isClass(fn) {
try {
if (typeof fn === "function") {
- var keys = es5.keys(fn.prototype);
+ var keys = es5.names(fn.prototype);
+ if (es5.isES5) return keys.length > 1;
return keys.length > 0 &&
!(keys.length === 1 && keys[0] === "constructor");
}
@@ -4644,10 +4759,12 @@ function isClass(fn) {
}
function toFastProperties(obj) {
- /*jshint -W027*/
+ /*jshint -W027,-W055,-W031*/
function f() {}
f.prototype = obj;
- return f;
+ var l = 8;
+ while (l--) new f();
+ return obj;
eval(obj);
}
@@ -4688,7 +4805,7 @@ function originatesFromRejection(e) {
function canAttachTrace(obj) {
// Added by Zotero
return obj && obj.stack && es5.propertyIsWritable(obj, "stack");
-
+
return obj instanceof Error && es5.propertyIsWritable(obj, "stack");
}
@@ -4711,6 +4828,16 @@ function classString(obj) {
return {}.toString.call(obj);
}
+function copyDescriptors(from, to, filter) {
+ var keys = es5.names(from);
+ for (var i = 0; i < keys.length; ++i) {
+ var key = keys[i];
+ if (filter(key)) {
+ es5.defineProperty(to, key, es5.getDescriptor(from, key));
+ }
+ }
+}
+
var ret = {
isClass: isClass,
isIdentifier: isIdentifier,
@@ -4727,7 +4854,6 @@ var ret = {
tryCatch: tryCatch,
inherits: inherits,
withAppended: withAppended,
- asString: asString,
maybeWrapAsError: maybeWrapAsError,
wrapsPrimitiveReceiver: wrapsPrimitiveReceiver,
toFastProperties: toFastProperties,
@@ -4738,11 +4864,321 @@ var ret = {
originatesFromRejection: originatesFromRejection,
markAsOriginatingFromRejection: markAsOriginatingFromRejection,
classString: classString,
+ copyDescriptors: copyDescriptors,
+ hasDevTools: typeof chrome !== "undefined" && chrome &&
+ typeof chrome.loadTimes === "function",
isNode: typeof process !== "undefined" &&
classString(process).toLowerCase() === "[object process]"
};
+ret.isRecentNode = ret.isNode && (function() {
+ var version = process.versions.node.split(".").map(Number);
+ return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
+})();
try {throw new Error(); } catch (e) {ret.lastLineError = e;}
module.exports = ret;
-},{"./es5.js":14}]},{},[4])(4)
+},{"./es5.js":14}],39:[function(_dereq_,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+ this._events = this._events || {};
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!isNumber(n) || n < 0 || isNaN(n))
+ throw TypeError('n must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+ var er, handler, len, args, i, listeners;
+
+ if (!this._events)
+ this._events = {};
+
+ // If there is no 'error' event listener then throw.
+ if (type === 'error') {
+ if (!this._events.error ||
+ (isObject(this._events.error) && !this._events.error.length)) {
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ }
+ throw TypeError('Uncaught, unspecified "error" event.');
+ }
+ }
+
+ handler = this._events[type];
+
+ if (isUndefined(handler))
+ return false;
+
+ if (isFunction(handler)) {
+ switch (arguments.length) {
+ // fast cases
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ // slower
+ default:
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ handler.apply(this, args);
+ }
+ } else if (isObject(handler)) {
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+
+ listeners = handler.slice();
+ len = listeners.length;
+ for (i = 0; i < len; i++)
+ listeners[i].apply(this, args);
+ }
+
+ return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ var m;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events)
+ this._events = {};
+
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (this._events.newListener)
+ this.emit('newListener', type,
+ isFunction(listener.listener) ?
+ listener.listener : listener);
+
+ if (!this._events[type])
+ // Optimize the case of one listener. Don't need the extra array object.
+ this._events[type] = listener;
+ else if (isObject(this._events[type]))
+ // If we've already got an array, just append.
+ this._events[type].push(listener);
+ else
+ // Adding the second element, need to change to array.
+ this._events[type] = [this._events[type], listener];
+
+ // Check for listener leak
+ if (isObject(this._events[type]) && !this._events[type].warned) {
+ var m;
+ if (!isUndefined(this._maxListeners)) {
+ m = this._maxListeners;
+ } else {
+ m = EventEmitter.defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ if (typeof console.trace === 'function') {
+ // not supported in IE 10
+ console.trace();
+ }
+ }
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ var fired = false;
+
+ function g() {
+ this.removeListener(type, g);
+
+ if (!fired) {
+ fired = true;
+ listener.apply(this, arguments);
+ }
+ }
+
+ g.listener = listener;
+ this.on(type, g);
+
+ return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+ var list, position, length, i;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events || !this._events[type])
+ return this;
+
+ list = this._events[type];
+ length = list.length;
+ position = -1;
+
+ if (list === listener ||
+ (isFunction(list.listener) && list.listener === listener)) {
+ delete this._events[type];
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+
+ } else if (isObject(list)) {
+ for (i = length; i-- > 0;) {
+ if (list[i] === listener ||
+ (list[i].listener && list[i].listener === listener)) {
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (list.length === 1) {
+ list.length = 0;
+ delete this._events[type];
+ } else {
+ list.splice(position, 1);
+ }
+
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ var key, listeners;
+
+ if (!this._events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!this._events.removeListener) {
+ if (arguments.length === 0)
+ this._events = {};
+ else if (this._events[type])
+ delete this._events[type];
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ for (key in this._events) {
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = {};
+ return this;
+ }
+
+ listeners = this._events[type];
+
+ if (isFunction(listeners)) {
+ this.removeListener(type, listeners);
+ } else {
+ // LIFO order
+ while (listeners.length)
+ this.removeListener(type, listeners[listeners.length - 1]);
+ }
+ delete this._events[type];
+
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ var ret;
+ if (!this._events || !this._events[type])
+ ret = [];
+ else if (isFunction(this._events[type]))
+ ret = [this._events[type]];
+ else
+ ret = this._events[type].slice();
+ return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ var ret;
+ if (!emitter._events || !emitter._events[type])
+ ret = 0;
+ else if (isFunction(emitter._events[type]))
+ ret = 1;
+ else
+ ret = emitter._events[type].length;
+ return ret;
+};
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+
+},{}]},{},[4])(4)
}); ;if (typeof window !== 'undefined' && window !== null) { window.P = window.Promise; } else if (typeof self !== 'undefined' && self !== null) { self.P = self.Promise; }
\ No newline at end of file
