{"version":3,"sources":["webpack:///./src/components/pages/approve/_api/api.js","webpack:///src/components/pages/approve/servicefacedetail.vue","webpack:///./src/components/pages/approve/servicefacedetail.vue","webpack:///./node_modules/q/q.js","webpack:///./src/components/pages/approve/servicefacedetail.vue?77ca","webpack:///./src/components/pages/approve/servicefacedetail.vue?3de5","webpack:///./src/components/pages/approve/servicefacedetail.vue?ff55","webpack:///./src/components/pages/approve/servicefacedetail.vue?31b5"],"names":["_allApi","require","_axios","_interopRequireDefault","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","listTrans","obj","result","data","map","item","i","num","index","size","total","exports","dataApi","_classCallCheck2","_createClass2","key","value","allObj","getAll","getFaceApproveList","axios","all","then","spread","allData","catch","error","Promise","reject","concat","JSON","stringify","tempFunc","_tempFunc","_asyncToGenerator2","regeneratorRuntime","mark","_callee","wrap","_context","prev","next","sent","abrupt","t0","console","log","stop","_vuex","status","isLoading","faceApproveDetail","computed","mapState","methods","handleFaceApproveDetail","_this","getFaceApproveDetail","gid","sessionStorage","getItem","res","handleUpdate","_this2","IsUpdateTheOld","isUpdateTheOld","faceInfoUpdate","code","$message","success","$router","go","des","created","mounted","render","_vm","this","_c","_self","directives","name","rawName","expression","staticClass","_m","attrs","_v","_s","theOldName","idCard","community","staticStyle","theOldPicture","updatePicturePath","_e","contactName","relationship","contactPhone","contactPicture","model","callback","$$v","on","staticRenderFns","definition","bootstrap","module","hasStacks","Error","stack","qFileName","qStartingLine","captureLine","noop","nextTick","head","task","tail","flushing","requestTick","isNodeJS","laterQueue","flush","domain","enter","runSingle","pop","exit","setTimeout","process","toString","setImmediate","window","bind","MessageChannel","channel","port1","onmessage","requestPortTick","port2","postMessage","runAfter","call","Function","uncurryThis","f","QReturnValue","array_slice","Array","prototype","slice","array_reduce","reduce","basis","TypeError","array_indexOf","indexOf","array_map","thisp","self","collect","undefined","object_create","create","Type","object_defineProperty","prop","descriptor","object_hasOwnProperty","hasOwnProperty","object_keys","object","object_toString","isObject","isStopIteration","exception","ReturnValue","STACK_JUMP_SEPARATOR","makeStackTraceLong","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","alternative","warn","Q","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","reason","notify","progress","progressListener","resolver","race","answerPs","len","fallback","inspected","when","fulfilled","rejected","progressed","isPending","isFulfilled","isRejected","Q_DEBUG","makeNodeResolver","passByCopy","x","y","that","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","current","onFulfilled","onRejected","err","onProgress","allResolved","allSettled","nodeify","nodeback","getUnhandledReasons","stopUnhandledRejectionTracking","array","get","set","del","mapply","post","send","mcall","invoke","fapply","fbind","regardless","fail","fin","onUnhandledError","timeout","ms","timeoutId","clearTimeout","delay","nfapply","nodeArgs","nfcall","nfbind","denodeify","baseArgs","nbind","bound","nmapply","npost","nsend","nmcall","ninvoke","noConflict","component"],"mappings":"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","file":"js/chunk-f135300a.a09d07cc.js","sourcesContent":["import { getFaceApproveList } from \"@/services/all-api.js\";\r\nimport axios from \"axios\";\r\n\r\nfunction listTrans(obj) {\r\n    const result = {\r\n        data: obj.data.map((item, i) => ({\r\n            num: obj.index * obj.size + i + 1,\r\n            ...item\r\n        })),\r\n        total: obj.total,\r\n        index: obj.index,\r\n        size: obj.size\r\n    };\r\n    return result;\r\n}\r\nexport default class dataApi {\r\n    static firstGet() {\r\n        const allObj = {\r\n            index: 0,\r\n            size: 20\r\n        };\r\n\r\n        function getAll() {\r\n            return getFaceApproveList(allObj);\r\n        }\r\n\r\n        return axios\r\n            .all([getAll()])\r\n            .then(\r\n                axios.spread(all => {\r\n                    const obj = {\r\n                        allData: listTrans(all)\r\n                    };\r\n                    return obj;\r\n                })\r\n            )\r\n            .catch(error => {\r\n                return Promise.reject(`获取数据失败:${JSON.stringify(error)}`);\r\n            });\r\n    }\r\n    static pageSearchGetFunc(obj) {\r\n        async function tempFunc() {\r\n            try {\r\n                let result = await getFaceApproveList(obj);\r\n                return {\r\n                    data: listTrans(result)\r\n                };\r\n            } catch (e) {\r\n                console.log(e);\r\n            }\r\n        }\r\n        return tempFunc();\r\n    }\r\n}\r\n\r\n//在这里面做接口对象值转化翻译","<template>\r\n    <div class=\"outDiv\" v-loading=\"isLoading\">\r\n        <div class=\"serviceopen\">\r\n            <div style=\"display:flex;align-items:center\">\r\n                <span class=\"approveTitle\">人脸信息登记详情</span>\r\n            </div>\r\n        </div>\r\n        <div class=\"openForm\">\r\n            <el-form labelWidth=\"160px\" labelPosition=\"right\" size=\"medium\">\r\n                <el-row :span=\"24\">\r\n                    <el-form-item label=\"老人姓名\">\r\n                        <span>{{ faceApproveDetail.theOldName }}</span>\r\n                    </el-form-item>\r\n                </el-row>\r\n                <el-row :span=\"24\">\r\n                    <el-form-item label=\"身份证号码\">\r\n                        <span>{{ faceApproveDetail.idCard }}</span>\r\n                    </el-form-item>\r\n                </el-row>\r\n\r\n                <el-row :span=\"24\">\r\n                    <el-form-item label=\"所属社区\">\r\n                        <span>{{ faceApproveDetail.community }}</span>\r\n                    </el-form-item>\r\n                </el-row>\r\n                <!-- v-if=\"faceApproveDetail.isUpdateTheOld\" -->\r\n\r\n                <el-row :span=\"24\">\r\n                    <el-form-item label=\"老人人脸照片\">\r\n                        <img :src=\"faceApproveDetail.theOldPicture\" style=\"width: 200px;\" />\r\n                    </el-form-item>\r\n                    <el-form-item label=\"更新老人人脸照片\" v-if=\"faceApproveDetail.isUpdateTheOld\">\r\n                        <img :src=\"faceApproveDetail.updatePicturePath\" style=\"width: 200px;\" />\r\n                    </el-form-item>\r\n                </el-row>\r\n                <el-row :span=\"24\" v-if=\"!faceApproveDetail.isUpdateTheOld\">\r\n                    <el-form-item label=\"联系人姓名\">\r\n                        <span>{{ faceApproveDetail.contactName }}</span>\r\n                    </el-form-item>\r\n                </el-row>\r\n                <el-row :span=\"24\" v-if=\"!faceApproveDetail.isUpdateTheOld\">\r\n                    <el-form-item label=\"与老人关系\">\r\n                        <span>{{ faceApproveDetail.relationship }}</span>\r\n                    </el-form-item>\r\n                </el-row>\r\n                <el-row :span=\"24\" v-if=\"!faceApproveDetail.isUpdateTheOld\">\r\n                    <el-form-item label=\"联系人电话\">\r\n                        <span>{{ faceApproveDetail.contactPhone }}</span>\r\n                    </el-form-item>\r\n                </el-row>\r\n                <el-row :span=\"24\" v-if=\"!faceApproveDetail.isUpdateTheOld\">\r\n                    <el-form-item label=\"联系人人脸照片\">\r\n                        <img :src=\"faceApproveDetail.contactPicture\" style=\"width: 200px;\" />\r\n                    </el-form-item>\r\n                    <el-form-item label=\"更新联系人人脸照片\">\r\n                        <img :src=\"faceApproveDetail.updatePicturePath\" style=\"width: 200px;\" />\r\n                    </el-form-item>\r\n\r\n                </el-row>\r\n\r\n                <el-row :span=\"24\">\r\n                    <el-form-item label=\"是否通过\">\r\n                        <el-select v-model=\"status\">\r\n                            <el-option label=\"通过\" value=\"1\"></el-option>\r\n                            <el-option label=\"不通过\" value=\"2\"></el-option>\r\n                        </el-select>\r\n                    </el-form-item>\r\n                </el-row>\r\n\r\n                <el-row :span=\"24\">\r\n                    <el-form-item>\r\n                        <el-button type=\"primary\" @click=\"handleUpdate\">确定</el-button>\r\n                    </el-form-item>\r\n                </el-row>\r\n            </el-form>\r\n        </div>\r\n    </div>\r\n</template>\r\n<script>\r\nimport {\r\n    getFaceApproveDetail,\r\n    faceInfoUpdate\r\n} from \"@/services/all-api.js\"\r\nimport { mapState } from \"vuex\";\r\nimport dataApi from \"./_api/api\";\r\nimport { async } from \"q\";\r\nexport default {\r\n    data() {\r\n        return {\r\n            status: \"1\",\r\n            isLoading: false,\r\n            faceApproveDetail: {}\r\n        };\r\n    },\r\n    computed: {\r\n        ...mapState([\"oneObj\"])\r\n    },\r\n    methods: {\r\n        handleFaceApproveDetail() {\r\n            getFaceApproveDetail({\r\n                gid: sessionStorage.getItem(\"faceUpdateGid\"),\r\n            }).then(res => {\r\n                console.log(res.data);\r\n                this.faceApproveDetail = res.data;\r\n            });\r\n        },\r\n        handleUpdate() {\r\n            this.isLoading = true;\r\n\r\n            //整合接口后\r\n            let obj = {\r\n                gid: this.faceApproveDetail.gid,\r\n                IsUpdateTheOld: this.faceApproveDetail.isUpdateTheOld,\r\n                status: this.status\r\n            }\r\n\r\n            faceInfoUpdate(obj).then(res => {\r\n                this.isLoading = false;\r\n                if (res.code === 0) {\r\n                    this.$message.success(\"更新成功\");\r\n                    this.$router.go(-1);\r\n                } else {\r\n                    this.$message.error(`更新失败:${res.des || \"\"}`);\r\n                }\r\n\r\n            });\r\n\r\n        }\r\n    },\r\n    created() {\r\n        this.handleFaceApproveDetail();\r\n        console.log(sessionStorage.getItem(\"faceUpdateGid\"));\r\n    },\r\n    mounted() { }\r\n};\r\n</script>  \r\n<style lang=\"scss\" scoped>\r\n.outDiv {\r\n    width: 100%;\r\n    -webkit-box-shadow: 0 2px 12px 0 rgba(0, 0, 0, 0.1);\r\n    box-shadow: 0 2px 12px 0 rgba(0, 0, 0, 0.1);\r\n    border: 1px solid #ebeef5;\r\n    padding: 20px;\r\n    min-height: 200px;\r\n}\r\n\r\n.serviceopen {\r\n    display: flex;\r\n    flex-flow: row;\r\n}\r\n\r\n.openForm {\r\n    padding-top: 30px;\r\n}\r\n\r\n.textFont {\r\n    font-size: 14px;\r\n    color: green;\r\n}\r\n</style>\r\n","var render = function render(){var _vm=this,_c=_vm._self._c;return _c('div',{directives:[{name:\"loading\",rawName:\"v-loading\",value:(_vm.isLoading),expression:\"isLoading\"}],staticClass:\"outDiv\"},[_vm._m(0),_c('div',{staticClass:\"openForm\"},[_c('el-form',{attrs:{\"labelWidth\":\"160px\",\"labelPosition\":\"right\",\"size\":\"medium\"}},[_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"老人姓名\"}},[_c('span',[_vm._v(_vm._s(_vm.faceApproveDetail.theOldName))])])],1),_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"身份证号码\"}},[_c('span',[_vm._v(_vm._s(_vm.faceApproveDetail.idCard))])])],1),_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"所属社区\"}},[_c('span',[_vm._v(_vm._s(_vm.faceApproveDetail.community))])])],1),_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"老人人脸照片\"}},[_c('img',{staticStyle:{\"width\":\"200px\"},attrs:{\"src\":_vm.faceApproveDetail.theOldPicture}})]),(_vm.faceApproveDetail.isUpdateTheOld)?_c('el-form-item',{attrs:{\"label\":\"更新老人人脸照片\"}},[_c('img',{staticStyle:{\"width\":\"200px\"},attrs:{\"src\":_vm.faceApproveDetail.updatePicturePath}})]):_vm._e()],1),(!_vm.faceApproveDetail.isUpdateTheOld)?_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"联系人姓名\"}},[_c('span',[_vm._v(_vm._s(_vm.faceApproveDetail.contactName))])])],1):_vm._e(),(!_vm.faceApproveDetail.isUpdateTheOld)?_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"与老人关系\"}},[_c('span',[_vm._v(_vm._s(_vm.faceApproveDetail.relationship))])])],1):_vm._e(),(!_vm.faceApproveDetail.isUpdateTheOld)?_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"联系人电话\"}},[_c('span',[_vm._v(_vm._s(_vm.faceApproveDetail.contactPhone))])])],1):_vm._e(),(!_vm.faceApproveDetail.isUpdateTheOld)?_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"联系人人脸照片\"}},[_c('img',{staticStyle:{\"width\":\"200px\"},attrs:{\"src\":_vm.faceApproveDetail.contactPicture}})]),_c('el-form-item',{attrs:{\"label\":\"更新联系人人脸照片\"}},[_c('img',{staticStyle:{\"width\":\"200px\"},attrs:{\"src\":_vm.faceApproveDetail.updatePicturePath}})])],1):_vm._e(),_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',{attrs:{\"label\":\"是否通过\"}},[_c('el-select',{model:{value:(_vm.status),callback:function ($$v) {_vm.status=$$v},expression:\"status\"}},[_c('el-option',{attrs:{\"label\":\"通过\",\"value\":\"1\"}}),_c('el-option',{attrs:{\"label\":\"不通过\",\"value\":\"2\"}})],1)],1)],1),_c('el-row',{attrs:{\"span\":24}},[_c('el-form-item',[_c('el-button',{attrs:{\"type\":\"primary\"},on:{\"click\":_vm.handleUpdate}},[_vm._v(\"确定\")])],1)],1)],1)],1)])\n}\nvar staticRenderFns = [function (){var _vm=this,_c=_vm._self._c;return _c('div',{staticClass:\"serviceopen\"},[_c('div',{staticStyle:{\"display\":\"flex\",\"align-items\":\"center\"}},[_c('span',{staticClass:\"approveTitle\"},[_vm._v(\"人脸信息登记详情\")])])])\n}]\n\nexport { render, staticRenderFns }","// 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","import mod from \"-!../../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../../node_modules/thread-loader/dist/cjs.js!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./servicefacedetail.vue?vue&type=script&lang=js\"; export default mod; export * from \"-!../../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../../node_modules/thread-loader/dist/cjs.js!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./servicefacedetail.vue?vue&type=script&lang=js\"","export * from \"-!../../../../node_modules/cache-loader/dist/cjs.js?{\\\"cacheDirectory\\\":\\\"node_modules/.cache/vue-loader\\\",\\\"cacheIdentifier\\\":\\\"fefe3d06-vue-loader-template\\\"}!../../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/vue-loader/lib/loaders/templateLoader.js??ref--6!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./servicefacedetail.vue?vue&type=template&id=4b6806c5&scoped=true\"","import { render, staticRenderFns } from \"./servicefacedetail.vue?vue&type=template&id=4b6806c5&scoped=true\"\nimport script from \"./servicefacedetail.vue?vue&type=script&lang=js\"\nexport * from \"./servicefacedetail.vue?vue&type=script&lang=js\"\nimport style0 from \"./servicefacedetail.vue?vue&type=style&index=0&id=4b6806c5&prod&lang=scss&scoped=true\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  \"4b6806c5\",\n  null\n  \n)\n\nexport default component.exports","export * from \"-!../../../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--8-oneOf-1-0!../../../../node_modules/css-loader/index.js??ref--8-oneOf-1-1!../../../../node_modules/vue-loader/lib/loaders/stylePostLoader.js!../../../../node_modules/postcss-loader/src/index.js??ref--8-oneOf-1-2!../../../../node_modules/sass-loader/dist/cjs.js??ref--8-oneOf-1-3!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./servicefacedetail.vue?vue&type=style&index=0&id=4b6806c5&prod&lang=scss&scoped=true\""],"sourceRoot":""}