/* @preserve
* The MIT License (MIT) * * Copyright (c) 2013-2015 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: * * 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.11.0 * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, cancel, using, filter, any, each, timers
*/ !function(e){if(“object”==typeof exports&&“undefined”!=typeof module)module.exports=e();else if(“function”==typeof define&&define.amd)define([],e);else{var f;“undefined”!=typeof window?f=window:“undefined”!=typeof global?f=global:“undefined”!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n){if(!t){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={exports:{}};t[0].call(l.exports,function(e){var n=t[1];return s(n?n:e)},l,l.exports,e,t,n,r)}return n.exports}var i=typeof dereq==“function”&&dereq;for(var o=0;o
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 util = dereq(“./util.js”);
function Async() {
this._isTickUsed = false; this._lateQueue = new Queue(16); this._normalQueue = new Queue(16); this._trampolineEnabled = true; var self = this; this.drainQueues = function () { self._drainQueues(); }; this._schedule = schedule.isStatic ? schedule(this.drainQueues) : schedule;
}
Async.prototype.disableTrampolineIfNecessary = function() {
if (util.hasDevTools) { this._trampolineEnabled = false; }
};
Async.prototype.enableTrampoline = function() {
if (!this._trampolineEnabled) { this._trampolineEnabled = true; this._schedule = function(fn) { setTimeout(fn, 0); }; }
};
Async.prototype.haveItemsQueued = function () {
return this._normalQueue.length() > 0;
};
Async.prototype.throwLater = function(fn, arg) {
if (arguments.length === 1) { arg = fn; fn = function () { throw arg; }; } 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"); }
};
function AsyncInvokeLater(fn, receiver, arg) {
this._lateQueue.push(fn, receiver, arg); this._queueTick();
}
function AsyncInvoke(fn, receiver, arg) {
this._normalQueue.push(fn, receiver, arg); this._queueTick();
}
function AsyncSettlePromises(promise) {
this._normalQueue._pushOne(promise); this._queueTick();
}
if (!util.hasDevTools) {
Async.prototype.invokeLater = AsyncInvokeLater; Async.prototype.invoke = AsyncInvoke; Async.prototype.settlePromises = AsyncSettlePromises;
} else {
if (schedule.isStatic) { schedule = function(fn) { setTimeout(fn, 0); }; } Async.prototype.invokeLater = function (fn, receiver, arg) { if (this._trampolineEnabled) { AsyncInvokeLater.call(this, fn, receiver, arg); } else { this._schedule(function() { setTimeout(function() { fn.call(receiver, arg); }, 100); }); } }; Async.prototype.invoke = function (fn, receiver, arg) { if (this._trampolineEnabled) { AsyncInvoke.call(this, fn, receiver, arg); } else { this._schedule(function() { fn.call(receiver, arg); }); } }; Async.prototype.settlePromises = function(promise) { if (this._trampolineEnabled) { AsyncSettlePromises.call(this, promise); } else { this._schedule(function() { promise._settlePromises(); }); } };
}
Async.prototype.invokeFirst = function (fn, receiver, arg) {
this._normalQueue.unshift(fn, receiver, arg); 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,“./util.js”:38}],3:[function(dereq,module,exports){ “use strict”; module.exports = function(Promise, INTERNAL, tryConvertToPromise) { var rejectThis = function(_, e) {
this._reject(e);
};
var targetRejected = function(e, context) {
context.promiseRejectionQueued = true; context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
};
var bindingResolved = function(thisArg, context) {
if (this._isPending()) { this._resolveCallback(context.target); }
};
var bindingRejected = function(e, context) {
if (!context.promiseRejectionQueued) this._reject(e);
};
Promise.prototype.bind = function (thisArg) {
var maybePromise = tryConvertToPromise(thisArg); var ret = new Promise(INTERNAL); ret._propagateFrom(this, 1); var target = this._target(); ret._setBoundTo(maybePromise); if (maybePromise instanceof Promise) { var context = { promiseRejectionQueued: false, promise: ret, target: target, bindingPromise: maybePromise }; target._then(INTERNAL, targetRejected, ret._progress, ret, context); maybePromise._then( bindingResolved, bindingRejected, ret._progress, ret, context); } else { ret._resolveCallback(target); } return ret;
};
Promise.prototype._setBoundTo = function (obj) {
if (obj !== undefined) { this._bitField = this._bitField | 131072; this._boundTo = obj; } else { this._bitField = this._bitField & (~131072); }
};
Promise.prototype._isBound = function () {
return (this._bitField & 131072) === 131072;
};
Promise.bind = function (thisArg, value) {
var maybePromise = tryConvertToPromise(thisArg); var ret = new Promise(INTERNAL); ret._setBoundTo(maybePromise); if (maybePromise instanceof Promise) { maybePromise._then(function() { ret._resolveCallback(value); }, ret._reject, ret._progress, ret, null); } else { ret._resolveCallback(value); } return ret;
}; };
},{}],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; async.enableTrampoline(); this._setCancellable(); this._cancellationParent = undefined; 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; var warn;
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); util.notEnumerableProp(error, "stack", reconstructStack(message, stacks)); util.notEnumerableProp(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 !== "undefined") { 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 warn === "function") { 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, "Unhandled rejection "); }
};
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 && typeof Error.stackTraceLimit === "number") { 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; }; }
})();
if (typeof console !== “undefined” && typeof console.warn !== “undefined”) {
warn = function (message) { console.warn(message); }; if (util.isNode && process.stderr.isTTY) { warn = function(message) { process.stderr.write("\u001b[31m" + message + "\u001b[39m\n"); }; } else if (!util.isNode && typeof (new Error().stack) === "string") { warn = function(message) { console.warn("%c" + message, "color: red"); }; }
}
return CapturedTrace; };
},{“./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._boundValue(); 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 getDomain = Promise._getDomain; 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"));
if (util.isNode && process.env == 0) debugging = false;
if (debugging) {
async.disableTrampolineIfNecessary();
}
Promise.prototype._ignoreRejections = function() {
this._unsetRejectionIsUnhandled(); this._bitField = this._bitField | 16777216;
};
Promise.prototype._ensurePossibleRejectionHandled = function () {
if ((this._bitField & 16777216) !== 0) return; 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); util.notEnumerableProp(error, "stack", parsed.message + "\n" + parsed.stack.join("\n")); util.notEnumerableProp(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) {
var domain = getDomain(); possiblyUnhandledRejection = typeof fn === "function" ? (domain === null ? fn : domain.bind(fn)) : undefined;
};
Promise.onUnhandledRejectionHandled = function (fn) {
var domain = getDomain(); unhandledRejectionHandled = typeof fn === "function" ? (domain === null ? fn : domain.bind(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(); if (debugging) { async.disableTrampolineIfNecessary(); }
};
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;
module.exports = function(Promise) { var returner = function () {
return this;
}; var thrower = function () {
throw this;
}; var returnUndefined = function() {}; var throwUndefined = function() {
throw undefined;
};
var wrapper = function (value, action) {
if (action === 1) { return function () { throw value; }; } else if (action === 2) { return function () { return value; }; }
};
Promise.prototype = Promise.prototype.thenReturn = function (value) {
if (value === undefined) return this.then(returnUndefined); if (isPrimitive(value)) { return this._then( wrapper(value, 2), undefined, undefined, undefined, undefined ); } else if (value instanceof Promise) { value._ignoreRejections(); } return this._then(returner, undefined, undefined, value, undefined);
};
Promise.prototype = Promise.prototype.thenThrow = function (reason) {
if (reason === undefined) return this.then(throwUndefined); if (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 es5 = dereq(“./es5.js”); var Objectfreeze = es5.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]]; }
}
es5.defineProperty(AggregateError.prototype, “length”, {
value: 0, configurable: false, writable: true, enumerable: true
}); AggregateError.prototype = 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; 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, getDescriptor: Object.getOwnPropertyDescriptor, keys: Object.keys, names: Object.getOwnPropertyNames, 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 ObjectGetDescriptor = function(o, key) { return {value: o[key]}; }; 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, names: ObjectKeys, defineProperty: ObjectDefineProperty, getDescriptor: ObjectGetDescriptor, 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 isPrimitive = util.isPrimitive; var thrower = util.thrower;
function returnThis() {
return this;
} function throwThis() {
throw this;
} function return$® {
return function() { return r; };
} function throw$® {
return function() { throw r; };
} function promisedFinally(ret, reasonOrValue, isFulfilled) {
var then; if (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._boundValue()) : 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._boundValue(), 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 = 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 getDomain = Promise._getDomain; var async = dereq(“./async.js”); 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._captureStackTrace(); var domain = getDomain(); this._callback = domain === null ? fn : domain.bind(fn); this._preservedValues = _filter === INTERNAL ? new Array(this.length()) : null; this._limit = limit; this._inFlight = 0; this._queue = limit >= 1 ? [] : EMPTY_ARRAY; async.invoke(init, this, undefined);
} util.inherits(MappingPromiseArray, PromiseArray); function init() {this._init$(undefined, -2);}
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._boundValue(); 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();
};
};
},{“./async.js”:2,“./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 = 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._boundValue(), [null].concat(val)); if (ret === errorObj) { async.throwLater(ret.e); }
}
function successAdapter(val, nodeback) {
var promise = this; var receiver = promise._boundValue(); 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._boundValue(), reason); if (ret === errorObj) { async.throwLater(ret.e); }
}
Promise.prototype.asCallback = 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 getDomain; if (util.isNode) {
getDomain = function() { var ret = process.domain; if (ret === undefined) ret = null; return ret; };
} else {
getDomain = function() { return null; };
} util.notEnumerableProp(Promise, “_getDomain”, getDomain);
var UNDEFINED_BINDING = {}; 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; if (resolver !== INTERNAL) this._resolveFromResolver(resolver);
}
Promise.prototype.toString = function () {
return "[object Promise]";
};
Promise.prototype.caught = Promise.prototype = 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) {
return this.all()._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 () {
return new PromiseArray(this).promise();
};
Promise.prototype.error = function (fn) {
return this.caught(util.originatesFromRejection, fn);
};
Promise.getNewLibraryCopy = module.exports;
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) {
return new PromiseArray(promises).promise();
};
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 (receiver === undefined) receiver = this._boundTo; if (!haveInternalData) ret._setIsMigrated(); } var callbackIndex = target._addCallbacks(didFulfill, didReject, didProgress, ret, receiver, getDomain()); 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._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 (ret === UNDEFINED_BINDING) { return undefined; } else if (ret === undefined && this._isBound()) { return this._boundValue(); } 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._boundValue = function() {
var ret = this._boundTo; if (ret !== undefined) { if (ret instanceof Promise) { if (ret.isFulfilled()) { return ret.value(); } else { return undefined; } } } return ret;
};
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 = UNDEFINED_BINDING; this._addCallbacks(fulfill, reject, progress, promise, receiver, null);
};
Promise.prototype._addCallbacks = function (
fulfill, reject, progress, promise, receiver, domain
) {
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 = domain === null ? fulfill : domain.bind(fulfill); } if (typeof reject === "function") { this._rejectionHandler0 = domain === null ? reject : domain.bind(reject); } if (typeof progress === "function") { this._progressHandler0 = domain === null ? progress : domain.bind(progress); } } else { var base = index * 5 - 5; this[base + 3] = promise; this[base + 4] = receiver; if (typeof fulfill === "function") { this[base + 0] = domain === null ? fulfill : domain.bind(fulfill); } if (typeof reject === "function") { this[base + 1] = domain === null ? reject : domain.bind(reject); } if (typeof progress === "function") { this[base + 2] = domain === null ? progress : domain.bind(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 = trace === reason; this._attachExtraTrace(trace, synchronous ? hasStack : false); this._reject(reason, hasStack ? 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._boundValue(), 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 && parent._isBound()) { 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); 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); }
};
util.notEnumerableProp(Promise,
"_makeSelfResolutionError", makeSelfResolutionError);
dereq(“./progress.js”)(Promise, PromiseArray); dereq(“./method.js”)(Promise, INTERNAL, tryConvertToPromise, apiRejection); dereq(“./bind.js”)(Promise, INTERNAL, tryConvertToPromise); dereq(“./finally.js”)(Promise, NEXT_FILTER, tryConvertToPromise); dereq(“./direct_resolve.js”)(Promise); dereq(“./synchronous_inspection.js”)(Promise); dereq(“./join.js”)(Promise, PromiseArray, tryConvertToPromise, INTERNAL); Promise.version = “2.11.0”; Promise.Promise = Promise; dereq('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL); dereq('./cancel.js')(Promise); dereq('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext); dereq('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise); dereq('./nodeify.js')(Promise); dereq('./call_get.js')(Promise); dereq('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection); dereq('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection); dereq('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL); dereq('./settle.js')(Promise, PromiseArray); dereq('./some.js')(Promise, PromiseArray, apiRejection); dereq('./promisify.js')(Promise, INTERNAL); dereq('./any.js')(Promise); dereq('./each.js')(Promise, INTERNAL); dereq('./timers.js')(Promise, INTERNAL); dereq('./filter.js')(Promise, INTERNAL);
util.toFastProperties(Promise); util.toFastProperties(Promise.prototype); function fillTypes(value) { var p = new Promise(INTERNAL); p._fulfillmentHandler0 = value; p._rejectionHandler0 = value; p._progressHandler0 = value; p._promise0 = value; p._receiver0 = value; p._settledValue = value; } // Complete slack tracking, opt out of field-type tracking and // stabilize map fillTypes({a: 1}); fillTypes({b: 2}); fillTypes({c: 3}); fillTypes(1); fillTypes(function(){}); fillTypes(undefined); fillTypes(false); fillTypes(new Promise(INTERNAL)); CapturedTrace.setBounds(async.firstLineError, util.lastLineError); return Promise;
};
},{“./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 = 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._ignoreRejections(); } 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 defaultPromisified = {__isPromisified__: true}; var noCopyProps = [
"arity", "length", "name", "arguments", "caller", "callee", "prototype", "__isPromisified__"
]; var noCopyPropsPattern = new RegExp(“^(?:” + noCopyProps.join(“|”) + “)$”);
var defaultFilter = function(name) {
return util.isIdentifier(name) && name.charAt(0) !== "_" && name !== "constructor";
};
function propsFilter(key) {
return !noCopyPropsPattern.test(key);
}
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 - 3); for(var i = likelyArgumentCount - 1; i >= min; --i) { ret.push(i); } for(var i = likelyArgumentCount + 1; i <= 3; ++i) { ret.push(i); } return ret;
};
var argumentSequence = function(argumentCount) {
return util.filledRange(argumentCount, "_arg", "");
};
var parameterDeclaration = function(parameterCount) {
return util.filledRange( Math.max(parameterCount, 3), "_arg", "");
};
var parameterCount = function(fn) {
if (typeof fn.length === "number") { return Math.max(Math.min(fn.length, 1023 + 1), 0); } return 0;
};
makeNodePromisifiedEval = function(callback, receiver, originalName, fn) {
var newParameterCount = Math.max(0, parameterCount(fn) - 1); var argumentOrder = switchCaseArgumentOrder(newParameterCount); var shouldProxyThis = typeof callback === "string" || receiver === THIS; function generateCallForArgumentCount(count) { var args = argumentSequence(count).join(", "); var comma = count > 0 ? ", " : ""; var ret; if (shouldProxyThis) { ret = "ret = callback.call(this, {{args}}, nodeback); break;\n"; } else { ret = receiver === undefined ? "ret = callback({{args}}, nodeback); break;\n" : "ret = callback.call(receiver, {{args}}, nodeback); break;\n"; } return ret.replace("{{args}}", args).replace(", ", comma); } function generateArgumentSwitchCase() { var ret = ""; for (var i = 0; i < argumentOrder.length; ++i) { ret += "case " + argumentOrder[i] +":" + generateCallForArgumentCount(argumentOrder[i]); } 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] = nodeback; \n\ [CodeForCall] \n\ break; \n\ ".replace("[CodeForCall]", (shouldProxyThis ? "ret = callback.apply(this, args);\n" : "ret = callback.apply(receiver, args);\n")); return ret; } var getFunctionCode = typeof callback === "string" ? ("this != null ? this['"+callback+"'] : fn") : "fn"; return new Function("Promise", "fn", "receiver", "withAppended", "maybeWrapAsError", "nodebackForPromise", "tryCatch", "errorObj", "notEnumerableProp", "INTERNAL","'use strict'; \n\ var ret = function (Parameters) { \n\ 'use strict'; \n\ var len = arguments.length; \n\ var promise = new Promise(INTERNAL); \n\ promise._captureStackTrace(); \n\ var nodeback = nodebackForPromise(promise); \n\ var ret; \n\ var callback = tryCatch([GetFunctionCode]); \n\ switch(len) { \n\ [CodeForSwitchCase] \n\ } \n\ if (ret === errorObj) { \n\ promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\n\ } \n\ return promise; \n\ }; \n\ notEnumerableProp(ret, '__isPromisified__', true); \n\ return ret; \n\ " .replace("Parameters", parameterDeclaration(newParameterCount)) .replace("[CodeForSwitchCase]", generateArgumentSwitchCase()) .replace("[GetFunctionCode]", getFunctionCode))( Promise, fn, receiver, withAppended, maybeWrapAsError, nodebackForPromise, util.tryCatch, util.errorObj, util.notEnumerableProp, INTERNAL );
}; }
function makeNodePromisifiedClosure(callback, receiver, _, fn) {
var defaultThis = (function() {return this;})(); var method = callback; if (typeof method === "string") { callback = fn; } function promisified() { var _receiver = receiver; if (receiver === THIS) _receiver = this; var promise = new Promise(INTERNAL); promise._captureStackTrace(); var cb = typeof method === "string" && this !== defaultThis ? this[method] : callback; var fn = nodebackForPromise(promise); try { cb.apply(_receiver, withAppended(arguments, fn)); } catch(e) { promise._rejectCallback(maybeWrapAsError(e), true, true); } return promise; } util.notEnumerableProp(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; if (promisifier === makeNodePromisified) { obj[promisifiedKey] = makeNodePromisified(key, THIS, key, fn, suffix); } else { var promisified = promisifier(fn, function() { return makeNodePromisified(key, THIS, key, fn, suffix); }); util.notEnumerableProp(promisified, "__isPromisified__", true); obj[promisifiedKey] = promisified; } } 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; } var ret = promisify(fn, arguments.length < 2 ? THIS : receiver); util.copyDescriptors(fn, ret, propsFilter); return ret;
};
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); 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 getDomain = Promise._getDomain; var async = dereq(“./async.js”); 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; var domain = getDomain(); this._callback = domain === null ? fn : domain.bind(fn); this._accum = accum; if (!rejected) async.invoke(init, this, undefined);
} function init() {
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._boundValue(); 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);
}; };
},{“./async.js”:2,“./util.js”:38}],31:[function(dereq,module,exports){ “use strict”; var schedule; var util = dereq(“./util”); var noAsyncScheduler = function() {
throw new Error("No async scheduler available\u000a\u000a See http://goo.gl/m3OTXk\u000a");
}; if (util.isNode && typeof MutationObserver === “undefined”) {
var GlobalSetImmediate = global.setImmediate; var ProcessNextTick = process.nextTick; schedule = util.isRecentNode ? function(fn) { GlobalSetImmediate.call(global, fn); } : function(fn) { ProcessNextTick.call(process, fn); };
} else if ((typeof MutationObserver !== “undefined”) &&
!(typeof window !== "undefined" && window.navigator && window.navigator.standalone)) { 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 setImmediate !== “undefined”) {
schedule = function (fn) { setImmediate(fn); };
} else if (typeof setTimeout !== “undefined”) {
schedule = function (fn) { setTimeout(fn, 0); };
} else {
schedule = noAsyncScheduler;
} module.exports = schedule;
},{“./util”: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);
} 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; } 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; 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; var err; if(!util.isPrimitive(message) && (message instanceof Error)) { err = message; } else { if (typeof message !== "string") { message = "operation timed out"; } 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"); var input; var spreadArgs = true; if (len === 2 && Array.isArray(arguments[0])) { input = arguments[0]; len = input.length; spreadArgs = false; } else { input = arguments; len--; } var resources = new Array(len); for (var i = 0; i < len; ++i) { var resource = input[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 = spreadArgs ? fn.apply(undefined, vals) : fn.call(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 { var target = tryCatchTarget; tryCatchTarget = null; return target.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 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(safeToString(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;
}
function thrower® {
throw r;
}
var inheritedDataKeys = (function() {
var excludedPrototypes = [ Array.prototype, Object.prototype, Function.prototype ]; var isExcludedProto = function(val) { for (var i = 0; i < excludedPrototypes.length; ++i) { if (excludedPrototypes[i] === val) { return true; } } return false; }; if (es5.isES5) { var getKeys = Object.getOwnPropertyNames; return function(obj) { var ret = []; var visitedKeys = Object.create(null); while (obj != null && !isExcludedProto(obj)) { 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 { var hasProp = {}.hasOwnProperty; return function(obj) { if (isExcludedProto(obj)) return []; var ret = []; /*jshint forin:false */ enumeration: for (var key in obj) { if (hasProp.call(obj, key)) { ret.push(key); } else { for (var i = 0; i < excludedPrototypes.length; ++i) { if (hasProp.call(excludedPrototypes[i], key)) { continue enumeration; } } ret.push(key); } } return ret; }; }
})();
var thisAssignmentPattern = /thiss*.s*S+s*=/; function isClass(fn) {
try { if (typeof fn === "function") { var keys = es5.names(fn.prototype); var hasMethods = es5.isES5 && keys.length > 1; var hasMethodsOtherThanConstructor = keys.length > 0 && !(keys.length === 1 && keys[0] === "constructor"); var hasThisAssignmentAndStaticMethods = thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0; if (hasMethods || hasMethodsOtherThanConstructor || hasThisAssignmentAndStaticMethods) { return true; } } return false; } catch (e) { return false; }
}
function toFastProperties(obj) {
/*jshint -W027,-W055,-W031*/ function f() {} f.prototype = obj; var l = 8; while (l--) new f(); return obj; eval(obj);
}
var rident = /^[a-z$_]*$/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) {
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);
}
function copyDescriptors(from, to, filter) {
var keys = es5.names(from); for (var i = 0; i < keys.length; ++i) { var key = keys[i]; if (filter(key)) { try { es5.defineProperty(to, key, es5.getDescriptor(from, key)); } catch (ignore) {} } }
}
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, maybeWrapAsError: maybeWrapAsError, toFastProperties: toFastProperties, filledRange: filledRange, toString: safeToString, canAttachTrace: canAttachTrace, ensureErrorObject: ensureErrorObject, originatesFromRejection: originatesFromRejection, markAsOriginatingFromRejection: markAsOriginatingFromRejection, classString: classString, copyDescriptors: copyDescriptors, hasDevTools: typeof chrome !== "undefined" && chrome && typeof chrome.loadTimes === "function", isNode: typeof process !== "undefined" && classString(process).toLowerCase() === "[object process]"
}; ret.isRecentNode = ret.isNode && (function() {
var version = process.versions.node.split(".").map(Number); return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
})();
if (ret.isNode) ret.toFastProperties(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; }