/* @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);return s})({1:[function(dereq,module,exports){ “use strict”; module.exports = function(Promise) { var SomePromiseArray = Promise._SomePromiseArray; function any(promises) {

var ret = new SomePromiseArray(promises);
var promise = ret.promise();
ret.setHowMany(1);
ret.setUnwrap();
ret.init();
return promise;

}

Promise.any = function (promises) {

return any(promises);

};

Promise.prototype.any = function () {

return any(this);

};

};

},{}],2:[function(dereq,module,exports){ “use strict”; var firstLineError; try {throw new Error(); } catch (e) {firstLineError = e;} var schedule = dereq(“./schedule.js”); var Queue = dereq(“./queue.js”); var 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; }