c322eaa1bc
I didn't really investigate this, but errors from the outside world seem to not pass the "obj instanceof Error" test due to some weirdness that Bluebird is doing. (When I took this out recently I thought we just were throwing some custom errors that didn't properly extend Error, but that isn't the issue.) This restores the earlier workaround.
4737 lines
No EOL
145 KiB
JavaScript
4737 lines
No EOL
145 KiB
JavaScript
/* @preserve
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2014 Petka Antonov
|
|
*
|
|
* 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:</p>
|
|
*
|
|
* 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.
|
|
*
|
|
*/
|
|
/**
|
|
* 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
|
|
*/
|
|
!function(e){
|
|
//
|
|
// Added by Zotero
|
|
//
|
|
EXPORTED_SYMBOLS = ["Promise"];
|
|
|
|
// Set BackstagePass (which contains .Error, etc.) as global object
|
|
self = this;
|
|
|
|
// Provide an implementation of setTimeout
|
|
self.setTimeout = new function() {
|
|
// We need to maintain references to running nsITimers. Otherwise, they can
|
|
// get garbage collected before they fire.
|
|
var _runningTimers = [];
|
|
|
|
return function setTimeout(func, ms) {
|
|
var useMethodjit = Components.utils.methodjit;
|
|
var timer = Components.classes["@mozilla.org/timer;1"]
|
|
.createInstance(Components.interfaces.nsITimer);
|
|
timer.initWithCallback({"notify":function() {
|
|
// Remove timer from array so it can be garbage collected
|
|
_runningTimers.splice(_runningTimers.indexOf(timer), 1);
|
|
|
|
// Execute callback function
|
|
try {
|
|
func();
|
|
} catch(err) {
|
|
// Rethrow errors that occur so that they appear in the error
|
|
// console with the appropriate name and line numbers. While the
|
|
// the errors appear without this, the line numbers get eaten.
|
|
var scriptError = Components.classes["@mozilla.org/scripterror;1"]
|
|
.createInstance(Components.interfaces.nsIScriptError);
|
|
scriptError.init(
|
|
err.message || err.toString(),
|
|
err.fileName || err.filename || null,
|
|
null,
|
|
err.lineNumber || null,
|
|
null,
|
|
scriptError.errorFlag,
|
|
'component javascript'
|
|
);
|
|
Components.classes["@mozilla.org/consoleservice;1"]
|
|
.getService(Components.interfaces.nsIConsoleService)
|
|
.logMessage(scriptError);
|
|
self.debug(err, 1);
|
|
self.debug(err.stack, 1);
|
|
}
|
|
}}, ms, Components.interfaces.nsITimer.TYPE_ONE_SHOT);
|
|
_runningTimers.push(timer);
|
|
}
|
|
};
|
|
|
|
self.debug = function (msg) {
|
|
dump(msg + "\n\n");
|
|
};
|
|
|
|
Promise = e();
|
|
// TEMP: Only turn on if debug logging enabled?
|
|
Promise.longStackTraces();
|
|
Promise.onPossiblyUnhandledRejection(function(error) {
|
|
self.debug('===========');
|
|
self.debug(error);
|
|
self.debug(error.stack);
|
|
throw error;
|
|
});
|
|
return;
|
|
|
|
|
|
if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof _dereq_=="function"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise) {
|
|
var SomePromiseArray = Promise._SomePromiseArray;
|
|
function any(promises) {
|
|
var ret = new SomePromiseArray(promises);
|
|
var promise = ret.promise();
|
|
ret.setHowMany(1);
|
|
ret.setUnwrap();
|
|
ret.init();
|
|
return promise;
|
|
}
|
|
|
|
Promise.any = function (promises) {
|
|
return any(promises);
|
|
};
|
|
|
|
Promise.prototype.any = function () {
|
|
return any(this);
|
|
};
|
|
|
|
};
|
|
|
|
},{}],2:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
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;
|
|
|
|
function Async() {
|
|
this._isTickUsed = false;
|
|
this._lateQueue = new Queue(16);
|
|
this._normalQueue = new Queue(16);
|
|
var self = this;
|
|
this.drainQueues = function () {
|
|
self._drainQueues();
|
|
};
|
|
this._schedule =
|
|
schedule.isStatic ? schedule(this.drainQueues) : schedule;
|
|
}
|
|
|
|
Async.prototype.haveItemsQueued = function () {
|
|
return this._normalQueue.length() > 0;
|
|
};
|
|
|
|
Async.prototype._withDomain = function(fn) {
|
|
if (_process !== undefined &&
|
|
_process.domain != null &&
|
|
!fn.domain) {
|
|
fn = _process.domain.bind(fn);
|
|
}
|
|
return fn;
|
|
};
|
|
|
|
Async.prototype.throwLater = function(fn, arg) {
|
|
if (arguments.length === 1) {
|
|
arg = fn;
|
|
fn = function () { throw arg; };
|
|
}
|
|
fn = this._withDomain(fn);
|
|
if (typeof setTimeout !== "undefined") {
|
|
setTimeout(function() {
|
|
fn(arg);
|
|
}, 0);
|
|
} else try {
|
|
this._schedule(function() {
|
|
fn(arg);
|
|
});
|
|
} catch (e) {
|
|
throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/m3OTXk\u000a");
|
|
}
|
|
};
|
|
|
|
Async.prototype.invokeLater = function (fn, receiver, arg) {
|
|
fn = this._withDomain(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);
|
|
this._queueTick();
|
|
};
|
|
|
|
Async.prototype.invoke = function (fn, receiver, arg) {
|
|
fn = this._withDomain(fn);
|
|
this._normalQueue.push(fn, receiver, arg);
|
|
this._queueTick();
|
|
};
|
|
|
|
Async.prototype.settlePromises = function(promise) {
|
|
this._normalQueue._pushOne(promise);
|
|
this._queueTick();
|
|
};
|
|
|
|
Async.prototype._drainQueue = function(queue) {
|
|
while (queue.length() > 0) {
|
|
var fn = queue.shift();
|
|
if (typeof fn !== "function") {
|
|
fn._settlePromises();
|
|
continue;
|
|
}
|
|
var receiver = queue.shift();
|
|
var arg = queue.shift();
|
|
fn.call(receiver, arg);
|
|
}
|
|
};
|
|
|
|
Async.prototype._drainQueues = function () {
|
|
this._drainQueue(this._normalQueue);
|
|
this._reset();
|
|
this._drainQueue(this._lateQueue);
|
|
};
|
|
|
|
Async.prototype._queueTick = function () {
|
|
if (!this._isTickUsed) {
|
|
this._isTickUsed = true;
|
|
this._schedule(this.drainQueues);
|
|
}
|
|
};
|
|
|
|
Async.prototype._reset = function () {
|
|
this._isTickUsed = false;
|
|
};
|
|
|
|
module.exports = new Async();
|
|
module.exports.firstLineError = firstLineError;
|
|
|
|
},{"./queue.js":28,"./schedule.js":31}],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;
|
|
};
|
|
|
|
Promise.bind = function (thisArg, value) {
|
|
return Promise.resolve(value).bind(thisArg);
|
|
};
|
|
|
|
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;
|
|
}
|
|
};
|
|
|
|
Promise.prototype._setIsMigratingBinding = function () {
|
|
this._bitField = this._bitField | 8388608;
|
|
};
|
|
|
|
Promise.prototype._unsetIsMigratingBinding = function () {
|
|
this._bitField = this._bitField & (~8388608);
|
|
};
|
|
|
|
Promise.prototype._isMigratingBinding = function () {
|
|
return (this._bitField & 8388608) === 8388608;
|
|
};
|
|
|
|
Promise.prototype._setBoundTo = function (obj) {
|
|
this._boundTo = obj;
|
|
};
|
|
|
|
Promise.prototype._isBound = function () {
|
|
return this._boundTo !== undefined;
|
|
};
|
|
};
|
|
|
|
},{}],4:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var old;
|
|
if (typeof Promise !== "undefined") old = Promise;
|
|
function noConflict() {
|
|
try { if (Promise === bluebird) Promise = old; }
|
|
catch (e) {}
|
|
return bluebird;
|
|
}
|
|
var bluebird = _dereq_("./promise.js")();
|
|
bluebird.noConflict = noConflict;
|
|
module.exports = bluebird;
|
|
|
|
},{"./promise.js":23}],5:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var cr = Object.create;
|
|
if (cr) {
|
|
var callerCache = cr(null);
|
|
var getterCache = cr(null);
|
|
callerCache[" size"] = getterCache[" size"] = 0;
|
|
}
|
|
|
|
module.exports = function(Promise) {
|
|
var util = _dereq_("./util.js");
|
|
var canEvaluate = util.canEvaluate;
|
|
var isIdentifier = util.isIdentifier;
|
|
|
|
var getMethodCaller;
|
|
var getGetter;
|
|
if (!true) {
|
|
var makeMethodCaller = function (methodName) {
|
|
return new Function("ensureMethod", " \n\
|
|
return function(obj) { \n\
|
|
'use strict' \n\
|
|
var len = this.length; \n\
|
|
ensureMethod(obj, 'methodName'); \n\
|
|
switch(len) { \n\
|
|
case 1: return obj.methodName(this[0]); \n\
|
|
case 2: return obj.methodName(this[0], this[1]); \n\
|
|
case 3: return obj.methodName(this[0], this[1], this[2]); \n\
|
|
case 0: return obj.methodName(); \n\
|
|
default: \n\
|
|
return obj.methodName.apply(obj, this); \n\
|
|
} \n\
|
|
}; \n\
|
|
".replace(/methodName/g, methodName))(ensureMethod);
|
|
};
|
|
|
|
var makeGetter = function (propertyName) {
|
|
return new Function("obj", " \n\
|
|
'use strict'; \n\
|
|
return obj.propertyName; \n\
|
|
".replace("propertyName", propertyName));
|
|
};
|
|
|
|
var getCompiled = function(name, compiler, cache) {
|
|
var ret = cache[name];
|
|
if (typeof ret !== "function") {
|
|
if (!isIdentifier(name)) {
|
|
return null;
|
|
}
|
|
ret = compiler(name);
|
|
cache[name] = ret;
|
|
cache[" size"]++;
|
|
if (cache[" size"] > 512) {
|
|
var keys = Object.keys(cache);
|
|
for (var i = 0; i < 256; ++i) delete cache[keys[i]];
|
|
cache[" size"] = keys.length - 256;
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
getMethodCaller = function(name) {
|
|
return getCompiled(name, makeMethodCaller, callerCache);
|
|
};
|
|
|
|
getGetter = function(name) {
|
|
return getCompiled(name, makeGetter, getterCache);
|
|
};
|
|
}
|
|
|
|
function ensureMethod(obj, methodName) {
|
|
var fn;
|
|
if (obj != null) fn = obj[methodName];
|
|
if (typeof fn !== "function") {
|
|
var message = "Object " + util.classString(obj) + " has no method '" +
|
|
util.toString(methodName) + "'";
|
|
throw new Promise.TypeError(message);
|
|
}
|
|
return fn;
|
|
}
|
|
|
|
function caller(obj) {
|
|
var methodName = this.pop();
|
|
var fn = ensureMethod(obj, methodName);
|
|
return fn.apply(obj, this);
|
|
}
|
|
Promise.prototype.call = function (methodName) {
|
|
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
|
|
if (!true) {
|
|
if (canEvaluate) {
|
|
var maybeCaller = getMethodCaller(methodName);
|
|
if (maybeCaller !== null) {
|
|
return this._then(
|
|
maybeCaller, undefined, undefined, args, undefined);
|
|
}
|
|
}
|
|
}
|
|
args.push(methodName);
|
|
return this._then(caller, undefined, undefined, args, undefined);
|
|
};
|
|
|
|
function namedGetter(obj) {
|
|
return obj[this];
|
|
}
|
|
function indexedGetter(obj) {
|
|
var index = +this;
|
|
if (index < 0) index = Math.max(0, index + obj.length);
|
|
return obj[index];
|
|
}
|
|
Promise.prototype.get = function (propertyName) {
|
|
var isIndex = (typeof propertyName === "number");
|
|
var getter;
|
|
if (!isIndex) {
|
|
if (canEvaluate) {
|
|
var maybeGetter = getGetter(propertyName);
|
|
getter = maybeGetter !== null ? maybeGetter : namedGetter;
|
|
} else {
|
|
getter = namedGetter;
|
|
}
|
|
} else {
|
|
getter = indexedGetter;
|
|
}
|
|
return this._then(getter, undefined, undefined, propertyName, undefined);
|
|
};
|
|
};
|
|
|
|
},{"./util.js":38}],6:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise) {
|
|
var errors = _dereq_("./errors.js");
|
|
var async = _dereq_("./async.js");
|
|
var CancellationError = errors.CancellationError;
|
|
|
|
Promise.prototype._cancel = function (reason) {
|
|
if (!this.isCancellable()) return this;
|
|
var parent;
|
|
var promiseToReject = this;
|
|
while ((parent = promiseToReject._cancellationParent) !== undefined &&
|
|
parent.isCancellable()) {
|
|
promiseToReject = parent;
|
|
}
|
|
this._unsetCancellable();
|
|
promiseToReject._target()._rejectCallback(reason, false, true);
|
|
};
|
|
|
|
Promise.prototype.cancel = function (reason) {
|
|
if (!this.isCancellable()) return this;
|
|
if (reason === undefined) reason = new CancellationError();
|
|
async.invokeLater(this._cancel, this, reason);
|
|
return this;
|
|
};
|
|
|
|
Promise.prototype.cancellable = function () {
|
|
if (this._cancellable()) return this;
|
|
this._setCancellable();
|
|
this._cancellationParent = this._pendingCancellationParent();
|
|
return this;
|
|
};
|
|
|
|
Promise.prototype.uncancellable = function () {
|
|
var ret = this.then();
|
|
ret._unsetCancellable();
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype.fork = function (didFulfill, didReject, didProgress) {
|
|
var ret = this._then(didFulfill, didReject, didProgress,
|
|
undefined, undefined);
|
|
|
|
ret._setCancellable();
|
|
ret._cancellationParent = undefined;
|
|
return ret;
|
|
};
|
|
};
|
|
|
|
},{"./async.js":2,"./errors.js":13}],7:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function() {
|
|
var async = _dereq_("./async.js");
|
|
var util = _dereq_("./util.js");
|
|
var bluebirdFramePattern =
|
|
/[\\\/]bluebird[\\\/]js[\\\/](main|debug|zalgo|instrumented)/;
|
|
var stackFramePattern = null;
|
|
var formatStack = null;
|
|
var indentStackFrames = false;
|
|
|
|
function CapturedTrace(parent) {
|
|
this._parent = parent;
|
|
var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
|
|
captureStackTrace(this, CapturedTrace);
|
|
if (length > 32) this.uncycle();
|
|
}
|
|
util.inherits(CapturedTrace, Error);
|
|
|
|
CapturedTrace.prototype.uncycle = function() {
|
|
var length = this._length;
|
|
if (length < 2) return;
|
|
var nodes = [];
|
|
var stackToIndex = {};
|
|
|
|
for (var i = 0, node = this; node !== undefined; ++i) {
|
|
nodes.push(node);
|
|
node = node._parent;
|
|
}
|
|
length = this._length = i;
|
|
for (var i = length - 1; i >= 0; --i) {
|
|
var stack = nodes[i].stack;
|
|
if (stackToIndex[stack] === undefined) {
|
|
stackToIndex[stack] = i;
|
|
}
|
|
}
|
|
for (var i = 0; i < length; ++i) {
|
|
var currentStack = nodes[i].stack;
|
|
var index = stackToIndex[currentStack];
|
|
if (index !== undefined && index !== i) {
|
|
if (index > 0) {
|
|
nodes[index - 1]._parent = undefined;
|
|
nodes[index - 1]._length = 1;
|
|
}
|
|
nodes[i]._parent = undefined;
|
|
nodes[i]._length = 1;
|
|
var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
|
|
|
|
if (index < length - 1) {
|
|
cycleEdgeNode._parent = nodes[index + 1];
|
|
cycleEdgeNode._parent.uncycle();
|
|
cycleEdgeNode._length =
|
|
cycleEdgeNode._parent._length + 1;
|
|
} else {
|
|
cycleEdgeNode._parent = undefined;
|
|
cycleEdgeNode._length = 1;
|
|
}
|
|
var currentChildLength = cycleEdgeNode._length + 1;
|
|
for (var j = i - 2; j >= 0; --j) {
|
|
nodes[j]._length = currentChildLength;
|
|
currentChildLength++;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
|
|
CapturedTrace.prototype.parent = function() {
|
|
return this._parent;
|
|
};
|
|
|
|
CapturedTrace.prototype.hasParent = function() {
|
|
return this._parent !== undefined;
|
|
};
|
|
|
|
CapturedTrace.prototype.attachExtraTrace = function(error) {
|
|
if (error.__stackCleaned__) return;
|
|
this.uncycle();
|
|
var parsed = CapturedTrace.parseStackAndMessage(error);
|
|
var message = parsed.message;
|
|
var stacks = [parsed.stack];
|
|
|
|
var trace = this;
|
|
while (trace !== undefined) {
|
|
stacks.push(cleanStack(trace.stack.split("\n")));
|
|
trace = trace._parent;
|
|
}
|
|
removeCommonRoots(stacks);
|
|
removeDuplicateOrEmptyJumps(stacks);
|
|
error.stack = reconstructStack(message, stacks);
|
|
error.__stackCleaned__ = true;
|
|
};
|
|
|
|
function reconstructStack(message, stacks) {
|
|
for (var i = 0; i < stacks.length - 1; ++i) {
|
|
stacks[i].push("From previous event:");
|
|
stacks[i] = stacks[i].join("\n");
|
|
}
|
|
if (i < stacks.length) {
|
|
stacks[i] = stacks[i].join("\n");
|
|
}
|
|
return message + "\n" + stacks.join("\n");
|
|
}
|
|
|
|
function removeDuplicateOrEmptyJumps(stacks) {
|
|
for (var i = 0; i < stacks.length; ++i) {
|
|
if (stacks[i].length === 0 ||
|
|
((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
|
|
stacks.splice(i, 1);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
function removeCommonRoots(stacks) {
|
|
var current = stacks[0];
|
|
for (var i = 1; i < stacks.length; ++i) {
|
|
var prev = stacks[i];
|
|
var currentLastIndex = current.length - 1;
|
|
var currentLastLine = current[currentLastIndex];
|
|
var commonRootMeetPoint = -1;
|
|
|
|
for (var j = prev.length - 1; j >= 0; --j) {
|
|
if (prev[j] === currentLastLine) {
|
|
commonRootMeetPoint = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (var j = commonRootMeetPoint; j >= 0; --j) {
|
|
var line = prev[j];
|
|
if (current[currentLastIndex] === line) {
|
|
current.pop();
|
|
currentLastIndex--;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
current = prev;
|
|
}
|
|
}
|
|
|
|
function cleanStack(stack) {
|
|
var ret = [];
|
|
for (var i = 0; i < stack.length; ++i) {
|
|
var line = stack[i];
|
|
var isTraceLine = stackFramePattern.test(line) ||
|
|
" (No stack trace)" === line;
|
|
var isInternalFrame = isTraceLine && shouldIgnore(line);
|
|
if (isTraceLine && !isInternalFrame) {
|
|
if (indentStackFrames && line.charAt(0) !== " ") {
|
|
line = " " + line;
|
|
}
|
|
ret.push(line);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function stackFramesAsArray(error) {
|
|
var stack = error.stack.replace(/\s+$/g, "").split("\n");
|
|
for (var i = 0; i < stack.length; ++i) {
|
|
var line = stack[i];
|
|
if (" (No stack trace)" === line || stackFramePattern.test(line)) {
|
|
break;
|
|
}
|
|
}
|
|
if (i > 0) {
|
|
stack = stack.slice(i);
|
|
}
|
|
return stack;
|
|
}
|
|
|
|
CapturedTrace.parseStackAndMessage = function(error) {
|
|
var stack = error.stack;
|
|
var message = error.toString();
|
|
stack = typeof stack === "string" && stack.length > 0
|
|
? stackFramesAsArray(error) : [" (No stack trace)"];
|
|
return {
|
|
message: message,
|
|
stack: cleanStack(stack)
|
|
};
|
|
};
|
|
|
|
CapturedTrace.formatAndLogError = function(error, title) {
|
|
if (typeof console === "object") {
|
|
var message;
|
|
if (typeof error === "object" || typeof error === "function") {
|
|
var stack = error.stack;
|
|
message = title + formatStack(stack, error);
|
|
} else {
|
|
message = title + String(error);
|
|
}
|
|
if (typeof console.warn === "function" ||
|
|
typeof console.warn === "object") {
|
|
console.warn(message);
|
|
} else if (typeof console.log === "function" ||
|
|
typeof console.log === "object") {
|
|
console.log(message);
|
|
}
|
|
}
|
|
};
|
|
|
|
CapturedTrace.unhandledRejection = function (reason) {
|
|
CapturedTrace.formatAndLogError(reason, "^--- With additional stack trace: ");
|
|
};
|
|
|
|
CapturedTrace.isSupported = function () {
|
|
return typeof captureStackTrace === "function";
|
|
};
|
|
|
|
CapturedTrace.fireRejectionEvent =
|
|
function(name, localHandler, reason, promise) {
|
|
var localEventFired = false;
|
|
try {
|
|
if (typeof localHandler === "function") {
|
|
localEventFired = true;
|
|
if (name === "rejectionHandled") {
|
|
localHandler(promise);
|
|
} else {
|
|
localHandler(reason, promise);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
async.throwLater(e);
|
|
}
|
|
|
|
var globalEventFired = false;
|
|
try {
|
|
globalEventFired = fireGlobalEvent(name, reason, promise);
|
|
} catch (e) {
|
|
globalEventFired = true;
|
|
async.throwLater(e);
|
|
}
|
|
|
|
var domEventFired = false;
|
|
if (fireDomEvent) {
|
|
try {
|
|
domEventFired = fireDomEvent(name.toLowerCase(), {
|
|
reason: reason,
|
|
promise: promise
|
|
});
|
|
} catch (e) {
|
|
domEventFired = true;
|
|
async.throwLater(e);
|
|
}
|
|
}
|
|
|
|
if (!globalEventFired && !localEventFired && !domEventFired &&
|
|
name === "unhandledRejection") {
|
|
CapturedTrace.formatAndLogError(reason, "Possibly unhandled ");
|
|
}
|
|
};
|
|
|
|
function formatNonError(obj) {
|
|
var str;
|
|
if (typeof obj === "function") {
|
|
str = "[function " +
|
|
(obj.name || "anonymous") +
|
|
"]";
|
|
} else {
|
|
str = obj.toString();
|
|
var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
|
|
if (ruselessToString.test(str)) {
|
|
try {
|
|
var newStr = JSON.stringify(obj);
|
|
str = newStr;
|
|
}
|
|
catch(e) {
|
|
|
|
}
|
|
}
|
|
if (str.length === 0) {
|
|
str = "(empty array)";
|
|
}
|
|
}
|
|
return ("(<" + snip(str) + ">, no stack trace)");
|
|
}
|
|
|
|
function snip(str) {
|
|
var maxChars = 41;
|
|
if (str.length < maxChars) {
|
|
return str;
|
|
}
|
|
return str.substr(0, maxChars - 3) + "...";
|
|
}
|
|
|
|
var shouldIgnore = function() { return false; };
|
|
var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
|
|
function parseLineInfo(line) {
|
|
var matches = line.match(parseLineInfoRegex);
|
|
if (matches) {
|
|
return {
|
|
fileName: matches[1],
|
|
line: parseInt(matches[2], 10)
|
|
};
|
|
}
|
|
}
|
|
CapturedTrace.setBounds = function(firstLineError, lastLineError) {
|
|
if (!CapturedTrace.isSupported()) return;
|
|
var firstStackLines = firstLineError.stack.split("\n");
|
|
var lastStackLines = lastLineError.stack.split("\n");
|
|
var firstIndex = -1;
|
|
var lastIndex = -1;
|
|
var firstFileName;
|
|
var lastFileName;
|
|
for (var i = 0; i < firstStackLines.length; ++i) {
|
|
var result = parseLineInfo(firstStackLines[i]);
|
|
if (result) {
|
|
firstFileName = result.fileName;
|
|
firstIndex = result.line;
|
|
break;
|
|
}
|
|
}
|
|
for (var i = 0; i < lastStackLines.length; ++i) {
|
|
var result = parseLineInfo(lastStackLines[i]);
|
|
if (result) {
|
|
lastFileName = result.fileName;
|
|
lastIndex = result.line;
|
|
break;
|
|
}
|
|
}
|
|
if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
|
|
firstFileName !== lastFileName || firstIndex >= lastIndex) {
|
|
return;
|
|
}
|
|
|
|
shouldIgnore = function(line) {
|
|
if (bluebirdFramePattern.test(line)) return true;
|
|
var info = parseLineInfo(line);
|
|
if (info) {
|
|
if (info.fileName === firstFileName &&
|
|
(firstIndex <= info.line && info.line <= lastIndex)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
};
|
|
|
|
var captureStackTrace = (function stackDetection() {
|
|
var v8stackFramePattern = /^\s*at\s*/;
|
|
var v8stackFormatter = function(stack, error) {
|
|
if (typeof stack === "string") return stack;
|
|
|
|
if (error.name !== undefined &&
|
|
error.message !== undefined) {
|
|
return error.toString();
|
|
}
|
|
return formatNonError(error);
|
|
};
|
|
|
|
if (typeof Error.stackTraceLimit === "number" &&
|
|
typeof Error.captureStackTrace === "function") {
|
|
Error.stackTraceLimit = Error.stackTraceLimit + 6;
|
|
stackFramePattern = v8stackFramePattern;
|
|
formatStack = v8stackFormatter;
|
|
var captureStackTrace = Error.captureStackTrace;
|
|
|
|
shouldIgnore = function(line) {
|
|
return bluebirdFramePattern.test(line);
|
|
};
|
|
return function(receiver, ignoreUntil) {
|
|
Error.stackTraceLimit = Error.stackTraceLimit + 6;
|
|
captureStackTrace(receiver, ignoreUntil);
|
|
Error.stackTraceLimit = Error.stackTraceLimit - 6;
|
|
};
|
|
}
|
|
var err = new Error();
|
|
|
|
if (typeof err.stack === "string" &&
|
|
err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
|
|
stackFramePattern = /@/;
|
|
formatStack = v8stackFormatter;
|
|
indentStackFrames = true;
|
|
return function captureStackTrace(o) {
|
|
o.stack = new Error().stack;
|
|
};
|
|
}
|
|
|
|
var hasStackAfterThrow;
|
|
try { throw new Error(); }
|
|
catch(e) {
|
|
hasStackAfterThrow = ("stack" in e);
|
|
}
|
|
if (!("stack" in err) && hasStackAfterThrow) {
|
|
stackFramePattern = v8stackFramePattern;
|
|
formatStack = v8stackFormatter;
|
|
return function captureStackTrace(o) {
|
|
Error.stackTraceLimit = Error.stackTraceLimit + 6;
|
|
try { throw new Error(); }
|
|
catch(e) { o.stack = e.stack; }
|
|
Error.stackTraceLimit = Error.stackTraceLimit - 6;
|
|
};
|
|
}
|
|
|
|
formatStack = function(stack, error) {
|
|
if (typeof stack === "string") return stack;
|
|
|
|
if ((typeof error === "object" ||
|
|
typeof error === "function") &&
|
|
error.name !== undefined &&
|
|
error.message !== undefined) {
|
|
return error.toString();
|
|
}
|
|
return formatNonError(error);
|
|
};
|
|
|
|
return null;
|
|
|
|
})([]);
|
|
|
|
var fireDomEvent;
|
|
var fireGlobalEvent = (function() {
|
|
if (util.isNode) {
|
|
return function(name, reason, promise) {
|
|
if (name === "rejectionHandled") {
|
|
return process.emit(name, promise);
|
|
} else {
|
|
return process.emit(name, reason, promise);
|
|
}
|
|
};
|
|
} else {
|
|
var customEventWorks = false;
|
|
var anyEventWorks = true;
|
|
try {
|
|
var ev = new self.CustomEvent("test");
|
|
customEventWorks = ev instanceof CustomEvent;
|
|
} catch (e) {}
|
|
if (!customEventWorks) {
|
|
try {
|
|
var event = document.createEvent("CustomEvent");
|
|
event.initCustomEvent("testingtheevent", false, true, {});
|
|
self.dispatchEvent(event);
|
|
} catch (e) {
|
|
anyEventWorks = false;
|
|
}
|
|
}
|
|
if (anyEventWorks) {
|
|
fireDomEvent = function(type, detail) {
|
|
var event;
|
|
if (customEventWorks) {
|
|
event = new self.CustomEvent(type, {
|
|
detail: detail,
|
|
bubbles: false,
|
|
cancelable: true
|
|
});
|
|
} else if (self.dispatchEvent) {
|
|
event = document.createEvent("CustomEvent");
|
|
event.initCustomEvent(type, false, true, detail);
|
|
}
|
|
|
|
return event ? !self.dispatchEvent(event) : false;
|
|
};
|
|
}
|
|
|
|
var toWindowMethodNameMap = {};
|
|
toWindowMethodNameMap["unhandledRejection"] = ("on" +
|
|
"unhandledRejection").toLowerCase();
|
|
toWindowMethodNameMap["rejectionHandled"] = ("on" +
|
|
"rejectionHandled").toLowerCase();
|
|
|
|
return function(name, reason, promise) {
|
|
var methodName = toWindowMethodNameMap[name];
|
|
var method = self[methodName];
|
|
if (!method) return false;
|
|
if (name === "rejectionHandled") {
|
|
method.call(self, promise);
|
|
} else {
|
|
method.call(self, reason, promise);
|
|
}
|
|
return true;
|
|
};
|
|
}
|
|
})();
|
|
|
|
return CapturedTrace;
|
|
};
|
|
|
|
},{"./async.js":2,"./util.js":38}],8:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(NEXT_FILTER) {
|
|
var util = _dereq_("./util.js");
|
|
var errors = _dereq_("./errors.js");
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
var keys = _dereq_("./es5.js").keys;
|
|
var TypeError = errors.TypeError;
|
|
|
|
function CatchFilter(instances, callback, promise) {
|
|
this._instances = instances;
|
|
this._callback = callback;
|
|
this._promise = promise;
|
|
}
|
|
|
|
function safePredicate(predicate, e) {
|
|
var safeObject = {};
|
|
var retfilter = tryCatch(predicate).call(safeObject, e);
|
|
|
|
if (retfilter === errorObj) return retfilter;
|
|
|
|
var safeKeys = keys(safeObject);
|
|
if (safeKeys.length) {
|
|
errorObj.e = new TypeError("Catch filter must inherit from Error or be a simple predicate function\u000a\u000a See http://goo.gl/o84o68\u000a");
|
|
return errorObj;
|
|
}
|
|
return retfilter;
|
|
}
|
|
|
|
CatchFilter.prototype.doFilter = function (e) {
|
|
var cb = this._callback;
|
|
var promise = this._promise;
|
|
var boundTo = promise._boundTo;
|
|
for (var i = 0, len = this._instances.length; i < len; ++i) {
|
|
var item = this._instances[i];
|
|
var itemIsErrorType = item === Error ||
|
|
(item != null && item.prototype instanceof Error);
|
|
|
|
if (itemIsErrorType && e instanceof item) {
|
|
var ret = tryCatch(cb).call(boundTo, e);
|
|
if (ret === errorObj) {
|
|
NEXT_FILTER.e = ret.e;
|
|
return NEXT_FILTER;
|
|
}
|
|
return ret;
|
|
} else if (typeof item === "function" && !itemIsErrorType) {
|
|
var shouldHandle = safePredicate(item, e);
|
|
if (shouldHandle === errorObj) {
|
|
e = errorObj.e;
|
|
break;
|
|
} else if (shouldHandle) {
|
|
var ret = tryCatch(cb).call(boundTo, e);
|
|
if (ret === errorObj) {
|
|
NEXT_FILTER.e = ret.e;
|
|
return NEXT_FILTER;
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
NEXT_FILTER.e = e;
|
|
return NEXT_FILTER;
|
|
};
|
|
|
|
return CatchFilter;
|
|
};
|
|
|
|
},{"./errors.js":13,"./es5.js":14,"./util.js":38}],9:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, CapturedTrace, isDebugging) {
|
|
var contextStack = [];
|
|
function Context() {
|
|
this._trace = new CapturedTrace(peekContext());
|
|
}
|
|
Context.prototype._pushContext = function () {
|
|
if (!isDebugging()) return;
|
|
if (this._trace !== undefined) {
|
|
contextStack.push(this._trace);
|
|
}
|
|
};
|
|
|
|
Context.prototype._popContext = function () {
|
|
if (!isDebugging()) return;
|
|
if (this._trace !== undefined) {
|
|
contextStack.pop();
|
|
}
|
|
};
|
|
|
|
function createContext() {
|
|
if (isDebugging()) return new Context();
|
|
}
|
|
|
|
function peekContext() {
|
|
var lastIndex = contextStack.length - 1;
|
|
if (lastIndex >= 0) {
|
|
return contextStack[lastIndex];
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
Promise.prototype._peekContext = peekContext;
|
|
Promise.prototype._pushContext = Context.prototype._pushContext;
|
|
Promise.prototype._popContext = Context.prototype._popContext;
|
|
|
|
return createContext;
|
|
};
|
|
|
|
},{}],10:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, CapturedTrace) {
|
|
var async = _dereq_("./async.js");
|
|
var Warning = _dereq_("./errors.js").Warning;
|
|
var util = _dereq_("./util.js");
|
|
var canAttachTrace = util.canAttachTrace;
|
|
var unhandledRejectionHandled;
|
|
var possiblyUnhandledRejection;
|
|
var debugging = false || (util.isNode &&
|
|
(!!process.env["BLUEBIRD_DEBUG"] ||
|
|
process.env["NODE_ENV"] === "development"));
|
|
|
|
Promise.prototype._ensurePossibleRejectionHandled = function () {
|
|
this._setRejectionIsUnhandled();
|
|
async.invokeLater(this._notifyUnhandledRejection, this, undefined);
|
|
};
|
|
|
|
Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
|
|
CapturedTrace.fireRejectionEvent("rejectionHandled",
|
|
unhandledRejectionHandled, undefined, this);
|
|
};
|
|
|
|
Promise.prototype._notifyUnhandledRejection = function () {
|
|
if (this._isRejectionUnhandled()) {
|
|
var reason = this._getCarriedStackTrace() || this._settledValue;
|
|
this._setUnhandledRejectionIsNotified();
|
|
CapturedTrace.fireRejectionEvent("unhandledRejection",
|
|
possiblyUnhandledRejection, reason, this);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._setUnhandledRejectionIsNotified = function () {
|
|
this._bitField = this._bitField | 524288;
|
|
};
|
|
|
|
Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
|
|
this._bitField = this._bitField & (~524288);
|
|
};
|
|
|
|
Promise.prototype._isUnhandledRejectionNotified = function () {
|
|
return (this._bitField & 524288) > 0;
|
|
};
|
|
|
|
Promise.prototype._setRejectionIsUnhandled = function () {
|
|
this._bitField = this._bitField | 2097152;
|
|
};
|
|
|
|
Promise.prototype._unsetRejectionIsUnhandled = function () {
|
|
this._bitField = this._bitField & (~2097152);
|
|
if (this._isUnhandledRejectionNotified()) {
|
|
this._unsetUnhandledRejectionIsNotified();
|
|
this._notifyUnhandledRejectionIsHandled();
|
|
}
|
|
};
|
|
|
|
Promise.prototype._isRejectionUnhandled = function () {
|
|
return (this._bitField & 2097152) > 0;
|
|
};
|
|
|
|
Promise.prototype._setCarriedStackTrace = function (capturedTrace) {
|
|
this._bitField = this._bitField | 1048576;
|
|
this._fulfillmentHandler0 = capturedTrace;
|
|
};
|
|
|
|
Promise.prototype._isCarryingStackTrace = function () {
|
|
return (this._bitField & 1048576) > 0;
|
|
};
|
|
|
|
Promise.prototype._getCarriedStackTrace = function () {
|
|
return this._isCarryingStackTrace()
|
|
? this._fulfillmentHandler0
|
|
: undefined;
|
|
};
|
|
|
|
Promise.prototype._captureStackTrace = function () {
|
|
if (debugging) {
|
|
this._trace = new CapturedTrace(this._peekContext());
|
|
}
|
|
return this;
|
|
};
|
|
|
|
Promise.prototype._attachExtraTrace = function (error, ignoreSelf) {
|
|
if (debugging && canAttachTrace(error)) {
|
|
var trace = this._trace;
|
|
if (trace !== undefined) {
|
|
if (ignoreSelf) trace = trace._parent;
|
|
}
|
|
if (trace !== undefined) {
|
|
trace.attachExtraTrace(error);
|
|
} else if (!error.__stackCleaned__) {
|
|
var parsed = CapturedTrace.parseStackAndMessage(error);
|
|
error.stack = parsed.stack.join("\n");
|
|
error.__stackCleaned__ = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
Promise.prototype._warn = function(message) {
|
|
var warning = new Warning(message);
|
|
var ctx = this._peekContext();
|
|
if (ctx) {
|
|
ctx.attachExtraTrace(warning);
|
|
} else {
|
|
var parsed = CapturedTrace.parseStackAndMessage(warning);
|
|
warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
|
|
}
|
|
CapturedTrace.formatAndLogError(warning, "");
|
|
};
|
|
|
|
Promise.onPossiblyUnhandledRejection = function (fn) {
|
|
possiblyUnhandledRejection = typeof fn === "function" ? fn : undefined;
|
|
};
|
|
|
|
Promise.onUnhandledRejectionHandled = function (fn) {
|
|
unhandledRejectionHandled = typeof fn === "function" ? fn : undefined;
|
|
};
|
|
|
|
Promise.longStackTraces = function () {
|
|
if (async.haveItemsQueued() &&
|
|
debugging === false
|
|
) {
|
|
throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/DT1qyG\u000a");
|
|
}
|
|
debugging = CapturedTrace.isSupported();
|
|
};
|
|
|
|
Promise.hasLongStackTraces = function () {
|
|
return debugging && CapturedTrace.isSupported();
|
|
};
|
|
|
|
if (!CapturedTrace.isSupported()) {
|
|
Promise.longStackTraces = function(){};
|
|
debugging = false;
|
|
}
|
|
|
|
return function() {
|
|
return debugging;
|
|
};
|
|
};
|
|
|
|
},{"./async.js":2,"./errors.js":13,"./util.js":38}],11:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var util = _dereq_("./util.js");
|
|
var isPrimitive = util.isPrimitive;
|
|
var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver;
|
|
|
|
module.exports = function(Promise) {
|
|
var returner = function () {
|
|
return this;
|
|
};
|
|
var thrower = function () {
|
|
throw this;
|
|
};
|
|
|
|
var wrapper = function (value, action) {
|
|
if (action === 1) {
|
|
return function () {
|
|
throw value;
|
|
};
|
|
} else if (action === 2) {
|
|
return function () {
|
|
return value;
|
|
};
|
|
}
|
|
};
|
|
|
|
|
|
Promise.prototype["return"] =
|
|
Promise.prototype.thenReturn = function (value) {
|
|
if (wrapsPrimitiveReceiver && isPrimitive(value)) {
|
|
return this._then(
|
|
wrapper(value, 2),
|
|
undefined,
|
|
undefined,
|
|
undefined,
|
|
undefined
|
|
);
|
|
}
|
|
return this._then(returner, undefined, undefined, value, undefined);
|
|
};
|
|
|
|
Promise.prototype["throw"] =
|
|
Promise.prototype.thenThrow = function (reason) {
|
|
if (wrapsPrimitiveReceiver && isPrimitive(reason)) {
|
|
return this._then(
|
|
wrapper(reason, 1),
|
|
undefined,
|
|
undefined,
|
|
undefined,
|
|
undefined
|
|
);
|
|
}
|
|
return this._then(thrower, undefined, undefined, reason, undefined);
|
|
};
|
|
};
|
|
|
|
},{"./util.js":38}],12:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL) {
|
|
var PromiseReduce = Promise.reduce;
|
|
|
|
Promise.prototype.each = function (fn) {
|
|
return PromiseReduce(this, fn, null, INTERNAL);
|
|
};
|
|
|
|
Promise.each = function (promises, fn) {
|
|
return PromiseReduce(promises, fn, null, INTERNAL);
|
|
};
|
|
};
|
|
|
|
},{}],13:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var Objectfreeze = _dereq_("./es5.js").freeze;
|
|
var util = _dereq_("./util.js");
|
|
var inherits = util.inherits;
|
|
var notEnumerableProp = util.notEnumerableProp;
|
|
|
|
function subError(nameProperty, defaultMessage) {
|
|
function SubError(message) {
|
|
if (!(this instanceof SubError)) return new SubError(message);
|
|
notEnumerableProp(this, "message",
|
|
typeof message === "string" ? message : defaultMessage);
|
|
notEnumerableProp(this, "name", nameProperty);
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
} else {
|
|
Error.call(this);
|
|
}
|
|
}
|
|
inherits(SubError, Error);
|
|
return SubError;
|
|
}
|
|
|
|
var _TypeError, _RangeError;
|
|
var Warning = subError("Warning", "warning");
|
|
var CancellationError = subError("CancellationError", "cancellation error");
|
|
var TimeoutError = subError("TimeoutError", "timeout error");
|
|
var AggregateError = subError("AggregateError", "aggregate error");
|
|
try {
|
|
_TypeError = TypeError;
|
|
_RangeError = RangeError;
|
|
} catch(e) {
|
|
_TypeError = subError("TypeError", "type error");
|
|
_RangeError = subError("RangeError", "range error");
|
|
}
|
|
|
|
var methods = ("join pop push shift unshift slice filter forEach some " +
|
|
"every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
|
|
|
|
for (var i = 0; i < methods.length; ++i) {
|
|
if (typeof Array.prototype[methods[i]] === "function") {
|
|
AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
|
|
}
|
|
}
|
|
|
|
AggregateError.prototype.length = 0;
|
|
AggregateError.prototype["isOperational"] = true;
|
|
var level = 0;
|
|
AggregateError.prototype.toString = function() {
|
|
var indent = Array(level * 4 + 1).join(" ");
|
|
var ret = "\n" + indent + "AggregateError of:" + "\n";
|
|
level++;
|
|
indent = Array(level * 4 + 1).join(" ");
|
|
for (var i = 0; i < this.length; ++i) {
|
|
var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
|
|
var lines = str.split("\n");
|
|
for (var j = 0; j < lines.length; ++j) {
|
|
lines[j] = indent + lines[j];
|
|
}
|
|
str = lines.join("\n");
|
|
ret += str + "\n";
|
|
}
|
|
level--;
|
|
return ret;
|
|
};
|
|
|
|
function OperationalError(message) {
|
|
if (!(this instanceof OperationalError))
|
|
return new OperationalError(message);
|
|
notEnumerableProp(this, "name", "OperationalError");
|
|
notEnumerableProp(this, "message", message);
|
|
this.cause = message;
|
|
this["isOperational"] = true;
|
|
|
|
if (message instanceof Error) {
|
|
notEnumerableProp(this, "message", message.message);
|
|
notEnumerableProp(this, "stack", message.stack);
|
|
} else if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, this.constructor);
|
|
}
|
|
|
|
}
|
|
inherits(OperationalError, Error);
|
|
|
|
var errorTypes = Error["__BluebirdErrorTypes__"];
|
|
if (!errorTypes) {
|
|
errorTypes = Objectfreeze({
|
|
CancellationError: CancellationError,
|
|
TimeoutError: TimeoutError,
|
|
OperationalError: OperationalError,
|
|
RejectionError: OperationalError,
|
|
AggregateError: AggregateError
|
|
});
|
|
notEnumerableProp(Error, "__BluebirdErrorTypes__", errorTypes);
|
|
}
|
|
|
|
module.exports = {
|
|
Error: Error,
|
|
TypeError: _TypeError,
|
|
RangeError: _RangeError,
|
|
CancellationError: errorTypes.CancellationError,
|
|
OperationalError: errorTypes.OperationalError,
|
|
TimeoutError: errorTypes.TimeoutError,
|
|
AggregateError: errorTypes.AggregateError,
|
|
Warning: Warning
|
|
};
|
|
|
|
},{"./es5.js":14,"./util.js":38}],14:[function(_dereq_,module,exports){
|
|
var isES5 = (function(){
|
|
"use strict";
|
|
return this === undefined;
|
|
})();
|
|
|
|
if (isES5) {
|
|
module.exports = {
|
|
freeze: Object.freeze,
|
|
defineProperty: Object.defineProperty,
|
|
keys: Object.keys,
|
|
getPrototypeOf: Object.getPrototypeOf,
|
|
isArray: Array.isArray,
|
|
isES5: isES5,
|
|
propertyIsWritable: function(obj, prop) {
|
|
var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
|
|
return !!(!descriptor || descriptor.writable || descriptor.set);
|
|
}
|
|
};
|
|
} else {
|
|
var has = {}.hasOwnProperty;
|
|
var str = {}.toString;
|
|
var proto = {}.constructor.prototype;
|
|
|
|
var ObjectKeys = function (o) {
|
|
var ret = [];
|
|
for (var key in o) {
|
|
if (has.call(o, key)) {
|
|
ret.push(key);
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
var ObjectDefineProperty = function (o, key, desc) {
|
|
o[key] = desc.value;
|
|
return o;
|
|
};
|
|
|
|
var ObjectFreeze = function (obj) {
|
|
return obj;
|
|
};
|
|
|
|
var ObjectGetPrototypeOf = function (obj) {
|
|
try {
|
|
return Object(obj).constructor.prototype;
|
|
}
|
|
catch (e) {
|
|
return proto;
|
|
}
|
|
};
|
|
|
|
var ArrayIsArray = function (obj) {
|
|
try {
|
|
return str.call(obj) === "[object Array]";
|
|
}
|
|
catch(e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
module.exports = {
|
|
isArray: ArrayIsArray,
|
|
keys: ObjectKeys,
|
|
defineProperty: ObjectDefineProperty,
|
|
freeze: ObjectFreeze,
|
|
getPrototypeOf: ObjectGetPrototypeOf,
|
|
isES5: isES5,
|
|
propertyIsWritable: function() {
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
|
|
},{}],15:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL) {
|
|
var PromiseMap = Promise.map;
|
|
|
|
Promise.prototype.filter = function (fn, options) {
|
|
return PromiseMap(this, fn, options, INTERNAL);
|
|
};
|
|
|
|
Promise.filter = function (promises, fn, options) {
|
|
return PromiseMap(promises, fn, options, INTERNAL);
|
|
};
|
|
};
|
|
|
|
},{}],16:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, NEXT_FILTER, tryConvertToPromise) {
|
|
var util = _dereq_("./util.js");
|
|
var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver;
|
|
var isPrimitive = util.isPrimitive;
|
|
var thrower = util.thrower;
|
|
|
|
function returnThis() {
|
|
return this;
|
|
}
|
|
function throwThis() {
|
|
throw this;
|
|
}
|
|
function return$(r) {
|
|
return function() {
|
|
return r;
|
|
};
|
|
}
|
|
function throw$(r) {
|
|
return function() {
|
|
throw r;
|
|
};
|
|
}
|
|
function promisedFinally(ret, reasonOrValue, isFulfilled) {
|
|
var then;
|
|
if (wrapsPrimitiveReceiver && isPrimitive(reasonOrValue)) {
|
|
then = isFulfilled ? return$(reasonOrValue) : throw$(reasonOrValue);
|
|
} else {
|
|
then = isFulfilled ? returnThis : throwThis;
|
|
}
|
|
return ret._then(then, thrower, undefined, reasonOrValue, undefined);
|
|
}
|
|
|
|
function finallyHandler(reasonOrValue) {
|
|
var promise = this.promise;
|
|
var handler = this.handler;
|
|
|
|
var ret = promise._isBound()
|
|
? handler.call(promise._boundTo)
|
|
: handler();
|
|
|
|
if (ret !== undefined) {
|
|
var maybePromise = tryConvertToPromise(ret, promise);
|
|
if (maybePromise instanceof Promise) {
|
|
maybePromise = maybePromise._target();
|
|
return promisedFinally(maybePromise, reasonOrValue,
|
|
promise.isFulfilled());
|
|
}
|
|
}
|
|
|
|
if (promise.isRejected()) {
|
|
NEXT_FILTER.e = reasonOrValue;
|
|
return NEXT_FILTER;
|
|
} else {
|
|
return reasonOrValue;
|
|
}
|
|
}
|
|
|
|
function tapHandler(value) {
|
|
var promise = this.promise;
|
|
var handler = this.handler;
|
|
|
|
var ret = promise._isBound()
|
|
? handler.call(promise._boundTo, value)
|
|
: handler(value);
|
|
|
|
if (ret !== undefined) {
|
|
var maybePromise = tryConvertToPromise(ret, promise);
|
|
if (maybePromise instanceof Promise) {
|
|
maybePromise = maybePromise._target();
|
|
return promisedFinally(maybePromise, value, true);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
Promise.prototype._passThroughHandler = function (handler, isFinally) {
|
|
if (typeof handler !== "function") return this.then();
|
|
|
|
var promiseAndHandler = {
|
|
promise: this,
|
|
handler: handler
|
|
};
|
|
|
|
return this._then(
|
|
isFinally ? finallyHandler : tapHandler,
|
|
isFinally ? finallyHandler : undefined, undefined,
|
|
promiseAndHandler, undefined);
|
|
};
|
|
|
|
Promise.prototype.lastly =
|
|
Promise.prototype["finally"] = function (handler) {
|
|
return this._passThroughHandler(handler, true);
|
|
};
|
|
|
|
Promise.prototype.tap = function (handler) {
|
|
return this._passThroughHandler(handler, false);
|
|
};
|
|
};
|
|
|
|
},{"./util.js":38}],17:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise,
|
|
apiRejection,
|
|
INTERNAL,
|
|
tryConvertToPromise) {
|
|
var errors = _dereq_("./errors.js");
|
|
var TypeError = errors.TypeError;
|
|
var util = _dereq_("./util.js");
|
|
var errorObj = util.errorObj;
|
|
var tryCatch = util.tryCatch;
|
|
var yieldHandlers = [];
|
|
|
|
function promiseFromYieldHandler(value, yieldHandlers, traceParent) {
|
|
for (var i = 0; i < yieldHandlers.length; ++i) {
|
|
traceParent._pushContext();
|
|
var result = tryCatch(yieldHandlers[i])(value);
|
|
traceParent._popContext();
|
|
if (result === errorObj) {
|
|
traceParent._pushContext();
|
|
var ret = Promise.reject(errorObj.e);
|
|
traceParent._popContext();
|
|
return ret;
|
|
}
|
|
var maybePromise = tryConvertToPromise(result, traceParent);
|
|
if (maybePromise instanceof Promise) return maybePromise;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {
|
|
var promise = this._promise = new Promise(INTERNAL);
|
|
promise._captureStackTrace();
|
|
this._stack = stack;
|
|
this._generatorFunction = generatorFunction;
|
|
this._receiver = receiver;
|
|
this._generator = undefined;
|
|
this._yieldHandlers = typeof yieldHandler === "function"
|
|
? [yieldHandler].concat(yieldHandlers)
|
|
: yieldHandlers;
|
|
}
|
|
|
|
PromiseSpawn.prototype.promise = function () {
|
|
return this._promise;
|
|
};
|
|
|
|
PromiseSpawn.prototype._run = function () {
|
|
this._generator = this._generatorFunction.call(this._receiver);
|
|
this._receiver =
|
|
this._generatorFunction = undefined;
|
|
this._next(undefined);
|
|
};
|
|
|
|
PromiseSpawn.prototype._continue = function (result) {
|
|
if (result === errorObj) {
|
|
return this._promise._rejectCallback(result.e, false, true);
|
|
}
|
|
|
|
var value = result.value;
|
|
if (result.done === true) {
|
|
this._promise._resolveCallback(value);
|
|
} else {
|
|
var maybePromise = tryConvertToPromise(value, this._promise);
|
|
if (!(maybePromise instanceof Promise)) {
|
|
maybePromise =
|
|
promiseFromYieldHandler(maybePromise,
|
|
this._yieldHandlers,
|
|
this._promise);
|
|
if (maybePromise === null) {
|
|
this._throw(
|
|
new TypeError(
|
|
"A value %s was yielded that could not be treated as a promise\u000a\u000a See http://goo.gl/4Y4pDk\u000a\u000a".replace("%s", value) +
|
|
"From coroutine:\u000a" +
|
|
this._stack.split("\n").slice(1, -7).join("\n")
|
|
)
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
maybePromise._then(
|
|
this._next,
|
|
this._throw,
|
|
undefined,
|
|
this,
|
|
null
|
|
);
|
|
}
|
|
};
|
|
|
|
PromiseSpawn.prototype._throw = function (reason) {
|
|
this._promise._attachExtraTrace(reason);
|
|
this._promise._pushContext();
|
|
var result = tryCatch(this._generator["throw"])
|
|
.call(this._generator, reason);
|
|
this._promise._popContext();
|
|
this._continue(result);
|
|
};
|
|
|
|
PromiseSpawn.prototype._next = function (value) {
|
|
this._promise._pushContext();
|
|
var result = tryCatch(this._generator.next).call(this._generator, value);
|
|
this._promise._popContext();
|
|
this._continue(result);
|
|
};
|
|
|
|
Promise.coroutine = function (generatorFunction, options) {
|
|
if (typeof generatorFunction !== "function") {
|
|
throw new TypeError("generatorFunction must be a function\u000a\u000a See http://goo.gl/6Vqhm0\u000a");
|
|
}
|
|
var yieldHandler = Object(options).yieldHandler;
|
|
var PromiseSpawn$ = PromiseSpawn;
|
|
var stack = new Error().stack;
|
|
return function () {
|
|
var generator = generatorFunction.apply(this, arguments);
|
|
var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,
|
|
stack);
|
|
spawn._generator = generator;
|
|
spawn._next(undefined);
|
|
return spawn.promise();
|
|
};
|
|
};
|
|
|
|
Promise.coroutine.addYieldHandler = function(fn) {
|
|
if (typeof fn !== "function") throw new TypeError("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
yieldHandlers.push(fn);
|
|
};
|
|
|
|
Promise.spawn = function (generatorFunction) {
|
|
if (typeof generatorFunction !== "function") {
|
|
return apiRejection("generatorFunction must be a function\u000a\u000a See http://goo.gl/6Vqhm0\u000a");
|
|
}
|
|
var spawn = new PromiseSpawn(generatorFunction, this);
|
|
var ret = spawn.promise();
|
|
spawn._run(Promise.spawn);
|
|
return ret;
|
|
};
|
|
};
|
|
|
|
},{"./errors.js":13,"./util.js":38}],18:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports =
|
|
function(Promise, PromiseArray, tryConvertToPromise, INTERNAL) {
|
|
var util = _dereq_("./util.js");
|
|
var canEvaluate = util.canEvaluate;
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
var reject;
|
|
|
|
if (!true) {
|
|
if (canEvaluate) {
|
|
var thenCallback = function(i) {
|
|
return new Function("value", "holder", " \n\
|
|
'use strict'; \n\
|
|
holder.pIndex = value; \n\
|
|
holder.checkFulfillment(this); \n\
|
|
".replace(/Index/g, i));
|
|
};
|
|
|
|
var caller = function(count) {
|
|
var values = [];
|
|
for (var i = 1; i <= count; ++i) values.push("holder.p" + i);
|
|
return new Function("holder", " \n\
|
|
'use strict'; \n\
|
|
var callback = holder.fn; \n\
|
|
return callback(values); \n\
|
|
".replace(/values/g, values.join(", ")));
|
|
};
|
|
var thenCallbacks = [];
|
|
var callers = [undefined];
|
|
for (var i = 1; i <= 5; ++i) {
|
|
thenCallbacks.push(thenCallback(i));
|
|
callers.push(caller(i));
|
|
}
|
|
|
|
var Holder = function(total, fn) {
|
|
this.p1 = this.p2 = this.p3 = this.p4 = this.p5 = null;
|
|
this.fn = fn;
|
|
this.total = total;
|
|
this.now = 0;
|
|
};
|
|
|
|
Holder.prototype.callers = callers;
|
|
Holder.prototype.checkFulfillment = function(promise) {
|
|
var now = this.now;
|
|
now++;
|
|
var total = this.total;
|
|
if (now >= total) {
|
|
var handler = this.callers[total];
|
|
promise._pushContext();
|
|
var ret = tryCatch(handler)(this);
|
|
promise._popContext();
|
|
if (ret === errorObj) {
|
|
promise._rejectCallback(ret.e, false, true);
|
|
} else {
|
|
promise._resolveCallback(ret);
|
|
}
|
|
} else {
|
|
this.now = now;
|
|
}
|
|
};
|
|
|
|
var reject = function (reason) {
|
|
this._reject(reason);
|
|
};
|
|
}
|
|
}
|
|
|
|
Promise.join = function () {
|
|
var last = arguments.length - 1;
|
|
var fn;
|
|
if (last > 0 && typeof arguments[last] === "function") {
|
|
fn = arguments[last];
|
|
if (!true) {
|
|
if (last < 6 && canEvaluate) {
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
var holder = new Holder(last, fn);
|
|
var callbacks = thenCallbacks;
|
|
for (var i = 0; i < last; ++i) {
|
|
var maybePromise = tryConvertToPromise(arguments[i], ret);
|
|
if (maybePromise instanceof Promise) {
|
|
maybePromise = maybePromise._target();
|
|
if (maybePromise._isPending()) {
|
|
maybePromise._then(callbacks[i], reject,
|
|
undefined, ret, holder);
|
|
} else if (maybePromise._isFulfilled()) {
|
|
callbacks[i].call(ret,
|
|
maybePromise._value(), holder);
|
|
} else {
|
|
ret._reject(maybePromise._reason());
|
|
}
|
|
} else {
|
|
callbacks[i].call(ret, maybePromise, holder);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];}
|
|
if (fn) args.pop();
|
|
var ret = new PromiseArray(args).promise();
|
|
return fn !== undefined ? ret.spread(fn) : ret;
|
|
};
|
|
|
|
};
|
|
|
|
},{"./util.js":38}],19:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise,
|
|
PromiseArray,
|
|
apiRejection,
|
|
tryConvertToPromise,
|
|
INTERNAL) {
|
|
var util = _dereq_("./util.js");
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
var PENDING = {};
|
|
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
|
|
? new Array(this.length())
|
|
: null;
|
|
this._limit = limit;
|
|
this._inFlight = 0;
|
|
this._queue = limit >= 1 ? [] : EMPTY_ARRAY;
|
|
this._init$(undefined, -2);
|
|
}
|
|
util.inherits(MappingPromiseArray, PromiseArray);
|
|
|
|
MappingPromiseArray.prototype._init = function () {};
|
|
|
|
MappingPromiseArray.prototype._promiseFulfilled = function (value, index) {
|
|
var values = this._values;
|
|
var length = this.length();
|
|
var preservedValues = this._preservedValues;
|
|
var limit = this._limit;
|
|
if (values[index] === PENDING) {
|
|
values[index] = value;
|
|
if (limit >= 1) {
|
|
this._inFlight--;
|
|
this._drainQueue();
|
|
if (this._isResolved()) return;
|
|
}
|
|
} else {
|
|
if (limit >= 1 && this._inFlight >= limit) {
|
|
values[index] = value;
|
|
this._queue.push(index);
|
|
return;
|
|
}
|
|
if (preservedValues !== null) preservedValues[index] = value;
|
|
|
|
var callback = this._callback;
|
|
var receiver = this._promise._boundTo;
|
|
this._promise._pushContext();
|
|
var ret = tryCatch(callback).call(receiver, value, index, length);
|
|
this._promise._popContext();
|
|
if (ret === errorObj) return this._reject(ret.e);
|
|
|
|
var maybePromise = tryConvertToPromise(ret, this._promise);
|
|
if (maybePromise instanceof Promise) {
|
|
maybePromise = maybePromise._target();
|
|
if (maybePromise._isPending()) {
|
|
if (limit >= 1) this._inFlight++;
|
|
values[index] = PENDING;
|
|
return maybePromise._proxyPromiseArray(this, index);
|
|
} else if (maybePromise._isFulfilled()) {
|
|
ret = maybePromise._value();
|
|
} else {
|
|
return this._reject(maybePromise._reason());
|
|
}
|
|
}
|
|
values[index] = ret;
|
|
}
|
|
var totalResolved = ++this._totalResolved;
|
|
if (totalResolved >= length) {
|
|
if (preservedValues !== null) {
|
|
this._filter(values, preservedValues);
|
|
} else {
|
|
this._resolve(values);
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
MappingPromiseArray.prototype._drainQueue = function () {
|
|
var queue = this._queue;
|
|
var limit = this._limit;
|
|
var values = this._values;
|
|
while (queue.length > 0 && this._inFlight < limit) {
|
|
if (this._isResolved()) return;
|
|
var index = queue.pop();
|
|
this._promiseFulfilled(values[index], index);
|
|
}
|
|
};
|
|
|
|
MappingPromiseArray.prototype._filter = function (booleans, values) {
|
|
var len = values.length;
|
|
var ret = new Array(len);
|
|
var j = 0;
|
|
for (var i = 0; i < len; ++i) {
|
|
if (booleans[i]) ret[j++] = values[i];
|
|
}
|
|
ret.length = j;
|
|
this._resolve(ret);
|
|
};
|
|
|
|
MappingPromiseArray.prototype.preservedValues = function () {
|
|
return this._preservedValues;
|
|
};
|
|
|
|
function map(promises, fn, options, _filter) {
|
|
var limit = typeof options === "object" && options !== null
|
|
? options.concurrency
|
|
: 0;
|
|
limit = typeof limit === "number" &&
|
|
isFinite(limit) && limit >= 1 ? limit : 0;
|
|
return new MappingPromiseArray(promises, fn, limit, _filter);
|
|
}
|
|
|
|
Promise.prototype.map = function (fn, options) {
|
|
if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
|
|
return map(this, fn, options, null).promise();
|
|
};
|
|
|
|
Promise.map = function (promises, fn, options, _filter) {
|
|
if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
return map(promises, fn, options, _filter).promise();
|
|
};
|
|
|
|
|
|
};
|
|
|
|
},{"./util.js":38}],20:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports =
|
|
function(Promise, INTERNAL, tryConvertToPromise, apiRejection) {
|
|
var util = _dereq_("./util.js");
|
|
var tryCatch = util.tryCatch;
|
|
|
|
Promise.method = function (fn) {
|
|
if (typeof fn !== "function") {
|
|
throw new Promise.TypeError("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
}
|
|
return function () {
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
ret._pushContext();
|
|
var value = tryCatch(fn).apply(this, arguments);
|
|
ret._popContext();
|
|
ret._resolveFromSyncValue(value);
|
|
return ret;
|
|
};
|
|
};
|
|
|
|
Promise.attempt = Promise["try"] = function (fn, args, ctx) {
|
|
if (typeof fn !== "function") {
|
|
return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
}
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
ret._pushContext();
|
|
var value = util.isArray(args)
|
|
? tryCatch(fn).apply(ctx, args)
|
|
: tryCatch(fn).call(ctx, args);
|
|
ret._popContext();
|
|
ret._resolveFromSyncValue(value);
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype._resolveFromSyncValue = function (value) {
|
|
if (value === util.errorObj) {
|
|
this._rejectCallback(value.e, false, true);
|
|
} else {
|
|
this._resolveCallback(value, true);
|
|
}
|
|
};
|
|
};
|
|
|
|
},{"./util.js":38}],21:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise) {
|
|
var util = _dereq_("./util.js");
|
|
var async = _dereq_("./async.js");
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
|
|
function spreadAdapter(val, nodeback) {
|
|
var promise = this;
|
|
if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);
|
|
var ret = tryCatch(nodeback).apply(promise._boundTo, [null].concat(val));
|
|
if (ret === errorObj) {
|
|
async.throwLater(ret.e);
|
|
}
|
|
}
|
|
|
|
function successAdapter(val, nodeback) {
|
|
var promise = this;
|
|
var receiver = promise._boundTo;
|
|
var ret = val === undefined
|
|
? tryCatch(nodeback).call(receiver, null)
|
|
: tryCatch(nodeback).call(receiver, null, val);
|
|
if (ret === errorObj) {
|
|
async.throwLater(ret.e);
|
|
}
|
|
}
|
|
function errorAdapter(reason, nodeback) {
|
|
var promise = this;
|
|
if (!reason) {
|
|
var target = promise._target();
|
|
var newReason = target._getCarriedStackTrace();
|
|
newReason.cause = reason;
|
|
reason = newReason;
|
|
}
|
|
var ret = tryCatch(nodeback).call(promise._boundTo, reason);
|
|
if (ret === errorObj) {
|
|
async.throwLater(ret.e);
|
|
}
|
|
}
|
|
|
|
Promise.prototype.nodeify = function (nodeback, options) {
|
|
if (typeof nodeback == "function") {
|
|
var adapter = successAdapter;
|
|
if (options !== undefined && Object(options).spread) {
|
|
adapter = spreadAdapter;
|
|
}
|
|
this._then(
|
|
adapter,
|
|
errorAdapter,
|
|
undefined,
|
|
this,
|
|
nodeback
|
|
);
|
|
}
|
|
return this;
|
|
};
|
|
};
|
|
|
|
},{"./async.js":2,"./util.js":38}],22:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, PromiseArray) {
|
|
var util = _dereq_("./util.js");
|
|
var async = _dereq_("./async.js");
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
|
|
Promise.prototype.progressed = function (handler) {
|
|
return this._then(undefined, undefined, handler, undefined, undefined);
|
|
};
|
|
|
|
Promise.prototype._progress = function (progressValue) {
|
|
if (this._isFollowingOrFulfilledOrRejected()) return;
|
|
this._target()._progressUnchecked(progressValue);
|
|
|
|
};
|
|
|
|
Promise.prototype._progressHandlerAt = function (index) {
|
|
return index === 0
|
|
? this._progressHandler0
|
|
: this[(index << 2) + index - 5 + 2];
|
|
};
|
|
|
|
Promise.prototype._doProgressWith = function (progression) {
|
|
var progressValue = progression.value;
|
|
var handler = progression.handler;
|
|
var promise = progression.promise;
|
|
var receiver = progression.receiver;
|
|
|
|
var ret = tryCatch(handler).call(receiver, progressValue);
|
|
if (ret === errorObj) {
|
|
if (ret.e != null &&
|
|
ret.e.name !== "StopProgressPropagation") {
|
|
var trace = util.canAttachTrace(ret.e)
|
|
? ret.e : new Error(util.toString(ret.e));
|
|
promise._attachExtraTrace(trace);
|
|
promise._progress(ret.e);
|
|
}
|
|
} else if (ret instanceof Promise) {
|
|
ret._then(promise._progress, null, null, promise, undefined);
|
|
} else {
|
|
promise._progress(ret);
|
|
}
|
|
};
|
|
|
|
|
|
Promise.prototype._progressUnchecked = function (progressValue) {
|
|
var len = this._length();
|
|
var progress = this._progress;
|
|
for (var i = 0; i < len; i++) {
|
|
var handler = this._progressHandlerAt(i);
|
|
var promise = this._promiseAt(i);
|
|
if (!(promise instanceof Promise)) {
|
|
var receiver = this._receiverAt(i);
|
|
if (typeof handler === "function") {
|
|
handler.call(receiver, progressValue, promise);
|
|
} else if (receiver instanceof PromiseArray &&
|
|
!receiver._isResolved()) {
|
|
receiver._promiseProgressed(progressValue, promise);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (typeof handler === "function") {
|
|
async.invoke(this._doProgressWith, this, {
|
|
handler: handler,
|
|
promise: promise,
|
|
receiver: this._receiverAt(i),
|
|
value: progressValue
|
|
});
|
|
} else {
|
|
async.invoke(progress, promise, progressValue);
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
},{"./async.js":2,"./util.js":38}],23:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function() {
|
|
var makeSelfResolutionError = function () {
|
|
return new TypeError("circular promise resolution chain\u000a\u000a See http://goo.gl/LhFpo0\u000a");
|
|
};
|
|
var reflect = function() {
|
|
return new Promise.PromiseInspection(this._target());
|
|
};
|
|
var apiRejection = function(msg) {
|
|
return Promise.reject(new TypeError(msg));
|
|
};
|
|
var util = _dereq_("./util.js");
|
|
var async = _dereq_("./async.js");
|
|
var errors = _dereq_("./errors.js");
|
|
var TypeError = Promise.TypeError = errors.TypeError;
|
|
Promise.RangeError = errors.RangeError;
|
|
Promise.CancellationError = errors.CancellationError;
|
|
Promise.TimeoutError = errors.TimeoutError;
|
|
Promise.OperationalError = errors.OperationalError;
|
|
Promise.RejectionError = errors.OperationalError;
|
|
Promise.AggregateError = errors.AggregateError;
|
|
var INTERNAL = function(){};
|
|
var APPLY = {};
|
|
var NEXT_FILTER = {e: null};
|
|
var tryConvertToPromise = _dereq_("./thenables.js")(Promise, INTERNAL);
|
|
var PromiseArray =
|
|
_dereq_("./promise_array.js")(Promise, INTERNAL,
|
|
tryConvertToPromise, apiRejection);
|
|
var CapturedTrace = _dereq_("./captured_trace.js")();
|
|
var isDebugging = _dereq_("./debuggability.js")(Promise, CapturedTrace);
|
|
/*jshint unused:false*/
|
|
var createContext =
|
|
_dereq_("./context.js")(Promise, CapturedTrace, isDebugging);
|
|
var CatchFilter = _dereq_("./catch_filter.js")(NEXT_FILTER);
|
|
var PromiseResolver = _dereq_("./promise_resolver.js");
|
|
var nodebackForPromise = PromiseResolver._nodebackForPromise;
|
|
var errorObj = util.errorObj;
|
|
var tryCatch = util.tryCatch;
|
|
function Promise(resolver) {
|
|
if (typeof resolver !== "function") {
|
|
throw new TypeError("the promise constructor requires a resolver function\u000a\u000a See http://goo.gl/EC22Yn\u000a");
|
|
}
|
|
if (this.constructor !== Promise) {
|
|
throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a See http://goo.gl/KsIlge\u000a");
|
|
}
|
|
this._bitField = 0;
|
|
this._fulfillmentHandler0 = undefined;
|
|
this._rejectionHandler0 = undefined;
|
|
this._progressHandler0 = undefined;
|
|
this._promise0 = undefined;
|
|
this._receiver0 = undefined;
|
|
this._settledValue = undefined;
|
|
this._boundTo = undefined;
|
|
if (resolver !== INTERNAL) this._resolveFromResolver(resolver);
|
|
}
|
|
|
|
Promise.prototype.toString = function () {
|
|
return "[object Promise]";
|
|
};
|
|
|
|
Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
|
|
var len = arguments.length;
|
|
if (len > 1) {
|
|
var catchInstances = new Array(len - 1),
|
|
j = 0, i;
|
|
for (i = 0; i < len - 1; ++i) {
|
|
var item = arguments[i];
|
|
if (typeof item === "function") {
|
|
catchInstances[j++] = item;
|
|
} else {
|
|
return Promise.reject(
|
|
new TypeError("Catch filter must inherit from Error or be a simple predicate function\u000a\u000a See http://goo.gl/o84o68\u000a"));
|
|
}
|
|
}
|
|
catchInstances.length = j;
|
|
fn = arguments[i];
|
|
var catchFilter = new CatchFilter(catchInstances, fn, this);
|
|
return this._then(undefined, catchFilter.doFilter, undefined,
|
|
catchFilter, undefined);
|
|
}
|
|
return this._then(undefined, fn, undefined, undefined, undefined);
|
|
};
|
|
|
|
Promise.prototype.reflect = function () {
|
|
return this._then(reflect, reflect, undefined, this, undefined);
|
|
};
|
|
|
|
Promise.prototype.then = function (didFulfill, didReject, didProgress) {
|
|
if (isDebugging() && arguments.length > 0 &&
|
|
typeof didFulfill !== "function" &&
|
|
typeof didReject !== "function") {
|
|
var msg = ".then() only accepts functions but was passed: " +
|
|
util.classString(didFulfill);
|
|
if (arguments.length > 1) {
|
|
msg += ", " + util.classString(didReject);
|
|
}
|
|
this._warn(msg);
|
|
}
|
|
return this._then(didFulfill, didReject, didProgress,
|
|
undefined, undefined);
|
|
};
|
|
|
|
Promise.prototype.done = function (didFulfill, didReject, didProgress) {
|
|
var promise = this._then(didFulfill, didReject, didProgress,
|
|
undefined, undefined);
|
|
promise._setIsFinal();
|
|
};
|
|
|
|
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);
|
|
};
|
|
|
|
Promise.prototype.isCancellable = function () {
|
|
return !this.isResolved() &&
|
|
this._cancellable();
|
|
};
|
|
|
|
Promise.prototype.toJSON = function () {
|
|
var ret = {
|
|
isFulfilled: false,
|
|
isRejected: false,
|
|
fulfillmentValue: undefined,
|
|
rejectionReason: undefined
|
|
};
|
|
if (this.isFulfilled()) {
|
|
ret.fulfillmentValue = this.value();
|
|
ret.isFulfilled = true;
|
|
} else if (this.isRejected()) {
|
|
ret.rejectionReason = this.reason();
|
|
ret.isRejected = true;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype.all = function () {
|
|
var ret = new PromiseArray(this).promise();
|
|
ret._setIsSpreadable();
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype.error = function (fn) {
|
|
return this.caught(util.originatesFromRejection, fn);
|
|
};
|
|
|
|
Promise.is = function (val) {
|
|
return val instanceof Promise;
|
|
};
|
|
|
|
Promise.fromNode = function(fn) {
|
|
var ret = new Promise(INTERNAL);
|
|
var result = tryCatch(fn)(nodebackForPromise(ret));
|
|
if (result === errorObj) {
|
|
ret._rejectCallback(result.e, true, true);
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Promise.all = function (promises) {
|
|
var ret = new PromiseArray(promises).promise();
|
|
ret._setIsSpreadable();
|
|
return ret;
|
|
};
|
|
|
|
Promise.defer = Promise.pending = function () {
|
|
var promise = new Promise(INTERNAL);
|
|
return new PromiseResolver(promise);
|
|
};
|
|
|
|
Promise.cast = function (obj) {
|
|
var ret = tryConvertToPromise(obj);
|
|
if (!(ret instanceof Promise)) {
|
|
var val = ret;
|
|
ret = new Promise(INTERNAL);
|
|
ret._fulfillUnchecked(val);
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Promise.resolve = Promise.fulfilled = Promise.cast;
|
|
|
|
Promise.reject = Promise.rejected = function (reason) {
|
|
var ret = new Promise(INTERNAL);
|
|
ret._captureStackTrace();
|
|
ret._rejectCallback(reason, true);
|
|
return ret;
|
|
};
|
|
|
|
Promise.setScheduler = function(fn) {
|
|
if (typeof fn !== "function") throw new TypeError("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
var prev = async._schedule;
|
|
async._schedule = fn;
|
|
return prev;
|
|
};
|
|
|
|
Promise.prototype._then = function (
|
|
didFulfill,
|
|
didReject,
|
|
didProgress,
|
|
receiver,
|
|
internalData
|
|
) {
|
|
var haveInternalData = internalData !== undefined;
|
|
var ret = haveInternalData ? internalData : new Promise(INTERNAL);
|
|
|
|
if (!haveInternalData) {
|
|
ret._propagateFrom(this, 4 | 1);
|
|
ret._captureStackTrace();
|
|
}
|
|
|
|
var target = this._target();
|
|
if (target !== this) {
|
|
if (!haveInternalData) {
|
|
ret._setIsMigrated();
|
|
if (receiver === undefined) {
|
|
ret._setIsMigratingBinding();
|
|
receiver = this;
|
|
}
|
|
}
|
|
}
|
|
|
|
var callbackIndex =
|
|
target._addCallbacks(didFulfill, didReject, didProgress, ret, receiver);
|
|
|
|
if (target._isResolved() && !target._isSettlePromisesQueued()) {
|
|
async.invoke(
|
|
target._settlePromiseAtPostResolution, target, callbackIndex);
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype._settlePromiseAtPostResolution = function (index) {
|
|
if (this._isRejectionUnhandled()) this._unsetRejectionIsUnhandled();
|
|
this._settlePromiseAt(index);
|
|
};
|
|
|
|
Promise.prototype._length = function () {
|
|
return this._bitField & 131071;
|
|
};
|
|
|
|
Promise.prototype._isFollowingOrFulfilledOrRejected = function () {
|
|
return (this._bitField & 939524096) > 0;
|
|
};
|
|
|
|
Promise.prototype._isFollowing = function () {
|
|
return (this._bitField & 536870912) === 536870912;
|
|
};
|
|
|
|
Promise.prototype._setLength = function (len) {
|
|
this._bitField = (this._bitField & -131072) |
|
|
(len & 131071);
|
|
};
|
|
|
|
Promise.prototype._setFulfilled = function () {
|
|
this._bitField = this._bitField | 268435456;
|
|
};
|
|
|
|
Promise.prototype._setRejected = function () {
|
|
this._bitField = this._bitField | 134217728;
|
|
};
|
|
|
|
Promise.prototype._setFollowing = function () {
|
|
this._bitField = this._bitField | 536870912;
|
|
};
|
|
|
|
Promise.prototype._setIsFinal = function () {
|
|
this._bitField = this._bitField | 33554432;
|
|
};
|
|
|
|
Promise.prototype._isFinal = function () {
|
|
return (this._bitField & 33554432) > 0;
|
|
};
|
|
|
|
Promise.prototype._cancellable = function () {
|
|
return (this._bitField & 67108864) > 0;
|
|
};
|
|
|
|
Promise.prototype._setCancellable = function () {
|
|
this._bitField = this._bitField | 67108864;
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
Promise.prototype._unsetIsMigrated = function () {
|
|
this._bitField = this._bitField & (~4194304);
|
|
};
|
|
|
|
Promise.prototype._isMigrated = function () {
|
|
return (this._bitField & 4194304) > 0;
|
|
};
|
|
|
|
Promise.prototype._receiverAt = function (index) {
|
|
var ret = index === 0
|
|
? this._receiver0
|
|
: this[
|
|
index * 5 - 5 + 4];
|
|
if (this._isBound() && ret === undefined) {
|
|
return this._boundTo;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype._promiseAt = function (index) {
|
|
return index === 0
|
|
? this._promise0
|
|
: this[index * 5 - 5 + 3];
|
|
};
|
|
|
|
Promise.prototype._fulfillmentHandlerAt = function (index) {
|
|
return index === 0
|
|
? this._fulfillmentHandler0
|
|
: this[index * 5 - 5 + 0];
|
|
};
|
|
|
|
Promise.prototype._rejectionHandlerAt = function (index) {
|
|
return index === 0
|
|
? this._rejectionHandler0
|
|
: this[index * 5 - 5 + 1];
|
|
};
|
|
|
|
Promise.prototype._migrateCallbacks = function (follower, index) {
|
|
var fulfill = follower._fulfillmentHandlerAt(index);
|
|
var reject = follower._rejectionHandlerAt(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();
|
|
}
|
|
}
|
|
this._addCallbacks(fulfill, reject, progress, promise, receiver);
|
|
};
|
|
|
|
Promise.prototype._addCallbacks = function (
|
|
fulfill,
|
|
reject,
|
|
progress,
|
|
promise,
|
|
receiver
|
|
) {
|
|
var index = this._length();
|
|
|
|
if (index >= 131071 - 5) {
|
|
index = 0;
|
|
this._setLength(0);
|
|
}
|
|
|
|
if (index === 0) {
|
|
this._promise0 = promise;
|
|
if (receiver !== undefined) this._receiver0 = receiver;
|
|
if (typeof fulfill === "function" && !this._isCarryingStackTrace())
|
|
this._fulfillmentHandler0 = fulfill;
|
|
if (typeof reject === "function") this._rejectionHandler0 = reject;
|
|
if (typeof progress === "function") this._progressHandler0 = progress;
|
|
} else {
|
|
var base = index * 5 - 5;
|
|
this[base + 3] = promise;
|
|
this[base + 4] = receiver;
|
|
if (typeof fulfill === "function")
|
|
this[base + 0] = fulfill;
|
|
if (typeof reject === "function")
|
|
this[base + 1] = reject;
|
|
if (typeof progress === "function")
|
|
this[base + 2] = progress;
|
|
}
|
|
this._setLength(index + 1);
|
|
return index;
|
|
};
|
|
|
|
Promise.prototype._setProxyHandlers = function (receiver, promiseSlotValue) {
|
|
var index = this._length();
|
|
|
|
if (index >= 131071 - 5) {
|
|
index = 0;
|
|
this._setLength(0);
|
|
}
|
|
if (index === 0) {
|
|
this._promise0 = promiseSlotValue;
|
|
this._receiver0 = receiver;
|
|
} else {
|
|
var base = index * 5 - 5;
|
|
this[base + 3] = promiseSlotValue;
|
|
this[base + 4] = receiver;
|
|
}
|
|
this._setLength(index + 1);
|
|
};
|
|
|
|
Promise.prototype._proxyPromiseArray = function (promiseArray, index) {
|
|
this._setProxyHandlers(promiseArray, index);
|
|
};
|
|
|
|
Promise.prototype._resolveCallback = function(value, shouldBind) {
|
|
if (this._isFollowingOrFulfilledOrRejected()) return;
|
|
if (value === this)
|
|
return this._rejectCallback(makeSelfResolutionError(), false, true);
|
|
var maybePromise = tryConvertToPromise(value, this);
|
|
if (!(maybePromise instanceof Promise)) return this._fulfill(value);
|
|
|
|
var propagationFlags = 1 | (shouldBind ? 4 : 0);
|
|
this._propagateFrom(maybePromise, propagationFlags);
|
|
var promise = maybePromise._target();
|
|
if (promise._isPending()) {
|
|
var len = this._length();
|
|
for (var i = 0; i < len; ++i) {
|
|
promise._migrateCallbacks(this, i);
|
|
}
|
|
this._setFollowing();
|
|
this._setLength(0);
|
|
this._setFollowee(promise);
|
|
} else if (promise._isFulfilled()) {
|
|
this._fulfillUnchecked(promise._value());
|
|
} else {
|
|
this._rejectUnchecked(promise._reason(),
|
|
promise._getCarriedStackTrace());
|
|
}
|
|
};
|
|
|
|
Promise.prototype._rejectCallback =
|
|
function(reason, synchronous, shouldNotMarkOriginatingFromRejection) {
|
|
if (!shouldNotMarkOriginatingFromRejection) {
|
|
util.markAsOriginatingFromRejection(reason);
|
|
}
|
|
var trace = util.ensureErrorObject(reason);
|
|
var hasStack = util.canAttachTrace(reason) &&
|
|
typeof trace.stack === "string" && trace.stack.length > 0;
|
|
this._attachExtraTrace(trace, synchronous ? hasStack : false);
|
|
this._reject(reason, trace === reason ? undefined : trace);
|
|
};
|
|
|
|
Promise.prototype._resolveFromResolver = function (resolver) {
|
|
var promise = this;
|
|
this._captureStackTrace();
|
|
this._pushContext();
|
|
var synchronous = true;
|
|
var r = tryCatch(resolver)(function(value) {
|
|
if (promise === null) return;
|
|
promise._resolveCallback(value);
|
|
promise = null;
|
|
}, function (reason) {
|
|
if (promise === null) return;
|
|
promise._rejectCallback(reason, synchronous);
|
|
promise = null;
|
|
});
|
|
synchronous = false;
|
|
this._popContext();
|
|
|
|
if (r !== undefined && r === errorObj && promise !== null) {
|
|
promise._rejectCallback(r.e, true, true);
|
|
promise = null;
|
|
}
|
|
};
|
|
|
|
Promise.prototype._settlePromiseFromHandler = function (
|
|
handler, receiver, value, promise
|
|
) {
|
|
if (promise._isRejected()) return;
|
|
promise._pushContext();
|
|
var x;
|
|
if (receiver === APPLY && !this._isRejected()) {
|
|
x = tryCatch(handler).apply(this._boundTo, value);
|
|
} else {
|
|
x = tryCatch(handler).call(receiver, value);
|
|
}
|
|
promise._popContext();
|
|
|
|
if (x === errorObj || x === promise || x === NEXT_FILTER) {
|
|
var err = x === promise ? makeSelfResolutionError() : x.e;
|
|
promise._rejectCallback(err, false, true);
|
|
} else {
|
|
promise._resolveCallback(x);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._target = function() {
|
|
var ret = this;
|
|
while (ret._isFollowing()) ret = ret._followee();
|
|
return ret;
|
|
};
|
|
|
|
Promise.prototype._followee = function() {
|
|
return this._rejectionHandler0;
|
|
};
|
|
|
|
Promise.prototype._setFollowee = function(promise) {
|
|
this._rejectionHandler0 = promise;
|
|
};
|
|
|
|
Promise.prototype._cleanValues = function () {
|
|
if (this._cancellable()) {
|
|
this._cancellationParent = undefined;
|
|
}
|
|
};
|
|
|
|
Promise.prototype._propagateFrom = function (parent, flags) {
|
|
if ((flags & 1) > 0 && parent._cancellable()) {
|
|
this._setCancellable();
|
|
this._cancellationParent = parent;
|
|
}
|
|
if ((flags & 4) > 0) {
|
|
this._setBoundTo(parent._boundTo);
|
|
}
|
|
};
|
|
|
|
Promise.prototype._fulfill = function (value) {
|
|
if (this._isFollowingOrFulfilledOrRejected()) return;
|
|
this._fulfillUnchecked(value);
|
|
};
|
|
|
|
Promise.prototype._reject = function (reason, carriedStackTrace) {
|
|
if (this._isFollowingOrFulfilledOrRejected()) return;
|
|
this._rejectUnchecked(reason, carriedStackTrace);
|
|
};
|
|
|
|
Promise.prototype._settlePromiseAt = function (index) {
|
|
var promise = this._promiseAt(index);
|
|
var isPromise = promise instanceof Promise;
|
|
|
|
if (isPromise && promise._isMigrated()) {
|
|
promise._unsetIsMigrated();
|
|
return async.invoke(this._settlePromiseAt, this, index);
|
|
}
|
|
var handler = this._isFulfilled()
|
|
? this._fulfillmentHandlerAt(index)
|
|
: this._rejectionHandlerAt(index);
|
|
|
|
var carriedStackTrace =
|
|
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);
|
|
|
|
if (typeof handler === "function") {
|
|
if (!isPromise) {
|
|
handler.call(receiver, value, promise);
|
|
} else {
|
|
this._settlePromiseFromHandler(handler, receiver, value, promise);
|
|
}
|
|
} else if (receiver instanceof PromiseArray) {
|
|
if (!receiver._isResolved()) {
|
|
if (this._isFulfilled()) {
|
|
receiver._promiseFulfilled(value, promise);
|
|
}
|
|
else {
|
|
receiver._promiseRejected(value, promise);
|
|
}
|
|
}
|
|
} else if (isPromise) {
|
|
if (this._isFulfilled()) {
|
|
promise._fulfill(value);
|
|
} else {
|
|
promise._reject(value, carriedStackTrace);
|
|
}
|
|
}
|
|
|
|
if (index >= 4 && (index & 31) === 4)
|
|
async.invokeLater(this._setLength, this, 0);
|
|
};
|
|
|
|
Promise.prototype._clearCallbackDataAtIndex = function(index) {
|
|
if (index === 0) {
|
|
if (!this._isCarryingStackTrace()) {
|
|
this._fulfillmentHandler0 = undefined;
|
|
}
|
|
this._rejectionHandler0 =
|
|
this._progressHandler0 =
|
|
this._receiver0 =
|
|
this._promise0 = undefined;
|
|
} else {
|
|
var base = index * 5 - 5;
|
|
this[base + 3] =
|
|
this[base + 4] =
|
|
this[base + 0] =
|
|
this[base + 1] =
|
|
this[base + 2] = undefined;
|
|
}
|
|
};
|
|
|
|
Promise.prototype._isSettlePromisesQueued = function () {
|
|
return (this._bitField &
|
|
-1073741824) === -1073741824;
|
|
};
|
|
|
|
Promise.prototype._setSettlePromisesQueued = function () {
|
|
this._bitField = this._bitField | -1073741824;
|
|
};
|
|
|
|
Promise.prototype._unsetSettlePromisesQueued = function () {
|
|
this._bitField = this._bitField & (~-1073741824);
|
|
};
|
|
|
|
Promise.prototype._queueSettlePromises = function() {
|
|
async.settlePromises(this);
|
|
this._setSettlePromisesQueued();
|
|
};
|
|
|
|
Promise.prototype._fulfillUnchecked = function (value) {
|
|
if (value === this) {
|
|
var err = makeSelfResolutionError();
|
|
this._attachExtraTrace(err);
|
|
return this._rejectUnchecked(err, undefined);
|
|
}
|
|
this._setFulfilled();
|
|
this._settledValue = value;
|
|
this._cleanValues();
|
|
|
|
if (this._length() > 0) {
|
|
this._queueSettlePromises();
|
|
}
|
|
};
|
|
|
|
Promise.prototype._rejectUncheckedCheckError = function (reason) {
|
|
var trace = util.ensureErrorObject(reason);
|
|
this._rejectUnchecked(reason, trace === reason ? undefined : trace);
|
|
};
|
|
|
|
Promise.prototype._rejectUnchecked = function (reason, trace) {
|
|
if (reason === this) {
|
|
var err = makeSelfResolutionError();
|
|
this._attachExtraTrace(err);
|
|
return this._rejectUnchecked(err);
|
|
}
|
|
this._setRejected();
|
|
this._settledValue = reason;
|
|
this._cleanValues();
|
|
|
|
if (this._isFinal()) {
|
|
async.throwLater(function(e) {
|
|
if ("stack" in e) {
|
|
async.invokeFirst(
|
|
CapturedTrace.unhandledRejection, undefined, e);
|
|
}
|
|
throw e;
|
|
}, trace === undefined ? reason : trace);
|
|
return;
|
|
}
|
|
|
|
if (trace !== undefined && trace !== reason) {
|
|
this._setCarriedStackTrace(trace);
|
|
}
|
|
|
|
if (this._length() > 0) {
|
|
this._queueSettlePromises();
|
|
} else {
|
|
this._ensurePossibleRejectionHandled();
|
|
}
|
|
};
|
|
|
|
Promise.prototype._settlePromises = function () {
|
|
this._unsetSettlePromisesQueued();
|
|
var len = this._length();
|
|
for (var i = 0; i < len; i++) {
|
|
this._settlePromiseAt(i);
|
|
}
|
|
};
|
|
|
|
Promise._makeSelfResolutionError = makeSelfResolutionError;
|
|
_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_('./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_('./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_('./any.js')(Promise);
|
|
_dereq_('./each.js')(Promise, INTERNAL);
|
|
_dereq_('./timers.js')(Promise, INTERNAL);
|
|
_dereq_('./filter.js')(Promise, INTERNAL);
|
|
|
|
Promise.prototype = Promise.prototype;
|
|
return Promise;
|
|
|
|
};
|
|
|
|
},{"./any.js":1,"./async.js":2,"./bind.js":3,"./call_get.js":5,"./cancel.js":6,"./captured_trace.js":7,"./catch_filter.js":8,"./context.js":9,"./debuggability.js":10,"./direct_resolve.js":11,"./each.js":12,"./errors.js":13,"./filter.js":15,"./finally.js":16,"./generators.js":17,"./join.js":18,"./map.js":19,"./method.js":20,"./nodeify.js":21,"./progress.js":22,"./promise_array.js":24,"./promise_resolver.js":25,"./promisify.js":26,"./props.js":27,"./race.js":29,"./reduce.js":30,"./settle.js":32,"./some.js":33,"./synchronous_inspection.js":34,"./thenables.js":35,"./timers.js":36,"./using.js":37,"./util.js":38}],24:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL, tryConvertToPromise,
|
|
apiRejection) {
|
|
var util = _dereq_("./util.js");
|
|
var isArray = util.isArray;
|
|
|
|
function toResolutionValue(val) {
|
|
switch(val) {
|
|
case -2: return [];
|
|
case -3: return {};
|
|
}
|
|
}
|
|
|
|
function PromiseArray(values) {
|
|
var promise = this._promise = new Promise(INTERNAL);
|
|
var parent;
|
|
if (values instanceof Promise) {
|
|
parent = values;
|
|
promise._propagateFrom(parent, 1 | 4);
|
|
}
|
|
this._values = values;
|
|
this._length = 0;
|
|
this._totalResolved = 0;
|
|
this._init(undefined, -2);
|
|
}
|
|
PromiseArray.prototype.length = function () {
|
|
return this._length;
|
|
};
|
|
|
|
PromiseArray.prototype.promise = function () {
|
|
return this._promise;
|
|
};
|
|
|
|
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()) {
|
|
values = values._value();
|
|
if (!isArray(values)) {
|
|
var err = new Promise.TypeError("expecting an array, a promise or a thenable\u000a\u000a See http://goo.gl/s8MMhc\u000a");
|
|
this.__hardReject__(err);
|
|
return;
|
|
}
|
|
} else if (values._isPending()) {
|
|
values._then(
|
|
init,
|
|
this._reject,
|
|
undefined,
|
|
this,
|
|
resolveValueIfEmpty
|
|
);
|
|
return;
|
|
} else {
|
|
this._reject(values._reason());
|
|
return;
|
|
}
|
|
} else if (!isArray(values)) {
|
|
this._promise._reject(apiRejection("expecting an array, a promise or a thenable\u000a\u000a See http://goo.gl/s8MMhc\u000a")._reason());
|
|
return;
|
|
}
|
|
|
|
if (values.length === 0) {
|
|
if (resolveValueIfEmpty === -5) {
|
|
this._resolveEmptyArray();
|
|
}
|
|
else {
|
|
this._resolve(toResolutionValue(resolveValueIfEmpty));
|
|
}
|
|
return;
|
|
}
|
|
var len = this.getActualLength(values.length);
|
|
this._length = len;
|
|
this._values = this.shouldCopyValues() ? new Array(len) : this._values;
|
|
var promise = this._promise;
|
|
for (var i = 0; i < len; ++i) {
|
|
var isResolved = this._isResolved();
|
|
var maybePromise = tryConvertToPromise(values[i], promise);
|
|
if (maybePromise instanceof Promise) {
|
|
maybePromise = maybePromise._target();
|
|
if (isResolved) {
|
|
maybePromise._unsetRejectionIsUnhandled();
|
|
} else if (maybePromise._isPending()) {
|
|
maybePromise._proxyPromiseArray(this, i);
|
|
} else if (maybePromise._isFulfilled()) {
|
|
this._promiseFulfilled(maybePromise._value(), i);
|
|
} else {
|
|
this._promiseRejected(maybePromise._reason(), i);
|
|
}
|
|
} else if (!isResolved) {
|
|
this._promiseFulfilled(maybePromise, i);
|
|
}
|
|
}
|
|
};
|
|
|
|
PromiseArray.prototype._isResolved = function () {
|
|
return this._values === null;
|
|
};
|
|
|
|
PromiseArray.prototype._resolve = function (value) {
|
|
this._values = null;
|
|
this._promise._fulfill(value);
|
|
};
|
|
|
|
PromiseArray.prototype.__hardReject__ =
|
|
PromiseArray.prototype._reject = function (reason) {
|
|
this._values = null;
|
|
this._promise._rejectCallback(reason, false, true);
|
|
};
|
|
|
|
PromiseArray.prototype._promiseProgressed = function (progressValue, index) {
|
|
this._promise._progress({
|
|
index: index,
|
|
value: progressValue
|
|
});
|
|
};
|
|
|
|
|
|
PromiseArray.prototype._promiseFulfilled = function (value, index) {
|
|
this._values[index] = value;
|
|
var totalResolved = ++this._totalResolved;
|
|
if (totalResolved >= this._length) {
|
|
this._resolve(this._values);
|
|
}
|
|
};
|
|
|
|
PromiseArray.prototype._promiseRejected = function (reason, index) {
|
|
this._totalResolved++;
|
|
this._reject(reason);
|
|
};
|
|
|
|
PromiseArray.prototype.shouldCopyValues = function () {
|
|
return true;
|
|
};
|
|
|
|
PromiseArray.prototype.getActualLength = function (len) {
|
|
return len;
|
|
};
|
|
|
|
return PromiseArray;
|
|
};
|
|
|
|
},{"./util.js":38}],25:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var util = _dereq_("./util.js");
|
|
var maybeWrapAsError = util.maybeWrapAsError;
|
|
var errors = _dereq_("./errors.js");
|
|
var TimeoutError = errors.TimeoutError;
|
|
var OperationalError = errors.OperationalError;
|
|
var haveGetters = util.haveGetters;
|
|
var es5 = _dereq_("./es5.js");
|
|
|
|
function isUntypedError(obj) {
|
|
return obj instanceof Error &&
|
|
es5.getPrototypeOf(obj) === Error.prototype;
|
|
}
|
|
|
|
var rErrorKey = /^(?:name|message|stack|cause)$/;
|
|
function wrapAsOperationalError(obj) {
|
|
var ret;
|
|
if (isUntypedError(obj)) {
|
|
ret = new OperationalError(obj);
|
|
ret.name = obj.name;
|
|
ret.message = obj.message;
|
|
ret.stack = obj.stack;
|
|
var keys = es5.keys(obj);
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
if (!rErrorKey.test(key)) {
|
|
ret[key] = obj[key];
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
util.markAsOriginatingFromRejection(obj);
|
|
return obj;
|
|
}
|
|
|
|
function nodebackForPromise(promise) {
|
|
return function(err, value) {
|
|
if (promise === null) return;
|
|
|
|
if (err) {
|
|
var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
|
|
promise._attachExtraTrace(wrapped);
|
|
promise._reject(wrapped);
|
|
} else if (arguments.length > 2) {
|
|
var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
|
|
promise._fulfill(args);
|
|
} else {
|
|
promise._fulfill(value);
|
|
}
|
|
|
|
promise = null;
|
|
};
|
|
}
|
|
|
|
|
|
var PromiseResolver;
|
|
if (!haveGetters) {
|
|
PromiseResolver = function (promise) {
|
|
this.promise = promise;
|
|
this.asCallback = nodebackForPromise(promise);
|
|
this.callback = this.asCallback;
|
|
};
|
|
}
|
|
else {
|
|
PromiseResolver = function (promise) {
|
|
this.promise = promise;
|
|
};
|
|
}
|
|
if (haveGetters) {
|
|
var prop = {
|
|
get: function() {
|
|
return nodebackForPromise(this.promise);
|
|
}
|
|
};
|
|
es5.defineProperty(PromiseResolver.prototype, "asCallback", prop);
|
|
es5.defineProperty(PromiseResolver.prototype, "callback", prop);
|
|
}
|
|
|
|
PromiseResolver._nodebackForPromise = nodebackForPromise;
|
|
|
|
PromiseResolver.prototype.toString = function () {
|
|
return "[object PromiseResolver]";
|
|
};
|
|
|
|
PromiseResolver.prototype.resolve =
|
|
PromiseResolver.prototype.fulfill = function (value) {
|
|
if (!(this instanceof PromiseResolver)) {
|
|
throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a See http://goo.gl/sdkXL9\u000a");
|
|
}
|
|
this.promise._resolveCallback(value);
|
|
};
|
|
|
|
PromiseResolver.prototype.reject = function (reason) {
|
|
if (!(this instanceof PromiseResolver)) {
|
|
throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a See http://goo.gl/sdkXL9\u000a");
|
|
}
|
|
this.promise._rejectCallback(reason);
|
|
};
|
|
|
|
PromiseResolver.prototype.progress = function (value) {
|
|
if (!(this instanceof PromiseResolver)) {
|
|
throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.\u000a\u000a See http://goo.gl/sdkXL9\u000a");
|
|
}
|
|
this.promise._progress(value);
|
|
};
|
|
|
|
PromiseResolver.prototype.cancel = function (err) {
|
|
this.promise.cancel(err);
|
|
};
|
|
|
|
PromiseResolver.prototype.timeout = function () {
|
|
this.reject(new TimeoutError("timeout"));
|
|
};
|
|
|
|
PromiseResolver.prototype.isResolved = function () {
|
|
return this.promise.isResolved();
|
|
};
|
|
|
|
PromiseResolver.prototype.toJSON = function () {
|
|
return this.promise.toJSON();
|
|
};
|
|
|
|
module.exports = PromiseResolver;
|
|
|
|
},{"./errors.js":13,"./es5.js":14,"./util.js":38}],26:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL) {
|
|
var THIS = {};
|
|
var util = _dereq_("./util.js");
|
|
var nodebackForPromise = _dereq_("./promise_resolver.js")
|
|
._nodebackForPromise;
|
|
var withAppended = util.withAppended;
|
|
var maybeWrapAsError = util.maybeWrapAsError;
|
|
var canEvaluate = util.canEvaluate;
|
|
var TypeError = _dereq_("./errors").TypeError;
|
|
var defaultSuffix = "Async";
|
|
var defaultFilter = function(name, func) {
|
|
return util.isIdentifier(name) &&
|
|
name.charAt(0) !== "_" &&
|
|
!util.isClass(func);
|
|
};
|
|
var defaultPromisified = {__isPromisified__: true};
|
|
|
|
function isPromisified(fn) {
|
|
try {
|
|
return fn.__isPromisified__ === true;
|
|
}
|
|
catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function hasPromisified(obj, key, suffix) {
|
|
var val = util.getDataPropertyOrDefault(obj, key + suffix,
|
|
defaultPromisified);
|
|
return val ? isPromisified(val) : false;
|
|
}
|
|
function checkValid(ret, suffix, suffixRegexp) {
|
|
for (var i = 0; i < ret.length; i += 2) {
|
|
var key = ret[i];
|
|
if (suffixRegexp.test(key)) {
|
|
var keyWithoutAsyncSuffix = key.replace(suffixRegexp, "");
|
|
for (var j = 0; j < ret.length; j += 2) {
|
|
if (ret[j] === keyWithoutAsyncSuffix) {
|
|
throw new TypeError("Cannot promisify an API that has normal methods with '%s'-suffix\u000a\u000a See http://goo.gl/iWrZbw\u000a"
|
|
.replace("%s", suffix));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function promisifiableMethods(obj, suffix, suffixRegexp, filter) {
|
|
var keys = util.inheritedDataKeys(obj);
|
|
var ret = [];
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
var value = obj[key];
|
|
var passesDefaultFilter = filter === defaultFilter
|
|
? true : defaultFilter(key, value, obj);
|
|
if (typeof value === "function" &&
|
|
!isPromisified(value) &&
|
|
!hasPromisified(obj, key, suffix) &&
|
|
filter(key, value, obj, passesDefaultFilter)) {
|
|
ret.push(key, value);
|
|
}
|
|
}
|
|
checkValid(ret, suffix, suffixRegexp);
|
|
return ret;
|
|
}
|
|
|
|
var escapeIdentRegex = function(str) {
|
|
return str.replace(/([$])/, "\\$");
|
|
};
|
|
|
|
var makeNodePromisifiedEval;
|
|
if (!true) {
|
|
var switchCaseArgumentOrder = function(likelyArgumentCount) {
|
|
var ret = [likelyArgumentCount];
|
|
var min = Math.max(0, likelyArgumentCount - 1 - 5);
|
|
for(var i = likelyArgumentCount - 1; i >= min; --i) {
|
|
ret.push(i);
|
|
}
|
|
for(var i = likelyArgumentCount + 1; i <= 5; ++i) {
|
|
ret.push(i);
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
var argumentSequence = function(argumentCount) {
|
|
return util.filledRange(argumentCount, "arguments[", "]");
|
|
};
|
|
|
|
var parameterDeclaration = function(parameterCount) {
|
|
return util.filledRange(parameterCount, "_arg", "");
|
|
};
|
|
|
|
var parameterCount = function(fn) {
|
|
if (typeof fn.length === "number") {
|
|
return Math.max(Math.min(fn.length, 1023 + 1), 0);
|
|
}
|
|
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) {
|
|
var newParameterCount = Math.max(0, parameterCount(fn) - 1);
|
|
var argumentOrder = switchCaseArgumentOrder(newParameterCount);
|
|
var callbackName =
|
|
(typeof originalName === "string" && util.isIdentifier(originalName)
|
|
? originalName + suffix
|
|
: "promisified");
|
|
|
|
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\
|
|
";
|
|
} else {
|
|
ret = " \n\
|
|
callback({{args}}, fn); \n\
|
|
break; \n\
|
|
";
|
|
}
|
|
return ret.replace("{{args}}", args).replace(", ", comma);
|
|
}
|
|
|
|
function generateArgumentSwitchCase() {
|
|
var ret = "";
|
|
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\
|
|
var args = new Array(len + 1); \n\
|
|
var i = 0; \n\
|
|
for (var i = 0; i < len; ++i) { \n\
|
|
args[i] = arguments[i]; \n\
|
|
} \n\
|
|
args[i] = fn; \n\
|
|
[CodeForCall] \n\
|
|
break; \n\
|
|
".replace("[CodeForCall]", codeForCall);
|
|
return ret;
|
|
}
|
|
|
|
return new Function("Promise",
|
|
"callback",
|
|
"receiver",
|
|
"withAppended",
|
|
"maybeWrapAsError",
|
|
"nodebackForPromise",
|
|
"INTERNAL"," \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\
|
|
} \n\
|
|
return promise; \n\
|
|
}; \n\
|
|
ret.__isPromisified__ = true; \n\
|
|
return ret; \n\
|
|
"
|
|
.replace("FunctionName", callbackName)
|
|
.replace("Parameters", parameterDeclaration(newParameterCount))
|
|
.replace("[CodeForSwitchCase]", generateArgumentSwitchCase()))(
|
|
Promise,
|
|
callback,
|
|
receiver,
|
|
withAppended,
|
|
maybeWrapAsError,
|
|
nodebackForPromise,
|
|
INTERNAL
|
|
);
|
|
};
|
|
}
|
|
|
|
function makeNodePromisifiedClosure(callback, receiver) {
|
|
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 fn = nodebackForPromise(promise);
|
|
try {
|
|
callback.apply(_receiver, withAppended(arguments, fn));
|
|
} catch(e) {
|
|
var wrapped = maybeWrapAsError(e);
|
|
promise._attachExtraTrace(wrapped);
|
|
promise._reject(wrapped);
|
|
}
|
|
return promise;
|
|
}
|
|
promisified.__isPromisified__ = true;
|
|
return promisified;
|
|
}
|
|
|
|
var makeNodePromisified = canEvaluate
|
|
? makeNodePromisifiedEval
|
|
: makeNodePromisifiedClosure;
|
|
|
|
function promisifyAll(obj, suffix, filter, promisifier) {
|
|
var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$");
|
|
var methods =
|
|
promisifiableMethods(obj, suffix, suffixRegexp, filter);
|
|
|
|
for (var i = 0, len = methods.length; i < len; i+= 2) {
|
|
var key = methods[i];
|
|
var fn = methods[i+1];
|
|
var promisifiedKey = key + suffix;
|
|
obj[promisifiedKey] = promisifier === makeNodePromisified
|
|
? makeNodePromisified(key, THIS, key, fn, suffix)
|
|
: promisifier(fn, function() {
|
|
return makeNodePromisified(key, THIS, key, fn, suffix);
|
|
});
|
|
}
|
|
util.toFastProperties(obj);
|
|
return obj;
|
|
}
|
|
|
|
function promisify(callback, receiver) {
|
|
return makeNodePromisified(callback, receiver, undefined, callback);
|
|
}
|
|
|
|
Promise.promisify = function (fn, receiver) {
|
|
if (typeof fn !== "function") {
|
|
throw new TypeError("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
}
|
|
if (isPromisified(fn)) {
|
|
return fn;
|
|
}
|
|
return promisify(fn, arguments.length < 2 ? THIS : receiver);
|
|
};
|
|
|
|
Promise.promisifyAll = function (target, options) {
|
|
if (typeof target !== "function" && typeof target !== "object") {
|
|
throw new TypeError("the target of promisifyAll must be an object or a function\u000a\u000a See http://goo.gl/9ITlV0\u000a");
|
|
}
|
|
options = Object(options);
|
|
var suffix = options.suffix;
|
|
if (typeof suffix !== "string") suffix = defaultSuffix;
|
|
var filter = options.filter;
|
|
if (typeof filter !== "function") filter = defaultFilter;
|
|
var promisifier = options.promisifier;
|
|
if (typeof promisifier !== "function") promisifier = makeNodePromisified;
|
|
|
|
if (!util.isIdentifier(suffix)) {
|
|
throw new RangeError("suffix must be a valid identifier\u000a\u000a See http://goo.gl/8FZo5V\u000a");
|
|
}
|
|
|
|
var keys = util.inheritedDataKeys(target, {includeHidden: true});
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var value = target[keys[i]];
|
|
if (keys[i] !== "constructor" &&
|
|
util.isClass(value)) {
|
|
promisifyAll(value.prototype, suffix, filter, promisifier);
|
|
promisifyAll(value, suffix, filter, promisifier);
|
|
}
|
|
}
|
|
|
|
return promisifyAll(target, suffix, filter, promisifier);
|
|
};
|
|
};
|
|
|
|
|
|
},{"./errors":13,"./promise_resolver.js":25,"./util.js":38}],27:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(
|
|
Promise, PromiseArray, tryConvertToPromise, apiRejection) {
|
|
var util = _dereq_("./util.js");
|
|
var isObject = util.isObject;
|
|
var es5 = _dereq_("./es5.js");
|
|
|
|
function PropertiesPromiseArray(obj) {
|
|
var keys = es5.keys(obj);
|
|
var len = keys.length;
|
|
var values = new Array(len * 2);
|
|
for (var i = 0; i < len; ++i) {
|
|
var key = keys[i];
|
|
values[i] = obj[key];
|
|
values[i + len] = key;
|
|
}
|
|
this.constructor$(values);
|
|
}
|
|
util.inherits(PropertiesPromiseArray, PromiseArray);
|
|
|
|
PropertiesPromiseArray.prototype._init = function () {
|
|
this._init$(undefined, -3) ;
|
|
};
|
|
|
|
PropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {
|
|
this._values[index] = value;
|
|
var totalResolved = ++this._totalResolved;
|
|
if (totalResolved >= this._length) {
|
|
var val = {};
|
|
var keyOffset = this.length();
|
|
for (var i = 0, len = this.length(); i < len; ++i) {
|
|
val[this._values[i + keyOffset]] = this._values[i];
|
|
}
|
|
this._resolve(val);
|
|
}
|
|
};
|
|
|
|
PropertiesPromiseArray.prototype._promiseProgressed = function (value, index) {
|
|
this._promise._progress({
|
|
key: this._values[index + this.length()],
|
|
value: value
|
|
});
|
|
};
|
|
|
|
PropertiesPromiseArray.prototype.shouldCopyValues = function () {
|
|
return false;
|
|
};
|
|
|
|
PropertiesPromiseArray.prototype.getActualLength = function (len) {
|
|
return len >> 1;
|
|
};
|
|
|
|
function props(promises) {
|
|
var ret;
|
|
var castValue = tryConvertToPromise(promises);
|
|
|
|
if (!isObject(castValue)) {
|
|
return apiRejection("cannot await properties of a non-object\u000a\u000a See http://goo.gl/OsFKC8\u000a");
|
|
} else if (castValue instanceof Promise) {
|
|
ret = castValue._then(
|
|
Promise.props, undefined, undefined, undefined, undefined);
|
|
} else {
|
|
ret = new PropertiesPromiseArray(castValue).promise();
|
|
}
|
|
|
|
if (castValue instanceof Promise) {
|
|
ret._propagateFrom(castValue, 4);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Promise.prototype.props = function () {
|
|
return props(this);
|
|
};
|
|
|
|
Promise.props = function (promises) {
|
|
return props(promises);
|
|
};
|
|
};
|
|
|
|
},{"./es5.js":14,"./util.js":38}],28:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
function arrayMove(src, srcIndex, dst, dstIndex, len) {
|
|
for (var j = 0; j < len; ++j) {
|
|
dst[j + dstIndex] = src[j + srcIndex];
|
|
src[j + srcIndex] = void 0;
|
|
}
|
|
}
|
|
|
|
function Queue(capacity) {
|
|
this._capacity = capacity;
|
|
this._length = 0;
|
|
this._front = 0;
|
|
}
|
|
|
|
Queue.prototype._willBeOverCapacity = function (size) {
|
|
return this._capacity < size;
|
|
};
|
|
|
|
Queue.prototype._pushOne = function (arg) {
|
|
var length = this.length();
|
|
this._checkCapacity(length + 1);
|
|
var i = (this._front + length) & (this._capacity - 1);
|
|
this[i] = arg;
|
|
this._length = length + 1;
|
|
};
|
|
|
|
Queue.prototype._unshiftOne = function(value) {
|
|
var capacity = this._capacity;
|
|
this._checkCapacity(this.length() + 1);
|
|
var front = this._front;
|
|
var i = (((( front - 1 ) &
|
|
( capacity - 1) ) ^ capacity ) - capacity );
|
|
this[i] = value;
|
|
this._front = i;
|
|
this._length = this.length() + 1;
|
|
};
|
|
|
|
Queue.prototype.unshift = function(fn, receiver, arg) {
|
|
this._unshiftOne(arg);
|
|
this._unshiftOne(receiver);
|
|
this._unshiftOne(fn);
|
|
};
|
|
|
|
Queue.prototype.push = function (fn, receiver, arg) {
|
|
var length = this.length() + 3;
|
|
if (this._willBeOverCapacity(length)) {
|
|
this._pushOne(fn);
|
|
this._pushOne(receiver);
|
|
this._pushOne(arg);
|
|
return;
|
|
}
|
|
var j = this._front + length - 3;
|
|
this._checkCapacity(length);
|
|
var wrapMask = this._capacity - 1;
|
|
this[(j + 0) & wrapMask] = fn;
|
|
this[(j + 1) & wrapMask] = receiver;
|
|
this[(j + 2) & wrapMask] = arg;
|
|
this._length = length;
|
|
};
|
|
|
|
Queue.prototype.shift = function () {
|
|
var front = this._front,
|
|
ret = this[front];
|
|
|
|
this[front] = undefined;
|
|
this._front = (front + 1) & (this._capacity - 1);
|
|
this._length--;
|
|
return ret;
|
|
};
|
|
|
|
Queue.prototype.length = function () {
|
|
return this._length;
|
|
};
|
|
|
|
Queue.prototype._checkCapacity = function (size) {
|
|
if (this._capacity < size) {
|
|
this._resizeTo(this._capacity << 1);
|
|
}
|
|
};
|
|
|
|
Queue.prototype._resizeTo = function (capacity) {
|
|
var oldCapacity = this._capacity;
|
|
this._capacity = capacity;
|
|
var front = this._front;
|
|
var length = this._length;
|
|
var moveItemsCount = (front + length) & (oldCapacity - 1);
|
|
arrayMove(this, 0, this, oldCapacity, moveItemsCount);
|
|
};
|
|
|
|
module.exports = Queue;
|
|
|
|
},{}],29:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(
|
|
Promise, INTERNAL, tryConvertToPromise, apiRejection) {
|
|
var isArray = _dereq_("./util.js").isArray;
|
|
|
|
var raceLater = function (promise) {
|
|
return promise.then(function(array) {
|
|
return race(array, promise);
|
|
});
|
|
};
|
|
|
|
function race(promises, parent) {
|
|
var maybePromise = tryConvertToPromise(promises);
|
|
|
|
if (maybePromise instanceof Promise) {
|
|
return raceLater(maybePromise);
|
|
} else if (!isArray(promises)) {
|
|
return apiRejection("expecting an array, a promise or a thenable\u000a\u000a See http://goo.gl/s8MMhc\u000a");
|
|
}
|
|
|
|
var ret = new Promise(INTERNAL);
|
|
if (parent !== undefined) {
|
|
ret._propagateFrom(parent, 4 | 1);
|
|
}
|
|
var fulfill = ret._fulfill;
|
|
var reject = ret._reject;
|
|
for (var i = 0, len = promises.length; i < len; ++i) {
|
|
var val = promises[i];
|
|
|
|
if (val === undefined && !(i in promises)) {
|
|
continue;
|
|
}
|
|
|
|
Promise.cast(val)._then(fulfill, reject, undefined, ret, null);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Promise.race = function (promises) {
|
|
return race(promises, undefined);
|
|
};
|
|
|
|
Promise.prototype.race = function () {
|
|
return race(this, undefined);
|
|
};
|
|
|
|
};
|
|
|
|
},{"./util.js":38}],30:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise,
|
|
PromiseArray,
|
|
apiRejection,
|
|
tryConvertToPromise,
|
|
INTERNAL) {
|
|
var util = _dereq_("./util.js");
|
|
var tryCatch = util.tryCatch;
|
|
var errorObj = util.errorObj;
|
|
function ReductionPromiseArray(promises, fn, accum, _each) {
|
|
this.constructor$(promises);
|
|
this._promise._captureStackTrace();
|
|
this._preservedValues = _each === INTERNAL ? [] : null;
|
|
this._zerothIsAccum = (accum === undefined);
|
|
this._gotAccum = false;
|
|
this._reducingIndex = (this._zerothIsAccum ? 1 : 0);
|
|
this._valuesPhase = undefined;
|
|
var maybePromise = tryConvertToPromise(accum, this._promise);
|
|
var rejected = false;
|
|
var isPromise = maybePromise instanceof Promise;
|
|
if (isPromise) {
|
|
maybePromise = maybePromise._target();
|
|
if (maybePromise._isPending()) {
|
|
maybePromise._proxyPromiseArray(this, -1);
|
|
} else if (maybePromise._isFulfilled()) {
|
|
accum = maybePromise._value();
|
|
this._gotAccum = true;
|
|
} else {
|
|
this._reject(maybePromise._reason());
|
|
rejected = true;
|
|
}
|
|
}
|
|
if (!(isPromise || this._zerothIsAccum)) this._gotAccum = true;
|
|
this._callback = fn;
|
|
this._accum = accum;
|
|
if (!rejected) this._init$(undefined, -5);
|
|
}
|
|
util.inherits(ReductionPromiseArray, PromiseArray);
|
|
|
|
ReductionPromiseArray.prototype._init = function () {};
|
|
|
|
ReductionPromiseArray.prototype._resolveEmptyArray = function () {
|
|
if (this._gotAccum || this._zerothIsAccum) {
|
|
this._resolve(this._preservedValues !== null
|
|
? [] : this._accum);
|
|
}
|
|
};
|
|
|
|
ReductionPromiseArray.prototype._promiseFulfilled = function (value, index) {
|
|
var values = this._values;
|
|
values[index] = value;
|
|
var length = this.length();
|
|
var preservedValues = this._preservedValues;
|
|
var isEach = preservedValues !== null;
|
|
var gotAccum = this._gotAccum;
|
|
var valuesPhase = this._valuesPhase;
|
|
var valuesPhaseIndex;
|
|
if (!valuesPhase) {
|
|
valuesPhase = this._valuesPhase = new Array(length);
|
|
for (valuesPhaseIndex=0; valuesPhaseIndex<length; ++valuesPhaseIndex) {
|
|
valuesPhase[valuesPhaseIndex] = 0;
|
|
}
|
|
}
|
|
valuesPhaseIndex = valuesPhase[index];
|
|
|
|
if (index === 0 && this._zerothIsAccum) {
|
|
this._accum = value;
|
|
this._gotAccum = gotAccum = true;
|
|
valuesPhase[index] = ((valuesPhaseIndex === 0)
|
|
? 1 : 2);
|
|
} else if (index === -1) {
|
|
this._accum = value;
|
|
this._gotAccum = gotAccum = true;
|
|
} else {
|
|
if (valuesPhaseIndex === 0) {
|
|
valuesPhase[index] = 1;
|
|
} else {
|
|
valuesPhase[index] = 2;
|
|
this._accum = value;
|
|
}
|
|
}
|
|
if (!gotAccum) return;
|
|
|
|
var callback = this._callback;
|
|
var receiver = this._promise._boundTo;
|
|
var ret;
|
|
|
|
for (var i = this._reducingIndex; i < length; ++i) {
|
|
valuesPhaseIndex = valuesPhase[i];
|
|
if (valuesPhaseIndex === 2) {
|
|
this._reducingIndex = i + 1;
|
|
continue;
|
|
}
|
|
if (valuesPhaseIndex !== 1) return;
|
|
value = values[i];
|
|
this._promise._pushContext();
|
|
if (isEach) {
|
|
preservedValues.push(value);
|
|
ret = tryCatch(callback).call(receiver, value, i, length);
|
|
}
|
|
else {
|
|
ret = tryCatch(callback)
|
|
.call(receiver, this._accum, value, i, length);
|
|
}
|
|
this._promise._popContext();
|
|
|
|
if (ret === errorObj) return this._reject(ret.e);
|
|
|
|
var maybePromise = tryConvertToPromise(ret, this._promise);
|
|
if (maybePromise instanceof Promise) {
|
|
maybePromise = maybePromise._target();
|
|
if (maybePromise._isPending()) {
|
|
valuesPhase[i] = 4;
|
|
return maybePromise._proxyPromiseArray(this, i);
|
|
} else if (maybePromise._isFulfilled()) {
|
|
ret = maybePromise._value();
|
|
} else {
|
|
return this._reject(maybePromise._reason());
|
|
}
|
|
}
|
|
|
|
this._reducingIndex = i + 1;
|
|
this._accum = ret;
|
|
}
|
|
|
|
this._resolve(isEach ? preservedValues : this._accum);
|
|
};
|
|
|
|
function reduce(promises, fn, initialValue, _each) {
|
|
if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
|
|
return array.promise();
|
|
}
|
|
|
|
Promise.prototype.reduce = function (fn, initialValue) {
|
|
return reduce(this, fn, initialValue, null);
|
|
};
|
|
|
|
Promise.reduce = function (promises, fn, initialValue, _each) {
|
|
return reduce(promises, fn, initialValue, _each);
|
|
};
|
|
};
|
|
|
|
},{"./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") {
|
|
schedule = function(fn) {
|
|
var div = document.createElement("div");
|
|
var observer = new MutationObserver(fn);
|
|
observer.observe(div, {attributes: true});
|
|
return function() { div.classList.toggle("foo"); };
|
|
};
|
|
schedule.isStatic = true;
|
|
}
|
|
else if (typeof setTimeout !== "undefined") {
|
|
schedule = function (fn) {
|
|
setTimeout(fn, 0);
|
|
};
|
|
}
|
|
else {
|
|
schedule = function() {
|
|
throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/m3OTXk\u000a");
|
|
};
|
|
}
|
|
module.exports = schedule;
|
|
|
|
},{"./util.js":38}],32:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports =
|
|
function(Promise, PromiseArray) {
|
|
var PromiseInspection = Promise.PromiseInspection;
|
|
var util = _dereq_("./util.js");
|
|
|
|
function SettledPromiseArray(values) {
|
|
this.constructor$(values);
|
|
this._promise._setIsSpreadable();
|
|
}
|
|
util.inherits(SettledPromiseArray, PromiseArray);
|
|
|
|
SettledPromiseArray.prototype._promiseResolved = function (index, inspection) {
|
|
this._values[index] = inspection;
|
|
var totalResolved = ++this._totalResolved;
|
|
if (totalResolved >= this._length) {
|
|
this._resolve(this._values);
|
|
}
|
|
};
|
|
|
|
SettledPromiseArray.prototype._promiseFulfilled = function (value, index) {
|
|
var ret = new PromiseInspection();
|
|
ret._bitField = 268435456;
|
|
ret._settledValue = value;
|
|
this._promiseResolved(index, ret);
|
|
};
|
|
SettledPromiseArray.prototype._promiseRejected = function (reason, index) {
|
|
var ret = new PromiseInspection();
|
|
ret._bitField = 134217728;
|
|
ret._settledValue = reason;
|
|
this._promiseResolved(index, ret);
|
|
};
|
|
|
|
Promise.settle = function (promises) {
|
|
return new SettledPromiseArray(promises).promise();
|
|
};
|
|
|
|
Promise.prototype.settle = function () {
|
|
return new SettledPromiseArray(this).promise();
|
|
};
|
|
};
|
|
|
|
},{"./util.js":38}],33:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports =
|
|
function(Promise, PromiseArray, apiRejection) {
|
|
var util = _dereq_("./util.js");
|
|
var RangeError = _dereq_("./errors.js").RangeError;
|
|
var AggregateError = _dereq_("./errors.js").AggregateError;
|
|
var isArray = util.isArray;
|
|
|
|
|
|
function SomePromiseArray(values) {
|
|
this.constructor$(values);
|
|
this._howMany = 0;
|
|
this._unwrap = false;
|
|
this._initialized = false;
|
|
}
|
|
util.inherits(SomePromiseArray, PromiseArray);
|
|
|
|
SomePromiseArray.prototype._init = function () {
|
|
if (!this._initialized) {
|
|
return;
|
|
}
|
|
this._promise._setIsSpreadable();
|
|
if (this._howMany === 0) {
|
|
this._resolve([]);
|
|
return;
|
|
}
|
|
this._init$(undefined, -5);
|
|
var isArrayResolved = isArray(this._values);
|
|
if (!this._isResolved() &&
|
|
isArrayResolved &&
|
|
this._howMany > this._canPossiblyFulfill()) {
|
|
this._reject(this._getRangeError(this.length()));
|
|
}
|
|
};
|
|
|
|
SomePromiseArray.prototype.init = function () {
|
|
this._initialized = true;
|
|
this._init();
|
|
};
|
|
|
|
SomePromiseArray.prototype.setUnwrap = function () {
|
|
this._unwrap = true;
|
|
};
|
|
|
|
SomePromiseArray.prototype.howMany = function () {
|
|
return this._howMany;
|
|
};
|
|
|
|
SomePromiseArray.prototype.setHowMany = function (count) {
|
|
this._howMany = count;
|
|
};
|
|
|
|
SomePromiseArray.prototype._promiseFulfilled = function (value) {
|
|
this._addFulfilled(value);
|
|
if (this._fulfilled() === this.howMany()) {
|
|
this._values.length = this.howMany();
|
|
if (this.howMany() === 1 && this._unwrap) {
|
|
this._resolve(this._values[0]);
|
|
} else {
|
|
this._resolve(this._values);
|
|
}
|
|
}
|
|
|
|
};
|
|
SomePromiseArray.prototype._promiseRejected = function (reason) {
|
|
this._addRejected(reason);
|
|
if (this.howMany() > this._canPossiblyFulfill()) {
|
|
var e = new AggregateError();
|
|
for (var i = this.length(); i < this._values.length; ++i) {
|
|
e.push(this._values[i]);
|
|
}
|
|
this._reject(e);
|
|
}
|
|
};
|
|
|
|
SomePromiseArray.prototype._fulfilled = function () {
|
|
return this._totalResolved;
|
|
};
|
|
|
|
SomePromiseArray.prototype._rejected = function () {
|
|
return this._values.length - this.length();
|
|
};
|
|
|
|
SomePromiseArray.prototype._addRejected = function (reason) {
|
|
this._values.push(reason);
|
|
};
|
|
|
|
SomePromiseArray.prototype._addFulfilled = function (value) {
|
|
this._values[this._totalResolved++] = value;
|
|
};
|
|
|
|
SomePromiseArray.prototype._canPossiblyFulfill = function () {
|
|
return this.length() - this._rejected();
|
|
};
|
|
|
|
SomePromiseArray.prototype._getRangeError = function (count) {
|
|
var message = "Input array must contain at least " +
|
|
this._howMany + " items but contains only " + count + " items";
|
|
return new RangeError(message);
|
|
};
|
|
|
|
SomePromiseArray.prototype._resolveEmptyArray = function () {
|
|
this._reject(this._getRangeError(0));
|
|
};
|
|
|
|
function some(promises, howMany) {
|
|
if ((howMany | 0) !== howMany || howMany < 0) {
|
|
return apiRejection("expecting a positive integer\u000a\u000a See http://goo.gl/1wAmHx\u000a");
|
|
}
|
|
var ret = new SomePromiseArray(promises);
|
|
var promise = ret.promise();
|
|
ret.setHowMany(howMany);
|
|
ret.init();
|
|
return promise;
|
|
}
|
|
|
|
Promise.some = function (promises, howMany) {
|
|
return some(promises, howMany);
|
|
};
|
|
|
|
Promise.prototype.some = function (howMany) {
|
|
return some(this, howMany);
|
|
};
|
|
|
|
Promise._SomePromiseArray = SomePromiseArray;
|
|
};
|
|
|
|
},{"./errors.js":13,"./util.js":38}],34:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise) {
|
|
function PromiseInspection(promise) {
|
|
if (promise !== undefined) {
|
|
promise = promise._target();
|
|
this._bitField = promise._bitField;
|
|
this._settledValue = promise._settledValue;
|
|
}
|
|
else {
|
|
this._bitField = 0;
|
|
this._settledValue = undefined;
|
|
}
|
|
}
|
|
|
|
PromiseInspection.prototype.value = function () {
|
|
if (!this.isFulfilled()) {
|
|
throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a See http://goo.gl/hc1DLj\u000a");
|
|
}
|
|
return this._settledValue;
|
|
};
|
|
|
|
PromiseInspection.prototype.error =
|
|
PromiseInspection.prototype.reason = function () {
|
|
if (!this.isRejected()) {
|
|
throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a See http://goo.gl/hPuiwB\u000a");
|
|
}
|
|
return this._settledValue;
|
|
};
|
|
|
|
PromiseInspection.prototype.isFulfilled =
|
|
Promise.prototype._isFulfilled = function () {
|
|
return (this._bitField & 268435456) > 0;
|
|
};
|
|
|
|
PromiseInspection.prototype.isRejected =
|
|
Promise.prototype._isRejected = function () {
|
|
return (this._bitField & 134217728) > 0;
|
|
};
|
|
|
|
PromiseInspection.prototype.isPending =
|
|
Promise.prototype._isPending = function () {
|
|
return (this._bitField & 402653184) === 0;
|
|
};
|
|
|
|
PromiseInspection.prototype.isResolved =
|
|
Promise.prototype._isResolved = function () {
|
|
return (this._bitField & 402653184) > 0;
|
|
};
|
|
|
|
Promise.prototype.isPending = function() {
|
|
return this._target()._isPending();
|
|
};
|
|
|
|
Promise.prototype.isRejected = function() {
|
|
return this._target()._isRejected();
|
|
};
|
|
|
|
Promise.prototype.isFulfilled = function() {
|
|
return this._target()._isFulfilled();
|
|
};
|
|
|
|
Promise.prototype.isResolved = function() {
|
|
return this._target()._isResolved();
|
|
};
|
|
|
|
Promise.prototype._value = function() {
|
|
return this._settledValue;
|
|
};
|
|
|
|
Promise.prototype._reason = function() {
|
|
this._unsetRejectionIsUnhandled();
|
|
return this._settledValue;
|
|
};
|
|
|
|
Promise.prototype.value = function() {
|
|
var target = this._target();
|
|
if (!target.isFulfilled()) {
|
|
throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a See http://goo.gl/hc1DLj\u000a");
|
|
}
|
|
return target._settledValue;
|
|
};
|
|
|
|
Promise.prototype.reason = function() {
|
|
var target = this._target();
|
|
if (!target.isRejected()) {
|
|
throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a See http://goo.gl/hPuiwB\u000a");
|
|
}
|
|
target._unsetRejectionIsUnhandled();
|
|
return target._settledValue;
|
|
};
|
|
|
|
|
|
Promise.PromiseInspection = PromiseInspection;
|
|
};
|
|
|
|
},{}],35:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL) {
|
|
var util = _dereq_("./util.js");
|
|
var errorObj = util.errorObj;
|
|
var isObject = util.isObject;
|
|
|
|
function tryConvertToPromise(obj, context) {
|
|
if (isObject(obj)) {
|
|
if (obj instanceof Promise) {
|
|
return obj;
|
|
}
|
|
else if (isAnyBluebirdPromise(obj)) {
|
|
var ret = new Promise(INTERNAL);
|
|
obj._then(
|
|
ret._fulfillUnchecked,
|
|
ret._rejectUncheckedCheckError,
|
|
ret._progressUnchecked,
|
|
ret,
|
|
null
|
|
);
|
|
return ret;
|
|
}
|
|
var then = util.tryCatch(getThen)(obj);
|
|
if (then === errorObj) {
|
|
if (context) context._pushContext();
|
|
var ret = Promise.reject(then.e);
|
|
if (context) context._popContext();
|
|
return ret;
|
|
} else if (typeof then === "function") {
|
|
return doThenable(obj, then, context);
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
function getThen(obj) {
|
|
return obj.then;
|
|
}
|
|
|
|
var hasProp = {}.hasOwnProperty;
|
|
function isAnyBluebirdPromise(obj) {
|
|
return hasProp.call(obj, "_promise0");
|
|
}
|
|
|
|
function doThenable(x, then, context) {
|
|
var promise = new Promise(INTERNAL);
|
|
var ret = promise;
|
|
if (context) context._pushContext();
|
|
promise._captureStackTrace();
|
|
if (context) context._popContext();
|
|
var synchronous = true;
|
|
var result = util.tryCatch(then).call(x,
|
|
resolveFromThenable,
|
|
rejectFromThenable,
|
|
progressFromThenable);
|
|
synchronous = false;
|
|
if (promise && result === errorObj) {
|
|
promise._rejectCallback(result.e, true, true);
|
|
promise = null;
|
|
}
|
|
|
|
function resolveFromThenable(value) {
|
|
if (!promise) return;
|
|
if (x === value) {
|
|
promise._rejectCallback(
|
|
Promise._makeSelfResolutionError(), false, true);
|
|
} else {
|
|
promise._resolveCallback(value);
|
|
}
|
|
promise = null;
|
|
}
|
|
|
|
function rejectFromThenable(reason) {
|
|
if (!promise) return;
|
|
promise._rejectCallback(reason, synchronous, true);
|
|
promise = null;
|
|
}
|
|
|
|
function progressFromThenable(value) {
|
|
if (!promise) return;
|
|
if (typeof promise._progress === "function") {
|
|
promise._progress(value);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
return tryConvertToPromise;
|
|
};
|
|
|
|
},{"./util.js":38}],36:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function(Promise, INTERNAL) {
|
|
var util = _dereq_("./util.js");
|
|
var TimeoutError = Promise.TimeoutError;
|
|
|
|
var afterTimeout = function (promise, message) {
|
|
if (!promise.isPending()) return;
|
|
if (typeof message !== "string") {
|
|
message = "operation timed out";
|
|
}
|
|
var err = new TimeoutError(message);
|
|
util.markAsOriginatingFromRejection(err);
|
|
promise._attachExtraTrace(err);
|
|
promise._cancel(err);
|
|
};
|
|
|
|
var afterValue = function(value) { return delay(+this).thenReturn(value); };
|
|
var delay = Promise.delay = function (value, ms) {
|
|
if (ms === undefined) {
|
|
ms = value;
|
|
value = undefined;
|
|
var ret = new Promise(INTERNAL);
|
|
setTimeout(function() { ret._fulfill(); }, ms);
|
|
return ret;
|
|
}
|
|
ms = +ms;
|
|
return Promise.resolve(value)._then(afterValue, null, null, ms, undefined);
|
|
};
|
|
|
|
Promise.prototype.delay = function (ms) {
|
|
return delay(this, ms);
|
|
};
|
|
|
|
function successClear(value) {
|
|
var handle = this;
|
|
if (handle instanceof Number) handle = +handle;
|
|
clearTimeout(handle);
|
|
return value;
|
|
}
|
|
|
|
function failureClear(reason) {
|
|
var handle = this;
|
|
if (handle instanceof Number) handle = +handle;
|
|
clearTimeout(handle);
|
|
throw reason;
|
|
}
|
|
|
|
Promise.prototype.timeout = function (ms, message) {
|
|
ms = +ms;
|
|
var ret = this.then().cancellable();
|
|
ret._cancellationParent = this;
|
|
var handle = setTimeout(function timeoutTimeout() {
|
|
afterTimeout(ret, message);
|
|
}, ms);
|
|
return ret._then(successClear, failureClear, undefined, handle, undefined);
|
|
};
|
|
|
|
};
|
|
|
|
},{"./util.js":38}],37:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
module.exports = function (Promise, apiRejection, tryConvertToPromise,
|
|
createContext) {
|
|
var TypeError = _dereq_("./errors.js").TypeError;
|
|
var inherits = _dereq_("./util.js").inherits;
|
|
var PromiseInspection = Promise.PromiseInspection;
|
|
|
|
function inspectionMapper(inspections) {
|
|
var len = inspections.length;
|
|
for (var i = 0; i < len; ++i) {
|
|
var inspection = inspections[i];
|
|
if (inspection.isRejected()) {
|
|
return Promise.reject(inspection.error());
|
|
}
|
|
inspections[i] = inspection._settledValue;
|
|
}
|
|
return inspections;
|
|
}
|
|
|
|
function thrower(e) {
|
|
setTimeout(function(){throw e;}, 0);
|
|
}
|
|
|
|
function castPreservingDisposable(thenable) {
|
|
var maybePromise = tryConvertToPromise(thenable);
|
|
if (maybePromise !== thenable &&
|
|
typeof thenable._isDisposable === "function" &&
|
|
typeof thenable._getDisposer === "function" &&
|
|
thenable._isDisposable()) {
|
|
maybePromise._setDisposable(thenable._getDisposer());
|
|
}
|
|
return maybePromise;
|
|
}
|
|
function dispose(resources, inspection) {
|
|
var i = 0;
|
|
var len = resources.length;
|
|
var ret = Promise.defer();
|
|
function iterator() {
|
|
if (i >= len) return ret.resolve();
|
|
var maybePromise = castPreservingDisposable(resources[i++]);
|
|
if (maybePromise instanceof Promise &&
|
|
maybePromise._isDisposable()) {
|
|
try {
|
|
maybePromise = tryConvertToPromise(
|
|
maybePromise._getDisposer().tryDispose(inspection),
|
|
resources.promise);
|
|
} catch (e) {
|
|
return thrower(e);
|
|
}
|
|
if (maybePromise instanceof Promise) {
|
|
return maybePromise._then(iterator, thrower,
|
|
null, null, null);
|
|
}
|
|
}
|
|
iterator();
|
|
}
|
|
iterator();
|
|
return ret.promise;
|
|
}
|
|
|
|
function disposerSuccess(value) {
|
|
var inspection = new PromiseInspection();
|
|
inspection._settledValue = value;
|
|
inspection._bitField = 268435456;
|
|
return dispose(this, inspection).thenReturn(value);
|
|
}
|
|
|
|
function disposerFail(reason) {
|
|
var inspection = new PromiseInspection();
|
|
inspection._settledValue = reason;
|
|
inspection._bitField = 134217728;
|
|
return dispose(this, inspection).thenThrow(reason);
|
|
}
|
|
|
|
function Disposer(data, promise, context) {
|
|
this._data = data;
|
|
this._promise = promise;
|
|
this._context = context;
|
|
}
|
|
|
|
Disposer.prototype.data = function () {
|
|
return this._data;
|
|
};
|
|
|
|
Disposer.prototype.promise = function () {
|
|
return this._promise;
|
|
};
|
|
|
|
Disposer.prototype.resource = function () {
|
|
if (this.promise().isFulfilled()) {
|
|
return this.promise().value();
|
|
}
|
|
return null;
|
|
};
|
|
|
|
Disposer.prototype.tryDispose = function(inspection) {
|
|
var resource = this.resource();
|
|
var context = this._context;
|
|
if (context !== undefined) context._pushContext();
|
|
var ret = resource !== null
|
|
? this.doDispose(resource, inspection) : null;
|
|
if (context !== undefined) context._popContext();
|
|
this._promise._unsetDisposable();
|
|
this._data = null;
|
|
return ret;
|
|
};
|
|
|
|
Disposer.isDisposer = function (d) {
|
|
return (d != null &&
|
|
typeof d.resource === "function" &&
|
|
typeof d.tryDispose === "function");
|
|
};
|
|
|
|
function FunctionDisposer(fn, promise, context) {
|
|
this.constructor$(fn, promise, context);
|
|
}
|
|
inherits(FunctionDisposer, Disposer);
|
|
|
|
FunctionDisposer.prototype.doDispose = function (resource, inspection) {
|
|
var fn = this.data();
|
|
return fn.call(resource, resource, inspection);
|
|
};
|
|
|
|
function maybeUnwrapDisposer(value) {
|
|
if (Disposer.isDisposer(value)) {
|
|
this.resources[this.index]._setDisposable(value);
|
|
return value.promise();
|
|
}
|
|
return value;
|
|
}
|
|
|
|
Promise.using = function () {
|
|
var len = arguments.length;
|
|
if (len < 2) return apiRejection(
|
|
"you must pass at least 2 arguments to Promise.using");
|
|
var fn = arguments[len - 1];
|
|
if (typeof fn !== "function") return apiRejection("fn must be a function\u000a\u000a See http://goo.gl/916lJJ\u000a");
|
|
len--;
|
|
var resources = new Array(len);
|
|
for (var i = 0; i < len; ++i) {
|
|
var resource = arguments[i];
|
|
if (Disposer.isDisposer(resource)) {
|
|
var disposer = resource;
|
|
resource = resource.promise();
|
|
resource._setDisposable(disposer);
|
|
} else {
|
|
var maybePromise = tryConvertToPromise(resource);
|
|
if (maybePromise instanceof Promise) {
|
|
resource =
|
|
maybePromise._then(maybeUnwrapDisposer, null, null, {
|
|
resources: resources,
|
|
index: i
|
|
}, undefined);
|
|
}
|
|
}
|
|
resources[i] = resource;
|
|
}
|
|
|
|
var promise = Promise.settle(resources)
|
|
.then(inspectionMapper)
|
|
.then(function(vals) {
|
|
promise._pushContext();
|
|
var ret;
|
|
try {
|
|
ret = fn.apply(undefined, vals);
|
|
} finally {
|
|
promise._popContext();
|
|
}
|
|
return ret;
|
|
})
|
|
._then(
|
|
disposerSuccess, disposerFail, undefined, resources, undefined);
|
|
resources.promise = promise;
|
|
return promise;
|
|
};
|
|
|
|
Promise.prototype._setDisposable = function (disposer) {
|
|
this._bitField = this._bitField | 262144;
|
|
this._disposer = disposer;
|
|
};
|
|
|
|
Promise.prototype._isDisposable = function () {
|
|
return (this._bitField & 262144) > 0;
|
|
};
|
|
|
|
Promise.prototype._getDisposer = function () {
|
|
return this._disposer;
|
|
};
|
|
|
|
Promise.prototype._unsetDisposable = function () {
|
|
this._bitField = this._bitField & (~262144);
|
|
this._disposer = undefined;
|
|
};
|
|
|
|
Promise.prototype.disposer = function (fn) {
|
|
if (typeof fn === "function") {
|
|
return new FunctionDisposer(fn, this, createContext());
|
|
}
|
|
throw new TypeError();
|
|
};
|
|
|
|
};
|
|
|
|
},{"./errors.js":13,"./util.js":38}],38:[function(_dereq_,module,exports){
|
|
"use strict";
|
|
var es5 = _dereq_("./es5.js");
|
|
var canEvaluate = typeof navigator == "undefined";
|
|
var haveGetters = (function(){
|
|
try {
|
|
var o = {};
|
|
es5.defineProperty(o, "f", {
|
|
get: function () {
|
|
return 3;
|
|
}
|
|
});
|
|
return o.f === 3;
|
|
}
|
|
catch (e) {
|
|
return false;
|
|
}
|
|
|
|
})();
|
|
|
|
var errorObj = {e: {}};
|
|
var tryCatchTarget;
|
|
function tryCatcher() {
|
|
try {
|
|
return tryCatchTarget.apply(this, arguments);
|
|
} catch (e) {
|
|
errorObj.e = e;
|
|
return errorObj;
|
|
}
|
|
}
|
|
function tryCatch(fn) {
|
|
tryCatchTarget = fn;
|
|
return tryCatcher;
|
|
}
|
|
|
|
var inherits = function(Child, Parent) {
|
|
var hasProp = {}.hasOwnProperty;
|
|
|
|
function T() {
|
|
this.constructor = Child;
|
|
this.constructor$ = Parent;
|
|
for (var propertyName in Parent.prototype) {
|
|
if (hasProp.call(Parent.prototype, propertyName) &&
|
|
propertyName.charAt(propertyName.length-1) !== "$"
|
|
) {
|
|
this[propertyName + "$"] = Parent.prototype[propertyName];
|
|
}
|
|
}
|
|
}
|
|
T.prototype = Parent.prototype;
|
|
Child.prototype = new T();
|
|
return Child.prototype;
|
|
};
|
|
|
|
function asString(val) {
|
|
return typeof val === "string" ? val : ("" + val);
|
|
}
|
|
|
|
function isPrimitive(val) {
|
|
return val == null || val === true || val === false ||
|
|
typeof val === "string" || typeof val === "number";
|
|
|
|
}
|
|
|
|
function isObject(value) {
|
|
return !isPrimitive(value);
|
|
}
|
|
|
|
function maybeWrapAsError(maybeError) {
|
|
if (!isPrimitive(maybeError)) return maybeError;
|
|
|
|
return new Error(asString(maybeError));
|
|
}
|
|
|
|
function withAppended(target, appendee) {
|
|
var len = target.length;
|
|
var ret = new Array(len + 1);
|
|
var i;
|
|
for (i = 0; i < len; ++i) {
|
|
ret[i] = target[i];
|
|
}
|
|
ret[i] = appendee;
|
|
return ret;
|
|
}
|
|
|
|
function getDataPropertyOrDefault(obj, key, defaultValue) {
|
|
if (es5.isES5) {
|
|
var desc = Object.getOwnPropertyDescriptor(obj, key);
|
|
if (desc != null) {
|
|
return desc.get == null && desc.set == null
|
|
? desc.value
|
|
: defaultValue;
|
|
}
|
|
} else {
|
|
return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
|
|
}
|
|
}
|
|
|
|
function notEnumerableProp(obj, name, value) {
|
|
if (isPrimitive(obj)) return obj;
|
|
var descriptor = {
|
|
value: value,
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable: true
|
|
};
|
|
es5.defineProperty(obj, name, descriptor);
|
|
return obj;
|
|
}
|
|
|
|
|
|
var wrapsPrimitiveReceiver = (function() {
|
|
return this !== "string";
|
|
}).call("string");
|
|
|
|
function thrower(r) {
|
|
throw r;
|
|
}
|
|
|
|
var inheritedDataKeys = (function() {
|
|
if (es5.isES5) {
|
|
return function(obj, opts) {
|
|
var ret = [];
|
|
var visitedKeys = Object.create(null);
|
|
var getKeys = Object(opts).includeHidden
|
|
? Object.getOwnPropertyNames
|
|
: Object.keys;
|
|
while (obj != null) {
|
|
var keys;
|
|
try {
|
|
keys = getKeys(obj);
|
|
} catch (e) {
|
|
return ret;
|
|
}
|
|
for (var i = 0; i < keys.length; ++i) {
|
|
var key = keys[i];
|
|
if (visitedKeys[key]) continue;
|
|
visitedKeys[key] = true;
|
|
var desc = Object.getOwnPropertyDescriptor(obj, key);
|
|
if (desc != null && desc.get == null && desc.set == null) {
|
|
ret.push(key);
|
|
}
|
|
}
|
|
obj = es5.getPrototypeOf(obj);
|
|
}
|
|
return ret;
|
|
};
|
|
} else {
|
|
return function(obj) {
|
|
var ret = [];
|
|
/*jshint forin:false */
|
|
for (var key in obj) {
|
|
ret.push(key);
|
|
}
|
|
return ret;
|
|
};
|
|
}
|
|
|
|
})();
|
|
|
|
function isClass(fn) {
|
|
try {
|
|
if (typeof fn === "function") {
|
|
var keys = es5.keys(fn.prototype);
|
|
return keys.length > 0 &&
|
|
!(keys.length === 1 && keys[0] === "constructor");
|
|
}
|
|
return false;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function toFastProperties(obj) {
|
|
/*jshint -W027*/
|
|
function f() {}
|
|
f.prototype = obj;
|
|
return f;
|
|
eval(obj);
|
|
}
|
|
|
|
var rident = /^[a-z$_][a-z$_0-9]*$/i;
|
|
function isIdentifier(str) {
|
|
return rident.test(str);
|
|
}
|
|
|
|
function filledRange(count, prefix, suffix) {
|
|
var ret = new Array(count);
|
|
for(var i = 0; i < count; ++i) {
|
|
ret[i] = prefix + i + suffix;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
function safeToString(obj) {
|
|
try {
|
|
return obj + "";
|
|
} catch (e) {
|
|
return "[no string representation]";
|
|
}
|
|
}
|
|
|
|
function markAsOriginatingFromRejection(e) {
|
|
try {
|
|
notEnumerableProp(e, "isOperational", true);
|
|
}
|
|
catch(ignore) {}
|
|
}
|
|
|
|
function originatesFromRejection(e) {
|
|
if (e == null) return false;
|
|
return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
|
|
e["isOperational"] === true);
|
|
}
|
|
|
|
function canAttachTrace(obj) {
|
|
// Added by Zotero
|
|
return obj.message && obj.stack && es5.propertyIsWritable(obj, "stack");
|
|
|
|
return obj instanceof Error && es5.propertyIsWritable(obj, "stack");
|
|
}
|
|
|
|
var ensureErrorObject = (function() {
|
|
if (!("stack" in new Error())) {
|
|
return function(value) {
|
|
if (canAttachTrace(value)) return value;
|
|
try {throw new Error(safeToString(value));}
|
|
catch(err) {return err;}
|
|
};
|
|
} else {
|
|
return function(value) {
|
|
if (canAttachTrace(value)) return value;
|
|
return new Error(safeToString(value));
|
|
};
|
|
}
|
|
})();
|
|
|
|
function classString(obj) {
|
|
return {}.toString.call(obj);
|
|
}
|
|
|
|
var ret = {
|
|
isClass: isClass,
|
|
isIdentifier: isIdentifier,
|
|
inheritedDataKeys: inheritedDataKeys,
|
|
getDataPropertyOrDefault: getDataPropertyOrDefault,
|
|
thrower: thrower,
|
|
isArray: es5.isArray,
|
|
haveGetters: haveGetters,
|
|
notEnumerableProp: notEnumerableProp,
|
|
isPrimitive: isPrimitive,
|
|
isObject: isObject,
|
|
canEvaluate: canEvaluate,
|
|
errorObj: errorObj,
|
|
tryCatch: tryCatch,
|
|
inherits: inherits,
|
|
withAppended: withAppended,
|
|
asString: asString,
|
|
maybeWrapAsError: maybeWrapAsError,
|
|
wrapsPrimitiveReceiver: wrapsPrimitiveReceiver,
|
|
toFastProperties: toFastProperties,
|
|
filledRange: filledRange,
|
|
toString: safeToString,
|
|
canAttachTrace: canAttachTrace,
|
|
ensureErrorObject: ensureErrorObject,
|
|
originatesFromRejection: originatesFromRejection,
|
|
markAsOriginatingFromRejection: markAsOriginatingFromRejection,
|
|
classString: classString,
|
|
isNode: typeof process !== "undefined" &&
|
|
classString(process).toLowerCase() === "[object process]"
|
|
};
|
|
try {throw new Error(); } catch (e) {ret.lastLineError = e;}
|
|
module.exports = ret;
|
|
|
|
},{"./es5.js":14}]},{},[4])(4)
|
|
}); ;if (typeof window !== 'undefined' && window !== null) { window.P = window.Promise; } else if (typeof self !== 'undefined' && self !== null) { self.P = self.Promise; } |