{"version":3,"sources":["webpack:///D:/a/1/s/frontend/node_modules/babel-runtime/core-js/json/stringify.js","webpack:///D:/a/1/s/frontend/node_modules/core-js/library/fn/json/stringify.js","webpack:///D:/a/1/s/frontend/node_modules/timers-browserify/main.js","webpack:///D:/a/1/s/frontend/node_modules/setimmediate/setImmediate.js","webpack:///D:/a/1/s/frontend/node_modules/q/q.js"],"names":["module","exports","default","__webpack_require__","__esModule","core","$JSON","JSON","stringify","it","apply","arguments","global","scope","self","window","Function","prototype","Timeout","id","clearFn","this","_id","_clearFn","setTimeout","call","clearTimeout","setInterval","clearInterval","timeout","close","unref","ref","enroll","item","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","setImmediate","clearImmediate","process","undefined","registerImmediate","html","channel","messagePrefix","onGlobalMessage","nextHandle","tasksByHandle","currentlyRunningATask","doc","document","attachTo","Object","getPrototypeOf","toString","handle","nextTick","runIfPresent","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","canUsePostMessage","MessageChannel","port1","event","data","port2","createElement","documentElement","script","onreadystatechange","removeChild","appendChild","Math","random","source","indexOf","slice","length","addEventListener","attachEvent","callback","args","Array","i","task","run","definition","bootstrap","hasStacks","Error","e","stack","qFileName","qStartingLine","captureLine","noop","head","next","tail","flushing","requestTick","isNodeJS","laterQueue","flush","domain","enter","runSingle","pop","exit","bind","requestPortTick","runAfter","push","uncurryThis","f","QReturnValue","array_slice","array_reduce","reduce","basis","index","TypeError","array_indexOf","value","array_map","map","thisp","collect","object_create","create","Type","object_defineProperty","defineProperty","obj","prop","descriptor","object_hasOwnProperty","hasOwnProperty","object_keys","keys","object","key","object_toString","ReturnValue","STACK_JUMP_SEPARATOR","makeStackTraceLong","error","promise","stacks","p","__minimumStackCounter__","stackCounter","configurable","unshift","stackString","lines","split","desiredLines","line","isInternalFrame","stackLine","join","filterStackString","getFileNameAndLineNumber","attempt1","exec","Number","attempt2","attempt3","fileNameAndLineNumber","fileName","lineNumber","qEndingLine","Q","Promise","isPromiseAlike","deferred","defer","then","resolve","reject","notify","exception","fulfill","longStackSupport","longStackCounter","resolvedPromise","messages","progressListeners","promiseDispatch","op","operands","valueOf","nearerValue","nearer","isPromise","inspect","state","substring","become","newPromise","message","reason","progress","progressListener","resolver","race","answerPs","len","fallback","result","inspected","when","fulfilled","rejected","progressed","NODE_ENV","Q_DEBUG","makeNodeResolver","all","passByCopy","x","y","that","spread","makePromise","done","_fulfilled","newException","_rejected","newValue","threw","_progressed","onerror","tap","fcall","thenResolve","thenReject","isPending","isFulfilled","isRejected","unhandledReasons","unhandledRejections","reportedUnhandledRejections","trackUnhandledRejections","resetUnhandledRejections","rejection","at","emit","atReport","splice","untrackRejection","trackRejection","get","name","set","rhs","delete","post","dispatch","promises","pendingCount","snapshot","any","prev","current","err","allResolved","getUnhandledReasons","stopUnhandledRejectionTracking","master","isDef","array","async","makeGenerator","continuer","verb","arg","StopIteration","generator","errback","isStopIteration","spawn","promised","del","mapply","send","mcall","invoke","fapply","fbind","concat","console","warn","allSettled","regardless","fail","fin","onUnhandledError","ms","timeoutId","code","delay","nfapply","nodeArgs","nfcall","nfbind","denodeify","baseArgs","nbind","nmapply","npost","nsend","nmcall","ninvoke","nodeify","nodeback","noConflict"],"mappings":"qFAAAA,EAAAC,SAAkBC,QAAYC,EAAQ,KAAmCC,YAAA,8BCAzE,IAAAC,EAAWF,EAAQ,GACnBG,EAAAD,EAAAE,OAAAF,EAAAE,MAAuCC,UAAAD,KAAAC,YACvCR,EAAAC,QAAA,SAAAQ,GACA,OAAAH,EAAAE,UAAAE,MAAAJ,EAAAK,wCCHA,SAAAC,GAAA,IAAAC,OAAA,IAAAD,MACA,oBAAAE,YACAC,OACAL,EAAAM,SAAAC,UAAAP,MAiBA,SAAAQ,EAAAC,EAAAC,GACAC,KAAAC,IAAAH,EACAE,KAAAE,SAAAH,EAfAnB,QAAAuB,WAAA,WACA,WAAAN,EAAAR,EAAAe,KAAAD,WAAAX,EAAAF,WAAAe,eAEAzB,QAAA0B,YAAA,WACA,WAAAT,EAAAR,EAAAe,KAAAE,YAAAd,EAAAF,WAAAiB,gBAEA3B,QAAAyB,aACAzB,QAAA2B,cAAA,SAAAC,GACAA,GACAA,EAAAC,SAQAZ,EAAAD,UAAAc,MAAAb,EAAAD,UAAAe,IAAA,aACAd,EAAAD,UAAAa,MAAA,WACAT,KAAAE,SAAAE,KAAAZ,EAAAQ,KAAAC,MAIArB,QAAAgC,OAAA,SAAAC,EAAAC,GACAT,aAAAQ,EAAAE,gBACAF,EAAAG,aAAAF,GAGAlC,QAAAqC,SAAA,SAAAJ,GACAR,aAAAQ,EAAAE,gBACAF,EAAAG,cAAA,GAGApC,QAAAsC,aAAAtC,QAAAuC,OAAA,SAAAN,GACAR,aAAAQ,EAAAE,gBAEA,IAAAD,EAAAD,EAAAG,aACAF,GAAA,IACAD,EAAAE,eAAAZ,WAAA,WACAU,EAAAO,YACAP,EAAAO,cACKN,KAKLhC,EAAQ,KAIRF,QAAAyC,aAAA,oBAAA5B,WAAA4B,mBACA,IAAA9B,KAAA8B,cACArB,WAAAqB,aACAzC,QAAA0C,eAAA,oBAAA7B,WAAA6B,qBACA,IAAA/B,KAAA+B,gBACAtB,WAAAsB,8DC9DA,SAAA/B,EAAAgC,IAAA,SAAAhC,EAAAiC,GACA,aAEA,IAAAjC,EAAA8B,aAAA,CAIA,IAIAI,EA6HAC,EAZAC,EArBAC,EACAC,EAjGAC,EAAA,EACAC,KACAC,GAAA,EACAC,EAAA1C,EAAA2C,SAoJAC,EAAAC,OAAAC,gBAAAD,OAAAC,eAAA9C,GACA4C,OAAAhC,WAAAgC,EAAA5C,EAGU,wBAAA+C,SAAAlC,KAAAb,EAAAgC,SApFVE,EAAA,SAAAc,GACAhB,EAAAiB,SAAA,WAA0CC,EAAAF,OAI1C,WAGA,GAAAhD,EAAAmD,cAAAnD,EAAAoD,cAAA,CACA,IAAAC,GAAA,EACAC,EAAAtD,EAAAuD,UAMA,OALAvD,EAAAuD,UAAA,WACAF,GAAA,GAEArD,EAAAmD,YAAA,QACAnD,EAAAuD,UAAAD,EACAD,GAwEKG,GAIAxD,EAAAyD,iBA9CLrB,EAAA,IAAAqB,gBACAC,MAAAH,UAAA,SAAAI,GAEAT,EADAS,EAAAC,OAIA1B,EAAA,SAAAc,GACAZ,EAAAyB,MAAAV,YAAAH,KA2CKN,GAAA,uBAAAA,EAAAoB,cAAA,WAtCL3B,EAAAO,EAAAqB,gBACA7B,EAAA,SAAAc,GAGA,IAAAgB,EAAAtB,EAAAoB,cAAA,UACAE,EAAAC,mBAAA,WACAf,EAAAF,GACAgB,EAAAC,mBAAA,KACA9B,EAAA+B,YAAAF,GACAA,EAAA,MAEA7B,EAAAgC,YAAAH,KAKA9B,EAAA,SAAAc,GACApC,WAAAsC,EAAA,EAAAF,KAlDAX,EAAA,gBAAA+B,KAAAC,SAAA,IACA/B,EAAA,SAAAqB,GACAA,EAAAW,SAAAtE,GACA,iBAAA2D,EAAAC,MACA,IAAAD,EAAAC,KAAAW,QAAAlC,IACAa,GAAAS,EAAAC,KAAAY,MAAAnC,EAAAoC,UAIAzE,EAAA0E,iBACA1E,EAAA0E,iBAAA,UAAApC,GAAA,GAEAtC,EAAA2E,YAAA,YAAArC,GAGAJ,EAAA,SAAAc,GACAhD,EAAAmD,YAAAd,EAAAW,EAAA,OAgEAJ,EAAAd,aA1KA,SAAA8C,GAEA,mBAAAA,IACAA,EAAA,IAAAxE,SAAA,GAAAwE,IAIA,IADA,IAAAC,EAAA,IAAAC,MAAA/E,UAAA0E,OAAA,GACAM,EAAA,EAAqBA,EAAAF,EAAAJ,OAAiBM,IACtCF,EAAAE,GAAAhF,UAAAgF,EAAA,GAGA,IAAAC,GAAkBJ,WAAAC,QAGlB,OAFArC,EAAAD,GAAAyC,EACA9C,EAAAK,GACAA,KA6JAK,EAAAb,iBA1JA,SAAAA,EAAAiB,UACAR,EAAAQ,GAyBA,SAAAE,EAAAF,GAGA,GAAAP,EAGA7B,WAAAsC,EAAA,EAAAF,OACS,CACT,IAAAgC,EAAAxC,EAAAQ,GACA,GAAAgC,EAAA,CACAvC,GAAA,EACA,KAjCA,SAAAuC,GACA,IAAAJ,EAAAI,EAAAJ,SACAC,EAAAG,EAAAH,KACA,OAAAA,EAAAJ,QACA,OACAG,IACA,MACA,OACAA,EAAAC,EAAA,IACA,MACA,OACAD,EAAAC,EAAA,GAAAA,EAAA,IACA,MACA,OACAD,EAAAC,EAAA,GAAAA,EAAA,GAAAA,EAAA,IACA,MACA,QACAD,EAAA9E,MAAAmC,EAAA4C,IAiBAI,CAAAD,GACiB,QACjBjD,EAAAiB,GACAP,GAAA,MAvEA,CAyLC,oBAAAvC,UAAA,IAAAF,EAAAS,KAAAT,EAAAE,2DCzLD,SAAA8B,EAAAF,IA4BA,SAAAoD,GACA,aAQA,mBAAAC,UACAA,UAAA,UAAAD,GAIA9F,EAAAC,QAAA6F,IAdA,CAkDC,WACD,aAEA,IAAAE,GAAA,EACA,IACA,UAAAC,MACC,MAAAC,GACDF,IAAAE,EAAAC,MAKA,IACAC,EADAC,EAAAC,IAMAC,EAAA,aAIA1C,EAAA,WAEA,IAAA2C,GAAgBZ,UAAA,EAAAa,KAAA,MAChBC,EAAAF,EACAG,GAAA,EACAC,OAAA,EACAC,GAAA,EAEAC,KAEA,SAAAC,IAIA,IAFA,IAAAnB,EAAAoB,EAEAR,EAAAC,MAEAb,GADAY,IAAAC,MACAb,KACAY,EAAAZ,UAAA,GACAoB,EAAAR,EAAAQ,UAGAR,EAAAQ,YAAA,EACAA,EAAAC,SAEAC,EAAAtB,EAAAoB,GAGA,KAAAF,EAAAzB,QAEA6B,EADAtB,EAAAkB,EAAAK,OAGAR,GAAA,EAGA,SAAAO,EAAAtB,EAAAoB,GACA,IACApB,IAES,MAAAM,GACT,GAAAW,EAeA,MARAG,GACAA,EAAAI,OAEA5F,WAAAuF,EAAA,GACAC,GACAA,EAAAC,QAGAf,EAKA1E,WAAA,WACA,MAAA0E,GACiB,GAIjBc,GACAA,EAAAI,OAiBA,GAbAvD,EAAA,SAAA+B,GACAc,IAAAD,MACAb,OACAoB,OAAAH,GAAAjE,EAAAoE,OACAP,KAAA,MAGAE,IACAA,GAAA,EACAC,MAIA,iBAAAhE,GACA,qBAAAA,EAAAe,YAAAf,EAAAiB,SASAgD,GAAA,EAEAD,EAAA,WACAhE,EAAAiB,SAAAkD,SAGK,sBAAArE,EAGLkE,EADA,oBAAA7F,OACA2B,EAAA2E,KAAAtG,OAAAgG,GAEA,WACArE,EAAAqE,SAIK,uBAAA1C,eAAA,CAGL,IAAArB,EAAA,IAAAqB,eAGArB,EAAAsB,MAAAH,UAAA,WACAyC,EAAAU,EACAtE,EAAAsB,MAAAH,UAAA4C,EACAA,KAEA,IAAAO,EAAA,WAGAtE,EAAAyB,MAAAV,YAAA,IAEA6C,EAAA,WACApF,WAAAuF,EAAA,GACAO,UAKAV,EAAA,WACApF,WAAAuF,EAAA,IAaA,OAPAlD,EAAA0D,SAAA,SAAA3B,GACAkB,EAAAU,KAAA5B,GACAe,IACAA,GAAA,EACAC,MAGA/C,EAlJA,GA+JApC,EAAAT,SAAAS,KACA,SAAAgG,EAAAC,GACA,kBACA,OAAAjG,EAAAf,MAAAgH,EAAA/G,YAOA,IA+FAgH,EA/FAC,EAAAH,EAAA/B,MAAAzE,UAAAmE,OAEAyC,EAAAJ,EACA/B,MAAAzE,UAAA6G,QAAA,SAAAtC,EAAAuC,GACA,IAAAC,EAAA,EACA3C,EAAAhE,KAAAgE,OAEA,OAAA1E,UAAA0E,OAGA,QACA,GAAA2C,KAAA3G,KAAA,CACA0G,EAAA1G,KAAA2G,KACA,MAEA,KAAAA,GAAA3C,EACA,UAAA4C,UAKA,KAAcD,EAAA3C,EAAgB2C,IAE9BA,KAAA3G,OACA0G,EAAAvC,EAAAuC,EAAA1G,KAAA2G,OAGA,OAAAD,IAIAG,EAAAT,EACA/B,MAAAzE,UAAAkE,SAAA,SAAAgD,GAEA,QAAAxC,EAAA,EAAuBA,EAAAtE,KAAAgE,OAAiBM,IACxC,GAAAtE,KAAAsE,KAAAwC,EACA,OAAAxC,EAGA,WAIAyC,EAAAX,EACA/B,MAAAzE,UAAAoH,KAAA,SAAA7C,EAAA8C,GACA,IAAAxH,EAAAO,KACAkH,KAIA,OAHAV,EAAA/G,EAAA,SAAA+B,EAAAsF,EAAAH,GACAO,EAAAf,KAAAhC,EAAA/D,KAAA6G,EAAAH,EAAAH,EAAAlH,UACS,GACTyH,IAIAC,EAAA/E,OAAAgF,QAAA,SAAAxH,GACA,SAAAyH,KAEA,OADAA,EAAAzH,YACA,IAAAyH,GAGAC,EAAAlF,OAAAmF,gBAAA,SAAAC,EAAAC,EAAAC,GAEA,OADAF,EAAAC,GAAAC,EAAAZ,MACAU,GAGAG,EAAAvB,EAAAhE,OAAAxC,UAAAgI,gBAEAC,EAAAzF,OAAA0F,MAAA,SAAAC,GACA,IAAAD,KACA,QAAAE,KAAAD,EACAJ,EAAAI,EAAAC,IACAF,EAAA3B,KAAA6B,GAGA,OAAAF,GAGAG,EAAA7B,EAAAhE,OAAAxC,UAAA0C,UAoBAgE,EADA,oBAAA4B,YACAA,YAEA,SAAApB,GACA9G,KAAA8G,SAMA,IAAAqB,EAAA,uBAEA,SAAAC,EAAAC,EAAAC,GAGA,GAAA3D,GACA2D,EAAAxD,OACA,iBAAAuD,GACA,OAAAA,GACAA,EAAAvD,MACA,CAEA,IADA,IAAAyD,KACAC,EAAAF,EAA6BE,EAAKA,IAAA3E,OAClC2E,EAAA1D,SAAAuD,EAAAI,yBAAAJ,EAAAI,wBAAAD,EAAAE,gBACApB,EAAAe,EAAA,2BAAyEvB,MAAA0B,EAAAE,aAAAC,cAAA,IACzEJ,EAAAK,QAAAJ,EAAA1D,QAGAyD,EAAAK,QAAAP,EAAAvD,OAEA,IACAA,EAKA,SAAA+D,GAGA,IAFA,IAAAC,EAAAD,EAAAE,MAAA,MACAC,KACA1E,EAAA,EAAmBA,EAAAwE,EAAA9E,SAAkBM,EAAA,CACrC,IAAA2E,EAAAH,EAAAxE,IAEA4E,EAAAD,MAQA,KADAE,EAPAF,GAQAnF,QAAA,iBACA,IAAAqF,EAAArF,QAAA,eATAmF,GACAD,EAAA7C,KAAA8C,GAMA,IAAAE,EAHA,OAAAH,EAAAI,KAAA,MAfAC,CADAd,EAAAa,KAAA,KAAAjB,EAAA,OAEAb,EAAAe,EAAA,SAA+CvB,MAAAhC,EAAA6D,cAAA,KAsB/C,SAAAW,EAAAH,GAGA,IAAAI,EAAA,gCAAAC,KAAAL,GACA,GAAAI,EACA,OAAAA,EAAA,GAAAE,OAAAF,EAAA,KAIA,IAAAG,EAAA,4BAAAF,KAAAL,GACA,GAAAO,EACA,OAAAA,EAAA,GAAAD,OAAAC,EAAA,KAIA,IAAAC,EAAA,iBAAAH,KAAAL,GACA,OAAAQ,GACAA,EAAA,GAAAF,OAAAE,EAAA,UADA,EAKA,SAAAT,EAAAC,GACA,IAAAS,EAAAN,EAAAH,GAEA,IAAAS,EACA,SAGA,IAAAC,EAAAD,EAAA,GACAE,EAAAF,EAAA,GAEA,OAAAC,IAAA9E,GACA+E,GAAA9E,GACA8E,GAAAC,EAKA,SAAA9E,IACA,GAAAN,EAIA,IACA,UAAAC,MACK,MAAAC,GACL,IAAAiE,EAAAjE,EAAAC,MAAAiE,MAAA,MAEAa,EAAAN,EADAR,EAAA,GAAAhF,QAAA,OAAAgF,EAAA,GAAAA,EAAA,IAEA,IAAAc,EACA,OAIA,OADA7E,EAAA6E,EAAA,GACAA,EAAA,IAuBA,SAAAI,EAAAlD,GAIA,OAAAA,aAAAmD,EACAnD,EAIAoD,EAAApD,IAsrBAwB,EArrBAxB,EAsrBAqD,EAAAC,IACAJ,EAAAxH,SAAA,WACA,IACA8F,EAAA+B,KAAAF,EAAAG,QAAAH,EAAAI,OAAAJ,EAAAK,QACS,MAAAC,GACTN,EAAAI,OAAAE,MAGAN,EAAA7B,SA5rBAoC,EAAA5D,GAmrBA,IAAAwB,EACA6B,EAjrBAH,EAAAM,QAAAN,EAMAA,EAAAxH,WAKAwH,EAAAW,kBAAA,EAQA,IAAAC,EAAA,EAkBA,SAAAR,IAOA,IAAAS,EAAAC,KAAAC,KAEAZ,EAAAhD,EAAAiD,EAAAxK,WACA0I,EAAAnB,EAAA8C,EAAArK,WAmCA,GAjCA0I,EAAA0C,gBAAA,SAAAV,EAAAW,EAAAC,GACA,IAAA9G,EAAAmC,EAAAjH,WACAwL,GACAA,EAAA3E,KAAA/B,GACA,SAAA6G,GAAAC,EAAA,IACAH,EAAA5E,KAAA+E,EAAA,KAGAlB,EAAAxH,SAAA,WACAqI,EAAAG,gBAAA3L,MAAAwL,EAAAzG,MAMAkE,EAAA6C,QAAA,WACA,GAAAL,EACA,OAAAxC,EAEA,IAAA8C,EAAAC,EAAAR,GAIA,OAHAS,EAAAF,KACAP,EAAAO,GAEAA,GAGA9C,EAAAiD,QAAA,WACA,OAAAV,EAGAA,EAAAU,WAFoBC,MAAA,YAKpBxB,EAAAW,kBAAAhG,EACA,IACA,UAAAC,MACS,MAAAC,GAOTyD,EAAAxD,MAAAD,EAAAC,MAAA2G,UAAA5G,EAAAC,MAAAhB,QAAA,SACAwE,EAAAI,aAAAkC,IAQA,SAAAc,EAAAC,GACAd,EAAAc,EAEA3B,EAAAW,kBAAAhG,IAGA2D,EAAAzE,OAAA8H,GAGAnF,EAAAsE,EAAA,SAAAtJ,EAAAoK,GACA5B,EAAAxH,SAAA,WACAmJ,EAAAX,gBAAA3L,MAAAsM,EAAAC,WAES,GAETd,OAAA,EACAC,OAAA,EAsCA,OAnCAZ,EAAA7B,UACA6B,EAAAG,QAAA,SAAAxD,GACA+D,GAIAa,EAAA1B,EAAAlD,KAGAqD,EAAAO,QAAA,SAAA5D,GACA+D,GAIAa,EAAAhB,EAAA5D,KAEAqD,EAAAI,OAAA,SAAAsB,GACAhB,GAIAa,EAAAnB,EAAAsB,KAEA1B,EAAAK,OAAA,SAAAsB,GACAjB,GAIArE,EAAAuE,EAAA,SAAAvJ,EAAAuK,GACA/B,EAAAxH,SAAA,WACAuJ,EAAAD,WAES,IAGT3B,EA6BA,SAAA7B,EAAA0D,GACA,sBAAAA,EACA,UAAApF,UAAA,gCAEA,IAAAuD,EAAAC,IACA,IACA4B,EAAA7B,EAAAG,QAAAH,EAAAI,OAAAJ,EAAAK,QACK,MAAAqB,GACL1B,EAAAI,OAAAsB,GAEA,OAAA1B,EAAA7B,QAqDA,SAAA2D,EAAAC,GACA,OAAA5D,EAAA,SAAAgC,EAAAC,GAMA,QAAAjG,EAAA,EAAA6H,EAAAD,EAAAlI,OAA8CM,EAAA6H,EAAS7H,IACvD0F,EAAAkC,EAAA5H,IAAA+F,KAAAC,EAAAC,KAqBA,SAAAN,EAAAvC,EAAA0E,EAAAb,QACA,IAAAa,IACAA,EAAA,SAAAnB,GACA,OAAAV,EAAA,IAAA3F,MACA,uCAAAqG,WAIA,IAAAM,IACAA,EAAA,WACA,OAAoBC,MAAA,aAIpB,IAAAlD,EAAAnB,EAAA8C,EAAArK,WAqBA,GAnBA0I,EAAA0C,gBAAA,SAAAV,EAAAW,EAAA7G,GACA,IAAAiI,EACA,IAEAA,EADA3E,EAAAuD,GACAvD,EAAAuD,GAAA5L,MAAAiJ,EAAAlE,GAEAgI,EAAAhM,KAAAkI,EAAA2C,EAAA7G,GAES,MAAAqG,GACT4B,EAAA9B,EAAAE,GAEAH,GACAA,EAAA+B,IAIA/D,EAAAiD,UAGAA,EAAA,CACA,IAAAe,EAAAf,IACA,aAAAe,EAAAd,QACAlD,EAAAmC,UAAA6B,EAAAT,QAGAvD,EAAA6C,QAAA,WACA,IAAAmB,EAAAf,IACA,kBAAAe,EAAAd,OACA,aAAAc,EAAAd,MACAlD,EAEAgE,EAAAxF,OAIA,OAAAwB,EAuHA,SAAAiE,EAAAzF,EAAA0F,EAAAC,EAAAC,GACA,OAAA1C,EAAAlD,GAAAuD,KAAAmC,EAAAC,EAAAC,GA+BA,SAAArB,EAAAvE,GACA,GAAAwE,EAAAxE,GAAA,CACA,IAAAwF,EAAAxF,EAAAyE,UACA,iBAAAe,EAAAd,MACA,OAAAc,EAAAxF,MAGA,OAAAA,EAQA,SAAAwE,EAAAvD,GACA,OAAAA,aAAAkC,EAIA,SAAAC,EAAAnC,GACA,OAtpBAjB,EAspBAiB,KArpBA3F,OAAA0E,IAqpBA,mBAAAiB,EAAAsC,KAtpBA,IAAAvD,EAyLA,iBAAAvF,MAA8Ca,QAAAuK,SAAA,gBAAevK,QAAAuK,SAAA,eAAWC,UACxE5C,EAAAW,kBAAA,GAaAX,EAAAI,QA+HAA,EAAAxK,UAAAiN,iBAAA,WACA,IAAApN,EAAAO,KACA,gBAAAqI,EAAAvB,GACAuB,EACA5I,EAAA8K,OAAAlC,GACS/I,UAAA0E,OAAA,EACTvE,EAAA6K,QAAA/D,EAAAjH,UAAA,IAEAG,EAAA6K,QAAAxD,KAWAkD,EAAAC,QAAA3B,EACA0B,EAAA1B,UAcAA,EAAA2D,OACA3D,EAAAwE,MACAxE,EAAAiC,SACAjC,EAAAgC,QAAAN,EAKAA,EAAA+C,WAAA,SAAAhF,GAGA,OAAAA,GAGAkC,EAAArK,UAAAmN,WAAA,WAGA,OAAA/M,MAYAgK,EAAAZ,KAAA,SAAA4D,EAAAC,GACA,OAAAjD,EAAAgD,GAAA5D,KAAA6D,IAGAhD,EAAArK,UAAAwJ,KAAA,SAAA8D,GACA,OAAAlD,GAAAhK,KAAAkN,IAAAC,OAAA,SAAAH,EAAAC,GACA,GAAAD,IAAAC,EAEA,OAAAD,EAEA,UAAApI,MAAA,+BAAAoI,EAAA,IAAAC,MAUAjD,EAAAiC,OAcAhC,EAAArK,UAAAqM,KAAA,WACA,OAAAjM,KAAAqK,KAAAL,EAAAiC,OAcAjC,EAAAoD,YAAAnD,EAuDAA,EAAArK,UAAA0C,SAAA,WACA,0BAGA2H,EAAArK,UAAAyK,KAAA,SAAAmC,EAAAC,EAAAC,GACA,IAAAjN,EAAAO,KACAmK,EAAAC,IACAiD,GAAA,EAiEA,OAtCArD,EAAAxH,SAAA,WACA/C,EAAAuL,gBAAA,SAAAlE,GACAuG,IAGAA,GAAA,EAEAlD,EAAAG,QA/BA,SAAAxD,GACA,IACA,yBAAA0F,IAAA1F,KACS,MAAA2D,GACT,OAAAF,EAAAE,IA2BA6C,CAAAxG,MACS,iBAAA2D,GACT4C,IAGAA,GAAA,EAEAlD,EAAAG,QA9BA,SAAAG,GACA,sBAAAgC,EAAA,CACArE,EAAAqC,EAAAhL,GACA,IACA,OAAAgN,EAAAhC,GACa,MAAA8C,GACb,OAAAhD,EAAAgD,IAGA,OAAAhD,EAAAE,GAqBA+C,CAAA/C,UAKAhL,EAAAuL,qBAAA,0BAAAlE,GACA,IAAA2G,EACAC,GAAA,EACA,IACAD,EA3BA,SAAA3G,GACA,yBAAA4F,IAAA5F,KA0BA6G,CAAA7G,GACS,MAAAjC,GAET,GADA6I,GAAA,GACA1D,EAAA4D,QAGA,MAAA/I,EAFAmF,EAAA4D,QAAA/I,GAMA6I,GACAvD,EAAAK,OAAAiD,MAIAtD,EAAA7B,SAGA0B,EAAA6D,IAAA,SAAAvF,EAAAnE,GACA,OAAA6F,EAAA1B,GAAAuF,IAAA1J,IAeA8F,EAAArK,UAAAiO,IAAA,SAAA1J,GAGA,OAFAA,EAAA6F,EAAA7F,GAEAnE,KAAAqK,KAAA,SAAAvD,GACA,OAAA3C,EAAA2J,MAAAhH,GAAAiH,YAAAjH,MAoBAkD,EAAAuC,OAKAtC,EAAArK,UAAAmO,YAAA,SAAAjH,GACA,OAAA9G,KAAAqK,KAAA,WAAkC,OAAAvD,KAGlCkD,EAAA+D,YAAA,SAAAzF,EAAAxB,GACA,OAAAkD,EAAA1B,GAAAyF,YAAAjH,IAGAmD,EAAArK,UAAAoO,WAAA,SAAAnC,GACA,OAAA7L,KAAAqK,KAAA,WAAkC,MAAAwB,KAGlC7B,EAAAgE,WAAA,SAAA1F,EAAAuD,GACA,OAAA7B,EAAA1B,GAAA0F,WAAAnC,IAcA7B,EAAAqB,SAeArB,EAAAsB,YAKAtB,EAAAE,iBASAF,EAAAiE,UACA,SAAAlG,GACA,OAAAuD,EAAAvD,IAAA,YAAAA,EAAAwD,UAAAC,OAGAvB,EAAArK,UAAAqO,UAAA,WACA,kBAAAjO,KAAAuL,UAAAC,OAOAxB,EAAAkE,YACA,SAAAnG,GACA,OAAAuD,EAAAvD,IAAA,cAAAA,EAAAwD,UAAAC,OAGAvB,EAAArK,UAAAsO,YAAA,WACA,oBAAAlO,KAAAuL,UAAAC,OAMAxB,EAAAmE,WACA,SAAApG,GACA,OAAAuD,EAAAvD,IAAA,aAAAA,EAAAwD,UAAAC,OAGAvB,EAAArK,UAAAuO,WAAA,WACA,mBAAAnO,KAAAuL,UAAAC,OASA,IApkBArH,EAokBAiK,KACAC,KACAC,KACAC,GAAA,EAEA,SAAAC,IACAJ,EAAApK,OAAA,EACAqK,EAAArK,OAAA,EAEAuK,IACAA,GAAA,GAmEA,SAAAhE,EAAAsB,GACA,IAAA4C,EAAAxE,GACAsC,KAAA,SAAAE,GAKA,OAHAA,GA9CA,SAAAnE,GACA,GAAAiG,EAAA,CAIA,IAAAG,EAAA7H,EAAAwH,EAAA/F,IACA,IAAAoG,IACA,iBAAAnN,GAAA,mBAAAA,EAAAoN,MACA3E,EAAAxH,SAAA0D,SAAA,WACA,IAAA0I,EAAA/H,EAAAyH,EAAAhG,IACA,IAAAsG,IACArN,EAAAoN,KAAA,mBAAAP,EAAAM,GAAApG,GACAgG,EAAAO,OAAAD,EAAA,MAIAP,EAAAQ,OAAAH,EAAA,GACAN,EAAAS,OAAAH,EAAA,KA8BAI,CAAA9O,MAEAyM,IAAAZ,GAAA7L,OAEK,WACL,OAAAA,MACK,WACL,OAAgBwL,MAAA,WAAAK,YAMhB,OAjFA,SAAAvD,EAAAuD,GACA0C,IAGA,iBAAAhN,GAAA,mBAAAA,EAAAoN,MACA3E,EAAAxH,SAAA0D,SAAA,YACA,IAAAW,EAAAwH,EAAA/F,KACA/G,EAAAoN,KAAA,qBAAA9C,EAAAvD,GACAgG,EAAAnI,KAAAmC,MAKA+F,EAAAlI,KAAAmC,GACAuD,QAAA,IAAAA,EAAA/G,MACAsJ,EAAAjI,KAAA0F,EAAA/G,OAEAsJ,EAAAjI,KAAA,cAAA0F,IA8DAkD,CAAAN,EAAA5C,GAEA4C,EAQA,SAAA/D,EAAA5D,GACA,OAAAmD,GACAsC,KAAA,WACA,OAAAzF,GAEAkI,IAAA,SAAAC,GACA,OAAAnI,EAAAmI,IAEAC,IAAA,SAAAD,EAAAE,GACArI,EAAAmI,GAAAE,GAEAC,OAAA,SAAAH,UACAnI,EAAAmI,IAEAI,KAAA,SAAAJ,EAAA7K,GAGA,cAAA6K,QAAA,IAAAA,EACAnI,EAAAzH,WAAA,EAAA+E,GAEA0C,EAAAmI,GAAA5P,MAAAyH,EAAA1C,IAGA/E,MAAA,SAAA4H,EAAA7C,GACA,OAAA0C,EAAAzH,MAAA4H,EAAA7C,IAEA0D,KAAA,WACA,OAAAD,EAAAf,UAEK,aACL,OAAgB0E,MAAA,YAAA1E,WAoDhB,SAAAqG,EAAArG,EAAA0F,EAAAC,GACA,OAAAzC,EAAAlD,GAAAqG,OAAAX,EAAAC,GA+JA,SAAA6C,EAAAvH,EAAAkD,EAAA7G,GACA,OAAA4F,EAAAjC,GAAAuH,SAAArE,EAAA7G,GAiLA,SAAA0I,EAAAyC,GACA,OAAAhD,EAAAgD,EAAA,SAAAA,GACA,IAAAC,EAAA,EACArF,EAAAC,IA4BA,OA3BA5D,EAAA+I,EAAA,SAAA/N,EAAA8G,EAAA3B,GACA,IAAA8I,EAEAnE,EAAAhD,IACA,eAAAmH,EAAAnH,EAAAiD,WAAAC,MAEA+D,EAAA5I,GAAA8I,EAAA3I,SAEA0I,EACAjD,EACAjE,EACA,SAAAxB,GACAyI,EAAA5I,GAAAG,EACA,KAAA0I,GACArF,EAAAG,QAAAiF,IAGApF,EAAAI,OACA,SAAAuB,GACA3B,EAAAK,QAAyC7D,QAAAG,MAAAgF,aAIhC,GACT,IAAA0D,GACArF,EAAAG,QAAAiF,GAEApF,EAAA7B,UAiBA,SAAAoH,EAAAH,GACA,OAAAA,EAAAvL,OACA,OAAAgG,EAAAM,UAGA,IAAAH,EAAAH,EAAAI,QACAoF,EAAA,EA6BA,OA5BAhJ,EAAA+I,EAAA,SAAAI,EAAAC,EAAAjJ,GACA,IAAA2B,EAAAiH,EAAA5I,GAEA6I,IAEAjD,EAAAjE,EACA,SAAA+D,GACAlC,EAAAG,QAAA+B,IAEA,SAAAwD,GAEA,QADAL,EACA,CACA,IAAAf,EAAAoB,GAAA,IAAAjL,MAAA,GAAAiL,GAEApB,EAAA7C,QAAA,mGACA6C,EAAA7C,QAEAzB,EAAAI,OAAAkE,KAGA,SAAA3C,GACA3B,EAAAK,QACA7D,QACAG,MAAAgF,YAGKtK,GAEL2I,EAAA7B,QAiBA,SAAAwH,EAAAP,GACA,OAAAhD,EAAAgD,EAAA,SAAAA,GAEA,OADAA,EAAAxI,EAAAwI,EAAAvF,GACAuC,EAAAO,EAAA/F,EAAAwI,EAAA,SAAAjH,GACA,OAAAiE,EAAAjE,EAAApD,QACS,WACT,OAAAqK,MA7jBAvF,EAAAwE,2BAEAxE,EAAA+F,oBAAA,WAEA,OAAA3B,EAAArK,SAGAiG,EAAAgG,+BAAA,WACAxB,IACAD,GAAA,GAGAC,IAQAxE,EAAAO,SA0BAP,EAAAU,UA6DAV,EAAAiG,OACA,SAAAlI,GACA,OAAAkC,GACAiG,MAAA,cACK,SAAAjF,EAAA7G,GACL,OAAAkL,EAAAvH,EAAAkD,EAAA7G,IACK,WACL,OAAA4F,EAAAjC,GAAAwD,aAcAvB,EAAAmD,SAKAlD,EAAArK,UAAAuN,OAAA,SAAAX,EAAAC,GACA,OAAAzM,KAAA8M,MAAAzC,KAAA,SAAA8F,GACA,OAAA3D,EAAAnN,WAAA,EAAA8Q,IACK1D,IA6BLzC,EAAAoG,MACA,SAAAC,GACA,kBAGA,SAAAC,EAAAC,EAAAC,GACA,IAAAnE,EAUA,uBAAAoE,cAAA,CAEA,IACApE,EAAAqE,EAAAH,GAAAC,GACiB,MAAA/F,GACjB,OAAAF,EAAAE,GAEA,OAAA4B,EAAAgB,KACArD,EAAAqC,EAAAvF,OAEAyF,EAAAF,EAAAvF,MAAA3C,EAAAwM,GAKA,IACAtE,EAAAqE,EAAAH,GAAAC,GACiB,MAAA/F,GACjB,OA77BA,SAAAA,GACA,MACA,2BAAAxC,EAAAwC,IACAA,aAAAnE,EA07BAsK,CAAAnG,GACAT,EAAAS,EAAA3D,OAEAyD,EAAAE,GAGA,OAAA8B,EAAAF,EAAAlI,EAAAwM,GAGA,IAAAD,EAAAL,EAAAhR,MAAAW,KAAAV,WACA6E,EAAAmM,EAAAtK,KAAAsK,EAAA,QACAK,EAAAL,EAAAtK,KAAAsK,EAAA,SACA,OAAAnM,MAWA6F,EAAA6G,MACA,SAAAR,GACArG,EAAAqD,KAAArD,EAAAoG,MAAAC,EAAArG,KA4BAA,EAAA,OACA,SAAAlD,GACA,UAAAR,EAAAQ,IAkBAkD,EAAA8G,SACA,SAAA3M,GACA,kBACA,OAAAgJ,GAAAnN,KAAA8M,EAAAxN,YAAA,SAAAG,EAAA2E,GACA,OAAAD,EAAA9E,MAAAI,EAAA2E,OAYA4F,EAAAsF,WAKArF,EAAArK,UAAA0P,SAAA,SAAArE,EAAA7G,GACA,IAAA3E,EAAAO,KACAmK,EAAAC,IAIA,OAHAJ,EAAAxH,SAAA,WACA/C,EAAAuL,gBAAAb,EAAAG,QAAAW,EAAA7G,KAEA+F,EAAA7B,SASA0B,EAAAgF,IAAA,SAAAjH,EAAAC,GACA,OAAAgC,EAAAjC,GAAAuH,SAAA,OAAAtH,KAGAiC,EAAArK,UAAAoP,IAAA,SAAAhH,GACA,OAAAhI,KAAAsP,SAAA,OAAAtH,KAUAgC,EAAAkF,IAAA,SAAAnH,EAAAC,EAAAlB,GACA,OAAAkD,EAAAjC,GAAAuH,SAAA,OAAAtH,EAAAlB,KAGAmD,EAAArK,UAAAsP,IAAA,SAAAlH,EAAAlB,GACA,OAAA9G,KAAAsP,SAAA,OAAAtH,EAAAlB,KASAkD,EAAA+G,IACA/G,EAAA,gBAAAjC,EAAAC,GACA,OAAAgC,EAAAjC,GAAAuH,SAAA,UAAAtH,KAGAiC,EAAArK,UAAAmR,IACA9G,EAAArK,UAAA,gBAAAoI,GACA,OAAAhI,KAAAsP,SAAA,UAAAtH,KAgBAgC,EAAAgH,OACAhH,EAAAqF,KAAA,SAAAtH,EAAAkH,EAAA7K,GACA,OAAA4F,EAAAjC,GAAAuH,SAAA,QAAAL,EAAA7K,KAGA6F,EAAArK,UAAAoR,OACA/G,EAAArK,UAAAyP,KAAA,SAAAJ,EAAA7K,GACA,OAAApE,KAAAsP,SAAA,QAAAL,EAAA7K,KAUA4F,EAAAiH,KACAjH,EAAAkH,MACAlH,EAAAmH,OAAA,SAAApJ,EAAAkH,GACA,OAAAjF,EAAAjC,GAAAuH,SAAA,QAAAL,EAAA1I,EAAAjH,UAAA,MAGA2K,EAAArK,UAAAqR,KACAhH,EAAArK,UAAAsR,MACAjH,EAAArK,UAAAuR,OAAA,SAAAlC,GACA,OAAAjP,KAAAsP,SAAA,QAAAL,EAAA1I,EAAAjH,UAAA,MAQA0K,EAAAoH,OAAA,SAAArJ,EAAA3D,GACA,OAAA4F,EAAAjC,GAAAuH,SAAA,gBAAAlL,KAGA6F,EAAArK,UAAAwR,OAAA,SAAAhN,GACA,OAAApE,KAAAsP,SAAA,gBAAAlL,KAQA4F,EAAA,IACAA,EAAA8D,MAAA,SAAA/F,GACA,OAAAiC,EAAAjC,GAAAuH,SAAA,gBAAA/I,EAAAjH,UAAA,MAGA2K,EAAArK,UAAAkO,MAAA,WACA,OAAA9N,KAAAsP,SAAA,gBAAA/I,EAAAjH,cASA0K,EAAAqH,MAAA,SAAAtJ,GACA,IAAAO,EAAA0B,EAAAjC,GACA3D,EAAAmC,EAAAjH,UAAA,GACA,kBACA,OAAAgJ,EAAAgH,SAAA,SACAtP,KACAoE,EAAAkN,OAAA/K,EAAAjH,gBAIA2K,EAAArK,UAAAyR,MAAA,WACA,IAAA/I,EAAAtI,KACAoE,EAAAmC,EAAAjH,WACA,kBACA,OAAAgJ,EAAAgH,SAAA,SACAtP,KACAoE,EAAAkN,OAAA/K,EAAAjH,gBAWA0K,EAAAlC,KAAA,SAAAC,GACA,OAAAiC,EAAAjC,GAAAuH,SAAA,YAGArF,EAAArK,UAAAkI,KAAA,WACA,OAAA9H,KAAAsP,SAAA,YAYAtF,EAAA8C,MAoCA7C,EAAArK,UAAAkN,IAAA,WACA,OAAAA,EAAA9M,OAUAgK,EAAA0F,MAwCAzF,EAAArK,UAAA8P,IAAA,WACA,OAAAA,EAAA1P,OAYAgK,EAAA8F,aAlrCA3L,EAkrCA2L,EAjrCA,WAMA,MALA,oBAAAyB,SACAA,QAAAC,KAIArN,EAAA9E,MAAA8E,EAAA7E,aAurCA2K,EAAArK,UAAAkQ,YAAA,WACA,OAAAA,EAAA9P,OAMAgK,EAAAyH,WACA,SAAAlC,GACA,OAAAvF,EAAAuF,GAAAkC,cAUAxH,EAAArK,UAAA6R,WAAA,WACA,OAAAzR,KAAAqK,KAAA,SAAAkF,GACA,OAAAzC,EAAA/F,EAAAwI,EAAA,SAAAjH,GAEA,SAAAoJ,IACA,OAAApJ,EAAAiD,UAEA,OAJAjD,EAAA0B,EAAA1B,IAIA+B,KAAAqH,WAcA1H,EAAA2H,KACA3H,EAAA,eAAAjC,EAAA0E,GACA,OAAAzC,EAAAjC,GAAAsC,UAAA,EAAAoC,IAGAxC,EAAArK,UAAA+R,KACA1H,EAAArK,UAAA,eAAA6M,GACA,OAAAzM,KAAAqK,UAAA,EAAAoC,IAWAzC,EAAA8B,SACA,SAAA/D,EAAA2E,GACA,OAAA1C,EAAAjC,GAAAsC,UAAA,SAAAqC,IAGAzC,EAAArK,UAAAkM,SAAA,SAAAY,GACA,OAAA1M,KAAAqK,UAAA,SAAAqC,IAcA1C,EAAA4H,IACA5H,EAAA,iBAAAjC,EAAA5D,GACA,OAAA6F,EAAAjC,GAAA,QAAA5D,IAGA8F,EAAArK,UAAAgS,IACA3H,EAAArK,UAAA,iBAAAuE,GACA,IAAAA,GAAA,mBAAAA,EAAA9E,MACA,UAAAuF,MAAA,kCAGA,OADAT,EAAA6F,EAAA7F,GACAnE,KAAAqK,KAAA,SAAAvD,GACA,OAAA3C,EAAA2J,QAAAzD,KAAA,WACA,OAAAvD,KAEK,SAAA+E,GAEL,OAAA1H,EAAA2J,QAAAzD,KAAA,WACA,MAAAwB,OAWA7B,EAAAqD,KAAA,SAAAtF,EAAAyE,EAAAC,EAAAX,GACA,OAAA9B,EAAAjC,GAAAsF,KAAAb,EAAAC,EAAAX,IAGA7B,EAAArK,UAAAyN,KAAA,SAAAb,EAAAC,EAAAX,GACA,IAAA+F,EAAA,SAAAxJ,GAGA2B,EAAAxH,SAAA,WAEA,GADA4F,EAAAC,EAAAC,IACA0B,EAAA4D,QAGA,MAAAvF,EAFA2B,EAAA4D,QAAAvF,MAQAC,EAAAkE,GAAAC,GAAAX,EACA9L,KAAAqK,KAAAmC,EAAAC,EAAAX,GACA9L,KAEA,iBAAAuB,QAAAoE,SACAkM,EAAAtQ,EAAAoE,OAAAK,KAAA6L,IAGAvJ,EAAA+B,UAAA,EAAAwH,IAYA7H,EAAAxJ,QAAA,SAAAuH,EAAA+J,EAAAzJ,GACA,OAAA2B,EAAAjC,GAAAvH,QAAAsR,EAAAzJ,IAGA4B,EAAArK,UAAAY,QAAA,SAAAsR,EAAAzJ,GACA,IAAA8B,EAAAC,IACA2H,EAAA5R,WAAA,WACAkI,GAAA,iBAAAA,KACAA,EAAA,IAAAzD,MAAAyD,GAAA,mBAAAyJ,EAAA,QACAE,KAAA,aAEA7H,EAAAI,OAAAlC,IACKyJ,GAUL,OARA9R,KAAAqK,KAAA,SAAAvD,GACAzG,aAAA0R,GACA5H,EAAAG,QAAAxD,IACK,SAAA2D,GACLpK,aAAA0R,GACA5H,EAAAI,OAAAE,IACKN,EAAAK,QAELL,EAAA7B,SAYA0B,EAAAiI,MAAA,SAAAlK,EAAAvH,GAKA,YAJA,IAAAA,IACAA,EAAAuH,EACAA,OAAA,GAEAiC,EAAAjC,GAAAkK,MAAAzR,IAGAyJ,EAAArK,UAAAqS,MAAA,SAAAzR,GACA,OAAAR,KAAAqK,KAAA,SAAAvD,GACA,IAAAqD,EAAAC,IAIA,OAHAjK,WAAA,WACAgK,EAAAG,QAAAxD,IACStG,GACT2J,EAAA7B,WAaA0B,EAAAkI,QAAA,SAAA/N,EAAAC,GACA,OAAA4F,EAAA7F,GAAA+N,QAAA9N,IAGA6F,EAAArK,UAAAsS,QAAA,SAAA9N,GACA,IAAA+F,EAAAC,IACA+H,EAAA5L,EAAAnC,GAGA,OAFA+N,EAAAhM,KAAAgE,EAAA0C,oBACA7M,KAAAoR,OAAAe,GAAAR,KAAAxH,EAAAI,QACAJ,EAAA7B,SAYA0B,EAAAoI,OAAA,SAAAjO,GACA,IAAAC,EAAAmC,EAAAjH,UAAA,GACA,OAAA0K,EAAA7F,GAAA+N,QAAA9N,IAGA6F,EAAArK,UAAAwS,OAAA,WACA,IAAAD,EAAA5L,EAAAjH,WACA6K,EAAAC,IAGA,OAFA+H,EAAAhM,KAAAgE,EAAA0C,oBACA7M,KAAAoR,OAAAe,GAAAR,KAAAxH,EAAAI,QACAJ,EAAA7B,SAWA0B,EAAAqI,OACArI,EAAAsI,UAAA,SAAAnO,GACA,QAAA3C,IAAA2C,EACA,UAAAS,MAAA,sCAEA,IAAA2N,EAAAhM,EAAAjH,UAAA,GACA,kBACA,IAAA6S,EAAAI,EAAAjB,OAAA/K,EAAAjH,YACA6K,EAAAC,IAGA,OAFA+H,EAAAhM,KAAAgE,EAAA0C,oBACA7C,EAAA7F,GAAAiN,OAAAe,GAAAR,KAAAxH,EAAAI,QACAJ,EAAA7B,UAIA2B,EAAArK,UAAAyS,OACApI,EAAArK,UAAA0S,UAAA,WACA,IAAAlO,EAAAmC,EAAAjH,WAEA,OADA8E,EAAAwE,QAAA5I,MACAgK,EAAAsI,UAAAjT,WAAA,EAAA+E,IAGA4F,EAAAwI,MAAA,SAAArO,EAAA8C,GACA,IAAAsL,EAAAhM,EAAAjH,UAAA,GACA,kBACA,IAAA6S,EAAAI,EAAAjB,OAAA/K,EAAAjH,YACA6K,EAAAC,IAMA,OALA+H,EAAAhM,KAAAgE,EAAA0C,oBAIA7C,EAHA,WACA,OAAA7F,EAAA9E,MAAA4H,EAAA3H,aAEA8R,OAAAe,GAAAR,KAAAxH,EAAAI,QACAJ,EAAA7B,UAIA2B,EAAArK,UAAA4S,MAAA,WACA,IAAApO,EAAAmC,EAAAjH,UAAA,GAEA,OADA8E,EAAAwE,QAAA5I,MACAgK,EAAAwI,MAAAnT,WAAA,EAAA+E,IAYA4F,EAAAyI,QACAzI,EAAA0I,MAAA,SAAA3K,EAAAkH,EAAA7K,GACA,OAAA4F,EAAAjC,GAAA2K,MAAAzD,EAAA7K,IAGA6F,EAAArK,UAAA6S,QACAxI,EAAArK,UAAA8S,MAAA,SAAAzD,EAAA7K,GACA,IAAA+N,EAAA5L,EAAAnC,OACA+F,EAAAC,IAGA,OAFA+H,EAAAhM,KAAAgE,EAAA0C,oBACA7M,KAAAsP,SAAA,QAAAL,EAAAkD,IAAAR,KAAAxH,EAAAI,QACAJ,EAAA7B,SAaA0B,EAAA2I,MACA3I,EAAA4I,OACA5I,EAAA6I,QAAA,SAAA9K,EAAAkH,GACA,IAAAkD,EAAA5L,EAAAjH,UAAA,GACA6K,EAAAC,IAGA,OAFA+H,EAAAhM,KAAAgE,EAAA0C,oBACA7C,EAAAjC,GAAAuH,SAAA,QAAAL,EAAAkD,IAAAR,KAAAxH,EAAAI,QACAJ,EAAA7B,SAGA2B,EAAArK,UAAA+S,MACA1I,EAAArK,UAAAgT,OACA3I,EAAArK,UAAAiT,QAAA,SAAA5D,GACA,IAAAkD,EAAA5L,EAAAjH,UAAA,GACA6K,EAAAC,IAGA,OAFA+H,EAAAhM,KAAAgE,EAAA0C,oBACA7M,KAAAsP,SAAA,QAAAL,EAAAkD,IAAAR,KAAAxH,EAAAI,QACAJ,EAAA7B,SAaA0B,EAAA8I,QACA,SAAA/K,EAAAgL,GACA,OAAA/I,EAAAjC,GAAA+K,QAAAC,IAGA9I,EAAArK,UAAAkT,QAAA,SAAAC,GACA,IAAAA,EAWA,OAAA/S,KAVAA,KAAAqK,KAAA,SAAAvD,GACAkD,EAAAxH,SAAA,WACAuQ,EAAA,KAAAjM,MAES,SAAAuB,GACT2B,EAAAxH,SAAA,WACAuQ,EAAA1K,QAQA2B,EAAAgJ,WAAA,WACA,UAAApO,MAAA,uDAIA,IAAAmF,EAAA9E,IAEA,OAAA+E","file":"vendors~block-91.b9f88d4cffa17521b332.js","sourcesContent":["module.exports = { \"default\": require(\"core-js/library/fn/json/stringify\"), __esModule: true };","var core = require('../../modules/_core');\nvar $JSON = core.JSON || (core.JSON = { stringify: JSON.stringify });\nmodule.exports = function stringify(it) { // eslint-disable-line no-unused-vars\n  return $JSON.stringify.apply($JSON, arguments);\n};\n","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","// 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"],"sourceRoot":""}