{"version":3,"sources":["webpack:///./node_modules/q/q.js","webpack:///./node_modules/process/browser.js"],"names":["definition","bootstrap","module","exports","hasStacks","Error","e","stack","qFileName","qStartingLine","captureLine","noop","nextTick","head","task","next","tail","flushing","requestTick","isNodeJS","laterQueue","flush","domain","enter","runSingle","length","pop","exit","setTimeout","process","toString","setImmediate","window","bind","MessageChannel","channel","port1","onmessage","requestPortTick","port2","postMessage","runAfter","push","call","Function","uncurryThis","f","apply","arguments","QReturnValue","array_slice","Array","prototype","slice","array_reduce","reduce","callback","basis","index","this","TypeError","array_indexOf","indexOf","value","i","array_map","map","thisp","self","collect","undefined","object_create","Object","create","Type","object_defineProperty","defineProperty","obj","prop","descriptor","object_hasOwnProperty","hasOwnProperty","object_keys","keys","object","key","object_toString","isObject","isStopIteration","exception","ReturnValue","STACK_JUMP_SEPARATOR","makeStackTraceLong","error","promise","stacks","p","source","__minimumStackCounter__","stackCounter","configurable","unshift","concatedStacks","join","filterStackString","stackString","lines","split","desiredLines","line","isInternalFrame","isNodeFrame","stackLine","getFileNameAndLineNumber","attempt1","exec","Number","attempt2","attempt3","fileNameAndLineNumber","fileName","lineNumber","qEndingLine","firstLine","deprecate","name","alternative","console","warn","Q","Promise","isPromiseAlike","coerce","fulfill","resolve","longStackSupport","longStackCounter","defer","resolvedPromise","messages","progressListeners","deferred","promiseDispatch","op","operands","args","valueOf","nearerValue","nearer","isPromise","inspect","state","substring","become","newPromise","message","reject","reason","notify","progress","progressListener","resolver","race","answerPs","len","then","fallback","result","inspected","when","fulfilled","rejected","progressed","isPending","isFulfilled","isRejected","Q_DEBUG","makeNodeResolver","all","passByCopy","x","y","that","spread","makePromise","done","_fulfilled","_rejected","newException","_progressed","newValue","threw","onerror","tap","fcall","thenResolve","thenReject","unhandledReasons","unhandledRejections","reportedUnhandledRejections","trackUnhandledRejections","resetUnhandledRejections","trackRejection","emit","untrackRejection","at","atReport","splice","rejection","rhs","master","dispatch","async","makeGenerator","continuer","verb","arg","StopIteration","generator","errback","spawn","_return","promised","promises","pendingCount","snapshot","any","prev","current","onFulfilled","onRejected","err","onProgress","allResolved","allSettled","nodeify","nodeback","getUnhandledReasons","stopUnhandledRejectionTracking","array","get","set","del","mapply","post","send","mcall","invoke","fapply","fbind","concat","regardless","fail","fin","onUnhandledError","timeout","ms","timeoutId","code","clearTimeout","delay","nfapply","nodeArgs","nfcall","nfbind","denodeify","baseArgs","nbind","bound","nmapply","npost","nsend","nmcall","ninvoke","noConflict","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","runClearTimeout","marker","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","run","Item","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask"],"mappings":"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","file":"js/chunk-7b67f280.4590ade5.js","sourcesContent":["// vim:ts=4:sts=4:sw=4:\n/*!\n *\n * Copyright 2009-2017 Kris Kowal under the terms of the MIT\n * license found at https://github.com/kriskowal/q/blob/v1/LICENSE\n *\n * With parts by Tyler Close\n * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found\n * at http://www.opensource.org/licenses/mit-license.html\n * Forked at ref_send.js version: 2009-05-11\n *\n * With parts by Mark Miller\n * Copyright (C) 2011 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\n(function (definition) {\n    \"use strict\";\n\n    // This file will function properly as a <script> tag, or a module\n    // using CommonJS and NodeJS or RequireJS module formats.  In\n    // Common/Node/RequireJS, the module exports the Q API and when\n    // executed as a simple <script>, it creates a Q global instead.\n\n    // Montage Require\n    if (typeof bootstrap === \"function\") {\n        bootstrap(\"promise\", definition);\n\n    // CommonJS\n    } else if (typeof exports === \"object\" && typeof module === \"object\") {\n        module.exports = definition();\n\n    // RequireJS\n    } else if (typeof define === \"function\" && define.amd) {\n        define(definition);\n\n    // SES (Secure EcmaScript)\n    } else if (typeof ses !== \"undefined\") {\n        if (!ses.ok()) {\n            return;\n        } else {\n            ses.makeQ = definition;\n        }\n\n    // <script>\n    } else if (typeof window !== \"undefined\" || typeof self !== \"undefined\") {\n        // Prefer window over self for add-on scripts. Use self for\n        // non-windowed contexts.\n        var global = typeof window !== \"undefined\" ? window : self;\n\n        // Get the `window` object, save the previous Q global\n        // and initialize Q as a global.\n        var previousQ = global.Q;\n        global.Q = definition();\n\n        // Add a noConflict function so Q can be removed from the\n        // global namespace.\n        global.Q.noConflict = function () {\n            global.Q = previousQ;\n            return this;\n        };\n\n    } else {\n        throw new Error(\"This environment was not anticipated by Q. Please file a bug.\");\n    }\n\n})(function () {\n\"use strict\";\n\nvar hasStacks = false;\ntry {\n    throw new Error();\n} catch (e) {\n    hasStacks = !!e.stack;\n}\n\n// All code after this point will be filtered from stack traces reported\n// by Q.\nvar qStartingLine = captureLine();\nvar qFileName;\n\n// shims\n\n// used for fallback in \"allResolved\"\nvar noop = function () {};\n\n// Use the fastest possible means to execute a task in a future turn\n// of the event loop.\nvar nextTick =(function () {\n    // linked list of tasks (single, with head node)\n    var head = {task: void 0, next: null};\n    var tail = head;\n    var flushing = false;\n    var requestTick = void 0;\n    var isNodeJS = false;\n    // queue for late tasks, used by unhandled rejection tracking\n    var laterQueue = [];\n\n    function flush() {\n        /* jshint loopfunc: true */\n        var task, domain;\n\n        while (head.next) {\n            head = head.next;\n            task = head.task;\n            head.task = void 0;\n            domain = head.domain;\n\n            if (domain) {\n                head.domain = void 0;\n                domain.enter();\n            }\n            runSingle(task, domain);\n\n        }\n        while (laterQueue.length) {\n            task = laterQueue.pop();\n            runSingle(task);\n        }\n        flushing = false;\n    }\n    // runs a single function in the async queue\n    function runSingle(task, domain) {\n        try {\n            task();\n\n        } catch (e) {\n            if (isNodeJS) {\n                // In node, uncaught exceptions are considered fatal errors.\n                // Re-throw them synchronously to interrupt flushing!\n\n                // Ensure continuation if the uncaught exception is suppressed\n                // listening \"uncaughtException\" events (as domains does).\n                // Continue in next event to avoid tick recursion.\n                if (domain) {\n                    domain.exit();\n                }\n                setTimeout(flush, 0);\n                if (domain) {\n                    domain.enter();\n                }\n\n                throw e;\n\n            } else {\n                // In browsers, uncaught exceptions are not fatal.\n                // Re-throw them asynchronously to avoid slow-downs.\n                setTimeout(function () {\n                    throw e;\n                }, 0);\n            }\n        }\n\n        if (domain) {\n            domain.exit();\n        }\n    }\n\n    nextTick = function (task) {\n        tail = tail.next = {\n            task: task,\n            domain: isNodeJS && process.domain,\n            next: null\n        };\n\n        if (!flushing) {\n            flushing = true;\n            requestTick();\n        }\n    };\n\n    if (typeof process === \"object\" &&\n        process.toString() === \"[object process]\" && process.nextTick) {\n        // Ensure Q is in a real Node environment, with a `process.nextTick`.\n        // To see through fake Node environments:\n        // * Mocha test runner - exposes a `process` global without a `nextTick`\n        // * Browserify - exposes a `process.nexTick` function that uses\n        //   `setTimeout`. In this case `setImmediate` is preferred because\n        //    it is faster. Browserify's `process.toString()` yields\n        //   \"[object Object]\", while in a real Node environment\n        //   `process.toString()` yields \"[object process]\".\n        isNodeJS = true;\n\n        requestTick = function () {\n            process.nextTick(flush);\n        };\n\n    } else if (typeof setImmediate === \"function\") {\n        // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate\n        if (typeof window !== \"undefined\") {\n            requestTick = setImmediate.bind(window, flush);\n        } else {\n            requestTick = function () {\n                setImmediate(flush);\n            };\n        }\n\n    } else if (typeof MessageChannel !== \"undefined\") {\n        // modern browsers\n        // http://www.nonblocking.io/2011/06/windownexttick.html\n        var channel = new MessageChannel();\n        // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create\n        // working message ports the first time a page loads.\n        channel.port1.onmessage = function () {\n            requestTick = requestPortTick;\n            channel.port1.onmessage = flush;\n            flush();\n        };\n        var requestPortTick = function () {\n            // Opera requires us to provide a message payload, regardless of\n            // whether we use it.\n            channel.port2.postMessage(0);\n        };\n        requestTick = function () {\n            setTimeout(flush, 0);\n            requestPortTick();\n        };\n\n    } else {\n        // old browsers\n        requestTick = function () {\n            setTimeout(flush, 0);\n        };\n    }\n    // runs a task after all other tasks have been run\n    // this is useful for unhandled rejection tracking that needs to happen\n    // after all `then`d tasks have been run.\n    nextTick.runAfter = function (task) {\n        laterQueue.push(task);\n        if (!flushing) {\n            flushing = true;\n            requestTick();\n        }\n    };\n    return nextTick;\n})();\n\n// Attempt to make generics safe in the face of downstream\n// modifications.\n// There is no situation where this is necessary.\n// If you need a security guarantee, these primordials need to be\n// deeply frozen anyway, and if you don’t need a security guarantee,\n// this is just plain paranoid.\n// However, this **might** have the nice side-effect of reducing the size of\n// the minified code by reducing x.call() to merely x()\n// See Mark Miller’s explanation of what this does.\n// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming\nvar call = Function.call;\nfunction uncurryThis(f) {\n    return function () {\n        return call.apply(f, arguments);\n    };\n}\n// This is equivalent, but slower:\n// uncurryThis = Function_bind.bind(Function_bind.call);\n// http://jsperf.com/uncurrythis\n\nvar array_slice = uncurryThis(Array.prototype.slice);\n\nvar array_reduce = uncurryThis(\n    Array.prototype.reduce || function (callback, basis) {\n        var index = 0,\n            length = this.length;\n        // concerning the initial value, if one is not provided\n        if (arguments.length === 1) {\n            // seek to the first value in the array, accounting\n            // for the possibility that is is a sparse array\n            do {\n                if (index in this) {\n                    basis = this[index++];\n                    break;\n                }\n                if (++index >= length) {\n                    throw new TypeError();\n                }\n            } while (1);\n        }\n        // reduce\n        for (; index < length; index++) {\n            // account for the possibility that the array is sparse\n            if (index in this) {\n                basis = callback(basis, this[index], index);\n            }\n        }\n        return basis;\n    }\n);\n\nvar array_indexOf = uncurryThis(\n    Array.prototype.indexOf || function (value) {\n        // not a very good shim, but good enough for our one use of it\n        for (var i = 0; i < this.length; i++) {\n            if (this[i] === value) {\n                return i;\n            }\n        }\n        return -1;\n    }\n);\n\nvar array_map = uncurryThis(\n    Array.prototype.map || function (callback, thisp) {\n        var self = this;\n        var collect = [];\n        array_reduce(self, function (undefined, value, index) {\n            collect.push(callback.call(thisp, value, index, self));\n        }, void 0);\n        return collect;\n    }\n);\n\nvar object_create = Object.create || function (prototype) {\n    function Type() { }\n    Type.prototype = prototype;\n    return new Type();\n};\n\nvar object_defineProperty = Object.defineProperty || function (obj, prop, descriptor) {\n    obj[prop] = descriptor.value;\n    return obj;\n};\n\nvar object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);\n\nvar object_keys = Object.keys || function (object) {\n    var keys = [];\n    for (var key in object) {\n        if (object_hasOwnProperty(object, key)) {\n            keys.push(key);\n        }\n    }\n    return keys;\n};\n\nvar object_toString = uncurryThis(Object.prototype.toString);\n\nfunction isObject(value) {\n    return value === Object(value);\n}\n\n// generator related shims\n\n// FIXME: Remove this function once ES6 generators are in SpiderMonkey.\nfunction isStopIteration(exception) {\n    return (\n        object_toString(exception) === \"[object StopIteration]\" ||\n        exception instanceof QReturnValue\n    );\n}\n\n// FIXME: Remove this helper and Q.return once ES6 generators are in\n// SpiderMonkey.\nvar QReturnValue;\nif (typeof ReturnValue !== \"undefined\") {\n    QReturnValue = ReturnValue;\n} else {\n    QReturnValue = function (value) {\n        this.value = value;\n    };\n}\n\n// long stack traces\n\nvar STACK_JUMP_SEPARATOR = \"From previous event:\";\n\nfunction makeStackTraceLong(error, promise) {\n    // If possible, transform the error stack trace by removing Node and Q\n    // cruft, then concatenating with the stack trace of `promise`. See #57.\n    if (hasStacks &&\n        promise.stack &&\n        typeof error === \"object\" &&\n        error !== null &&\n        error.stack\n    ) {\n        var stacks = [];\n        for (var p = promise; !!p; p = p.source) {\n            if (p.stack && (!error.__minimumStackCounter__ || error.__minimumStackCounter__ > p.stackCounter)) {\n                object_defineProperty(error, \"__minimumStackCounter__\", {value: p.stackCounter, configurable: true});\n                stacks.unshift(p.stack);\n            }\n        }\n        stacks.unshift(error.stack);\n\n        var concatedStacks = stacks.join(\"\\n\" + STACK_JUMP_SEPARATOR + \"\\n\");\n        var stack = filterStackString(concatedStacks);\n        object_defineProperty(error, \"stack\", {value: stack, configurable: true});\n    }\n}\n\nfunction filterStackString(stackString) {\n    var lines = stackString.split(\"\\n\");\n    var desiredLines = [];\n    for (var i = 0; i < lines.length; ++i) {\n        var line = lines[i];\n\n        if (!isInternalFrame(line) && !isNodeFrame(line) && line) {\n            desiredLines.push(line);\n        }\n    }\n    return desiredLines.join(\"\\n\");\n}\n\nfunction isNodeFrame(stackLine) {\n    return stackLine.indexOf(\"(module.js:\") !== -1 ||\n           stackLine.indexOf(\"(node.js:\") !== -1;\n}\n\nfunction getFileNameAndLineNumber(stackLine) {\n    // Named functions: \"at functionName (filename:lineNumber:columnNumber)\"\n    // In IE10 function name can have spaces (\"Anonymous function\") O_o\n    var attempt1 = /at .+ \\((.+):(\\d+):(?:\\d+)\\)$/.exec(stackLine);\n    if (attempt1) {\n        return [attempt1[1], Number(attempt1[2])];\n    }\n\n    // Anonymous functions: \"at filename:lineNumber:columnNumber\"\n    var attempt2 = /at ([^ ]+):(\\d+):(?:\\d+)$/.exec(stackLine);\n    if (attempt2) {\n        return [attempt2[1], Number(attempt2[2])];\n    }\n\n    // Firefox style: \"function@filename:lineNumber or @filename:lineNumber\"\n    var attempt3 = /.*@(.+):(\\d+)$/.exec(stackLine);\n    if (attempt3) {\n        return [attempt3[1], Number(attempt3[2])];\n    }\n}\n\nfunction isInternalFrame(stackLine) {\n    var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);\n\n    if (!fileNameAndLineNumber) {\n        return false;\n    }\n\n    var fileName = fileNameAndLineNumber[0];\n    var lineNumber = fileNameAndLineNumber[1];\n\n    return fileName === qFileName &&\n        lineNumber >= qStartingLine &&\n        lineNumber <= qEndingLine;\n}\n\n// discover own file name and line number range for filtering stack\n// traces\nfunction captureLine() {\n    if (!hasStacks) {\n        return;\n    }\n\n    try {\n        throw new Error();\n    } catch (e) {\n        var lines = e.stack.split(\"\\n\");\n        var firstLine = lines[0].indexOf(\"@\") > 0 ? lines[1] : lines[2];\n        var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);\n        if (!fileNameAndLineNumber) {\n            return;\n        }\n\n        qFileName = fileNameAndLineNumber[0];\n        return fileNameAndLineNumber[1];\n    }\n}\n\nfunction deprecate(callback, name, alternative) {\n    return function () {\n        if (typeof console !== \"undefined\" &&\n            typeof console.warn === \"function\") {\n            console.warn(name + \" is deprecated, use \" + alternative +\n                         \" instead.\", new Error(\"\").stack);\n        }\n        return callback.apply(callback, arguments);\n    };\n}\n\n// end of shims\n// beginning of real work\n\n/**\n * Constructs a promise for an immediate reference, passes promises through, or\n * coerces promises from different systems.\n * @param value immediate reference or promise\n */\nfunction Q(value) {\n    // If the object is already a Promise, return it directly.  This enables\n    // the resolve function to both be used to created references from objects,\n    // but to tolerably coerce non-promises to promises.\n    if (value instanceof Promise) {\n        return value;\n    }\n\n    // assimilate thenables\n    if (isPromiseAlike(value)) {\n        return coerce(value);\n    } else {\n        return fulfill(value);\n    }\n}\nQ.resolve = Q;\n\n/**\n * Performs a task in a future turn of the event loop.\n * @param {Function} task\n */\nQ.nextTick = nextTick;\n\n/**\n * Controls whether or not long stack traces will be on\n */\nQ.longStackSupport = false;\n\n/**\n * The counter is used to determine the stopping point for building\n * long stack traces. In makeStackTraceLong we walk backwards through\n * the linked list of promises, only stacks which were created before\n * the rejection are concatenated.\n */\nvar longStackCounter = 1;\n\n// enable long stacks if Q_DEBUG is set\nif (typeof process === \"object\" && process && process.env && process.env.Q_DEBUG) {\n    Q.longStackSupport = true;\n}\n\n/**\n * Constructs a {promise, resolve, reject} object.\n *\n * `resolve` is a callback to invoke with a more resolved value for the\n * promise. To fulfill the promise, invoke `resolve` with any value that is\n * not a thenable. To reject the promise, invoke `resolve` with a rejected\n * thenable, or invoke `reject` with the reason directly. To resolve the\n * promise to another thenable, thus putting it in the same state, invoke\n * `resolve` with that other thenable.\n */\nQ.defer = defer;\nfunction defer() {\n    // if \"messages\" is an \"Array\", that indicates that the promise has not yet\n    // been resolved.  If it is \"undefined\", it has been resolved.  Each\n    // element of the messages array is itself an array of complete arguments to\n    // forward to the resolved promise.  We coerce the resolution value to a\n    // promise using the `resolve` function because it handles both fully\n    // non-thenable values and other thenables gracefully.\n    var messages = [], progressListeners = [], resolvedPromise;\n\n    var deferred = object_create(defer.prototype);\n    var promise = object_create(Promise.prototype);\n\n    promise.promiseDispatch = function (resolve, op, operands) {\n        var args = array_slice(arguments);\n        if (messages) {\n            messages.push(args);\n            if (op === \"when\" && operands[1]) { // progress operand\n                progressListeners.push(operands[1]);\n            }\n        } else {\n            Q.nextTick(function () {\n                resolvedPromise.promiseDispatch.apply(resolvedPromise, args);\n            });\n        }\n    };\n\n    // XXX deprecated\n    promise.valueOf = function () {\n        if (messages) {\n            return promise;\n        }\n        var nearerValue = nearer(resolvedPromise);\n        if (isPromise(nearerValue)) {\n            resolvedPromise = nearerValue; // shorten chain\n        }\n        return nearerValue;\n    };\n\n    promise.inspect = function () {\n        if (!resolvedPromise) {\n            return { state: \"pending\" };\n        }\n        return resolvedPromise.inspect();\n    };\n\n    if (Q.longStackSupport && hasStacks) {\n        try {\n            throw new Error();\n        } catch (e) {\n            // NOTE: don't try to use `Error.captureStackTrace` or transfer the\n            // accessor around; that causes memory leaks as per GH-111. Just\n            // reify the stack trace as a string ASAP.\n            //\n            // At the same time, cut off the first line; it's always just\n            // \"[object Promise]\\n\", as per the `toString`.\n            promise.stack = e.stack.substring(e.stack.indexOf(\"\\n\") + 1);\n            promise.stackCounter = longStackCounter++;\n        }\n    }\n\n    // NOTE: we do the checks for `resolvedPromise` in each method, instead of\n    // consolidating them into `become`, since otherwise we'd create new\n    // promises with the lines `become(whatever(value))`. See e.g. GH-252.\n\n    function become(newPromise) {\n        resolvedPromise = newPromise;\n\n        if (Q.longStackSupport && hasStacks) {\n            // Only hold a reference to the new promise if long stacks\n            // are enabled to reduce memory usage\n            promise.source = newPromise;\n        }\n\n        array_reduce(messages, function (undefined, message) {\n            Q.nextTick(function () {\n                newPromise.promiseDispatch.apply(newPromise, message);\n            });\n        }, void 0);\n\n        messages = void 0;\n        progressListeners = void 0;\n    }\n\n    deferred.promise = promise;\n    deferred.resolve = function (value) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(Q(value));\n    };\n\n    deferred.fulfill = function (value) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(fulfill(value));\n    };\n    deferred.reject = function (reason) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(reject(reason));\n    };\n    deferred.notify = function (progress) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        array_reduce(progressListeners, function (undefined, progressListener) {\n            Q.nextTick(function () {\n                progressListener(progress);\n            });\n        }, void 0);\n    };\n\n    return deferred;\n}\n\n/**\n * Creates a Node-style callback that will resolve or reject the deferred\n * promise.\n * @returns a nodeback\n */\ndefer.prototype.makeNodeResolver = function () {\n    var self = this;\n    return function (error, value) {\n        if (error) {\n            self.reject(error);\n        } else if (arguments.length > 2) {\n            self.resolve(array_slice(arguments, 1));\n        } else {\n            self.resolve(value);\n        }\n    };\n};\n\n/**\n * @param resolver {Function} a function that returns nothing and accepts\n * the resolve, reject, and notify functions for a deferred.\n * @returns a promise that may be resolved with the given resolve and reject\n * functions, or rejected by a thrown exception in resolver\n */\nQ.Promise = promise; // ES6\nQ.promise = promise;\nfunction promise(resolver) {\n    if (typeof resolver !== \"function\") {\n        throw new TypeError(\"resolver must be a function.\");\n    }\n    var deferred = defer();\n    try {\n        resolver(deferred.resolve, deferred.reject, deferred.notify);\n    } catch (reason) {\n        deferred.reject(reason);\n    }\n    return deferred.promise;\n}\n\npromise.race = race; // ES6\npromise.all = all; // ES6\npromise.reject = reject; // ES6\npromise.resolve = Q; // ES6\n\n// XXX experimental.  This method is a way to denote that a local value is\n// serializable and should be immediately dispatched to a remote upon request,\n// instead of passing a reference.\nQ.passByCopy = function (object) {\n    //freeze(object);\n    //passByCopies.set(object, true);\n    return object;\n};\n\nPromise.prototype.passByCopy = function () {\n    //freeze(object);\n    //passByCopies.set(object, true);\n    return this;\n};\n\n/**\n * If two promises eventually fulfill to the same value, promises that value,\n * but otherwise rejects.\n * @param x {Any*}\n * @param y {Any*}\n * @returns {Any*} a promise for x and y if they are the same, but a rejection\n * otherwise.\n *\n */\nQ.join = function (x, y) {\n    return Q(x).join(y);\n};\n\nPromise.prototype.join = function (that) {\n    return Q([this, that]).spread(function (x, y) {\n        if (x === y) {\n            // TODO: \"===\" should be Object.is or equiv\n            return x;\n        } else {\n            throw new Error(\"Q can't join: not the same: \" + x + \" \" + y);\n        }\n    });\n};\n\n/**\n * Returns a promise for the first of an array of promises to become settled.\n * @param answers {Array[Any*]} promises to race\n * @returns {Any*} the first promise to be settled\n */\nQ.race = race;\nfunction race(answerPs) {\n    return promise(function (resolve, reject) {\n        // Switch to this once we can assume at least ES5\n        // answerPs.forEach(function (answerP) {\n        //     Q(answerP).then(resolve, reject);\n        // });\n        // Use this in the meantime\n        for (var i = 0, len = answerPs.length; i < len; i++) {\n            Q(answerPs[i]).then(resolve, reject);\n        }\n    });\n}\n\nPromise.prototype.race = function () {\n    return this.then(Q.race);\n};\n\n/**\n * Constructs a Promise with a promise descriptor object and optional fallback\n * function.  The descriptor contains methods like when(rejected), get(name),\n * set(name, value), post(name, args), and delete(name), which all\n * return either a value, a promise for a value, or a rejection.  The fallback\n * accepts the operation name, a resolver, and any further arguments that would\n * have been forwarded to the appropriate method above had a method been\n * provided with the proper name.  The API makes no guarantees about the nature\n * of the returned object, apart from that it is usable whereever promises are\n * bought and sold.\n */\nQ.makePromise = Promise;\nfunction Promise(descriptor, fallback, inspect) {\n    if (fallback === void 0) {\n        fallback = function (op) {\n            return reject(new Error(\n                \"Promise does not support operation: \" + op\n            ));\n        };\n    }\n    if (inspect === void 0) {\n        inspect = function () {\n            return {state: \"unknown\"};\n        };\n    }\n\n    var promise = object_create(Promise.prototype);\n\n    promise.promiseDispatch = function (resolve, op, args) {\n        var result;\n        try {\n            if (descriptor[op]) {\n                result = descriptor[op].apply(promise, args);\n            } else {\n                result = fallback.call(promise, op, args);\n            }\n        } catch (exception) {\n            result = reject(exception);\n        }\n        if (resolve) {\n            resolve(result);\n        }\n    };\n\n    promise.inspect = inspect;\n\n    // XXX deprecated `valueOf` and `exception` support\n    if (inspect) {\n        var inspected = inspect();\n        if (inspected.state === \"rejected\") {\n            promise.exception = inspected.reason;\n        }\n\n        promise.valueOf = function () {\n            var inspected = inspect();\n            if (inspected.state === \"pending\" ||\n                inspected.state === \"rejected\") {\n                return promise;\n            }\n            return inspected.value;\n        };\n    }\n\n    return promise;\n}\n\nPromise.prototype.toString = function () {\n    return \"[object Promise]\";\n};\n\nPromise.prototype.then = function (fulfilled, rejected, progressed) {\n    var self = this;\n    var deferred = defer();\n    var done = false;   // ensure the untrusted promise makes at most a\n                        // single call to one of the callbacks\n\n    function _fulfilled(value) {\n        try {\n            return typeof fulfilled === \"function\" ? fulfilled(value) : value;\n        } catch (exception) {\n            return reject(exception);\n        }\n    }\n\n    function _rejected(exception) {\n        if (typeof rejected === \"function\") {\n            makeStackTraceLong(exception, self);\n            try {\n                return rejected(exception);\n            } catch (newException) {\n                return reject(newException);\n            }\n        }\n        return reject(exception);\n    }\n\n    function _progressed(value) {\n        return typeof progressed === \"function\" ? progressed(value) : value;\n    }\n\n    Q.nextTick(function () {\n        self.promiseDispatch(function (value) {\n            if (done) {\n                return;\n            }\n            done = true;\n\n            deferred.resolve(_fulfilled(value));\n        }, \"when\", [function (exception) {\n            if (done) {\n                return;\n            }\n            done = true;\n\n            deferred.resolve(_rejected(exception));\n        }]);\n    });\n\n    // Progress propagator need to be attached in the current tick.\n    self.promiseDispatch(void 0, \"when\", [void 0, function (value) {\n        var newValue;\n        var threw = false;\n        try {\n            newValue = _progressed(value);\n        } catch (e) {\n            threw = true;\n            if (Q.onerror) {\n                Q.onerror(e);\n            } else {\n                throw e;\n            }\n        }\n\n        if (!threw) {\n            deferred.notify(newValue);\n        }\n    }]);\n\n    return deferred.promise;\n};\n\nQ.tap = function (promise, callback) {\n    return Q(promise).tap(callback);\n};\n\n/**\n * Works almost like \"finally\", but not called for rejections.\n * Original resolution value is passed through callback unaffected.\n * Callback may return a promise that will be awaited for.\n * @param {Function} callback\n * @returns {Q.Promise}\n * @example\n * doSomething()\n *   .then(...)\n *   .tap(console.log)\n *   .then(...);\n */\nPromise.prototype.tap = function (callback) {\n    callback = Q(callback);\n\n    return this.then(function (value) {\n        return callback.fcall(value).thenResolve(value);\n    });\n};\n\n/**\n * Registers an observer on a promise.\n *\n * Guarantees:\n *\n * 1. that fulfilled and rejected will be called only once.\n * 2. that either the fulfilled callback or the rejected callback will be\n *    called, but not both.\n * 3. that fulfilled and rejected will not be called in this turn.\n *\n * @param value      promise or immediate reference to observe\n * @param fulfilled  function to be called with the fulfilled value\n * @param rejected   function to be called with the rejection exception\n * @param progressed function to be called on any progress notifications\n * @return promise for the return value from the invoked callback\n */\nQ.when = when;\nfunction when(value, fulfilled, rejected, progressed) {\n    return Q(value).then(fulfilled, rejected, progressed);\n}\n\nPromise.prototype.thenResolve = function (value) {\n    return this.then(function () { return value; });\n};\n\nQ.thenResolve = function (promise, value) {\n    return Q(promise).thenResolve(value);\n};\n\nPromise.prototype.thenReject = function (reason) {\n    return this.then(function () { throw reason; });\n};\n\nQ.thenReject = function (promise, reason) {\n    return Q(promise).thenReject(reason);\n};\n\n/**\n * If an object is not a promise, it is as \"near\" as possible.\n * If a promise is rejected, it is as \"near\" as possible too.\n * If it’s a fulfilled promise, the fulfillment value is nearer.\n * If it’s a deferred promise and the deferred has been resolved, the\n * resolution is \"nearer\".\n * @param object\n * @returns most resolved (nearest) form of the object\n */\n\n// XXX should we re-do this?\nQ.nearer = nearer;\nfunction nearer(value) {\n    if (isPromise(value)) {\n        var inspected = value.inspect();\n        if (inspected.state === \"fulfilled\") {\n            return inspected.value;\n        }\n    }\n    return value;\n}\n\n/**\n * @returns whether the given object is a promise.\n * Otherwise it is a fulfilled value.\n */\nQ.isPromise = isPromise;\nfunction isPromise(object) {\n    return object instanceof Promise;\n}\n\nQ.isPromiseAlike = isPromiseAlike;\nfunction isPromiseAlike(object) {\n    return isObject(object) && typeof object.then === \"function\";\n}\n\n/**\n * @returns whether the given object is a pending promise, meaning not\n * fulfilled or rejected.\n */\nQ.isPending = isPending;\nfunction isPending(object) {\n    return isPromise(object) && object.inspect().state === \"pending\";\n}\n\nPromise.prototype.isPending = function () {\n    return this.inspect().state === \"pending\";\n};\n\n/**\n * @returns whether the given object is a value or fulfilled\n * promise.\n */\nQ.isFulfilled = isFulfilled;\nfunction isFulfilled(object) {\n    return !isPromise(object) || object.inspect().state === \"fulfilled\";\n}\n\nPromise.prototype.isFulfilled = function () {\n    return this.inspect().state === \"fulfilled\";\n};\n\n/**\n * @returns whether the given object is a rejected promise.\n */\nQ.isRejected = isRejected;\nfunction isRejected(object) {\n    return isPromise(object) && object.inspect().state === \"rejected\";\n}\n\nPromise.prototype.isRejected = function () {\n    return this.inspect().state === \"rejected\";\n};\n\n//// BEGIN UNHANDLED REJECTION TRACKING\n\n// This promise library consumes exceptions thrown in handlers so they can be\n// handled by a subsequent promise.  The exceptions get added to this array when\n// they are created, and removed when they are handled.  Note that in ES6 or\n// shimmed environments, this would naturally be a `Set`.\nvar unhandledReasons = [];\nvar unhandledRejections = [];\nvar reportedUnhandledRejections = [];\nvar trackUnhandledRejections = true;\n\nfunction resetUnhandledRejections() {\n    unhandledReasons.length = 0;\n    unhandledRejections.length = 0;\n\n    if (!trackUnhandledRejections) {\n        trackUnhandledRejections = true;\n    }\n}\n\nfunction trackRejection(promise, reason) {\n    if (!trackUnhandledRejections) {\n        return;\n    }\n    if (typeof process === \"object\" && typeof process.emit === \"function\") {\n        Q.nextTick.runAfter(function () {\n            if (array_indexOf(unhandledRejections, promise) !== -1) {\n                process.emit(\"unhandledRejection\", reason, promise);\n                reportedUnhandledRejections.push(promise);\n            }\n        });\n    }\n\n    unhandledRejections.push(promise);\n    if (reason && typeof reason.stack !== \"undefined\") {\n        unhandledReasons.push(reason.stack);\n    } else {\n        unhandledReasons.push(\"(no stack) \" + reason);\n    }\n}\n\nfunction untrackRejection(promise) {\n    if (!trackUnhandledRejections) {\n        return;\n    }\n\n    var at = array_indexOf(unhandledRejections, promise);\n    if (at !== -1) {\n        if (typeof process === \"object\" && typeof process.emit === \"function\") {\n            Q.nextTick.runAfter(function () {\n                var atReport = array_indexOf(reportedUnhandledRejections, promise);\n                if (atReport !== -1) {\n                    process.emit(\"rejectionHandled\", unhandledReasons[at], promise);\n                    reportedUnhandledRejections.splice(atReport, 1);\n                }\n            });\n        }\n        unhandledRejections.splice(at, 1);\n        unhandledReasons.splice(at, 1);\n    }\n}\n\nQ.resetUnhandledRejections = resetUnhandledRejections;\n\nQ.getUnhandledReasons = function () {\n    // Make a copy so that consumers can't interfere with our internal state.\n    return unhandledReasons.slice();\n};\n\nQ.stopUnhandledRejectionTracking = function () {\n    resetUnhandledRejections();\n    trackUnhandledRejections = false;\n};\n\nresetUnhandledRejections();\n\n//// END UNHANDLED REJECTION TRACKING\n\n/**\n * Constructs a rejected promise.\n * @param reason value describing the failure\n */\nQ.reject = reject;\nfunction reject(reason) {\n    var rejection = Promise({\n        \"when\": function (rejected) {\n            // note that the error has been handled\n            if (rejected) {\n                untrackRejection(this);\n            }\n            return rejected ? rejected(reason) : this;\n        }\n    }, function fallback() {\n        return this;\n    }, function inspect() {\n        return { state: \"rejected\", reason: reason };\n    });\n\n    // Note that the reason has not been handled.\n    trackRejection(rejection, reason);\n\n    return rejection;\n}\n\n/**\n * Constructs a fulfilled promise for an immediate reference.\n * @param value immediate reference\n */\nQ.fulfill = fulfill;\nfunction fulfill(value) {\n    return Promise({\n        \"when\": function () {\n            return value;\n        },\n        \"get\": function (name) {\n            return value[name];\n        },\n        \"set\": function (name, rhs) {\n            value[name] = rhs;\n        },\n        \"delete\": function (name) {\n            delete value[name];\n        },\n        \"post\": function (name, args) {\n            // Mark Miller proposes that post with no name should apply a\n            // promised function.\n            if (name === null || name === void 0) {\n                return value.apply(void 0, args);\n            } else {\n                return value[name].apply(value, args);\n            }\n        },\n        \"apply\": function (thisp, args) {\n            return value.apply(thisp, args);\n        },\n        \"keys\": function () {\n            return object_keys(value);\n        }\n    }, void 0, function inspect() {\n        return { state: \"fulfilled\", value: value };\n    });\n}\n\n/**\n * Converts thenables to Q promises.\n * @param promise thenable promise\n * @returns a Q promise\n */\nfunction coerce(promise) {\n    var deferred = defer();\n    Q.nextTick(function () {\n        try {\n            promise.then(deferred.resolve, deferred.reject, deferred.notify);\n        } catch (exception) {\n            deferred.reject(exception);\n        }\n    });\n    return deferred.promise;\n}\n\n/**\n * Annotates an object such that it will never be\n * transferred away from this process over any promise\n * communication channel.\n * @param object\n * @returns promise a wrapping of that object that\n * additionally responds to the \"isDef\" message\n * without a rejection.\n */\nQ.master = master;\nfunction master(object) {\n    return Promise({\n        \"isDef\": function () {}\n    }, function fallback(op, args) {\n        return dispatch(object, op, args);\n    }, function () {\n        return Q(object).inspect();\n    });\n}\n\n/**\n * Spreads the values of a promised array of arguments into the\n * fulfillment callback.\n * @param fulfilled callback that receives variadic arguments from the\n * promised array\n * @param rejected callback that receives the exception if the promise\n * is rejected.\n * @returns a promise for the return value or thrown exception of\n * either callback.\n */\nQ.spread = spread;\nfunction spread(value, fulfilled, rejected) {\n    return Q(value).spread(fulfilled, rejected);\n}\n\nPromise.prototype.spread = function (fulfilled, rejected) {\n    return this.all().then(function (array) {\n        return fulfilled.apply(void 0, array);\n    }, rejected);\n};\n\n/**\n * The async function is a decorator for generator functions, turning\n * them into asynchronous generators.  Although generators are only part\n * of the newest ECMAScript 6 drafts, this code does not cause syntax\n * errors in older engines.  This code should continue to work and will\n * in fact improve over time as the language improves.\n *\n * ES6 generators are currently part of V8 version 3.19 with the\n * --harmony-generators runtime flag enabled.  SpiderMonkey has had them\n * for longer, but under an older Python-inspired form.  This function\n * works on both kinds of generators.\n *\n * Decorates a generator function such that:\n *  - it may yield promises\n *  - execution will continue when that promise is fulfilled\n *  - the value of the yield expression will be the fulfilled value\n *  - it returns a promise for the return value (when the generator\n *    stops iterating)\n *  - the decorated function returns a promise for the return value\n *    of the generator or the first rejected promise among those\n *    yielded.\n *  - if an error is thrown in the generator, it propagates through\n *    every following yield until it is caught, or until it escapes\n *    the generator function altogether, and is translated into a\n *    rejection for the promise returned by the decorated generator.\n */\nQ.async = async;\nfunction async(makeGenerator) {\n    return function () {\n        // when verb is \"send\", arg is a value\n        // when verb is \"throw\", arg is an exception\n        function continuer(verb, arg) {\n            var result;\n\n            // Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only\n            // engine that has a deployed base of browsers that support generators.\n            // However, SM's generators use the Python-inspired semantics of\n            // outdated ES6 drafts.  We would like to support ES6, but we'd also\n            // like to make it possible to use generators in deployed browsers, so\n            // we also support Python-style generators.  At some point we can remove\n            // this block.\n\n            if (typeof StopIteration === \"undefined\") {\n                // ES6 Generators\n                try {\n                    result = generator[verb](arg);\n                } catch (exception) {\n                    return reject(exception);\n                }\n                if (result.done) {\n                    return Q(result.value);\n                } else {\n                    return when(result.value, callback, errback);\n                }\n            } else {\n                // SpiderMonkey Generators\n                // FIXME: Remove this case when SM does ES6 generators.\n                try {\n                    result = generator[verb](arg);\n                } catch (exception) {\n                    if (isStopIteration(exception)) {\n                        return Q(exception.value);\n                    } else {\n                        return reject(exception);\n                    }\n                }\n                return when(result, callback, errback);\n            }\n        }\n        var generator = makeGenerator.apply(this, arguments);\n        var callback = continuer.bind(continuer, \"next\");\n        var errback = continuer.bind(continuer, \"throw\");\n        return callback();\n    };\n}\n\n/**\n * The spawn function is a small wrapper around async that immediately\n * calls the generator and also ends the promise chain, so that any\n * unhandled errors are thrown instead of forwarded to the error\n * handler. This is useful because it's extremely common to run\n * generators at the top-level to work with libraries.\n */\nQ.spawn = spawn;\nfunction spawn(makeGenerator) {\n    Q.done(Q.async(makeGenerator)());\n}\n\n// FIXME: Remove this interface once ES6 generators are in SpiderMonkey.\n/**\n * Throws a ReturnValue exception to stop an asynchronous generator.\n *\n * This interface is a stop-gap measure to support generator return\n * values in older Firefox/SpiderMonkey.  In browsers that support ES6\n * generators like Chromium 29, just use \"return\" in your generator\n * functions.\n *\n * @param value the return value for the surrounding generator\n * @throws ReturnValue exception with the value.\n * @example\n * // ES6 style\n * Q.async(function* () {\n *      var foo = yield getFooPromise();\n *      var bar = yield getBarPromise();\n *      return foo + bar;\n * })\n * // Older SpiderMonkey style\n * Q.async(function () {\n *      var foo = yield getFooPromise();\n *      var bar = yield getBarPromise();\n *      Q.return(foo + bar);\n * })\n */\nQ[\"return\"] = _return;\nfunction _return(value) {\n    throw new QReturnValue(value);\n}\n\n/**\n * The promised function decorator ensures that any promise arguments\n * are settled and passed as values (`this` is also settled and passed\n * as a value).  It will also ensure that the result of a function is\n * always a promise.\n *\n * @example\n * var add = Q.promised(function (a, b) {\n *     return a + b;\n * });\n * add(Q(a), Q(B));\n *\n * @param {function} callback The function to decorate\n * @returns {function} a function that has been decorated.\n */\nQ.promised = promised;\nfunction promised(callback) {\n    return function () {\n        return spread([this, all(arguments)], function (self, args) {\n            return callback.apply(self, args);\n        });\n    };\n}\n\n/**\n * sends a message to a value in a future turn\n * @param object* the recipient\n * @param op the name of the message operation, e.g., \"when\",\n * @param args further arguments to be forwarded to the operation\n * @returns result {Promise} a promise for the result of the operation\n */\nQ.dispatch = dispatch;\nfunction dispatch(object, op, args) {\n    return Q(object).dispatch(op, args);\n}\n\nPromise.prototype.dispatch = function (op, args) {\n    var self = this;\n    var deferred = defer();\n    Q.nextTick(function () {\n        self.promiseDispatch(deferred.resolve, op, args);\n    });\n    return deferred.promise;\n};\n\n/**\n * Gets the value of a property in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of property to get\n * @return promise for the property value\n */\nQ.get = function (object, key) {\n    return Q(object).dispatch(\"get\", [key]);\n};\n\nPromise.prototype.get = function (key) {\n    return this.dispatch(\"get\", [key]);\n};\n\n/**\n * Sets the value of a property in a future turn.\n * @param object    promise or immediate reference for object object\n * @param name      name of property to set\n * @param value     new value of property\n * @return promise for the return value\n */\nQ.set = function (object, key, value) {\n    return Q(object).dispatch(\"set\", [key, value]);\n};\n\nPromise.prototype.set = function (key, value) {\n    return this.dispatch(\"set\", [key, value]);\n};\n\n/**\n * Deletes a property in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of property to delete\n * @return promise for the return value\n */\nQ.del = // XXX legacy\nQ[\"delete\"] = function (object, key) {\n    return Q(object).dispatch(\"delete\", [key]);\n};\n\nPromise.prototype.del = // XXX legacy\nPromise.prototype[\"delete\"] = function (key) {\n    return this.dispatch(\"delete\", [key]);\n};\n\n/**\n * Invokes a method in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of method to invoke\n * @param value     a value to post, typically an array of\n *                  invocation arguments for promises that\n *                  are ultimately backed with `resolve` values,\n *                  as opposed to those backed with URLs\n *                  wherein the posted value can be any\n *                  JSON serializable object.\n * @return promise for the return value\n */\n// bound locally because it is used by other methods\nQ.mapply = // XXX As proposed by \"Redsandro\"\nQ.post = function (object, name, args) {\n    return Q(object).dispatch(\"post\", [name, args]);\n};\n\nPromise.prototype.mapply = // XXX As proposed by \"Redsandro\"\nPromise.prototype.post = function (name, args) {\n    return this.dispatch(\"post\", [name, args]);\n};\n\n/**\n * Invokes a method in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of method to invoke\n * @param ...args   array of invocation arguments\n * @return promise for the return value\n */\nQ.send = // XXX Mark Miller's proposed parlance\nQ.mcall = // XXX As proposed by \"Redsandro\"\nQ.invoke = function (object, name /*...args*/) {\n    return Q(object).dispatch(\"post\", [name, array_slice(arguments, 2)]);\n};\n\nPromise.prototype.send = // XXX Mark Miller's proposed parlance\nPromise.prototype.mcall = // XXX As proposed by \"Redsandro\"\nPromise.prototype.invoke = function (name /*...args*/) {\n    return this.dispatch(\"post\", [name, array_slice(arguments, 1)]);\n};\n\n/**\n * Applies the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param args      array of application arguments\n */\nQ.fapply = function (object, args) {\n    return Q(object).dispatch(\"apply\", [void 0, args]);\n};\n\nPromise.prototype.fapply = function (args) {\n    return this.dispatch(\"apply\", [void 0, args]);\n};\n\n/**\n * Calls the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param ...args   array of application arguments\n */\nQ[\"try\"] =\nQ.fcall = function (object /* ...args*/) {\n    return Q(object).dispatch(\"apply\", [void 0, array_slice(arguments, 1)]);\n};\n\nPromise.prototype.fcall = function (/*...args*/) {\n    return this.dispatch(\"apply\", [void 0, array_slice(arguments)]);\n};\n\n/**\n * Binds the promised function, transforming return values into a fulfilled\n * promise and thrown errors into a rejected one.\n * @param object    promise or immediate reference for target function\n * @param ...args   array of application arguments\n */\nQ.fbind = function (object /*...args*/) {\n    var promise = Q(object);\n    var args = array_slice(arguments, 1);\n    return function fbound() {\n        return promise.dispatch(\"apply\", [\n            this,\n            args.concat(array_slice(arguments))\n        ]);\n    };\n};\nPromise.prototype.fbind = function (/*...args*/) {\n    var promise = this;\n    var args = array_slice(arguments);\n    return function fbound() {\n        return promise.dispatch(\"apply\", [\n            this,\n            args.concat(array_slice(arguments))\n        ]);\n    };\n};\n\n/**\n * Requests the names of the owned properties of a promised\n * object in a future turn.\n * @param object    promise or immediate reference for target object\n * @return promise for the keys of the eventually settled object\n */\nQ.keys = function (object) {\n    return Q(object).dispatch(\"keys\", []);\n};\n\nPromise.prototype.keys = function () {\n    return this.dispatch(\"keys\", []);\n};\n\n/**\n * Turns an array of promises into a promise for an array.  If any of\n * the promises gets rejected, the whole array is rejected immediately.\n * @param {Array*} an array (or promise for an array) of values (or\n * promises for values)\n * @returns a promise for an array of the corresponding values\n */\n// By Mark Miller\n// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled\nQ.all = all;\nfunction all(promises) {\n    return when(promises, function (promises) {\n        var pendingCount = 0;\n        var deferred = defer();\n        array_reduce(promises, function (undefined, promise, index) {\n            var snapshot;\n            if (\n                isPromise(promise) &&\n                (snapshot = promise.inspect()).state === \"fulfilled\"\n            ) {\n                promises[index] = snapshot.value;\n            } else {\n                ++pendingCount;\n                when(\n                    promise,\n                    function (value) {\n                        promises[index] = value;\n                        if (--pendingCount === 0) {\n                            deferred.resolve(promises);\n                        }\n                    },\n                    deferred.reject,\n                    function (progress) {\n                        deferred.notify({ index: index, value: progress });\n                    }\n                );\n            }\n        }, void 0);\n        if (pendingCount === 0) {\n            deferred.resolve(promises);\n        }\n        return deferred.promise;\n    });\n}\n\nPromise.prototype.all = function () {\n    return all(this);\n};\n\n/**\n * Returns the first resolved promise of an array. Prior rejected promises are\n * ignored.  Rejects only if all promises are rejected.\n * @param {Array*} an array containing values or promises for values\n * @returns a promise fulfilled with the value of the first resolved promise,\n * or a rejected promise if all promises are rejected.\n */\nQ.any = any;\n\nfunction any(promises) {\n    if (promises.length === 0) {\n        return Q.resolve();\n    }\n\n    var deferred = Q.defer();\n    var pendingCount = 0;\n    array_reduce(promises, function (prev, current, index) {\n        var promise = promises[index];\n\n        pendingCount++;\n\n        when(promise, onFulfilled, onRejected, onProgress);\n        function onFulfilled(result) {\n            deferred.resolve(result);\n        }\n        function onRejected(err) {\n            pendingCount--;\n            if (pendingCount === 0) {\n                var rejection = err || new Error(\"\" + err);\n\n                rejection.message = (\"Q can't get fulfillment value from any promise, all \" +\n                    \"promises were rejected. Last error message: \" + rejection.message);\n\n                deferred.reject(rejection);\n            }\n        }\n        function onProgress(progress) {\n            deferred.notify({\n                index: index,\n                value: progress\n            });\n        }\n    }, undefined);\n\n    return deferred.promise;\n}\n\nPromise.prototype.any = function () {\n    return any(this);\n};\n\n/**\n * Waits for all promises to be settled, either fulfilled or\n * rejected.  This is distinct from `all` since that would stop\n * waiting at the first rejection.  The promise returned by\n * `allResolved` will never be rejected.\n * @param promises a promise for an array (or an array) of promises\n * (or values)\n * @return a promise for an array of promises\n */\nQ.allResolved = deprecate(allResolved, \"allResolved\", \"allSettled\");\nfunction allResolved(promises) {\n    return when(promises, function (promises) {\n        promises = array_map(promises, Q);\n        return when(all(array_map(promises, function (promise) {\n            return when(promise, noop, noop);\n        })), function () {\n            return promises;\n        });\n    });\n}\n\nPromise.prototype.allResolved = function () {\n    return allResolved(this);\n};\n\n/**\n * @see Promise#allSettled\n */\nQ.allSettled = allSettled;\nfunction allSettled(promises) {\n    return Q(promises).allSettled();\n}\n\n/**\n * Turns an array of promises into a promise for an array of their states (as\n * returned by `inspect`) when they have all settled.\n * @param {Array[Any*]} values an array (or promise for an array) of values (or\n * promises for values)\n * @returns {Array[State]} an array of states for the respective values.\n */\nPromise.prototype.allSettled = function () {\n    return this.then(function (promises) {\n        return all(array_map(promises, function (promise) {\n            promise = Q(promise);\n            function regardless() {\n                return promise.inspect();\n            }\n            return promise.then(regardless, regardless);\n        }));\n    });\n};\n\n/**\n * Captures the failure of a promise, giving an oportunity to recover\n * with a callback.  If the given promise is fulfilled, the returned\n * promise is fulfilled.\n * @param {Any*} promise for something\n * @param {Function} callback to fulfill the returned promise if the\n * given promise is rejected\n * @returns a promise for the return value of the callback\n */\nQ.fail = // XXX legacy\nQ[\"catch\"] = function (object, rejected) {\n    return Q(object).then(void 0, rejected);\n};\n\nPromise.prototype.fail = // XXX legacy\nPromise.prototype[\"catch\"] = function (rejected) {\n    return this.then(void 0, rejected);\n};\n\n/**\n * Attaches a listener that can respond to progress notifications from a\n * promise's originating deferred. This listener receives the exact arguments\n * passed to ``deferred.notify``.\n * @param {Any*} promise for something\n * @param {Function} callback to receive any progress notifications\n * @returns the given promise, unchanged\n */\nQ.progress = progress;\nfunction progress(object, progressed) {\n    return Q(object).then(void 0, void 0, progressed);\n}\n\nPromise.prototype.progress = function (progressed) {\n    return this.then(void 0, void 0, progressed);\n};\n\n/**\n * Provides an opportunity to observe the settling of a promise,\n * regardless of whether the promise is fulfilled or rejected.  Forwards\n * the resolution to the returned promise when the callback is done.\n * The callback can return a promise to defer completion.\n * @param {Any*} promise\n * @param {Function} callback to observe the resolution of the given\n * promise, takes no arguments.\n * @returns a promise for the resolution of the given promise when\n * ``fin`` is done.\n */\nQ.fin = // XXX legacy\nQ[\"finally\"] = function (object, callback) {\n    return Q(object)[\"finally\"](callback);\n};\n\nPromise.prototype.fin = // XXX legacy\nPromise.prototype[\"finally\"] = function (callback) {\n    if (!callback || typeof callback.apply !== \"function\") {\n        throw new Error(\"Q can't apply finally callback\");\n    }\n    callback = Q(callback);\n    return this.then(function (value) {\n        return callback.fcall().then(function () {\n            return value;\n        });\n    }, function (reason) {\n        // TODO attempt to recycle the rejection with \"this\".\n        return callback.fcall().then(function () {\n            throw reason;\n        });\n    });\n};\n\n/**\n * Terminates a chain of promises, forcing rejections to be\n * thrown as exceptions.\n * @param {Any*} promise at the end of a chain of promises\n * @returns nothing\n */\nQ.done = function (object, fulfilled, rejected, progress) {\n    return Q(object).done(fulfilled, rejected, progress);\n};\n\nPromise.prototype.done = function (fulfilled, rejected, progress) {\n    var onUnhandledError = function (error) {\n        // forward to a future turn so that ``when``\n        // does not catch it and turn it into a rejection.\n        Q.nextTick(function () {\n            makeStackTraceLong(error, promise);\n            if (Q.onerror) {\n                Q.onerror(error);\n            } else {\n                throw error;\n            }\n        });\n    };\n\n    // Avoid unnecessary `nextTick`ing via an unnecessary `when`.\n    var promise = fulfilled || rejected || progress ?\n        this.then(fulfilled, rejected, progress) :\n        this;\n\n    if (typeof process === \"object\" && process && process.domain) {\n        onUnhandledError = process.domain.bind(onUnhandledError);\n    }\n\n    promise.then(void 0, onUnhandledError);\n};\n\n/**\n * Causes a promise to be rejected if it does not get fulfilled before\n * some milliseconds time out.\n * @param {Any*} promise\n * @param {Number} milliseconds timeout\n * @param {Any*} custom error message or Error object (optional)\n * @returns a promise for the resolution of the given promise if it is\n * fulfilled before the timeout, otherwise rejected.\n */\nQ.timeout = function (object, ms, error) {\n    return Q(object).timeout(ms, error);\n};\n\nPromise.prototype.timeout = function (ms, error) {\n    var deferred = defer();\n    var timeoutId = setTimeout(function () {\n        if (!error || \"string\" === typeof error) {\n            error = new Error(error || \"Timed out after \" + ms + \" ms\");\n            error.code = \"ETIMEDOUT\";\n        }\n        deferred.reject(error);\n    }, ms);\n\n    this.then(function (value) {\n        clearTimeout(timeoutId);\n        deferred.resolve(value);\n    }, function (exception) {\n        clearTimeout(timeoutId);\n        deferred.reject(exception);\n    }, deferred.notify);\n\n    return deferred.promise;\n};\n\n/**\n * Returns a promise for the given value (or promised value), some\n * milliseconds after it resolved. Passes rejections immediately.\n * @param {Any*} promise\n * @param {Number} milliseconds\n * @returns a promise for the resolution of the given promise after milliseconds\n * time has elapsed since the resolution of the given promise.\n * If the given promise rejects, that is passed immediately.\n */\nQ.delay = function (object, timeout) {\n    if (timeout === void 0) {\n        timeout = object;\n        object = void 0;\n    }\n    return Q(object).delay(timeout);\n};\n\nPromise.prototype.delay = function (timeout) {\n    return this.then(function (value) {\n        var deferred = defer();\n        setTimeout(function () {\n            deferred.resolve(value);\n        }, timeout);\n        return deferred.promise;\n    });\n};\n\n/**\n * Passes a continuation to a Node function, which is called with the given\n * arguments provided as an array, and returns a promise.\n *\n *      Q.nfapply(FS.readFile, [__filename])\n *      .then(function (content) {\n *      })\n *\n */\nQ.nfapply = function (callback, args) {\n    return Q(callback).nfapply(args);\n};\n\nPromise.prototype.nfapply = function (args) {\n    var deferred = defer();\n    var nodeArgs = array_slice(args);\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.fapply(nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Passes a continuation to a Node function, which is called with the given\n * arguments provided individually, and returns a promise.\n * @example\n * Q.nfcall(FS.readFile, __filename)\n * .then(function (content) {\n * })\n *\n */\nQ.nfcall = function (callback /*...args*/) {\n    var args = array_slice(arguments, 1);\n    return Q(callback).nfapply(args);\n};\n\nPromise.prototype.nfcall = function (/*...args*/) {\n    var nodeArgs = array_slice(arguments);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.fapply(nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Wraps a NodeJS continuation passing function and returns an equivalent\n * version that returns a promise.\n * @example\n * Q.nfbind(FS.readFile, __filename)(\"utf-8\")\n * .then(console.log)\n * .done()\n */\nQ.nfbind =\nQ.denodeify = function (callback /*...args*/) {\n    if (callback === undefined) {\n        throw new Error(\"Q can't wrap an undefined function\");\n    }\n    var baseArgs = array_slice(arguments, 1);\n    return function () {\n        var nodeArgs = baseArgs.concat(array_slice(arguments));\n        var deferred = defer();\n        nodeArgs.push(deferred.makeNodeResolver());\n        Q(callback).fapply(nodeArgs).fail(deferred.reject);\n        return deferred.promise;\n    };\n};\n\nPromise.prototype.nfbind =\nPromise.prototype.denodeify = function (/*...args*/) {\n    var args = array_slice(arguments);\n    args.unshift(this);\n    return Q.denodeify.apply(void 0, args);\n};\n\nQ.nbind = function (callback, thisp /*...args*/) {\n    var baseArgs = array_slice(arguments, 2);\n    return function () {\n        var nodeArgs = baseArgs.concat(array_slice(arguments));\n        var deferred = defer();\n        nodeArgs.push(deferred.makeNodeResolver());\n        function bound() {\n            return callback.apply(thisp, arguments);\n        }\n        Q(bound).fapply(nodeArgs).fail(deferred.reject);\n        return deferred.promise;\n    };\n};\n\nPromise.prototype.nbind = function (/*thisp, ...args*/) {\n    var args = array_slice(arguments, 0);\n    args.unshift(this);\n    return Q.nbind.apply(void 0, args);\n};\n\n/**\n * Calls a method of a Node-style object that accepts a Node-style\n * callback with a given array of arguments, plus a provided callback.\n * @param object an object that has the named method\n * @param {String} name name of the method of object\n * @param {Array} args arguments to pass to the method; the callback\n * will be provided by Q and appended to these arguments.\n * @returns a promise for the value or error\n */\nQ.nmapply = // XXX As proposed by \"Redsandro\"\nQ.npost = function (object, name, args) {\n    return Q(object).npost(name, args);\n};\n\nPromise.prototype.nmapply = // XXX As proposed by \"Redsandro\"\nPromise.prototype.npost = function (name, args) {\n    var nodeArgs = array_slice(args || []);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Calls a method of a Node-style object that accepts a Node-style\n * callback, forwarding the given variadic arguments, plus a provided\n * callback argument.\n * @param object an object that has the named method\n * @param {String} name name of the method of object\n * @param ...args arguments to pass to the method; the callback will\n * be provided by Q and appended to these arguments.\n * @returns a promise for the value or error\n */\nQ.nsend = // XXX Based on Mark Miller's proposed \"send\"\nQ.nmcall = // XXX Based on \"Redsandro's\" proposal\nQ.ninvoke = function (object, name /*...args*/) {\n    var nodeArgs = array_slice(arguments, 2);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    Q(object).dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\nPromise.prototype.nsend = // XXX Based on Mark Miller's proposed \"send\"\nPromise.prototype.nmcall = // XXX Based on \"Redsandro's\" proposal\nPromise.prototype.ninvoke = function (name /*...args*/) {\n    var nodeArgs = array_slice(arguments, 1);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * If a function would like to support both Node continuation-passing-style and\n * promise-returning-style, it can end its internal promise chain with\n * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user\n * elects to use a nodeback, the result will be sent there.  If they do not\n * pass a nodeback, they will receive the result promise.\n * @param object a result (or a promise for a result)\n * @param {Function} nodeback a Node.js-style callback\n * @returns either the promise or nothing\n */\nQ.nodeify = nodeify;\nfunction nodeify(object, nodeback) {\n    return Q(object).nodeify(nodeback);\n}\n\nPromise.prototype.nodeify = function (nodeback) {\n    if (nodeback) {\n        this.then(function (value) {\n            Q.nextTick(function () {\n                nodeback(null, value);\n            });\n        }, function (error) {\n            Q.nextTick(function () {\n                nodeback(error);\n            });\n        });\n    } else {\n        return this;\n    }\n};\n\nQ.noConflict = function() {\n    throw new Error(\"Q.noConflict only works when Q is used as a global\");\n};\n\n// All code before this point will be filtered from stack traces.\nvar qEndingLine = captureLine();\n\nreturn Q;\n\n});\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n"],"sourceRoot":""}