{"version":3,"sources":["webpack:///./node_modules/url/url.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/https-browserify/index.js","webpack:///./node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/url/util.js","webpack:///./node_modules/core-util-is/lib/util.js","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/xtend/immutable.js","webpack:///./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/builtin-status-codes/browser.js","webpack:///./node_modules/querystring-es3/decode.js","webpack:///./node_modules/stream-http/lib/request.js","webpack:///./node_modules/stream-http/index.js","webpack:///./node_modules/process-nextick-args/index.js","webpack:///./node_modules/stream-http/lib/capability.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/querystring-es3/index.js","webpack:///./node_modules/util-deprecate/browser.js","webpack:///./node_modules/stream-http/lib/response.js","webpack:///./node_modules/to-arraybuffer/index.js","webpack:///./node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/querystring-es3/encode.js","webpack:///./node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/bankcardinfo/index.js","webpack:///./node_modules/bluebird/js/browser/bluebird.js","webpack:///./node_modules/events/events.js"],"names":["punycode","util","Url","this","protocol","slashes","auth","host","port","hostname","hash","search","query","pathname","path","href","exports","parse","urlParse","resolve","urlResolve","resolveObject","urlResolveObject","format","urlFormat","protocolPattern","portPattern","simplePathPattern","delims","unwise","concat","autoEscape","nonHostChars","hostEndingChars","hostnameMaxLen","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","url","parseQueryString","slashesDenoteHost","isObject","u","obj","isString","prototype","call","source","relative","TypeError","queryIndex","indexOf","splitter","uSplit","split","slashRegex","replace","join","rest","trim","length","simplePath","exec","substr","proto","lowerProto","toLowerCase","match","atSign","hostEnd","i","hec","lastIndexOf","slice","decodeURIComponent","parseHost","ipv6Hostname","hostparts","l","part","newpart","j","k","charCodeAt","validParts","notHost","bit","push","unshift","toASCII","p","h","ae","esc","encodeURIComponent","escape","qm","s","Object","keys","stringify","charAt","rel","result","tkeys","tk","tkey","rkeys","rk","rkey","v","relPath","shift","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","pop","isNullOrUndefined","authInHost","isNull","last","hasTrailingSlash","up","splice","isAbsolute","root","nodeType","module","freeGlobal","global","window","self","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","errors","baseMinusTMin","floor","Math","stringFromCharCode","String","fromCharCode","error","type","RangeError","map","array","fn","mapDomain","string","parts","labels","encoded","ucs2decode","value","extra","output","counter","ucs2encode","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","decode","input","out","basic","index","oldi","w","t","baseMinusT","inputLength","n","bias","encode","handledCPCount","basicLength","m","q","currentValue","handledCPCountPlusOne","qMinusT","toUnicode","test","http","https","key","hasOwnProperty","validateParams","params","Error","request","cb","get","Transform","Duplex","create","afterTransform","er","data","ts","_transformState","transforming","writecb","emit","writechunk","rs","_readableState","reading","needReadable","highWaterMark","_read","options","bind","needTransform","writeencoding","sync","transform","_transform","flush","_flush","on","prefinish","_this","done","stream","_writableState","inherits","chunk","encoding","_write","_destroy","err","_this2","err2","arg","isArray","Array","objectToString","isBoolean","isNumber","isSymbol","isUndefined","isRegExp","re","isDate","d","isError","e","isFunction","isPrimitive","o","toString","isBuffer","Buffer","ctor","superCtor","super_","constructor","enumerable","writable","configurable","TempCtor","EventEmitter","pna","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","nextTick","emitErrorNT","undestroy","ended","endEmitted","ending","finished","extend","target","arguments","_classCallCheck","instance","Constructor","copyBuffer","src","offset","copy","BufferList","head","tail","entry","next","ret","clear","alloc","allocUnsafe","inspect","custom","name","PassThrough","isEncoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","StringDecoder","nb","text","utf16Text","end","utf16End","fillLast","utf8FillLast","base64Text","base64End","write","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","buf","utf8CheckExtraBytes","r","undefined","utf8Text","total","utf8End","c","buffer","copyProps","dst","SafeBuffer","encodingOrOffset","from","allocUnsafeSlow","size","fill","SlowBuffer","prop","qs","sep","eq","regexp","maxKeys","len","kstr","vstr","x","idx","xs","response","toArrayBuffer","IncomingMessage","rStates","readyStates","decideMode","preferBinary","useFetch","capability","fetch","mozchunkedarraybuffer","msstream","arraybuffer","vbArray","ClientRequest","opts","Writable","_opts","_body","_headers","setHeader","headers","forEach","mode","abortController","overrideMimeType","_mode","_fetchTimer","_onFinish","statusValid","xhr","status","lowerName","unsafeHeaders","getHeader","header","removeHeader","_destroyed","headersObj","body","method","blobConstructor","Blob","headersList","keyName","signal","controller","AbortController","_fetchAbortController","requestTimeout","setTimeout","abort","credentials","withCredentials","then","_fetchResponse","_connect","reason","clearTimeout","_xhr","XMLHttpRequest","open","process","responseType","timeout","ontimeout","setRequestHeader","_response","onreadystatechange","readyState","LOADING","DONE","_onXHRProgress","onprogress","onerror","send","flushHeaders","setNoDelay","setSocketKeepAlive","statusCodes","defaultProtocol","location","toUpperCase","req","Agent","defaultMaxSockets","globalAgent","STATUS_CODES","METHODS","arg1","arg2","arg3","args","apply","version","writableStream","WritableStream","ArrayBuffer","getXHR","XDomainRequest","checkTypeSupport","haveArrayBuffer","haveSlice","VBArray","Readable","ReadableState","EElistenerCount","emitter","listeners","Stream","OurUint8Array","Uint8Array","_uint8ArrayToBuffer","_isUint8Array","debugUtil","debug","debuglog","destroyImpl","kProxyEvents","prependListener","event","_events","isDuplex","objectMode","readableObjectMode","hwm","readableHwm","readableHighWaterMark","defaultHwm","pipes","pipesCount","flowing","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","readable","read","readableAddChunk","addToFront","skipChunkCheck","state","onEofChunk","chunkInvalid","getPrototypeOf","addChunk","maybeReadMore","needMoreData","emitReadable","defineProperty","set","_undestroy","isPaused","setEncoding","MAX_HWM","computeNewHighWaterMark","howMuchToRead","emitReadable_","flow","maybeReadMore_","pipeOnDrain","nReadingNextTick","resume","resume_","fromList","fromListPartial","list","hasStrings","copyFromBufferString","copyFromBuffer","str","endReadable","endReadableNT","parseInt","nOrig","doRead","pipe","dest","pipeOpts","doEnd","stdout","stderr","endFn","onend","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","once","ondrain","cleanedUp","removeListener","onclose","onfinish","ondata","needDrain","increasedAwaitDrain","pause","dests","ev","res","addListener","wrap","paused","_fromList","objectKeys","allowHalfOpen","onEndNT","deprecate","msg","config","warned","deprecated","console","trace","warn","localStorage","_","val","UNSENT","OPENED","HEADERS_RECEIVED","fetchTimer","rawHeaders","trailers","rawTrailers","statusCode","statusMessage","statusText","Promise","reject","_resumeFetch","close","pipeTo","catch","reader","getReader","_pos","responseURL","getAllResponseHeaders","matches","_charset","mimeType","charsetMatch","responseBody","toArray","responseText","newData","MSStreamReader","byteLength","onload","readAsArrayBuffer","byteOffset","arrayCopy","CorkedRequest","finish","onCorkedFinish","asyncWrite","browser","setImmediate","WritableState","internalUtil","realHasInstance","nop","writableObjectMode","writableHwm","writableHighWaterMark","finalCalled","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","bufferedRequestCount","corkedRequestsFree","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","callback","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","count","allBuffers","callFinal","need","endWritable","corkReq","getBuffer","current","Symbol","hasInstance","Function","object","cork","uncork","setDefaultEncoding","stringifyPrimitive","isFinite","ks","f","cardTypeMap","DC","CC","SCC","PC","getCardTypeName","cardType","bankcardList","bankName","bankCode","patterns","reg","getBankNameByBankCode","bankcode","bankcard","_getBankInfoByCardNo","cardNo","cbf","jLen","pattern","RegExp","info","_getBankInfoByCardNoAsync","errMsg","bankInfo","JSON","validated","bank","getBankBin","isNaN","bin","promiseApi","asCallback","define","a","_dereq_","code","1","SomePromiseArray","_SomePromiseArray","any","promises","promise","setHowMany","setUnwrap","init","2","firstLineError","schedule","Queue","Async","_customScheduler","_isTickUsed","_lateQueue","_normalQueue","_haveDrainedQueues","drainQueues","_drainQueues","_schedule","AsyncInvokeLater","receiver","_queueTick","AsyncInvoke","AsyncSettlePromises","_pushOne","_drainQueue","queue","_drainQueueStep","_settlePromises","setScheduler","prev","hasCustomScheduler","haveItemsQueued","fatalError","isNode","stack","exit","throwLater","invokeLater","invoke","settlePromises","_reset","3","INTERNAL","tryConvertToPromise","calledBind","rejectThis","_reject","targetRejected","context","promiseRejectionQueued","bindingPromise","_then","bindingResolved","thisArg","_bitField","_resolveCallback","bindingRejected","_propagateFrom","propagateFromFunction","_boundValue","boundValueFunction","maybePromise","_target","_setBoundTo","_setOnCancel","_boundTo","_isBound","4","old","noConflict","bluebird","5","cr","callerCache","getterCache","getGetter","canEvaluate","isIdentifier","ensureMethod","methodName","message","classString","caller","namedGetter","indexedGetter","max","propertyName","getter","isIndex","maybeGetter","6","PromiseArray","apiRejection","tryCatch","errorObj","async","_async","cancel","cancellation","_warn","child","_isCancellable","_cancelBy","_isFollowing","_followee","_cancelBranched","parent","_cancellationParent","_setWillBeCancelled","_branchHasCancelled","_branchesRemainingToCancel","_enoughBranchesHaveCancelled","canceller","_invokeOnCancel","_cancel","_setCancelled","_cancelPromises","_length","_unsetOnCancel","_onCancelField","isPending","_isCancelled","isCancellable","isCancelled","_doInvokeOnCancel","onCancelCallback","internalOnly","_attachExtraTrace","_resultCancelled","_onCancel","_invokeInternalOnCancel","7","NEXT_FILTER","getKeys","catchFilter","instances","boundTo","predicateLoop","item","matchesPredicate","8","longStackTraces","contextStack","Context","_trace","CapturedTrace","peekContext","createContext","lastIndex","_promiseCreated","_pushContext","_popContext","_peekContext","deactivateLongStackTraces","activateLongStackTraces","Promise_pushContext","Promise_popContext","Promise_PeekContext","Promise_peekContext","Promise_promiseCreated","ctx","9","enableAsyncHooks","disableAsyncHooks","unhandledRejectionHandled","possiblyUnhandledRejection","printWarning","deferUnhandledRejectionCheck","Warning","es5","canAttachTrace","bluebirdFramePattern","nodeFramePattern","parseLinePattern","stackFramePattern","formatStack","indentStackFrames","debugging","env","warnings","wForgottenReturn","unhandledRejectionCheck","_notifyUnhandledRejection","unhandledRejectionClear","suppressUnhandledRejections","_ensurePossibleRejectionHandled","_setRejectionIsUnhandled","_notifyUnhandledRejectionIsHandled","fireRejectionEvent","_setReturnedNonUndefined","_returnedNonUndefined","_isRejectionUnhandled","_settledValue","_setUnhandledRejectionIsNotified","_unsetUnhandledRejectionIsNotified","_isUnhandledRejectionNotified","_unsetRejectionIsUnhandled","shouldUseOwnTrace","onPossiblyUnhandledRejection","_getContext","contextBind","onUnhandledRejectionHandled","disableLongStackTraces","longStackTracesIsSupported","Promise_captureStackTrace","_captureStackTrace","Promise_attachExtraTrace","Promise_dereferenceTrace","_dereferenceTrace","longStackTracesCaptureStackTrace","longStackTracesAttachExtraTrace","longStackTracesDereferenceTrace","hasLongStackTraces","legacyHandlers","unhandledrejection","before","onunhandledrejection","after","rejectionhandled","onrejectionhandled","fireDomEvent","dispatch","legacy","dispatchEvent","CustomEvent","eventData","detail","cancelable","domEvent","Event","document","createEvent","initCustomEvent","fireGlobalEvent","generatePromiseLifecycleEventObject","eventToObjectGenerator","promiseCreated","promiseFulfilled","promiseRejected","promiseResolved","promiseCancelled","promiseChained","warning","unhandledRejection","rejectionHandled","activeFireEvent","globalEventFired","domEventFired","defaultFireEvent","cancellationExecute","executor","onCancel","_attachCancellationCallback","cancellationAttachCancellationCallback","previousOnCancel","cancellationOnCancel","cancellationSetOnCancel","cancellationClearCancellationData","cancellationPropagateFrom","flags","branchesRemainingToCancel","bindingPropagateFrom","warningsOption","_clearCancellationData","_execute","monitoring","_fireEvent","nodeSupportsAsyncResource","asyncHooks","cur","handler","isFulfilled","ignoreSelf","_parent","attachExtraTrace","__stackCleaned__","parsed","parseStackAndMessage","notEnumerableProp","checkForgottenReturns","returnValue","handlerLine","creatorLine","traceLines","cleanStack","line","lineMatches","firstUserLine","replacement","formatAndLogError","reconstructStack","stacks","removeDuplicateOrEmptyJumps","removeCommonRoots","currentLastIndex","currentLastLine","commonRootMeetPoint","isTraceLine","isInternalFrame","shouldIgnore","stackFramesAsArray","title","isSoft","log","localHandler","localEventFired","formatNonError","ruselessToString","newStr","snip","maxChars","captureStackTrace","parseLineInfoRegex","parseLineInfo","fileName","setBounds","lastLineError","firstFileName","lastFileName","firstStackLines","lastStackLines","firstIndex","_promisesCreated","uncycle","nodes","stackToIndex","node","currentStack","cycleEdgeNode","currentChildLength","v8stackFramePattern","v8stackFormatter","stackTraceLimit","ignoreUntil","hasStackAfterThrow","isTTY","color","10","returner","thrower","thenReturn","thenThrow","catchThrow","_reason","caught","catchReturn","_value","11","PromiseReduce","reduce","PromiseAll","all","promiseAllThis","PromiseMapSeries","each","mapSeries","12","_TypeError","_RangeError","Objectfreeze","freeze","subError","nameProperty","defaultMessage","SubError","CancellationError","TimeoutError","AggregateError","methods","level","OperationalError","cause","indent","lines","errorTypes","RejectionError","13","isES5","getDescriptor","getOwnPropertyDescriptor","names","getOwnPropertyNames","propertyIsWritable","descriptor","has","ObjectKeys","ObjectGetDescriptor","ObjectDefineProperty","desc","ObjectFreeze","ObjectGetPrototypeOf","ArrayIsArray","14","PromiseMap","filter","15","PassThroughHandlerContext","called","cancelPromise","FinallyHandlerCancelReaction","finallyHandler","checkCancel","succeed","fail","reasonOrValue","isFinallyHandler","isRejected","_passThrough","success","lastly","tap","tapCatch","handlerOrPredicate","catchInstances","16","Proxyable","yieldHandlers","promiseFromYieldHandler","traceParent","PromiseSpawn","generatorFunction","yieldHandler","internal","_finallyPromise","_promise","_stack","_generatorFunction","_receiver","_generator","_yieldHandlers","_yieldedPromise","_cancellationPhase","_isResolved","_cleanup","_fulfill","_promiseCancelled","implementsReturn","coroutine","returnSentinel","_continue","_promiseFulfilled","_promiseRejected","_run","_rejectCallback","bitField","_proxy","PromiseSpawn$","generator","spawn","addYieldHandler","17","spread","18","MappingPromiseArray","limit","_filter","constructor$","_callback","_preservedValues","_limit","_inFlight","_queue","_asyncInit","concurrency","_init$","_init","values","_values","preservedValues","totalResolved","_totalResolved","_resolve","booleans","19","_resolveFromSyncValue","attempt","20","maybeWrapAsError","isUntypedError","rErrorKey","wrapAsOperationalError","markAsOriginatingFromRejection","nodebackForPromise","multiArgs","wrapped","21","spreadAdapter","nodeback","successAdapter","errorAdapter","newReason","nodeify","adapter","22","makeSelfResolutionError","reflectHandler","PromiseInspection","UNDEFINED_BINDING","setReflectHandler","getDomain","domain","getContextDefault","getContextDomain","AsyncResource","getContextAsyncHooks","getContext","APPLY","check","_fulfillmentHandler0","_rejectionHandler0","_promise0","_receiver0","_resolveFromExecutor","deferResolve","deferReject","fillTypes","reflect","didFulfill","didReject","_setIsFinal","toJSON","fulfillmentValue","rejectionReason","originatesFromRejection","getNewLibraryCopy","is","fromNode","fromCallback","_isFateSealed","_setAsyncGuaranteed","cast","_setFulfilled","fulfilled","rejected","internalData","haveInternalData","settler","_settlePromiseCtx","_settlePromiseLateCancellationObserver","_addCallbacks","_setLength","_setRejected","_setFollowing","_isFinal","_unsetCancelled","_setNoAsyncGuarantee","_receiverAt","_promiseAt","_fulfillmentHandlerAt","_rejectionHandlerAt","_migrateCallback0","follower","fulfill","_migrateCallbackAt","proxyable","shouldBind","_setFollowee","synchronous","ignoreNonErrorWarnings","ensureErrorObject","hasStack","_settlePromiseFromHandler","_settlePromise","isPromise","asyncGuaranteed","_settlePromise0","_clearCallbackDataAtIndex","_fulfillPromises","_rejectPromises","toStringTag","defer","pending","toFastProperties","b","23","toResolutionValue","Map","resolveValueIfEmpty","asArray","_iterate","_resolveEmptyArray","getActualLength","shouldCopyValues","isResolved","24","THIS","withAppended","defaultSuffix","defaultPromisified","__isPromisified__","noCopyProps","noCopyPropsPattern","defaultFilter","propsFilter","isPromisified","hasPromisified","suffix","getDataPropertyOrDefault","checkValid","suffixRegexp","keyWithoutAsyncSuffix","promisifiableMethods","inheritedDataKeys","passesDefaultFilter","makeNodePromisifiedEval","escapeIdentRegex","makeNodePromisifiedClosure","__","defaultThis","promisified","makeNodePromisified","promisifyAll","promisifier","promisifiedKey","promisify","copyDescriptors","isClass","25","Es6Map","mapToEntries","extractEntry","entriesToMap","entries","PropertiesPromiseArray","isMap","_isMap","props","castValue","keyOffset","26","arrayMove","srcIndex","dstIndex","capacity","_capacity","_front","_willBeOverCapacity","_checkCapacity","wrapMask","front","_resizeTo","oldCapacity","moveItemsCount","27","raceLater","race","28","ReductionPromiseArray","initialValue","_each","_fn","_initialValue","_currentCancellable","_eachValues","completed","valueOrReason","gotAccum","accum","_gotAccum","gotValue","_eachComplete","sender","_resultCancelled$","29","noAsyncScheduler","NativePromise","getNativePromise","MutationObserver","GlobalSetImmediate","ProcessNextTick","isRecentNode","nativePromise","navigator","standalone","cordova","documentElement","div","createElement","attributes","toggleScheduled","div2","o2","classList","toggle","observe","scheduleToggle","disconnect","30","SettledPromiseArray","_promiseResolved","inspection","_settledValueField","settle","allSettled","31","CANCELLATION","_howMany","_unwrap","_initialized","some","howMany","isArrayResolved","_canPossiblyFulfill","_getRangeError","_addFulfilled","_fulfilled","_addRejected","_checkOutcome","_rejected","32","__isCancelled","33","getThen","isAnyBluebirdPromise","doThenable","doGetThen","hasProp","34","HandleWrapper","handle","afterValue","delay","ms","afterTimeout","successClear","failureClear","handleWrapper","35","NULL","castPreservingDisposable","thenable","_isDisposable","_getDisposer","_setDisposable","dispose","resources","iterator","tryDispose","Disposer","_data","_context","FunctionDisposer","maybeUnwrapDisposer","isDisposer","ResourceList","resource","doDispose","_unsetDisposable","using","spreadArgs","disposer","reflectedResources","resultPromise","inspections","_disposer","36","tryCatchTarget","globalObject","tryCatcher","Child","Parent","T","maybeError","safeToString","appendee","defaultValue","excludedPrototypes","isExcludedProto","visitedKeys","enumeration","thisAssignmentPattern","hasMethods","hasMethodsOtherThanConstructor","hasThisAssignmentAndStaticMethods","FakeConstructor","ic","foo","rident","filledRange","prefix","ignore","to","ArrayFrom","itResult","it","hasEnvVariables","runInAsyncScope","versions","Number","supportsAsync","P","ReflectOwnKeys","R","Reflect","ReflectApply","ProcessEmitWarning","ownKeys","getOwnPropertySymbols","NumberIsNaN","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","events","existing","newListener","onceWrapper","fired","wrapFn","_onceWrap","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","arr","spliceOne","errorListener","resolver","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","addEventListener","wrapListener","removeEventListener","setMaxListeners","getMaxListeners","doError","prependOnceListener","position","originalListener","off","removeAllListeners","rawListeners","eventNames"],"mappings":"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CACLL,SAAU,OACT,CACDK,IAAK,iGACLL,SAAU,MACT,CACDK,IAAK,gDACLL,SAAU,QAEX,CACDE,SAAU,SACVC,SAAU,MACVC,SAAU,CAAC,CACTC,IAAK,wGACLL,SAAU,MACT,CACDK,IAAK,2IACLL,SAAU,MACT,CACDK,IAAK,iCACLL,SAAU,MACT,CACDK,IAAK,oBACLL,SAAU,MACT,CACDK,IAAK,6OACLL,SAAU,MACT,CACDK,IAAK,qCACLL,SAAU,MACT,CACDK,IAAK,4EACLL,SAAU,OACT,CACDK,IAAK,yBACLL,SAAU,SAEX,CACDE,SAAU,SACVC,SAAU,OACVC,SAAU,CAAC,CACTC,IAAK,8DACLL,SAAU,MACT,CACDK,IAAK,oBACLL,SAAU,MACT,CACDK,IAAK,qEACLL,SAAU,MACT,CACDK,IAAK,yBACLL,SAAU,MACT,CACDK,IAAK,yJACLL,SAAU,MACT,CACDK,IAAK,gDACLL,SAAU,OACT,CACDK,IAAK,2BACLL,SAAU,QAEX,CACDE,SAAU,OACVC,SAAU,MACVC,SAAU,CAAC,CACTC,IAAK,qHACLL,SAAU,MACT,CACDK,IAAK,mBACLL,SAAU,MACT,CACDK,IAAK,oBACLL,SAAU,MACT,CACDK,IAAK,kQACLL,SAAU,MACT,CACDK,IAAK,wCACLL,SAAU,MACT,CACDK,IAAK,oBACLL,SAAU,QAEX,CACDE,SAAU,SACVC,SAAU,OACVC,SAAU,CAAC,CACTC,IAAK,+GACLL,SAAU,MACT,CACDK,IAAK,6OACLL,SAAU,MACT,CACDK,IAAK,wCACLL,SAAU,QAEX,CACDE,SAAU,SACVC,SAAU,MACVC,SAAU,CAAC,CACTC,IAAK,iBACLL,SAAU,MACT,CACDK,IAAK,mBACLL,SAAU,MACT,CACDK,IAAK,oBACLL,SAAU,MACT,CACDK,IAAK,kJACLL,SAAU,MACT,CACDK,IAAK,+NACLL,SAAU,QAEX,CACDE,SAAU,OACVC,SAAU,QACVC,SAAU,CAAC,CACTC,IAAK,qLACLL,SAAU,MACT,CACDK,IAAK,oBACLL,SAAU,MACT,CACDK,IAAK,iCACLL,SAAU,MACT,CACD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","file":"js/chunk-695d7877.1.2.2.1732696861440.js","sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = ['\\''].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n    hostEndingChars = ['/', '?', '#'],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    unsafeProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    },\n    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n\n  var u = new Url;\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n  if (!util.isString(url)) {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  }\n\n  // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n  var queryIndex = url.indexOf('?'),\n      splitter =\n          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n      uSplit = url.split(splitter),\n      slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n\n  var rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1)\n      hostEnd = rest.length;\n\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) continue;\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host;\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1)\n        continue;\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\n  }\n\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n  if (rest) this.pathname = rest;\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  //to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (util.isString(obj)) obj = urlParse(obj);\n  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n  return obj.format();\n}\n\nUrl.prototype.format = function() {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n      pathname = this.pathname || '',\n      hash = this.hash || '',\n      host = false,\n      query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ?\n        this.hostname :\n        '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query &&\n      util.isObject(this.query) &&\n      Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n  if (search && search.charAt(0) !== '?') search = '?' + search;\n\n  pathname = pathname.replace(/[?#]/g, function(match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n  if (util.isString(relative)) {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n      isRelAbs = (\n          relative.host ||\n          relative.pathname && relative.pathname.charAt(0) === '/'\n      ),\n      mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (result.host && relative.pathname)),\n      removeAllDots = mustEndAbs,\n      srcPath = result.pathname && result.pathname.split('/') || [],\n      relPath = relative.pathname && relative.pathname.split('/') || [],\n      psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n                  relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n                      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (!util.isNullOrUndefined(relative.search)) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift();\n      //occationaly the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n      var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                       result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n      (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n                                    srcPath.length ? srcPath.shift() : '';\n    //occationaly the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n    var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                     result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  }\n\n  //to support request.http\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function() {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) this.hostname = host;\n};\n","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","var http = require('http')\nvar url = require('url')\n\nvar https = module.exports\n\nfor (var key in http) {\n  if (http.hasOwnProperty(key)) https[key] = http[key]\n}\n\nhttps.request = function (params, cb) {\n  params = validateParams(params)\n  return http.request.call(this, params, cb)\n}\n\nhttps.get = function (params, cb) {\n  params = validateParams(params)\n  return http.get.call(this, params, cb)\n}\n\nfunction validateParams (params) {\n  if (typeof params === 'string') {\n    params = url.parse(params)\n  }\n  if (!params.protocol) {\n    params.protocol = 'https:'\n  }\n  if (params.protocol !== 'https:') {\n    throw new Error('Protocol \"' + params.protocol + '\" not supported. Expected \"https:\"')\n  }\n  return params\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","'use strict';\n\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('buffer').Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","module.exports = require('events').EventEmitter;\n","'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\nvar util = require('util');\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","module.exports = {\n  \"100\": \"Continue\",\n  \"101\": \"Switching Protocols\",\n  \"102\": \"Processing\",\n  \"200\": \"OK\",\n  \"201\": \"Created\",\n  \"202\": \"Accepted\",\n  \"203\": \"Non-Authoritative Information\",\n  \"204\": \"No Content\",\n  \"205\": \"Reset Content\",\n  \"206\": \"Partial Content\",\n  \"207\": \"Multi-Status\",\n  \"208\": \"Already Reported\",\n  \"226\": \"IM Used\",\n  \"300\": \"Multiple Choices\",\n  \"301\": \"Moved Permanently\",\n  \"302\": \"Found\",\n  \"303\": \"See Other\",\n  \"304\": \"Not Modified\",\n  \"305\": \"Use Proxy\",\n  \"307\": \"Temporary Redirect\",\n  \"308\": \"Permanent Redirect\",\n  \"400\": \"Bad Request\",\n  \"401\": \"Unauthorized\",\n  \"402\": \"Payment Required\",\n  \"403\": \"Forbidden\",\n  \"404\": \"Not Found\",\n  \"405\": \"Method Not Allowed\",\n  \"406\": \"Not Acceptable\",\n  \"407\": \"Proxy Authentication Required\",\n  \"408\": \"Request Timeout\",\n  \"409\": \"Conflict\",\n  \"410\": \"Gone\",\n  \"411\": \"Length Required\",\n  \"412\": \"Precondition Failed\",\n  \"413\": \"Payload Too Large\",\n  \"414\": \"URI Too Long\",\n  \"415\": \"Unsupported Media Type\",\n  \"416\": \"Range Not Satisfiable\",\n  \"417\": \"Expectation Failed\",\n  \"418\": \"I'm a teapot\",\n  \"421\": \"Misdirected Request\",\n  \"422\": \"Unprocessable Entity\",\n  \"423\": \"Locked\",\n  \"424\": \"Failed Dependency\",\n  \"425\": \"Unordered Collection\",\n  \"426\": \"Upgrade Required\",\n  \"428\": \"Precondition Required\",\n  \"429\": \"Too Many Requests\",\n  \"431\": \"Request Header Fields Too Large\",\n  \"451\": \"Unavailable For Legal Reasons\",\n  \"500\": \"Internal Server Error\",\n  \"501\": \"Not Implemented\",\n  \"502\": \"Bad Gateway\",\n  \"503\": \"Service Unavailable\",\n  \"504\": \"Gateway Timeout\",\n  \"505\": \"HTTP Version Not Supported\",\n  \"506\": \"Variant Also Negotiates\",\n  \"507\": \"Insufficient Storage\",\n  \"508\": \"Loop Detected\",\n  \"509\": \"Bandwidth Limit Exceeded\",\n  \"510\": \"Not Extended\",\n  \"511\": \"Network Authentication Required\"\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr, vstr, k, v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar response = require('./response')\nvar stream = require('readable-stream')\nvar toArrayBuffer = require('to-arraybuffer')\n\nvar IncomingMessage = response.IncomingMessage\nvar rStates = response.readyStates\n\nfunction decideMode (preferBinary, useFetch) {\n\tif (capability.fetch && useFetch) {\n\t\treturn 'fetch'\n\t} else if (capability.mozchunkedarraybuffer) {\n\t\treturn 'moz-chunked-arraybuffer'\n\t} else if (capability.msstream) {\n\t\treturn 'ms-stream'\n\t} else if (capability.arraybuffer && preferBinary) {\n\t\treturn 'arraybuffer'\n\t} else if (capability.vbArray && preferBinary) {\n\t\treturn 'text:vbarray'\n\t} else {\n\t\treturn 'text'\n\t}\n}\n\nvar ClientRequest = module.exports = function (opts) {\n\tvar self = this\n\tstream.Writable.call(self)\n\n\tself._opts = opts\n\tself._body = []\n\tself._headers = {}\n\tif (opts.auth)\n\t\tself.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'))\n\tObject.keys(opts.headers).forEach(function (name) {\n\t\tself.setHeader(name, opts.headers[name])\n\t})\n\n\tvar preferBinary\n\tvar useFetch = true\n\tif (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {\n\t\t// If the use of XHR should be preferred. Not typically needed.\n\t\tuseFetch = false\n\t\tpreferBinary = true\n\t} else if (opts.mode === 'prefer-streaming') {\n\t\t// If streaming is a high priority but binary compatibility and\n\t\t// the accuracy of the 'content-type' header aren't\n\t\tpreferBinary = false\n\t} else if (opts.mode === 'allow-wrong-content-type') {\n\t\t// If streaming is more important than preserving the 'content-type' header\n\t\tpreferBinary = !capability.overrideMimeType\n\t} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {\n\t\t// Use binary if text streaming may corrupt data or the content-type header, or for speed\n\t\tpreferBinary = true\n\t} else {\n\t\tthrow new Error('Invalid value for opts.mode')\n\t}\n\tself._mode = decideMode(preferBinary, useFetch)\n\tself._fetchTimer = null\n\n\tself.on('finish', function () {\n\t\tself._onFinish()\n\t})\n}\n\ninherits(ClientRequest, stream.Writable)\n\nClientRequest.prototype.setHeader = function (name, value) {\n\tvar self = this\n\tvar lowerName = name.toLowerCase()\n\t// This check is not necessary, but it prevents warnings from browsers about setting unsafe\n\t// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but\n\t// http-browserify did it, so I will too.\n\tif (unsafeHeaders.indexOf(lowerName) !== -1)\n\t\treturn\n\n\tself._headers[lowerName] = {\n\t\tname: name,\n\t\tvalue: value\n\t}\n}\n\nClientRequest.prototype.getHeader = function (name) {\n\tvar header = this._headers[name.toLowerCase()]\n\tif (header)\n\t\treturn header.value\n\treturn null\n}\n\nClientRequest.prototype.removeHeader = function (name) {\n\tvar self = this\n\tdelete self._headers[name.toLowerCase()]\n}\n\nClientRequest.prototype._onFinish = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\tvar opts = self._opts\n\n\tvar headersObj = self._headers\n\tvar body = null\n\tif (opts.method !== 'GET' && opts.method !== 'HEAD') {\n\t\tif (capability.arraybuffer) {\n\t\t\tbody = toArrayBuffer(Buffer.concat(self._body))\n\t\t} else if (capability.blobConstructor) {\n\t\t\tbody = new global.Blob(self._body.map(function (buffer) {\n\t\t\t\treturn toArrayBuffer(buffer)\n\t\t\t}), {\n\t\t\t\ttype: (headersObj['content-type'] || {}).value || ''\n\t\t\t})\n\t\t} else {\n\t\t\t// get utf8 string\n\t\t\tbody = Buffer.concat(self._body).toString()\n\t\t}\n\t}\n\n\t// create flattened list of headers\n\tvar headersList = []\n\tObject.keys(headersObj).forEach(function (keyName) {\n\t\tvar name = headersObj[keyName].name\n\t\tvar value = headersObj[keyName].value\n\t\tif (Array.isArray(value)) {\n\t\t\tvalue.forEach(function (v) {\n\t\t\t\theadersList.push([name, v])\n\t\t\t})\n\t\t} else {\n\t\t\theadersList.push([name, value])\n\t\t}\n\t})\n\n\tif (self._mode === 'fetch') {\n\t\tvar signal = null\n\t\tvar fetchTimer = null\n\t\tif (capability.abortController) {\n\t\t\tvar controller = new AbortController()\n\t\t\tsignal = controller.signal\n\t\t\tself._fetchAbortController = controller\n\n\t\t\tif ('requestTimeout' in opts && opts.requestTimeout !== 0) {\n\t\t\t\tself._fetchTimer = global.setTimeout(function () {\n\t\t\t\t\tself.emit('requestTimeout')\n\t\t\t\t\tif (self._fetchAbortController)\n\t\t\t\t\t\tself._fetchAbortController.abort()\n\t\t\t\t}, opts.requestTimeout)\n\t\t\t}\n\t\t}\n\n\t\tglobal.fetch(self._opts.url, {\n\t\t\tmethod: self._opts.method,\n\t\t\theaders: headersList,\n\t\t\tbody: body || undefined,\n\t\t\tmode: 'cors',\n\t\t\tcredentials: opts.withCredentials ? 'include' : 'same-origin',\n\t\t\tsignal: signal\n\t\t}).then(function (response) {\n\t\t\tself._fetchResponse = response\n\t\t\tself._connect()\n\t\t}, function (reason) {\n\t\t\tglobal.clearTimeout(self._fetchTimer)\n\t\t\tif (!self._destroyed)\n\t\t\t\tself.emit('error', reason)\n\t\t})\n\t} else {\n\t\tvar xhr = self._xhr = new global.XMLHttpRequest()\n\t\ttry {\n\t\t\txhr.open(self._opts.method, self._opts.url, true)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\n\t\t// Can't set responseType on really old browsers\n\t\tif ('responseType' in xhr)\n\t\t\txhr.responseType = self._mode.split(':')[0]\n\n\t\tif ('withCredentials' in xhr)\n\t\t\txhr.withCredentials = !!opts.withCredentials\n\n\t\tif (self._mode === 'text' && 'overrideMimeType' in xhr)\n\t\t\txhr.overrideMimeType('text/plain; charset=x-user-defined')\n\n\t\tif ('requestTimeout' in opts) {\n\t\t\txhr.timeout = opts.requestTimeout\n\t\t\txhr.ontimeout = function () {\n\t\t\t\tself.emit('requestTimeout')\n\t\t\t}\n\t\t}\n\n\t\theadersList.forEach(function (header) {\n\t\t\txhr.setRequestHeader(header[0], header[1])\n\t\t})\n\n\t\tself._response = null\n\t\txhr.onreadystatechange = function () {\n\t\t\tswitch (xhr.readyState) {\n\t\t\t\tcase rStates.LOADING:\n\t\t\t\tcase rStates.DONE:\n\t\t\t\t\tself._onXHRProgress()\n\t\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// Necessary for streaming in Firefox, since xhr.response is ONLY defined\n\t\t// in onprogress, not in onreadystatechange with xhr.readyState = 3\n\t\tif (self._mode === 'moz-chunked-arraybuffer') {\n\t\t\txhr.onprogress = function () {\n\t\t\t\tself._onXHRProgress()\n\t\t\t}\n\t\t}\n\n\t\txhr.onerror = function () {\n\t\t\tif (self._destroyed)\n\t\t\t\treturn\n\t\t\tself.emit('error', new Error('XHR error'))\n\t\t}\n\n\t\ttry {\n\t\t\txhr.send(body)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\t}\n}\n\n/**\n * Checks if xhr.status is readable and non-zero, indicating no error.\n * Even though the spec says it should be available in readyState 3,\n * accessing it throws an exception in IE8\n */\nfunction statusValid (xhr) {\n\ttry {\n\t\tvar status = xhr.status\n\t\treturn (status !== null && status !== 0)\n\t} catch (e) {\n\t\treturn false\n\t}\n}\n\nClientRequest.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tif (!statusValid(self._xhr) || self._destroyed)\n\t\treturn\n\n\tif (!self._response)\n\t\tself._connect()\n\n\tself._response._onXHRProgress()\n}\n\nClientRequest.prototype._connect = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\n\tself._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer)\n\tself._response.on('error', function(err) {\n\t\tself.emit('error', err)\n\t})\n\n\tself.emit('response', self._response)\n}\n\nClientRequest.prototype._write = function (chunk, encoding, cb) {\n\tvar self = this\n\n\tself._body.push(chunk)\n\tcb()\n}\n\nClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {\n\tvar self = this\n\tself._destroyed = true\n\tglobal.clearTimeout(self._fetchTimer)\n\tif (self._response)\n\t\tself._response._destroyed = true\n\tif (self._xhr)\n\t\tself._xhr.abort()\n\telse if (self._fetchAbortController)\n\t\tself._fetchAbortController.abort()\n}\n\nClientRequest.prototype.end = function (data, encoding, cb) {\n\tvar self = this\n\tif (typeof data === 'function') {\n\t\tcb = data\n\t\tdata = undefined\n\t}\n\n\tstream.Writable.prototype.end.call(self, data, encoding, cb)\n}\n\nClientRequest.prototype.flushHeaders = function () {}\nClientRequest.prototype.setTimeout = function () {}\nClientRequest.prototype.setNoDelay = function () {}\nClientRequest.prototype.setSocketKeepAlive = function () {}\n\n// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method\nvar unsafeHeaders = [\n\t'accept-charset',\n\t'accept-encoding',\n\t'access-control-request-headers',\n\t'access-control-request-method',\n\t'connection',\n\t'content-length',\n\t'cookie',\n\t'cookie2',\n\t'date',\n\t'dnt',\n\t'expect',\n\t'host',\n\t'keep-alive',\n\t'origin',\n\t'referer',\n\t'te',\n\t'trailer',\n\t'transfer-encoding',\n\t'upgrade',\n\t'via'\n]\n","var ClientRequest = require('./lib/request')\nvar response = require('./lib/response')\nvar extend = require('xtend')\nvar statusCodes = require('builtin-status-codes')\nvar url = require('url')\n\nvar http = exports\n\nhttp.request = function (opts, cb) {\n\tif (typeof opts === 'string')\n\t\topts = url.parse(opts)\n\telse\n\t\topts = extend(opts)\n\n\t// Normally, the page is loaded from http or https, so not specifying a protocol\n\t// will result in a (valid) protocol-relative url. However, this won't work if\n\t// the protocol is something else, like 'file:'\n\tvar defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''\n\n\tvar protocol = opts.protocol || defaultProtocol\n\tvar host = opts.hostname || opts.host\n\tvar port = opts.port\n\tvar path = opts.path || '/'\n\n\t// Necessary for IPv6 addresses\n\tif (host && host.indexOf(':') !== -1)\n\t\thost = '[' + host + ']'\n\n\t// This may be a relative url. The browser should always be able to interpret it correctly.\n\topts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path\n\topts.method = (opts.method || 'GET').toUpperCase()\n\topts.headers = opts.headers || {}\n\n\t// Also valid opts.auth, opts.mode\n\n\tvar req = new ClientRequest(opts)\n\tif (cb)\n\t\treq.on('response', cb)\n\treturn req\n}\n\nhttp.get = function get (opts, cb) {\n\tvar req = http.request(opts, cb)\n\treq.end()\n\treturn req\n}\n\nhttp.ClientRequest = ClientRequest\nhttp.IncomingMessage = response.IncomingMessage\n\nhttp.Agent = function () {}\nhttp.Agent.defaultMaxSockets = 4\n\nhttp.globalAgent = new http.Agent()\n\nhttp.STATUS_CODES = statusCodes\n\nhttp.METHODS = [\n\t'CHECKOUT',\n\t'CONNECT',\n\t'COPY',\n\t'DELETE',\n\t'GET',\n\t'HEAD',\n\t'LOCK',\n\t'M-SEARCH',\n\t'MERGE',\n\t'MKACTIVITY',\n\t'MKCOL',\n\t'MOVE',\n\t'NOTIFY',\n\t'OPTIONS',\n\t'PATCH',\n\t'POST',\n\t'PROPFIND',\n\t'PROPPATCH',\n\t'PURGE',\n\t'PUT',\n\t'REPORT',\n\t'SEARCH',\n\t'SUBSCRIBE',\n\t'TRACE',\n\t'UNLOCK',\n\t'UNSUBSCRIBE'\n]","'use strict';\n\nif (typeof process === 'undefined' ||\n    !process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)\n\nexports.writableStream = isFunction(global.WritableStream)\n\nexports.abortController = isFunction(global.AbortController)\n\nexports.blobConstructor = false\ntry {\n\tnew Blob([new ArrayBuffer(1)])\n\texports.blobConstructor = true\n} catch (e) {}\n\n// The xhr request to example.com may violate some restrictive CSP configurations,\n// so if we're running in a browser that supports `fetch`, avoid calling getXHR()\n// and assume support for certain features below.\nvar xhr\nfunction getXHR () {\n\t// Cache the xhr value\n\tif (xhr !== undefined) return xhr\n\n\tif (global.XMLHttpRequest) {\n\t\txhr = new global.XMLHttpRequest()\n\t\t// If XDomainRequest is available (ie only, where xhr might not work\n\t\t// cross domain), use the page location. Otherwise use example.com\n\t\t// Note: this doesn't actually make an http request.\n\t\ttry {\n\t\t\txhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')\n\t\t} catch(e) {\n\t\t\txhr = null\n\t\t}\n\t} else {\n\t\t// Service workers don't have XHR\n\t\txhr = null\n\t}\n\treturn xhr\n}\n\nfunction checkTypeSupport (type) {\n\tvar xhr = getXHR()\n\tif (!xhr) return false\n\ttry {\n\t\txhr.responseType = type\n\t\treturn xhr.responseType === type\n\t} catch (e) {}\n\treturn false\n}\n\n// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.\n// Safari 7.1 appears to have fixed this bug.\nvar haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined'\nvar haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice)\n\n// If fetch is supported, then arraybuffer will be supported too. Skip calling\n// checkTypeSupport(), since that calls getXHR().\nexports.arraybuffer = exports.fetch || (haveArrayBuffer && checkTypeSupport('arraybuffer'))\n\n// These next two tests unavoidably show warnings in Chrome. Since fetch will always\n// be used if it's available, just return false for these to avoid the warnings.\nexports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream')\nexports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer &&\n\tcheckTypeSupport('moz-chunked-arraybuffer')\n\n// If fetch is supported, then overrideMimeType will be supported too. Skip calling\n// getXHR().\nexports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)\n\nexports.vbArray = isFunction(global.VBArray)\n\nfunction isFunction (value) {\n\treturn typeof value === 'function'\n}\n\nxhr = null // Help gc\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar stream = require('readable-stream')\n\nvar rStates = exports.readyStates = {\n\tUNSENT: 0,\n\tOPENED: 1,\n\tHEADERS_RECEIVED: 2,\n\tLOADING: 3,\n\tDONE: 4\n}\n\nvar IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {\n\tvar self = this\n\tstream.Readable.call(self)\n\n\tself._mode = mode\n\tself.headers = {}\n\tself.rawHeaders = []\n\tself.trailers = {}\n\tself.rawTrailers = []\n\n\t// Fake the 'close' event, but only once 'end' fires\n\tself.on('end', function () {\n\t\t// The nextTick is necessary to prevent the 'request' module from causing an infinite loop\n\t\tprocess.nextTick(function () {\n\t\t\tself.emit('close')\n\t\t})\n\t})\n\n\tif (mode === 'fetch') {\n\t\tself._fetchResponse = response\n\n\t\tself.url = response.url\n\t\tself.statusCode = response.status\n\t\tself.statusMessage = response.statusText\n\t\t\n\t\tresponse.headers.forEach(function (header, key){\n\t\t\tself.headers[key.toLowerCase()] = header\n\t\t\tself.rawHeaders.push(key, header)\n\t\t})\n\n\t\tif (capability.writableStream) {\n\t\t\tvar writable = new WritableStream({\n\t\t\t\twrite: function (chunk) {\n\t\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\t\tif (self._destroyed) {\n\t\t\t\t\t\t\treject()\n\t\t\t\t\t\t} else if(self.push(new Buffer(chunk))) {\n\t\t\t\t\t\t\tresolve()\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tself._resumeFetch = resolve\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t},\n\t\t\t\tclose: function () {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.push(null)\n\t\t\t\t},\n\t\t\t\tabort: function (err) {\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t}\n\t\t\t})\n\n\t\t\ttry {\n\t\t\t\tresponse.body.pipeTo(writable).catch(function (err) {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t})\n\t\t\t\treturn\n\t\t\t} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this\n\t\t}\n\t\t// fallback for when writableStream or pipeTo aren't available\n\t\tvar reader = response.body.getReader()\n\t\tfunction read () {\n\t\t\treader.read().then(function (result) {\n\t\t\t\tif (self._destroyed)\n\t\t\t\t\treturn\n\t\t\t\tif (result.done) {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tself.push(null)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tself.push(new Buffer(result.value))\n\t\t\t\tread()\n\t\t\t}).catch(function (err) {\n\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\tif (!self._destroyed)\n\t\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t}\n\t\tread()\n\t} else {\n\t\tself._xhr = xhr\n\t\tself._pos = 0\n\n\t\tself.url = xhr.responseURL\n\t\tself.statusCode = xhr.status\n\t\tself.statusMessage = xhr.statusText\n\t\tvar headers = xhr.getAllResponseHeaders().split(/\\r?\\n/)\n\t\theaders.forEach(function (header) {\n\t\t\tvar matches = header.match(/^([^:]+):\\s*(.*)/)\n\t\t\tif (matches) {\n\t\t\t\tvar key = matches[1].toLowerCase()\n\t\t\t\tif (key === 'set-cookie') {\n\t\t\t\t\tif (self.headers[key] === undefined) {\n\t\t\t\t\t\tself.headers[key] = []\n\t\t\t\t\t}\n\t\t\t\t\tself.headers[key].push(matches[2])\n\t\t\t\t} else if (self.headers[key] !== undefined) {\n\t\t\t\t\tself.headers[key] += ', ' + matches[2]\n\t\t\t\t} else {\n\t\t\t\t\tself.headers[key] = matches[2]\n\t\t\t\t}\n\t\t\t\tself.rawHeaders.push(matches[1], matches[2])\n\t\t\t}\n\t\t})\n\n\t\tself._charset = 'x-user-defined'\n\t\tif (!capability.overrideMimeType) {\n\t\t\tvar mimeType = self.rawHeaders['mime-type']\n\t\t\tif (mimeType) {\n\t\t\t\tvar charsetMatch = mimeType.match(/;\\s*charset=([^;])(;|$)/)\n\t\t\t\tif (charsetMatch) {\n\t\t\t\t\tself._charset = charsetMatch[1].toLowerCase()\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!self._charset)\n\t\t\t\tself._charset = 'utf-8' // best guess\n\t\t}\n\t}\n}\n\ninherits(IncomingMessage, stream.Readable)\n\nIncomingMessage.prototype._read = function () {\n\tvar self = this\n\n\tvar resolve = self._resumeFetch\n\tif (resolve) {\n\t\tself._resumeFetch = null\n\t\tresolve()\n\t}\n}\n\nIncomingMessage.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tvar xhr = self._xhr\n\n\tvar response = null\n\tswitch (self._mode) {\n\t\tcase 'text:vbarray': // For IE9\n\t\t\tif (xhr.readyState !== rStates.DONE)\n\t\t\t\tbreak\n\t\t\ttry {\n\t\t\t\t// This fails in IE8\n\t\t\t\tresponse = new global.VBArray(xhr.responseBody).toArray()\n\t\t\t} catch (e) {}\n\t\t\tif (response !== null) {\n\t\t\t\tself.push(new Buffer(response))\n\t\t\t\tbreak\n\t\t\t}\n\t\t\t// Falls through in IE8\t\n\t\tcase 'text':\n\t\t\ttry { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4\n\t\t\t\tresponse = xhr.responseText\n\t\t\t} catch (e) {\n\t\t\t\tself._mode = 'text:vbarray'\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tif (response.length > self._pos) {\n\t\t\t\tvar newData = response.substr(self._pos)\n\t\t\t\tif (self._charset === 'x-user-defined') {\n\t\t\t\t\tvar buffer = new Buffer(newData.length)\n\t\t\t\t\tfor (var i = 0; i < newData.length; i++)\n\t\t\t\t\t\tbuffer[i] = newData.charCodeAt(i) & 0xff\n\n\t\t\t\t\tself.push(buffer)\n\t\t\t\t} else {\n\t\t\t\t\tself.push(newData, self._charset)\n\t\t\t\t}\n\t\t\t\tself._pos = response.length\n\t\t\t}\n\t\t\tbreak\n\t\tcase 'arraybuffer':\n\t\t\tif (xhr.readyState !== rStates.DONE || !xhr.response)\n\t\t\t\tbreak\n\t\t\tresponse = xhr.response\n\t\t\tself.push(new Buffer(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'moz-chunked-arraybuffer': // take whole\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING || !response)\n\t\t\t\tbreak\n\t\t\tself.push(new Buffer(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'ms-stream':\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING)\n\t\t\t\tbreak\n\t\t\tvar reader = new global.MSStreamReader()\n\t\t\treader.onprogress = function () {\n\t\t\t\tif (reader.result.byteLength > self._pos) {\n\t\t\t\t\tself.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))))\n\t\t\t\t\tself._pos = reader.result.byteLength\n\t\t\t\t}\n\t\t\t}\n\t\t\treader.onload = function () {\n\t\t\t\tself.push(null)\n\t\t\t}\n\t\t\t// reader.onerror = ??? // TODO: this\n\t\t\treader.readAsArrayBuffer(response)\n\t\t\tbreak\n\t}\n\n\t// The ms-stream case handles end separately in reader.onload()\n\tif (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {\n\t\tself.push(null)\n\t}\n}\n","var Buffer = require('buffer').Buffer\n\nmodule.exports = function (buf) {\n\t// If the buffer is backed by a Uint8Array, a faster version will work\n\tif (buf instanceof Uint8Array) {\n\t\t// If the buffer isn't a subarray, return the underlying ArrayBuffer\n\t\tif (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {\n\t\t\treturn buf.buffer\n\t\t} else if (typeof buf.buffer.slice === 'function') {\n\t\t\t// Otherwise we need to get a proper copy\n\t\t\treturn buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)\n\t\t}\n\t}\n\n\tif (Buffer.isBuffer(buf)) {\n\t\t// This is the slow version that will work with any Buffer\n\t\t// implementation (even in old browsers)\n\t\tvar arrayCopy = new Uint8Array(buf.length)\n\t\tvar len = buf.length\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tarrayCopy[i] = buf[i]\n\t\t}\n\t\treturn arrayCopy.buffer\n\t} else {\n\t\tthrow new Error('Argument must be a Buffer')\n\t}\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return map(objectKeys(obj), function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (isArray(obj[k])) {\n        return map(obj[k], function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nfunction map (xs, f) {\n  if (xs.map) return xs.map(f);\n  var res = [];\n  for (var i = 0; i < xs.length; i++) {\n    res.push(f(xs[i], i));\n  }\n  return res;\n}\n\nvar objectKeys = Object.keys || function (obj) {\n  var res = [];\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n  }\n  return res;\n};\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","//test url : https://ccdcapi.alipay.com/validateAndCacheCardInfo.json?cardNo=6222005865412565805&cardBinCheck=true\n//cardType:DC->储蓄卡,CC->信用卡\n(function() {\n  var root = this;\n  var cardTypeMap = {\n    DC: \"储蓄卡\",\n    CC: \"信用卡\",\n    SCC: \"准贷记卡\",\n    PC: \"预付费卡\"\n  };\n\n  function isFunction(fn) {\n    return Object.prototype.toString.call(fn) === '[object Function]';\n  }\n\n  function extend(target, source) {\n    var result = {};\n    var key;\n    target = target || {};\n    source = source || {};\n    for (key in target) {\n      if (target.hasOwnProperty(key)) {\n        result[key] = target[key];\n      }\n    }\n    for (key in source) {\n      if (source.hasOwnProperty(key)) {\n        result[key] = source[key];\n      }\n    }\n    return result;\n  }\n\n  function getCardTypeName(cardType) {\n    if (cardTypeMap[cardType]) {\n      return cardTypeMap[cardType]\n    }\n    return undefined;\n  }\n  var bankcardList = [{\n    bankName: \"中国邮政储蓄银行\",\n    bankCode: \"PSBC\",\n    patterns: [{\n      reg: /^(621096|621098|622150|622151|622181|622188|622199|955100|621095|620062|621285|621798|621799|621797|620529|621622|621599|621674|623218|623219)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(62215049|62215050|62215051|62218850|62218851|62218849)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622812|622810|622811|628310|625919)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"中国工商银行\",\n    bankCode: \"ICBC\",\n    patterns: [{\n      reg: /^(620200|620302|620402|620403|620404|620406|620407|620409|620410|620411|620412|620502|620503|620405|620408|620512|620602|620604|620607|620611|620612|620704|620706|620707|620708|620709|620710|620609|620712|620713|620714|620802|620711|620904|620905|621001|620902|621103|621105|621106|621107|621102|621203|621204|621205|621206|621207|621208|621209|621210|621302|621303|621202|621305|621306|621307|621309|621311|621313|621211|621315|621304|621402|621404|621405|621406|621407|621408|621409|621410|621502|621317|621511|621602|621603|621604|621605|621608|621609|621610|621611|621612|621613|621614|621615|621616|621617|621607|621606|621804|621807|621813|621814|621817|621901|621904|621905|621906|621907|621908|621909|621910|621911|621912|621913|621915|622002|621903|622004|622005|622006|622007|622008|622010|622011|622012|621914|622015|622016|622003|622018|622019|622020|622102|622103|622104|622105|622013|622111|622114|622017|622110|622303|622304|622305|622306|622307|622308|622309|622314|622315|622317|622302|622402|622403|622404|622313|622504|622505|622509|622513|622517|622502|622604|622605|622606|622510|622703|622715|622806|622902|622903|622706|623002|623006|623008|623011|623012|622904|623015|623100|623202|623301|623400|623500|623602|623803|623901|623014|624100|624200|624301|624402|623700|624000)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622200|622202|622203|622208|621225|620058|621281|900000|621558|621559|621722|621723|620086|621226|621618|620516|621227|621288|621721|900010|623062|621670|621720|621379|621240|621724|621762|621414|621375|622926|622927|622928|622929|622930|622931|621733|621732|621372|621369|621763)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(402791|427028|427038|548259|621376|621423|621428|621434|621761|621749|621300|621378|622944|622949|621371|621730|621734|621433|621370|621764|621464|621765|621750|621377|621367|621374|621731|621781)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(9558)\\d{15}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(370246|370248|370249|370247|370267|374738|374739)\\d{9}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(427010|427018|427019|427020|427029|427030|427039|438125|438126|451804|451810|451811|458071|489734|489735|489736|510529|427062|524091|427064|530970|530990|558360|524047|525498|622230|622231|622232|622233|622234|622235|622237|622239|622240|622245|622238|451804|451810|451811|458071|628288|628286|622206|526836|513685|543098|458441|622246|544210|548943|356879|356880|356881|356882|528856|625330|625331|625332|622236|524374|550213|625929|625927|625939|625987|625930|625114|622159|625021|625022|625932|622889|625900|625915|625916|622171|625931|625113|625928|625914|625986|625925|625921|625926|625942|622158|625917|625922|625934|625933|625920|625924|625017|625018|625019)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(45806|53098|45806|53098)\\d{11}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(622210|622211|622212|622213|622214|622220|622223|622225|622229|622215|622224)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(620054|620142|620184|620030|620050|620143|620149|620124|620183|620094|620186|620148|620185)\\d{10}$/g,\n      cardType: \"PC\"\n    }, {\n      reg: /^(620114|620187|620046)\\d{13}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"中国农业银行\",\n    bankCode: \"ABC\",\n    patterns: [{\n      reg: /^(622841|622824|622826|622848|620059|621282|622828|622823|621336|621619|622821|622822|622825|622827|622845|622849|623018|623206|621671|622840|622843|622844|622846|622847|620501)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(95595|95596|95597|95598|95599)\\d{14}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(103)\\d{16}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(403361|404117|404118|404119|404120|404121|463758|519412|519413|520082|520083|552599|558730|514027|622836|622837|628268|625996|625998|625997|622838|625336|625826|625827|544243|548478|628269)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(622820|622830)\\d{10}$/g,\n      cardType: \"SCC\"\n    }]\n  }, {\n    bankName: \"中国银行\",\n    bankCode: \"BOC\",\n    patterns: [{\n      reg: /^(621660|621661|621662|621663|621665|621667|621668|621669|621666|456351|601382|621256|621212|621283|620061|621725|621330|621331|621332|621333|621297|621568|621569|621672|623208|621620|621756|621757|621758|621759|621785|621786|621787|621788|621789|621790|622273|622274|622771|622772|622770|621741|621041)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621293|621294|621342|621343|621364|621394|621648|621248|621215|621249|621231|621638|621334|621395|623040|622348)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625908|625910|625909|356833|356835|409665|409666|409668|409669|409670|409671|409672|512315|512316|512411|512412|514957|409667|438088|552742|553131|514958|622760|628388|518377|622788|628313|628312|622750|622751|625145|622479|622480|622789|625140|622346|622347)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(518378|518379|518474|518475|518476|524865|525745|525746|547766|558868|622752|622753|622755|524864|622757|622758|622759|622761|622762|622763|622756|622754|622764|622765|558869|625905|625906|625907|625333)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(53591|49102|377677)\\d{11}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(620514|620025|620026|620210|620211|620019|620035|620202|620203|620048|620515|920000)\\d{10}$/g,\n      cardType: \"PC\"\n    }, {\n      reg: /^(620040|620531|620513|921000|620038)\\d{13}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"中国建设银行\",\n    bankCode: \"CCB\",\n    patterns: [{\n      reg: /^(621284|436742|589970|620060|621081|621467|621598|621621|621700|622280|622700|623211|623668)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(421349|434061|434062|524094|526410|552245|621080|621082|621466|621488|621499|622966|622988|622382|621487|621083|621084|620107)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(436742193|622280193)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(553242)\\d{12}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(625362|625363|628316|628317|356896|356899|356895|436718|436738|436745|436748|489592|531693|532450|532458|544887|552801|557080|558895|559051|622166|622168|622708|625964|625965|625966|628266|628366|622381|622675|622676|622677)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(5453242|5491031|5544033)\\d{11}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(622725|622728|436728|453242|491031|544033|622707|625955|625956)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(53242|53243)\\d{11}$/g,\n      cardType: \"SCC\"\n    }]\n  }, {\n    bankName: \"中国交通银行\",\n    bankCode: \"COMM\",\n    patterns: [{\n      reg: /^(622261|622260|622262|621002|621069|621436|621335)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(620013)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(405512|601428|405512|601428|622258|622259|405512|601428)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(49104|53783)\\d{11}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(434910|458123|458124|520169|522964|552853|622250|622251|521899|622253|622656|628216|622252|955590|955591|955592|955593|628218|625028|625029)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(622254|622255|622256|622257|622284)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(620021|620521)\\d{13}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"招商银行\",\n    bankCode: \"CMB\",\n    patterns: [{\n      reg: /^(402658|410062|468203|512425|524011|622580|622588|622598|622609|95555|621286|621483|621485|621486|621299)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(690755)\\d{9}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(690755)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(356885|356886|356887|356888|356890|439188|439227|479228|479229|521302|356889|545620|545621|545947|545948|552534|552587|622575|622576|622577|622578|622579|545619|622581|622582|545623|628290|439225|518710|518718|628362|439226|628262|625802|625803)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(370285|370286|370287|370289)\\d{9}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(620520)\\d{13}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"中国民生银行\",\n    bankCode: \"CMBC\",\n    patterns: [{\n      reg: /^(622615|622616|622618|622622|622617|622619|415599|421393|421865|427570|427571|472067|472068|622620)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(545392|545393|545431|545447|356859|356857|407405|421869|421870|421871|512466|356856|528948|552288|622600|622601|622602|517636|622621|628258|556610|622603|464580|464581|523952|545217|553161|356858|622623|625912|625913|625911)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(377155|377152|377153|377158)\\d{9}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"中国光大银行\",\n    bankCode: \"CEB\",\n    patterns: [{\n      reg: /^(303)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(90030)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(620535)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(620085|622660|622662|622663|622664|622665|622666|622667|622669|622670|622671|622672|622668|622661|622674|622673|620518|621489|621492)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(356837|356838|486497|622657|622685|622659|622687|625978|625980|625981|625979|356839|356840|406252|406254|425862|481699|524090|543159|622161|622570|622650|622655|622658|625975|625977|628201|628202|625339|625976)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"中信银行\",\n    bankCode: \"CITIC\",\n    patterns: [{\n      reg: /^(433670|433680|442729|442730|620082|622690|622691|622692|622696|622698|622998|622999|433671|968807|968808|968809|621771|621767|621768|621770|621772|621773|622453|622456)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622459)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(376968|376969|376966)\\d{9}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(400360|403391|403392|404158|404159|404171|404172|404173|404174|404157|433667|433668|433669|514906|403393|520108|433666|558916|622678|622679|622680|622688|622689|628206|556617|628209|518212|628208|356390|356391|356392|622916|622918|622919)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"华夏银行\",\n    bankCode: \"HXBANK\",\n    patterns: [{\n      reg: /^(622630|622631|622632|622633|999999|621222|623020|623021|623022|623023)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(523959|528709|539867|539868|622637|622638|628318|528708|622636|625967|625968|625969)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"深发/平安银行\",\n    bankCode: \"SPABANK\",\n    patterns: [{\n      reg: /^(621626|623058)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(602907|622986|622989|622298|627069|627068|627066|627067|412963|415752|415753|622535|622536|622538|622539|998800|412962|622983)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(531659|622157|528020|622155|622156|526855|356869|356868|625360|625361|628296|435744|435745|483536|622525|622526|998801|998802)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(620010)\\d{10}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"兴业银行\",\n    bankCode: \"CIB\",\n    patterns: [{\n      reg: /^(438589)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(90592)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(966666|622909|438588|622908)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(461982|486493|486494|486861|523036|451289|527414|528057|622901|622902|622922|628212|451290|524070|625084|625085|625086|625087|548738|549633|552398|625082|625083|625960|625961|625962|625963)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(620010)\\d{10}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"上海银行\",\n    bankCode: \"SHBANK\",\n    patterns: [{\n      reg: /^(621050|622172|622985|622987|620522|622267|622278|622279|622468|622892|940021)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(438600)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(356827|356828|356830|402673|402674|486466|519498|520131|524031|548838|622148|622149|622268|356829|622300|628230|622269|625099|625953)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"浦东发展银行\",\n    bankCode: \"SPDB\",\n    patterns: [{\n      reg: /^(622516|622517|622518|622521|622522|622523|984301|984303|621352|621793|621795|621796|621351|621390|621792|621791)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(84301|84336|84373|84385|84390|87000|87010|87030|87040|84380|84361|87050|84342)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(356851|356852|404738|404739|456418|498451|515672|356850|517650|525998|622177|622277|628222|622500|628221|622176|622276|622228|625957|625958|625993|625831)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(622520|622519)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(620530)\\d{13}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"广发银行\",\n    bankCode: \"GDB\",\n    patterns: [{\n      reg: /^(622516|622517|622518|622521|622522|622523|984301|984303|621352|621793|621795|621796|621351|621390|621792|621791)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622568|6858001|6858009|621462)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(9111)\\d{15}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(406365|406366|428911|436768|436769|436770|487013|491032|491033|491034|491035|491036|491037|491038|436771|518364|520152|520382|541709|541710|548844|552794|493427|622555|622556|622557|622558|622559|622560|528931|558894|625072|625071|628260|628259|625805|625806|625807|625808|625809|625810)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(685800|6858000)\\d{13}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"渤海银行\",\n    bankCode: \"BOHAIB\",\n    patterns: [{\n      reg: /^(621268|622684|622884|621453)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"广州银行\",\n    bankCode: \"GCB\",\n    patterns: [{\n      reg: /^(603445|622467|940016|621463)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"金华银行\",\n    bankCode: \"JHBANK\",\n    patterns: [{\n      reg: /^(622449|940051)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622450|628204)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"温州银行\",\n    bankCode: \"WZCB\",\n    patterns: [{\n      reg: /^(621977)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622868|622899|628255)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"徽商银行\",\n    bankCode: \"HSBANK\",\n    patterns: [{\n      reg: /^(622877|622879|621775|623203)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(603601|622137|622327|622340|622366)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628251|622651|625828)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"江苏银行\",\n    bankCode: \"JSBANK\",\n    patterns: [{\n      reg: /^(621076|622173|622131|621579|622876)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(504923|622422|622447|940076)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628210|622283|625902)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"南京银行\",\n    bankCode: \"NJCB\",\n    patterns: [{\n      reg: /^(621777|622305|621259)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622303|628242|622595|622596)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"宁波银行\",\n    bankCode: \"NBBANK\",\n    patterns: [{\n      reg: /^(621279|622281|622316|940022)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621418)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625903|622778|628207|512431|520194|622282|622318)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"北京银行\",\n    bankCode: \"BJBANK\",\n    patterns: [{\n      reg: /^(623111|421317|422161|602969|422160|621030|621420|621468)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(522001|622163|622853|628203|622851|622852)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"北京农村商业银行\",\n    bankCode: \"BJRCB\",\n    patterns: [{\n      reg: /^(620088|621068|622138|621066|621560)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625526|625186|628336)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"汇丰银行\",\n    bankCode: \"HSBC\",\n    patterns: [{\n      reg: /^(622946)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622406|621442)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622407|621443)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622360|622361|625034|625096|625098)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"渣打银行\",\n    bankCode: \"SCB\",\n    patterns: [{\n      reg: /^(622948|621740|622942|622994)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622482|622483|622484)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"花旗银行\",\n    bankCode: \"CITI\",\n    patterns: [{\n      reg: /^(621062|621063)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625076|625077|625074|625075|622371|625091)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"东亚银行\",\n    bankCode: \"HKBEA\",\n    patterns: [{\n      reg: /^(622933|622938|623031|622943|621411)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622372|622471|622472|622265|622266|625972|625973)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(622365)\\d{11}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"广东华兴银行\",\n    bankCode: \"GHB\",\n    patterns: [{\n      reg: /^(621469|621625)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"深圳农村商业银行\",\n    bankCode: \"SRCB\",\n    patterns: [{\n      reg: /^(622128|622129|623035)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"广州农村商业银行股份有限公司\",\n    bankCode: \"GZRCU\",\n    patterns: [{\n      reg: /^(909810|940035|621522|622439)\\d{12}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"东莞农村商业银行\",\n    bankCode: \"DRCBCL\",\n    patterns: [{\n      reg: /^(622328|940062|623038)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625288|625888)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"东莞市商业银行\",\n    bankCode: \"BOD\",\n    patterns: [{\n      reg: /^(622333|940050)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621439|623010)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622888)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"广东省农村信用社联合社\",\n    bankCode: \"GDRCC\",\n    patterns: [{\n      reg: /^(622302)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622477|622509|622510|622362|621018|621518)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"大新银行\",\n    bankCode: \"DSB\",\n    patterns: [{\n      reg: /^(622297|621277)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622375|622489)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622293|622295|622296|622373|622451|622294|625940)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"永亨银行\",\n    bankCode: \"WHB\",\n    patterns: [{\n      reg: /^(622871|622958|622963|622957|622861|622932|622862|621298)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622798|625010|622775|622785)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"星展银行香港有限公司\",\n    bankCode: \"DBS\",\n    patterns: [{\n      reg: /^(621016|621015)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622487|622490|622491|622492)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622487|622490|622491|622492|621744|621745|621746|621747)\\d{11}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"恒丰银行\",\n    bankCode: \"EGBANK\",\n    patterns: [{\n      reg: /^(623078)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622384|940034)\\d{11}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"天津市商业银行\",\n    bankCode: \"TCCB\",\n    patterns: [{\n      reg: /^(940015|622331)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(6091201)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622426|628205)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"天津滨海德商村镇银行\",\n    bankCode: \"BDCBANK\",\n    patterns: [{\n      reg: /^(621091)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"浙商银行\",\n    bankCode: \"CZBANK\",\n    patterns: [{\n      reg: /^(621019|622309|621019)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(6223091100|6223092900|6223093310|6223093320|6223093330|6223093370|6223093380|6223096510|6223097910)\\d{9}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"南洋商业银行\",\n    bankCode: \"NCB\",\n    patterns: [{\n      reg: /^(621213|621289|621290|621291|621292|621042|621743)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(623041|622351)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625046|625044|625058|622349|622350)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(620208|620209|625093|625095)\\d{10}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"厦门银行\",\n    bankCode: \"XMBANK\",\n    patterns: [{\n      reg: /^(622393|940023)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(6886592)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(623019|621600)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"福建海峡银行\",\n    bankCode: \"FJHXBC\",\n    patterns: [{\n      reg: /^(622388)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621267|623063)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(620043)\\d{12}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"吉林银行\",\n    bankCode: \"JLBANK\",\n    patterns: [{\n      reg: /^(622865|623131)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(940012)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622178|622179|628358)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"汉口银行\",\n    bankCode: \"HKB\",\n    patterns: [{\n      reg: /^(990027)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622325|623105|623029)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"盛京银行\",\n    bankCode: \"SJBANK\",\n    patterns: [{\n      reg: /^(566666)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622455|940039)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(623108|623081)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622466|628285)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"大连银行\",\n    bankCode: \"DLB\",\n    patterns: [{\n      reg: /^(603708)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622993|623069|623070|623172|623173)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622383|622385|628299)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"河北银行\",\n    bankCode: \"BHB\",\n    patterns: [{\n      reg: /^(622498|622499|623000|940046)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622921|628321)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"乌鲁木齐市商业银行\",\n    bankCode: \"URMQCCB\",\n    patterns: [{\n      reg: /^(621751|622143|940001|621754)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622476|628278)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"绍兴银行\",\n    bankCode: \"SXCB\",\n    patterns: [{\n      reg: /^(622486)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(603602|623026|623086)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628291)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"成都商业银行\",\n    bankCode: \"CDCB\",\n    patterns: [{\n      reg: /^(622152|622154|622996|622997|940027|622153|622135|621482|621532)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"抚顺银行\",\n    bankCode: \"FSCB\",\n    patterns: [{\n      reg: /^(622442)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(940053)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622442|623099)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"郑州银行\",\n    bankCode: \"ZZBANK\",\n    patterns: [{\n      reg: /^(622421)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(940056)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(96828)\\d{11}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"宁夏银行\",\n    bankCode: \"NXBANK\",\n    patterns: [{\n      reg: /^(621529|622429|621417|623089|623200)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628214|625529|622428)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"重庆银行\",\n    bankCode: \"CQBANK\",\n    patterns: [{\n      reg: /^(9896)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622134|940018|623016)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"哈尔滨银行\",\n    bankCode: \"HRBANK\",\n    patterns: [{\n      reg: /^(621577|622425)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(940049)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622425)\\d{11}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"兰州银行\",\n    bankCode: \"LZYH\",\n    patterns: [{\n      reg: /^(622139|940040|628263)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621242|621538|621496)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"青岛银行\",\n    bankCode: \"QDCCB\",\n    patterns: [{\n      reg: /^(621252|622146|940061|628239)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621419|623170)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"秦皇岛市商业银行\",\n    bankCode: \"QHDCCB\",\n    patterns: [{\n      reg: /^(62249802|94004602)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621237|623003)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"青海银行\",\n    bankCode: \"BOQH\",\n    patterns: [{\n      reg: /^(622310|940068)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622817|628287|625959)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(62536601)\\d{8}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"台州银行\",\n    bankCode: \"TZCB\",\n    patterns: [{\n      reg: /^(622427)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(940069)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(623039)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622321|628273)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(625001)\\d{10}$/g,\n      cardType: \"SCC\"\n    }]\n  }, {\n    bankName: \"长沙银行\",\n    bankCode: \"CSCB\",\n    patterns: [{\n      reg: /^(694301)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(940071|622368|621446)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625901|622898|622900|628281|628282|622806|628283)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(620519)\\d{13}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"泉州银行\",\n    bankCode: \"BOQZ\",\n    patterns: [{\n      reg: /^(683970|940074)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622370)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621437)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628319)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"包商银行\",\n    bankCode: \"BSB\",\n    patterns: [{\n      reg: /^(622336|621760)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622165)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622315|625950|628295)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"龙江银行\",\n    bankCode: \"DAQINGB\",\n    patterns: [{\n      reg: /^(621037|621097|621588|622977)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(62321601)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622860)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622644|628333)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"上海农商银行\",\n    bankCode: \"SHRCB\",\n    patterns: [{\n      reg: /^(622478|940013|621495)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625500)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(622611|622722|628211|625989)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"浙江泰隆商业银行\",\n    bankCode: \"ZJQL\",\n    patterns: [{\n      reg: /^(622717)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(628275|622565|622287)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"内蒙古银行\",\n    bankCode: \"H3CB\",\n    patterns: [{\n      reg: /^(622147|621633)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628252)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"广西北部湾银行\",\n    bankCode: \"BGB\",\n    patterns: [{\n      reg: /^(623001)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628227)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"桂林银行\",\n    bankCode: \"GLBANK\",\n    patterns: [{\n      reg: /^(621456)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621562)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628219)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"龙江银行\",\n    bankCode: \"DAQINGB\",\n    patterns: [{\n      reg: /^(621037|621097|621588|622977)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(62321601)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622475|622860)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625588)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(622270|628368|625090|622644|628333)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"成都农村商业银行\",\n    bankCode: \"CDRCB\",\n    patterns: [{\n      reg: /^(623088)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622829|628301|622808|628308)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"福建省农村信用社联合社\",\n    bankCode: \"FJNX\",\n    patterns: [{\n      reg: /^(622127|622184|621701|621251|621589|623036)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628232|622802|622290)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"天津农村商业银行\",\n    bankCode: \"TRCB\",\n    patterns: [{\n      reg: /^(622531|622329)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622829|628301)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"江苏省农村信用社联合社\",\n    bankCode: \"JSRCU\",\n    patterns: [{\n      reg: /^(621578|623066|622452|622324)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622815|622816|628226)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"湖南农村信用社联合社\",\n    bankCode: \"SLH\",\n    patterns: [{\n      reg: /^(622906|628386|625519|625506)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"江西省农村信用社联合社\",\n    bankCode: \"JXNCX\",\n    patterns: [{\n      reg: /^(621592)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628392)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"商丘市商业银行\",\n    bankCode: \"SCBBANK\",\n    patterns: [{\n      reg: /^(621748)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628271)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"华融湘江银行\",\n    bankCode: \"HRXJB\",\n    patterns: [{\n      reg: /^(621366|621388)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628328)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"衡水市商业银行\",\n    bankCode: \"HSBK\",\n    patterns: [{\n      reg: /^(621239|623068)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"重庆南川石银村镇银行\",\n    bankCode: \"CQNCSYCZ\",\n    patterns: [{\n      reg: /^(621653004)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"湖南省农村信用社联合社\",\n    bankCode: \"HNRCC\",\n    patterns: [{\n      reg: /^(622169|621519|621539|623090)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"邢台银行\",\n    bankCode: \"XTB\",\n    patterns: [{\n      reg: /^(621238|620528)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"临汾市尧都区农村信用合作联社\",\n    bankCode: \"LPRDNCXYS\",\n    patterns: [{\n      reg: /^(628382|625158)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"东营银行\",\n    bankCode: \"DYCCB\",\n    patterns: [{\n      reg: /^(621004)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628217)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"上饶银行\",\n    bankCode: \"SRBANK\",\n    patterns: [{\n      reg: /^(621416)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628217)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"德州银行\",\n    bankCode: \"DZBANK\",\n    patterns: [{\n      reg: /^(622937)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628397)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"承德银行\",\n    bankCode: \"CDB\",\n    patterns: [{\n      reg: /^(628229)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"云南省农村信用社\",\n    bankCode: \"YNRCC\",\n    patterns: [{\n      reg: /^(622469|628307)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"柳州银行\",\n    bankCode: \"LZCCB\",\n    patterns: [{\n      reg: /^(622292|622291|621412)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622880|622881)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(62829)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"威海市商业银行\",\n    bankCode: \"WHSYBANK\",\n    patterns: [{\n      reg: /^(623102)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628234)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"湖州银行\",\n    bankCode: \"HZBANK\",\n    patterns: [{\n      reg: /^(628306)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"潍坊银行\",\n    bankCode: \"BANKWF\",\n    patterns: [{\n      reg: /^(622391|940072)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628391)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"赣州银行\",\n    bankCode: \"GZB\",\n    patterns: [{\n      reg: /^(622967|940073)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628233)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"日照银行\",\n    bankCode: \"RZGWYBANK\",\n    patterns: [{\n      reg: /^(628257)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"南昌银行\",\n    bankCode: \"NCB\",\n    patterns: [{\n      reg: /^(621269|622275)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(940006)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628305)\\d{11}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"贵阳银行\",\n    bankCode: \"GYCB\",\n    patterns: [{\n      reg: /^(622133|621735)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(888)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628213)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"锦州银行\",\n    bankCode: \"BOJZ\",\n    patterns: [{\n      reg: /^(622990|940003)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628261)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"齐商银行\",\n    bankCode: \"QSBANK\",\n    patterns: [{\n      reg: /^(622311|940057)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628311)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"珠海华润银行\",\n    bankCode: \"RBOZ\",\n    patterns: [{\n      reg: /^(622363|940048)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628270)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"葫芦岛市商业银行\",\n    bankCode: \"HLDCCB\",\n    patterns: [{\n      reg: /^(622398|940054)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"宜昌市商业银行\",\n    bankCode: \"HBC\",\n    patterns: [{\n      reg: /^(940055)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622397)\\d{11}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"杭州银行\",\n    bankCode: \"HZCB\",\n    patterns: [{\n      reg: /^(603367|622878|623061)\\d{12}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622397|622286|628236|625800)\\d{11}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"苏州市商业银行\",\n    bankCode: \"JSBANK\",\n    patterns: [{\n      reg: /^(603506)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"辽阳银行\",\n    bankCode: \"LYCB\",\n    patterns: [{\n      reg: /^(622399|940043)\\d{11}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"洛阳银行\",\n    bankCode: \"LYB\",\n    patterns: [{\n      reg: /^(622420|940041)\\d{11}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"焦作市商业银行\",\n    bankCode: \"JZCBANK\",\n    patterns: [{\n      reg: /^(622338)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(940032)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"镇江市商业银行\",\n    bankCode: \"ZJCCB\",\n    patterns: [{\n      reg: /^(622394|940025)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"法国兴业银行\",\n    bankCode: \"FGXYBANK\",\n    patterns: [{\n      reg: /^(621245)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"大华银行\",\n    bankCode: \"DYBANK\",\n    patterns: [{\n      reg: /^(621328)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"企业银行\",\n    bankCode: \"DIYEBANK\",\n    patterns: [{\n      reg: /^(621651)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"华侨银行\",\n    bankCode: \"HQBANK\",\n    patterns: [{\n      reg: /^(621077)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"恒生银行\",\n    bankCode: \"HSB\",\n    patterns: [{\n      reg: /^(622409|621441)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622410|621440)\\d{11}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622950|622951)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625026|625024|622376|622378|622377|625092)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"临沂商业银行\",\n    bankCode: \"LSB\",\n    patterns: [{\n      reg: /^(622359|940066)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"烟台商业银行\",\n    bankCode: \"YTCB\",\n    patterns: [{\n      reg: /^(622886)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"齐鲁银行\",\n    bankCode: \"QLB\",\n    patterns: [{\n      reg: /^(940008|622379)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(628379)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"BC卡公司\",\n    bankCode: \"BCCC\",\n    patterns: [{\n      reg: /^(620011|620027|620031|620039|620103|620106|620120|620123|620125|620220|620278|620812|621006|621011|621012|621020|621023|621025|621027|621031|620132|621039|621078|621220|621003)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625003|625011|625012|625020|625023|625025|625027|625031|621032|625039|625078|625079|625103|625106|625006|625112|625120|625123|625125|625127|625131|625032|625139|625178|625179|625220|625320|625111|625132|625244)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"集友银行\",\n    bankCode: \"CYB\",\n    patterns: [{\n      reg: /^(622355|623042)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(621043|621742)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622352|622353|625048|625053|625060)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(620206|620207)\\d{10}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"大丰银行\",\n    bankCode: \"TFB\",\n    patterns: [{\n      reg: /^(622547|622548|622546)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(625198|625196|625147)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(620072)\\d{13}$/g,\n      cardType: \"PC\"\n    }, {\n      reg: /^(620204|620205)\\d{10}$/g,\n      cardType: \"PC\"\n    }]\n  }, {\n    bankName: \"AEON信贷财务亚洲有限公司\",\n    bankCode: \"AEON\",\n    patterns: [{\n      reg: /^(621064|622941|622974)\\d{10}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622493)\\d{10}$/g,\n      cardType: \"CC\"\n    }]\n  }, {\n    bankName: \"澳门BDA\",\n    bankCode: \"MABDA\",\n    patterns: [{\n      reg: /^(621274|621324)\\d{13}$/g,\n      cardType: \"DC\"\n    }]\n  }, {\n    bankName: \"浙江泰隆商业银行\",\n    bankCode: \"ZJTLCB\",\n    patterns: [{\n      reg: /^(622287)\\d{10}$/g,\n      cardType: \"CC\"\n    }, {\n      reg: /^(622717)\\d{10}$/g,\n      cardType: \"SCC\"\n    }, {\n      reg: /^(621480)\\d{13}$/g,\n      cardType: \"DC\"\n    }, {\n      reg: /^(622141)\\d{10}$/g,\n      cardType: \"DC\"\n    }]\n  }]\n\n  function getBankNameByBankCode(bankcode) {\n    for (var i = 0, len = bankcardList.length; i < len; i++) {\n      var bankcard = bankcardList[i];\n      if (bankcode == bankcard.bankCode) {\n        return bankcard.bankName;\n      }\n    }\n    return \"\";\n  }\n\n  function _getBankInfoByCardNo(cardNo, cbf) {\n    for (var i = 0, len = bankcardList.length; i < len; i++) {\n      var bankcard = bankcardList[i];\n      var patterns = bankcard.patterns;\n      for (var j = 0, jLen = patterns.length; j < jLen; j++) {\n        var pattern = patterns[j];\n        if ((new RegExp(pattern.reg)).test(cardNo)) {\n          var info = extend(bankcard, pattern);\n          delete info.patterns;\n          delete info.reg;\n          info['cardTypeName'] = getCardTypeName(info['cardType']);\n          return cbf(null, info);\n        }\n      }\n    }\n    return cbf(null);\n  }\n\n  function _getBankInfoByCardNoAsync(cardNo, cbf) {\n    var errMsg = \"\";\n    _getBankInfoByCardNo(cardNo, function(err, info) {\n      if (!err && info) {\n        return cbf(null, info);\n      } else {\n        if (typeof module !== 'undefined' && module.exports) {\n          var https = require('https');\n          https.get(\"https://ccdcapi.alipay.com/validateAndCacheCardInfo.json?_input_charset=utf-8&cardNo=\" + cardNo + \"&cardBinCheck=true\", function(res) {\n            if (res.statusCode == 200) {\n              var chunk = \"\";\n              res.on('data', function(d) {\n                chunk += d;\n              });\n              res.on('end', function() {\n                try {\n                  var bankInfo = JSON.parse(chunk);\n                  if (bankInfo.validated) {\n                    var info = {};\n                    info['bankName'] = getBankNameByBankCode(bankInfo.bank);\n                    info['cardType'] = bankInfo.cardType;\n                    info['bankCode'] = bankInfo.bank;\n                    info['cardTypeName'] = getCardTypeName(bankInfo.cardType);\n                    info['backName'] = info['bankName']; //向下兼容，修改字段错别字\n                    cbf(null, info);\n                  } else {\n                    errMsg = cardNo + \":该银行卡不存在,\" + chunk;\n                    cbf(errMsg);\n                  }\n                } catch (e) {\n                  errMsg = cardNo + ':获取alipay接口信息出错了,返回json格式不正确';\n                  cbf(errMsg);\n                }\n              })\n            } else {\n              errMsg = cardNo + ':获取alipay接口信息出错了,statusCode,' + res.statusCode;\n              cbf(errMsg);\n            }\n          }).on('error', function(e) {\n            errMsg = cardNo + ':获取alipay接口信息出错了';\n            cbf(errMsg);\n          });\n        } else {\n          cbf(cardNo + \":该银行卡不存在\");\n        }\n      }\n    });\n  }\n\n  function getBankBin(cardNo, cbf) {\n    var errMsg = '';\n    if (!isFunction(cbf)) {\n      cbf = function() {};\n    }\n    if (isNaN(cardNo)) {\n      cardNo = parseInt(cardNo);\n      if (isNaN(cardNo)) {\n        errMsg = cardNo + ':银行卡号必须是数字';\n        return cbf(errMsg)\n      }\n    }\n    if (cardNo.toString().length < 15 || cardNo.toString().length > 19) {\n      errMsg = cardNo + ':银行卡位数必须是15到19位';\n      return cbf(errMsg)\n    }\n    _getBankInfoByCardNoAsync(cardNo, function(err, bin) {\n      cbf(err, bin);\n    });\n  }\n\n  function promiseApi(cardNo, cbf) {\n    var Promise = require('bluebird');\n    return new Promise(function(resolve, reject) {\n      getBankBin(cardNo, function(err, data) {\n        if (err) {\n          return reject(err)\n        }\n        resolve(data)\n      })\n    }).asCallback(cbf)\n  }\n  if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = {\n        getBankBin: promiseApi\n      };\n    }\n    exports.getBankBin = promiseApi;\n  } else if (typeof define === 'function' && define.amd) {\n    define('bankInfo', [], function() {\n      return {\n        getBankBin: getBankBin\n      };\n    });\n  } else if (typeof define === 'function' && define.cmd) {\n    define(function() {\n      return {\n        getBankBin: getBankBin\n      };\n    })\n  } else {\n    root.getBankBin = getBankBin;\n  }\n}.call(this));","/* @preserve\n * The MIT License (MIT)\n * \n * Copyright (c) 2013-2018 Petka Antonov\n * \n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n * \n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n * \n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n * \n */\n/**\n * bluebird build version 3.7.2\n * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each\n*/\n!function(e){if(\"object\"==typeof exports&&\"undefined\"!=typeof module)module.exports=e();else if(\"function\"==typeof define&&define.amd)define([],e);else{var f;\"undefined\"!=typeof window?f=window:\"undefined\"!=typeof global?f=global:\"undefined\"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_==\"function\"&&_dereq_;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof _dereq_==\"function\"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise) {\nvar SomePromiseArray = Promise._SomePromiseArray;\nfunction any(promises) {\n    var ret = new SomePromiseArray(promises);\n    var promise = ret.promise();\n    ret.setHowMany(1);\n    ret.setUnwrap();\n    ret.init();\n    return promise;\n}\n\nPromise.any = function (promises) {\n    return any(promises);\n};\n\nPromise.prototype.any = function () {\n    return any(this);\n};\n\n};\n\n},{}],2:[function(_dereq_,module,exports){\n\"use strict\";\nvar firstLineError;\ntry {throw new Error(); } catch (e) {firstLineError = e;}\nvar schedule = _dereq_(\"./schedule\");\nvar Queue = _dereq_(\"./queue\");\n\nfunction Async() {\n    this._customScheduler = false;\n    this._isTickUsed = false;\n    this._lateQueue = new Queue(16);\n    this._normalQueue = new Queue(16);\n    this._haveDrainedQueues = false;\n    var self = this;\n    this.drainQueues = function () {\n        self._drainQueues();\n    };\n    this._schedule = schedule;\n}\n\nAsync.prototype.setScheduler = function(fn) {\n    var prev = this._schedule;\n    this._schedule = fn;\n    this._customScheduler = true;\n    return prev;\n};\n\nAsync.prototype.hasCustomScheduler = function() {\n    return this._customScheduler;\n};\n\nAsync.prototype.haveItemsQueued = function () {\n    return this._isTickUsed || this._haveDrainedQueues;\n};\n\n\nAsync.prototype.fatalError = function(e, isNode) {\n    if (isNode) {\n        process.stderr.write(\"Fatal \" + (e instanceof Error ? e.stack : e) +\n            \"\\n\");\n        process.exit(2);\n    } else {\n        this.throwLater(e);\n    }\n};\n\nAsync.prototype.throwLater = function(fn, arg) {\n    if (arguments.length === 1) {\n        arg = fn;\n        fn = function () { throw arg; };\n    }\n    if (typeof setTimeout !== \"undefined\") {\n        setTimeout(function() {\n            fn(arg);\n        }, 0);\n    } else try {\n        this._schedule(function() {\n            fn(arg);\n        });\n    } catch (e) {\n        throw new Error(\"No async scheduler available\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n};\n\nfunction AsyncInvokeLater(fn, receiver, arg) {\n    this._lateQueue.push(fn, receiver, arg);\n    this._queueTick();\n}\n\nfunction AsyncInvoke(fn, receiver, arg) {\n    this._normalQueue.push(fn, receiver, arg);\n    this._queueTick();\n}\n\nfunction AsyncSettlePromises(promise) {\n    this._normalQueue._pushOne(promise);\n    this._queueTick();\n}\n\nAsync.prototype.invokeLater = AsyncInvokeLater;\nAsync.prototype.invoke = AsyncInvoke;\nAsync.prototype.settlePromises = AsyncSettlePromises;\n\n\nfunction _drainQueue(queue) {\n    while (queue.length() > 0) {\n        _drainQueueStep(queue);\n    }\n}\n\nfunction _drainQueueStep(queue) {\n    var fn = queue.shift();\n    if (typeof fn !== \"function\") {\n        fn._settlePromises();\n    } else {\n        var receiver = queue.shift();\n        var arg = queue.shift();\n        fn.call(receiver, arg);\n    }\n}\n\nAsync.prototype._drainQueues = function () {\n    _drainQueue(this._normalQueue);\n    this._reset();\n    this._haveDrainedQueues = true;\n    _drainQueue(this._lateQueue);\n};\n\nAsync.prototype._queueTick = function () {\n    if (!this._isTickUsed) {\n        this._isTickUsed = true;\n        this._schedule(this.drainQueues);\n    }\n};\n\nAsync.prototype._reset = function () {\n    this._isTickUsed = false;\n};\n\nmodule.exports = Async;\nmodule.exports.firstLineError = firstLineError;\n\n},{\"./queue\":26,\"./schedule\":29}],3:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {\nvar calledBind = false;\nvar rejectThis = function(_, e) {\n    this._reject(e);\n};\n\nvar targetRejected = function(e, context) {\n    context.promiseRejectionQueued = true;\n    context.bindingPromise._then(rejectThis, rejectThis, null, this, e);\n};\n\nvar bindingResolved = function(thisArg, context) {\n    if (((this._bitField & 50397184) === 0)) {\n        this._resolveCallback(context.target);\n    }\n};\n\nvar bindingRejected = function(e, context) {\n    if (!context.promiseRejectionQueued) this._reject(e);\n};\n\nPromise.prototype.bind = function (thisArg) {\n    if (!calledBind) {\n        calledBind = true;\n        Promise.prototype._propagateFrom = debug.propagateFromFunction();\n        Promise.prototype._boundValue = debug.boundValueFunction();\n    }\n    var maybePromise = tryConvertToPromise(thisArg);\n    var ret = new Promise(INTERNAL);\n    ret._propagateFrom(this, 1);\n    var target = this._target();\n    ret._setBoundTo(maybePromise);\n    if (maybePromise instanceof Promise) {\n        var context = {\n            promiseRejectionQueued: false,\n            promise: ret,\n            target: target,\n            bindingPromise: maybePromise\n        };\n        target._then(INTERNAL, targetRejected, undefined, ret, context);\n        maybePromise._then(\n            bindingResolved, bindingRejected, undefined, ret, context);\n        ret._setOnCancel(maybePromise);\n    } else {\n        ret._resolveCallback(target);\n    }\n    return ret;\n};\n\nPromise.prototype._setBoundTo = function (obj) {\n    if (obj !== undefined) {\n        this._bitField = this._bitField | 2097152;\n        this._boundTo = obj;\n    } else {\n        this._bitField = this._bitField & (~2097152);\n    }\n};\n\nPromise.prototype._isBound = function () {\n    return (this._bitField & 2097152) === 2097152;\n};\n\nPromise.bind = function (thisArg, value) {\n    return Promise.resolve(value).bind(thisArg);\n};\n};\n\n},{}],4:[function(_dereq_,module,exports){\n\"use strict\";\nvar old;\nif (typeof Promise !== \"undefined\") old = Promise;\nfunction noConflict() {\n    try { if (Promise === bluebird) Promise = old; }\n    catch (e) {}\n    return bluebird;\n}\nvar bluebird = _dereq_(\"./promise\")();\nbluebird.noConflict = noConflict;\nmodule.exports = bluebird;\n\n},{\"./promise\":22}],5:[function(_dereq_,module,exports){\n\"use strict\";\nvar cr = Object.create;\nif (cr) {\n    var callerCache = cr(null);\n    var getterCache = cr(null);\n    callerCache[\" size\"] = getterCache[\" size\"] = 0;\n}\n\nmodule.exports = function(Promise) {\nvar util = _dereq_(\"./util\");\nvar canEvaluate = util.canEvaluate;\nvar isIdentifier = util.isIdentifier;\n\nvar getMethodCaller;\nvar getGetter;\nif (!true) {\nvar makeMethodCaller = function (methodName) {\n    return new Function(\"ensureMethod\", \"                                    \\n\\\n        return function(obj) {                                               \\n\\\n            'use strict'                                                     \\n\\\n            var len = this.length;                                           \\n\\\n            ensureMethod(obj, 'methodName');                                 \\n\\\n            switch(len) {                                                    \\n\\\n                case 1: return obj.methodName(this[0]);                      \\n\\\n                case 2: return obj.methodName(this[0], this[1]);             \\n\\\n                case 3: return obj.methodName(this[0], this[1], this[2]);    \\n\\\n                case 0: return obj.methodName();                             \\n\\\n                default:                                                     \\n\\\n                    return obj.methodName.apply(obj, this);                  \\n\\\n            }                                                                \\n\\\n        };                                                                   \\n\\\n        \".replace(/methodName/g, methodName))(ensureMethod);\n};\n\nvar makeGetter = function (propertyName) {\n    return new Function(\"obj\", \"                                             \\n\\\n        'use strict';                                                        \\n\\\n        return obj.propertyName;                                             \\n\\\n        \".replace(\"propertyName\", propertyName));\n};\n\nvar getCompiled = function(name, compiler, cache) {\n    var ret = cache[name];\n    if (typeof ret !== \"function\") {\n        if (!isIdentifier(name)) {\n            return null;\n        }\n        ret = compiler(name);\n        cache[name] = ret;\n        cache[\" size\"]++;\n        if (cache[\" size\"] > 512) {\n            var keys = Object.keys(cache);\n            for (var i = 0; i < 256; ++i) delete cache[keys[i]];\n            cache[\" size\"] = keys.length - 256;\n        }\n    }\n    return ret;\n};\n\ngetMethodCaller = function(name) {\n    return getCompiled(name, makeMethodCaller, callerCache);\n};\n\ngetGetter = function(name) {\n    return getCompiled(name, makeGetter, getterCache);\n};\n}\n\nfunction ensureMethod(obj, methodName) {\n    var fn;\n    if (obj != null) fn = obj[methodName];\n    if (typeof fn !== \"function\") {\n        var message = \"Object \" + util.classString(obj) + \" has no method '\" +\n            util.toString(methodName) + \"'\";\n        throw new Promise.TypeError(message);\n    }\n    return fn;\n}\n\nfunction caller(obj) {\n    var methodName = this.pop();\n    var fn = ensureMethod(obj, methodName);\n    return fn.apply(obj, this);\n}\nPromise.prototype.call = function (methodName) {\n    var args = [].slice.call(arguments, 1);;\n    if (!true) {\n        if (canEvaluate) {\n            var maybeCaller = getMethodCaller(methodName);\n            if (maybeCaller !== null) {\n                return this._then(\n                    maybeCaller, undefined, undefined, args, undefined);\n            }\n        }\n    }\n    args.push(methodName);\n    return this._then(caller, undefined, undefined, args, undefined);\n};\n\nfunction namedGetter(obj) {\n    return obj[this];\n}\nfunction indexedGetter(obj) {\n    var index = +this;\n    if (index < 0) index = Math.max(0, index + obj.length);\n    return obj[index];\n}\nPromise.prototype.get = function (propertyName) {\n    var isIndex = (typeof propertyName === \"number\");\n    var getter;\n    if (!isIndex) {\n        if (canEvaluate) {\n            var maybeGetter = getGetter(propertyName);\n            getter = maybeGetter !== null ? maybeGetter : namedGetter;\n        } else {\n            getter = namedGetter;\n        }\n    } else {\n        getter = indexedGetter;\n    }\n    return this._then(getter, undefined, undefined, propertyName, undefined);\n};\n};\n\n},{\"./util\":36}],6:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, PromiseArray, apiRejection, debug) {\nvar util = _dereq_(\"./util\");\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar async = Promise._async;\n\nPromise.prototype[\"break\"] = Promise.prototype.cancel = function() {\n    if (!debug.cancellation()) return this._warn(\"cancellation is disabled\");\n\n    var promise = this;\n    var child = promise;\n    while (promise._isCancellable()) {\n        if (!promise._cancelBy(child)) {\n            if (child._isFollowing()) {\n                child._followee().cancel();\n            } else {\n                child._cancelBranched();\n            }\n            break;\n        }\n\n        var parent = promise._cancellationParent;\n        if (parent == null || !parent._isCancellable()) {\n            if (promise._isFollowing()) {\n                promise._followee().cancel();\n            } else {\n                promise._cancelBranched();\n            }\n            break;\n        } else {\n            if (promise._isFollowing()) promise._followee().cancel();\n            promise._setWillBeCancelled();\n            child = promise;\n            promise = parent;\n        }\n    }\n};\n\nPromise.prototype._branchHasCancelled = function() {\n    this._branchesRemainingToCancel--;\n};\n\nPromise.prototype._enoughBranchesHaveCancelled = function() {\n    return this._branchesRemainingToCancel === undefined ||\n           this._branchesRemainingToCancel <= 0;\n};\n\nPromise.prototype._cancelBy = function(canceller) {\n    if (canceller === this) {\n        this._branchesRemainingToCancel = 0;\n        this._invokeOnCancel();\n        return true;\n    } else {\n        this._branchHasCancelled();\n        if (this._enoughBranchesHaveCancelled()) {\n            this._invokeOnCancel();\n            return true;\n        }\n    }\n    return false;\n};\n\nPromise.prototype._cancelBranched = function() {\n    if (this._enoughBranchesHaveCancelled()) {\n        this._cancel();\n    }\n};\n\nPromise.prototype._cancel = function() {\n    if (!this._isCancellable()) return;\n    this._setCancelled();\n    async.invoke(this._cancelPromises, this, undefined);\n};\n\nPromise.prototype._cancelPromises = function() {\n    if (this._length() > 0) this._settlePromises();\n};\n\nPromise.prototype._unsetOnCancel = function() {\n    this._onCancelField = undefined;\n};\n\nPromise.prototype._isCancellable = function() {\n    return this.isPending() && !this._isCancelled();\n};\n\nPromise.prototype.isCancellable = function() {\n    return this.isPending() && !this.isCancelled();\n};\n\nPromise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {\n    if (util.isArray(onCancelCallback)) {\n        for (var i = 0; i < onCancelCallback.length; ++i) {\n            this._doInvokeOnCancel(onCancelCallback[i], internalOnly);\n        }\n    } else if (onCancelCallback !== undefined) {\n        if (typeof onCancelCallback === \"function\") {\n            if (!internalOnly) {\n                var e = tryCatch(onCancelCallback).call(this._boundValue());\n                if (e === errorObj) {\n                    this._attachExtraTrace(e.e);\n                    async.throwLater(e.e);\n                }\n            }\n        } else {\n            onCancelCallback._resultCancelled(this);\n        }\n    }\n};\n\nPromise.prototype._invokeOnCancel = function() {\n    var onCancelCallback = this._onCancel();\n    this._unsetOnCancel();\n    async.invoke(this._doInvokeOnCancel, this, onCancelCallback);\n};\n\nPromise.prototype._invokeInternalOnCancel = function() {\n    if (this._isCancellable()) {\n        this._doInvokeOnCancel(this._onCancel(), true);\n        this._unsetOnCancel();\n    }\n};\n\nPromise.prototype._resultCancelled = function() {\n    this.cancel();\n};\n\n};\n\n},{\"./util\":36}],7:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(NEXT_FILTER) {\nvar util = _dereq_(\"./util\");\nvar getKeys = _dereq_(\"./es5\").keys;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\n\nfunction catchFilter(instances, cb, promise) {\n    return function(e) {\n        var boundTo = promise._boundValue();\n        predicateLoop: for (var i = 0; i < instances.length; ++i) {\n            var item = instances[i];\n\n            if (item === Error ||\n                (item != null && item.prototype instanceof Error)) {\n                if (e instanceof item) {\n                    return tryCatch(cb).call(boundTo, e);\n                }\n            } else if (typeof item === \"function\") {\n                var matchesPredicate = tryCatch(item).call(boundTo, e);\n                if (matchesPredicate === errorObj) {\n                    return matchesPredicate;\n                } else if (matchesPredicate) {\n                    return tryCatch(cb).call(boundTo, e);\n                }\n            } else if (util.isObject(e)) {\n                var keys = getKeys(item);\n                for (var j = 0; j < keys.length; ++j) {\n                    var key = keys[j];\n                    if (item[key] != e[key]) {\n                        continue predicateLoop;\n                    }\n                }\n                return tryCatch(cb).call(boundTo, e);\n            }\n        }\n        return NEXT_FILTER;\n    };\n}\n\nreturn catchFilter;\n};\n\n},{\"./es5\":13,\"./util\":36}],8:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise) {\nvar longStackTraces = false;\nvar contextStack = [];\n\nPromise.prototype._promiseCreated = function() {};\nPromise.prototype._pushContext = function() {};\nPromise.prototype._popContext = function() {return null;};\nPromise._peekContext = Promise.prototype._peekContext = function() {};\n\nfunction Context() {\n    this._trace = new Context.CapturedTrace(peekContext());\n}\nContext.prototype._pushContext = function () {\n    if (this._trace !== undefined) {\n        this._trace._promiseCreated = null;\n        contextStack.push(this._trace);\n    }\n};\n\nContext.prototype._popContext = function () {\n    if (this._trace !== undefined) {\n        var trace = contextStack.pop();\n        var ret = trace._promiseCreated;\n        trace._promiseCreated = null;\n        return ret;\n    }\n    return null;\n};\n\nfunction createContext() {\n    if (longStackTraces) return new Context();\n}\n\nfunction peekContext() {\n    var lastIndex = contextStack.length - 1;\n    if (lastIndex >= 0) {\n        return contextStack[lastIndex];\n    }\n    return undefined;\n}\nContext.CapturedTrace = null;\nContext.create = createContext;\nContext.deactivateLongStackTraces = function() {};\nContext.activateLongStackTraces = function() {\n    var Promise_pushContext = Promise.prototype._pushContext;\n    var Promise_popContext = Promise.prototype._popContext;\n    var Promise_PeekContext = Promise._peekContext;\n    var Promise_peekContext = Promise.prototype._peekContext;\n    var Promise_promiseCreated = Promise.prototype._promiseCreated;\n    Context.deactivateLongStackTraces = function() {\n        Promise.prototype._pushContext = Promise_pushContext;\n        Promise.prototype._popContext = Promise_popContext;\n        Promise._peekContext = Promise_PeekContext;\n        Promise.prototype._peekContext = Promise_peekContext;\n        Promise.prototype._promiseCreated = Promise_promiseCreated;\n        longStackTraces = false;\n    };\n    longStackTraces = true;\n    Promise.prototype._pushContext = Context.prototype._pushContext;\n    Promise.prototype._popContext = Context.prototype._popContext;\n    Promise._peekContext = Promise.prototype._peekContext = peekContext;\n    Promise.prototype._promiseCreated = function() {\n        var ctx = this._peekContext();\n        if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;\n    };\n};\nreturn Context;\n};\n\n},{}],9:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, Context,\n    enableAsyncHooks, disableAsyncHooks) {\nvar async = Promise._async;\nvar Warning = _dereq_(\"./errors\").Warning;\nvar util = _dereq_(\"./util\");\nvar es5 = _dereq_(\"./es5\");\nvar canAttachTrace = util.canAttachTrace;\nvar unhandledRejectionHandled;\nvar possiblyUnhandledRejection;\nvar bluebirdFramePattern =\n    /[\\\\\\/]bluebird[\\\\\\/]js[\\\\\\/](release|debug|instrumented)/;\nvar nodeFramePattern = /\\((?:timers\\.js):\\d+:\\d+\\)/;\nvar parseLinePattern = /[\\/<\\(](.+?):(\\d+):(\\d+)\\)?\\s*$/;\nvar stackFramePattern = null;\nvar formatStack = null;\nvar indentStackFrames = false;\nvar printWarning;\nvar debugging = !!(util.env(\"BLUEBIRD_DEBUG\") != 0 &&\n                        (true ||\n                         util.env(\"BLUEBIRD_DEBUG\") ||\n                         util.env(\"NODE_ENV\") === \"development\"));\n\nvar warnings = !!(util.env(\"BLUEBIRD_WARNINGS\") != 0 &&\n    (debugging || util.env(\"BLUEBIRD_WARNINGS\")));\n\nvar longStackTraces = !!(util.env(\"BLUEBIRD_LONG_STACK_TRACES\") != 0 &&\n    (debugging || util.env(\"BLUEBIRD_LONG_STACK_TRACES\")));\n\nvar wForgottenReturn = util.env(\"BLUEBIRD_W_FORGOTTEN_RETURN\") != 0 &&\n    (warnings || !!util.env(\"BLUEBIRD_W_FORGOTTEN_RETURN\"));\n\nvar deferUnhandledRejectionCheck;\n(function() {\n    var promises = [];\n\n    function unhandledRejectionCheck() {\n        for (var i = 0; i < promises.length; ++i) {\n            promises[i]._notifyUnhandledRejection();\n        }\n        unhandledRejectionClear();\n    }\n\n    function unhandledRejectionClear() {\n        promises.length = 0;\n    }\n\n    deferUnhandledRejectionCheck = function(promise) {\n        promises.push(promise);\n        setTimeout(unhandledRejectionCheck, 1);\n    };\n\n    es5.defineProperty(Promise, \"_unhandledRejectionCheck\", {\n        value: unhandledRejectionCheck\n    });\n    es5.defineProperty(Promise, \"_unhandledRejectionClear\", {\n        value: unhandledRejectionClear\n    });\n})();\n\nPromise.prototype.suppressUnhandledRejections = function() {\n    var target = this._target();\n    target._bitField = ((target._bitField & (~1048576)) |\n                      524288);\n};\n\nPromise.prototype._ensurePossibleRejectionHandled = function () {\n    if ((this._bitField & 524288) !== 0) return;\n    this._setRejectionIsUnhandled();\n    deferUnhandledRejectionCheck(this);\n};\n\nPromise.prototype._notifyUnhandledRejectionIsHandled = function () {\n    fireRejectionEvent(\"rejectionHandled\",\n                                  unhandledRejectionHandled, undefined, this);\n};\n\nPromise.prototype._setReturnedNonUndefined = function() {\n    this._bitField = this._bitField | 268435456;\n};\n\nPromise.prototype._returnedNonUndefined = function() {\n    return (this._bitField & 268435456) !== 0;\n};\n\nPromise.prototype._notifyUnhandledRejection = function () {\n    if (this._isRejectionUnhandled()) {\n        var reason = this._settledValue();\n        this._setUnhandledRejectionIsNotified();\n        fireRejectionEvent(\"unhandledRejection\",\n                                      possiblyUnhandledRejection, reason, this);\n    }\n};\n\nPromise.prototype._setUnhandledRejectionIsNotified = function () {\n    this._bitField = this._bitField | 262144;\n};\n\nPromise.prototype._unsetUnhandledRejectionIsNotified = function () {\n    this._bitField = this._bitField & (~262144);\n};\n\nPromise.prototype._isUnhandledRejectionNotified = function () {\n    return (this._bitField & 262144) > 0;\n};\n\nPromise.prototype._setRejectionIsUnhandled = function () {\n    this._bitField = this._bitField | 1048576;\n};\n\nPromise.prototype._unsetRejectionIsUnhandled = function () {\n    this._bitField = this._bitField & (~1048576);\n    if (this._isUnhandledRejectionNotified()) {\n        this._unsetUnhandledRejectionIsNotified();\n        this._notifyUnhandledRejectionIsHandled();\n    }\n};\n\nPromise.prototype._isRejectionUnhandled = function () {\n    return (this._bitField & 1048576) > 0;\n};\n\nPromise.prototype._warn = function(message, shouldUseOwnTrace, promise) {\n    return warn(message, shouldUseOwnTrace, promise || this);\n};\n\nPromise.onPossiblyUnhandledRejection = function (fn) {\n    var context = Promise._getContext();\n    possiblyUnhandledRejection = util.contextBind(context, fn);\n};\n\nPromise.onUnhandledRejectionHandled = function (fn) {\n    var context = Promise._getContext();\n    unhandledRejectionHandled = util.contextBind(context, fn);\n};\n\nvar disableLongStackTraces = function() {};\nPromise.longStackTraces = function () {\n    if (async.haveItemsQueued() && !config.longStackTraces) {\n        throw new Error(\"cannot enable long stack traces after promises have been created\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    if (!config.longStackTraces && longStackTracesIsSupported()) {\n        var Promise_captureStackTrace = Promise.prototype._captureStackTrace;\n        var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;\n        var Promise_dereferenceTrace = Promise.prototype._dereferenceTrace;\n        config.longStackTraces = true;\n        disableLongStackTraces = function() {\n            if (async.haveItemsQueued() && !config.longStackTraces) {\n                throw new Error(\"cannot enable long stack traces after promises have been created\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n            }\n            Promise.prototype._captureStackTrace = Promise_captureStackTrace;\n            Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;\n            Promise.prototype._dereferenceTrace = Promise_dereferenceTrace;\n            Context.deactivateLongStackTraces();\n            config.longStackTraces = false;\n        };\n        Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;\n        Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;\n        Promise.prototype._dereferenceTrace = longStackTracesDereferenceTrace;\n        Context.activateLongStackTraces();\n    }\n};\n\nPromise.hasLongStackTraces = function () {\n    return config.longStackTraces && longStackTracesIsSupported();\n};\n\n\nvar legacyHandlers = {\n    unhandledrejection: {\n        before: function() {\n            var ret = util.global.onunhandledrejection;\n            util.global.onunhandledrejection = null;\n            return ret;\n        },\n        after: function(fn) {\n            util.global.onunhandledrejection = fn;\n        }\n    },\n    rejectionhandled: {\n        before: function() {\n            var ret = util.global.onrejectionhandled;\n            util.global.onrejectionhandled = null;\n            return ret;\n        },\n        after: function(fn) {\n            util.global.onrejectionhandled = fn;\n        }\n    }\n};\n\nvar fireDomEvent = (function() {\n    var dispatch = function(legacy, e) {\n        if (legacy) {\n            var fn;\n            try {\n                fn = legacy.before();\n                return !util.global.dispatchEvent(e);\n            } finally {\n                legacy.after(fn);\n            }\n        } else {\n            return !util.global.dispatchEvent(e);\n        }\n    };\n    try {\n        if (typeof CustomEvent === \"function\") {\n            var event = new CustomEvent(\"CustomEvent\");\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                name = name.toLowerCase();\n                var eventData = {\n                    detail: event,\n                    cancelable: true\n                };\n                var domEvent = new CustomEvent(name, eventData);\n                es5.defineProperty(\n                    domEvent, \"promise\", {value: event.promise});\n                es5.defineProperty(\n                    domEvent, \"reason\", {value: event.reason});\n\n                return dispatch(legacyHandlers[name], domEvent);\n            };\n        } else if (typeof Event === \"function\") {\n            var event = new Event(\"CustomEvent\");\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                name = name.toLowerCase();\n                var domEvent = new Event(name, {\n                    cancelable: true\n                });\n                domEvent.detail = event;\n                es5.defineProperty(domEvent, \"promise\", {value: event.promise});\n                es5.defineProperty(domEvent, \"reason\", {value: event.reason});\n                return dispatch(legacyHandlers[name], domEvent);\n            };\n        } else {\n            var event = document.createEvent(\"CustomEvent\");\n            event.initCustomEvent(\"testingtheevent\", false, true, {});\n            util.global.dispatchEvent(event);\n            return function(name, event) {\n                name = name.toLowerCase();\n                var domEvent = document.createEvent(\"CustomEvent\");\n                domEvent.initCustomEvent(name, false, true,\n                    event);\n                return dispatch(legacyHandlers[name], domEvent);\n            };\n        }\n    } catch (e) {}\n    return function() {\n        return false;\n    };\n})();\n\nvar fireGlobalEvent = (function() {\n    if (util.isNode) {\n        return function() {\n            return process.emit.apply(process, arguments);\n        };\n    } else {\n        if (!util.global) {\n            return function() {\n                return false;\n            };\n        }\n        return function(name) {\n            var methodName = \"on\" + name.toLowerCase();\n            var method = util.global[methodName];\n            if (!method) return false;\n            method.apply(util.global, [].slice.call(arguments, 1));\n            return true;\n        };\n    }\n})();\n\nfunction generatePromiseLifecycleEventObject(name, promise) {\n    return {promise: promise};\n}\n\nvar eventToObjectGenerator = {\n    promiseCreated: generatePromiseLifecycleEventObject,\n    promiseFulfilled: generatePromiseLifecycleEventObject,\n    promiseRejected: generatePromiseLifecycleEventObject,\n    promiseResolved: generatePromiseLifecycleEventObject,\n    promiseCancelled: generatePromiseLifecycleEventObject,\n    promiseChained: function(name, promise, child) {\n        return {promise: promise, child: child};\n    },\n    warning: function(name, warning) {\n        return {warning: warning};\n    },\n    unhandledRejection: function (name, reason, promise) {\n        return {reason: reason, promise: promise};\n    },\n    rejectionHandled: generatePromiseLifecycleEventObject\n};\n\nvar activeFireEvent = function (name) {\n    var globalEventFired = false;\n    try {\n        globalEventFired = fireGlobalEvent.apply(null, arguments);\n    } catch (e) {\n        async.throwLater(e);\n        globalEventFired = true;\n    }\n\n    var domEventFired = false;\n    try {\n        domEventFired = fireDomEvent(name,\n                    eventToObjectGenerator[name].apply(null, arguments));\n    } catch (e) {\n        async.throwLater(e);\n        domEventFired = true;\n    }\n\n    return domEventFired || globalEventFired;\n};\n\nPromise.config = function(opts) {\n    opts = Object(opts);\n    if (\"longStackTraces\" in opts) {\n        if (opts.longStackTraces) {\n            Promise.longStackTraces();\n        } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {\n            disableLongStackTraces();\n        }\n    }\n    if (\"warnings\" in opts) {\n        var warningsOption = opts.warnings;\n        config.warnings = !!warningsOption;\n        wForgottenReturn = config.warnings;\n\n        if (util.isObject(warningsOption)) {\n            if (\"wForgottenReturn\" in warningsOption) {\n                wForgottenReturn = !!warningsOption.wForgottenReturn;\n            }\n        }\n    }\n    if (\"cancellation\" in opts && opts.cancellation && !config.cancellation) {\n        if (async.haveItemsQueued()) {\n            throw new Error(\n                \"cannot enable cancellation after promises are in use\");\n        }\n        Promise.prototype._clearCancellationData =\n            cancellationClearCancellationData;\n        Promise.prototype._propagateFrom = cancellationPropagateFrom;\n        Promise.prototype._onCancel = cancellationOnCancel;\n        Promise.prototype._setOnCancel = cancellationSetOnCancel;\n        Promise.prototype._attachCancellationCallback =\n            cancellationAttachCancellationCallback;\n        Promise.prototype._execute = cancellationExecute;\n        propagateFromFunction = cancellationPropagateFrom;\n        config.cancellation = true;\n    }\n    if (\"monitoring\" in opts) {\n        if (opts.monitoring && !config.monitoring) {\n            config.monitoring = true;\n            Promise.prototype._fireEvent = activeFireEvent;\n        } else if (!opts.monitoring && config.monitoring) {\n            config.monitoring = false;\n            Promise.prototype._fireEvent = defaultFireEvent;\n        }\n    }\n    if (\"asyncHooks\" in opts && util.nodeSupportsAsyncResource) {\n        var prev = config.asyncHooks;\n        var cur = !!opts.asyncHooks;\n        if (prev !== cur) {\n            config.asyncHooks = cur;\n            if (cur) {\n                enableAsyncHooks();\n            } else {\n                disableAsyncHooks();\n            }\n        }\n    }\n    return Promise;\n};\n\nfunction defaultFireEvent() { return false; }\n\nPromise.prototype._fireEvent = defaultFireEvent;\nPromise.prototype._execute = function(executor, resolve, reject) {\n    try {\n        executor(resolve, reject);\n    } catch (e) {\n        return e;\n    }\n};\nPromise.prototype._onCancel = function () {};\nPromise.prototype._setOnCancel = function (handler) { ; };\nPromise.prototype._attachCancellationCallback = function(onCancel) {\n    ;\n};\nPromise.prototype._captureStackTrace = function () {};\nPromise.prototype._attachExtraTrace = function () {};\nPromise.prototype._dereferenceTrace = function () {};\nPromise.prototype._clearCancellationData = function() {};\nPromise.prototype._propagateFrom = function (parent, flags) {\n    ;\n    ;\n};\n\nfunction cancellationExecute(executor, resolve, reject) {\n    var promise = this;\n    try {\n        executor(resolve, reject, function(onCancel) {\n            if (typeof onCancel !== \"function\") {\n                throw new TypeError(\"onCancel must be a function, got: \" +\n                                    util.toString(onCancel));\n            }\n            promise._attachCancellationCallback(onCancel);\n        });\n    } catch (e) {\n        return e;\n    }\n}\n\nfunction cancellationAttachCancellationCallback(onCancel) {\n    if (!this._isCancellable()) return this;\n\n    var previousOnCancel = this._onCancel();\n    if (previousOnCancel !== undefined) {\n        if (util.isArray(previousOnCancel)) {\n            previousOnCancel.push(onCancel);\n        } else {\n            this._setOnCancel([previousOnCancel, onCancel]);\n        }\n    } else {\n        this._setOnCancel(onCancel);\n    }\n}\n\nfunction cancellationOnCancel() {\n    return this._onCancelField;\n}\n\nfunction cancellationSetOnCancel(onCancel) {\n    this._onCancelField = onCancel;\n}\n\nfunction cancellationClearCancellationData() {\n    this._cancellationParent = undefined;\n    this._onCancelField = undefined;\n}\n\nfunction cancellationPropagateFrom(parent, flags) {\n    if ((flags & 1) !== 0) {\n        this._cancellationParent = parent;\n        var branchesRemainingToCancel = parent._branchesRemainingToCancel;\n        if (branchesRemainingToCancel === undefined) {\n            branchesRemainingToCancel = 0;\n        }\n        parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;\n    }\n    if ((flags & 2) !== 0 && parent._isBound()) {\n        this._setBoundTo(parent._boundTo);\n    }\n}\n\nfunction bindingPropagateFrom(parent, flags) {\n    if ((flags & 2) !== 0 && parent._isBound()) {\n        this._setBoundTo(parent._boundTo);\n    }\n}\nvar propagateFromFunction = bindingPropagateFrom;\n\nfunction boundValueFunction() {\n    var ret = this._boundTo;\n    if (ret !== undefined) {\n        if (ret instanceof Promise) {\n            if (ret.isFulfilled()) {\n                return ret.value();\n            } else {\n                return undefined;\n            }\n        }\n    }\n    return ret;\n}\n\nfunction longStackTracesCaptureStackTrace() {\n    this._trace = new CapturedTrace(this._peekContext());\n}\n\nfunction longStackTracesAttachExtraTrace(error, ignoreSelf) {\n    if (canAttachTrace(error)) {\n        var trace = this._trace;\n        if (trace !== undefined) {\n            if (ignoreSelf) trace = trace._parent;\n        }\n        if (trace !== undefined) {\n            trace.attachExtraTrace(error);\n        } else if (!error.__stackCleaned__) {\n            var parsed = parseStackAndMessage(error);\n            util.notEnumerableProp(error, \"stack\",\n                parsed.message + \"\\n\" + parsed.stack.join(\"\\n\"));\n            util.notEnumerableProp(error, \"__stackCleaned__\", true);\n        }\n    }\n}\n\nfunction longStackTracesDereferenceTrace() {\n    this._trace = undefined;\n}\n\nfunction checkForgottenReturns(returnValue, promiseCreated, name, promise,\n                               parent) {\n    if (returnValue === undefined && promiseCreated !== null &&\n        wForgottenReturn) {\n        if (parent !== undefined && parent._returnedNonUndefined()) return;\n        if ((promise._bitField & 65535) === 0) return;\n\n        if (name) name = name + \" \";\n        var handlerLine = \"\";\n        var creatorLine = \"\";\n        if (promiseCreated._trace) {\n            var traceLines = promiseCreated._trace.stack.split(\"\\n\");\n            var stack = cleanStack(traceLines);\n            for (var i = stack.length - 1; i >= 0; --i) {\n                var line = stack[i];\n                if (!nodeFramePattern.test(line)) {\n                    var lineMatches = line.match(parseLinePattern);\n                    if (lineMatches) {\n                        handlerLine  = \"at \" + lineMatches[1] +\n                            \":\" + lineMatches[2] + \":\" + lineMatches[3] + \" \";\n                    }\n                    break;\n                }\n            }\n\n            if (stack.length > 0) {\n                var firstUserLine = stack[0];\n                for (var i = 0; i < traceLines.length; ++i) {\n\n                    if (traceLines[i] === firstUserLine) {\n                        if (i > 0) {\n                            creatorLine = \"\\n\" + traceLines[i - 1];\n                        }\n                        break;\n                    }\n                }\n\n            }\n        }\n        var msg = \"a promise was created in a \" + name +\n            \"handler \" + handlerLine + \"but was not returned from it, \" +\n            \"see http://goo.gl/rRqMUw\" +\n            creatorLine;\n        promise._warn(msg, true, promiseCreated);\n    }\n}\n\nfunction deprecated(name, replacement) {\n    var message = name +\n        \" is deprecated and will be removed in a future version.\";\n    if (replacement) message += \" Use \" + replacement + \" instead.\";\n    return warn(message);\n}\n\nfunction warn(message, shouldUseOwnTrace, promise) {\n    if (!config.warnings) return;\n    var warning = new Warning(message);\n    var ctx;\n    if (shouldUseOwnTrace) {\n        promise._attachExtraTrace(warning);\n    } else if (config.longStackTraces && (ctx = Promise._peekContext())) {\n        ctx.attachExtraTrace(warning);\n    } else {\n        var parsed = parseStackAndMessage(warning);\n        warning.stack = parsed.message + \"\\n\" + parsed.stack.join(\"\\n\");\n    }\n\n    if (!activeFireEvent(\"warning\", warning)) {\n        formatAndLogError(warning, \"\", true);\n    }\n}\n\nfunction reconstructStack(message, stacks) {\n    for (var i = 0; i < stacks.length - 1; ++i) {\n        stacks[i].push(\"From previous event:\");\n        stacks[i] = stacks[i].join(\"\\n\");\n    }\n    if (i < stacks.length) {\n        stacks[i] = stacks[i].join(\"\\n\");\n    }\n    return message + \"\\n\" + stacks.join(\"\\n\");\n}\n\nfunction removeDuplicateOrEmptyJumps(stacks) {\n    for (var i = 0; i < stacks.length; ++i) {\n        if (stacks[i].length === 0 ||\n            ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {\n            stacks.splice(i, 1);\n            i--;\n        }\n    }\n}\n\nfunction removeCommonRoots(stacks) {\n    var current = stacks[0];\n    for (var i = 1; i < stacks.length; ++i) {\n        var prev = stacks[i];\n        var currentLastIndex = current.length - 1;\n        var currentLastLine = current[currentLastIndex];\n        var commonRootMeetPoint = -1;\n\n        for (var j = prev.length - 1; j >= 0; --j) {\n            if (prev[j] === currentLastLine) {\n                commonRootMeetPoint = j;\n                break;\n            }\n        }\n\n        for (var j = commonRootMeetPoint; j >= 0; --j) {\n            var line = prev[j];\n            if (current[currentLastIndex] === line) {\n                current.pop();\n                currentLastIndex--;\n            } else {\n                break;\n            }\n        }\n        current = prev;\n    }\n}\n\nfunction cleanStack(stack) {\n    var ret = [];\n    for (var i = 0; i < stack.length; ++i) {\n        var line = stack[i];\n        var isTraceLine = \"    (No stack trace)\" === line ||\n            stackFramePattern.test(line);\n        var isInternalFrame = isTraceLine && shouldIgnore(line);\n        if (isTraceLine && !isInternalFrame) {\n            if (indentStackFrames && line.charAt(0) !== \" \") {\n                line = \"    \" + line;\n            }\n            ret.push(line);\n        }\n    }\n    return ret;\n}\n\nfunction stackFramesAsArray(error) {\n    var stack = error.stack.replace(/\\s+$/g, \"\").split(\"\\n\");\n    for (var i = 0; i < stack.length; ++i) {\n        var line = stack[i];\n        if (\"    (No stack trace)\" === line || stackFramePattern.test(line)) {\n            break;\n        }\n    }\n    if (i > 0 && error.name != \"SyntaxError\") {\n        stack = stack.slice(i);\n    }\n    return stack;\n}\n\nfunction parseStackAndMessage(error) {\n    var stack = error.stack;\n    var message = error.toString();\n    stack = typeof stack === \"string\" && stack.length > 0\n                ? stackFramesAsArray(error) : [\"    (No stack trace)\"];\n    return {\n        message: message,\n        stack: error.name == \"SyntaxError\" ? stack : cleanStack(stack)\n    };\n}\n\nfunction formatAndLogError(error, title, isSoft) {\n    if (typeof console !== \"undefined\") {\n        var message;\n        if (util.isObject(error)) {\n            var stack = error.stack;\n            message = title + formatStack(stack, error);\n        } else {\n            message = title + String(error);\n        }\n        if (typeof printWarning === \"function\") {\n            printWarning(message, isSoft);\n        } else if (typeof console.log === \"function\" ||\n            typeof console.log === \"object\") {\n            console.log(message);\n        }\n    }\n}\n\nfunction fireRejectionEvent(name, localHandler, reason, promise) {\n    var localEventFired = false;\n    try {\n        if (typeof localHandler === \"function\") {\n            localEventFired = true;\n            if (name === \"rejectionHandled\") {\n                localHandler(promise);\n            } else {\n                localHandler(reason, promise);\n            }\n        }\n    } catch (e) {\n        async.throwLater(e);\n    }\n\n    if (name === \"unhandledRejection\") {\n        if (!activeFireEvent(name, reason, promise) && !localEventFired) {\n            formatAndLogError(reason, \"Unhandled rejection \");\n        }\n    } else {\n        activeFireEvent(name, promise);\n    }\n}\n\nfunction formatNonError(obj) {\n    var str;\n    if (typeof obj === \"function\") {\n        str = \"[function \" +\n            (obj.name || \"anonymous\") +\n            \"]\";\n    } else {\n        str = obj && typeof obj.toString === \"function\"\n            ? obj.toString() : util.toString(obj);\n        var ruselessToString = /\\[object [a-zA-Z0-9$_]+\\]/;\n        if (ruselessToString.test(str)) {\n            try {\n                var newStr = JSON.stringify(obj);\n                str = newStr;\n            }\n            catch(e) {\n\n            }\n        }\n        if (str.length === 0) {\n            str = \"(empty array)\";\n        }\n    }\n    return (\"(<\" + snip(str) + \">, no stack trace)\");\n}\n\nfunction snip(str) {\n    var maxChars = 41;\n    if (str.length < maxChars) {\n        return str;\n    }\n    return str.substr(0, maxChars - 3) + \"...\";\n}\n\nfunction longStackTracesIsSupported() {\n    return typeof captureStackTrace === \"function\";\n}\n\nvar shouldIgnore = function() { return false; };\nvar parseLineInfoRegex = /[\\/<\\(]([^:\\/]+):(\\d+):(?:\\d+)\\)?\\s*$/;\nfunction parseLineInfo(line) {\n    var matches = line.match(parseLineInfoRegex);\n    if (matches) {\n        return {\n            fileName: matches[1],\n            line: parseInt(matches[2], 10)\n        };\n    }\n}\n\nfunction setBounds(firstLineError, lastLineError) {\n    if (!longStackTracesIsSupported()) return;\n    var firstStackLines = (firstLineError.stack || \"\").split(\"\\n\");\n    var lastStackLines = (lastLineError.stack || \"\").split(\"\\n\");\n    var firstIndex = -1;\n    var lastIndex = -1;\n    var firstFileName;\n    var lastFileName;\n    for (var i = 0; i < firstStackLines.length; ++i) {\n        var result = parseLineInfo(firstStackLines[i]);\n        if (result) {\n            firstFileName = result.fileName;\n            firstIndex = result.line;\n            break;\n        }\n    }\n    for (var i = 0; i < lastStackLines.length; ++i) {\n        var result = parseLineInfo(lastStackLines[i]);\n        if (result) {\n            lastFileName = result.fileName;\n            lastIndex = result.line;\n            break;\n        }\n    }\n    if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||\n        firstFileName !== lastFileName || firstIndex >= lastIndex) {\n        return;\n    }\n\n    shouldIgnore = function(line) {\n        if (bluebirdFramePattern.test(line)) return true;\n        var info = parseLineInfo(line);\n        if (info) {\n            if (info.fileName === firstFileName &&\n                (firstIndex <= info.line && info.line <= lastIndex)) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\n\nfunction CapturedTrace(parent) {\n    this._parent = parent;\n    this._promisesCreated = 0;\n    var length = this._length = 1 + (parent === undefined ? 0 : parent._length);\n    captureStackTrace(this, CapturedTrace);\n    if (length > 32) this.uncycle();\n}\nutil.inherits(CapturedTrace, Error);\nContext.CapturedTrace = CapturedTrace;\n\nCapturedTrace.prototype.uncycle = function() {\n    var length = this._length;\n    if (length < 2) return;\n    var nodes = [];\n    var stackToIndex = {};\n\n    for (var i = 0, node = this; node !== undefined; ++i) {\n        nodes.push(node);\n        node = node._parent;\n    }\n    length = this._length = i;\n    for (var i = length - 1; i >= 0; --i) {\n        var stack = nodes[i].stack;\n        if (stackToIndex[stack] === undefined) {\n            stackToIndex[stack] = i;\n        }\n    }\n    for (var i = 0; i < length; ++i) {\n        var currentStack = nodes[i].stack;\n        var index = stackToIndex[currentStack];\n        if (index !== undefined && index !== i) {\n            if (index > 0) {\n                nodes[index - 1]._parent = undefined;\n                nodes[index - 1]._length = 1;\n            }\n            nodes[i]._parent = undefined;\n            nodes[i]._length = 1;\n            var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;\n\n            if (index < length - 1) {\n                cycleEdgeNode._parent = nodes[index + 1];\n                cycleEdgeNode._parent.uncycle();\n                cycleEdgeNode._length =\n                    cycleEdgeNode._parent._length + 1;\n            } else {\n                cycleEdgeNode._parent = undefined;\n                cycleEdgeNode._length = 1;\n            }\n            var currentChildLength = cycleEdgeNode._length + 1;\n            for (var j = i - 2; j >= 0; --j) {\n                nodes[j]._length = currentChildLength;\n                currentChildLength++;\n            }\n            return;\n        }\n    }\n};\n\nCapturedTrace.prototype.attachExtraTrace = function(error) {\n    if (error.__stackCleaned__) return;\n    this.uncycle();\n    var parsed = parseStackAndMessage(error);\n    var message = parsed.message;\n    var stacks = [parsed.stack];\n\n    var trace = this;\n    while (trace !== undefined) {\n        stacks.push(cleanStack(trace.stack.split(\"\\n\")));\n        trace = trace._parent;\n    }\n    removeCommonRoots(stacks);\n    removeDuplicateOrEmptyJumps(stacks);\n    util.notEnumerableProp(error, \"stack\", reconstructStack(message, stacks));\n    util.notEnumerableProp(error, \"__stackCleaned__\", true);\n};\n\nvar captureStackTrace = (function stackDetection() {\n    var v8stackFramePattern = /^\\s*at\\s*/;\n    var v8stackFormatter = function(stack, error) {\n        if (typeof stack === \"string\") return stack;\n\n        if (error.name !== undefined &&\n            error.message !== undefined) {\n            return error.toString();\n        }\n        return formatNonError(error);\n    };\n\n    if (typeof Error.stackTraceLimit === \"number\" &&\n        typeof Error.captureStackTrace === \"function\") {\n        Error.stackTraceLimit += 6;\n        stackFramePattern = v8stackFramePattern;\n        formatStack = v8stackFormatter;\n        var captureStackTrace = Error.captureStackTrace;\n\n        shouldIgnore = function(line) {\n            return bluebirdFramePattern.test(line);\n        };\n        return function(receiver, ignoreUntil) {\n            Error.stackTraceLimit += 6;\n            captureStackTrace(receiver, ignoreUntil);\n            Error.stackTraceLimit -= 6;\n        };\n    }\n    var err = new Error();\n\n    if (typeof err.stack === \"string\" &&\n        err.stack.split(\"\\n\")[0].indexOf(\"stackDetection@\") >= 0) {\n        stackFramePattern = /@/;\n        formatStack = v8stackFormatter;\n        indentStackFrames = true;\n        return function captureStackTrace(o) {\n            o.stack = new Error().stack;\n        };\n    }\n\n    var hasStackAfterThrow;\n    try { throw new Error(); }\n    catch(e) {\n        hasStackAfterThrow = (\"stack\" in e);\n    }\n    if (!(\"stack\" in err) && hasStackAfterThrow &&\n        typeof Error.stackTraceLimit === \"number\") {\n        stackFramePattern = v8stackFramePattern;\n        formatStack = v8stackFormatter;\n        return function captureStackTrace(o) {\n            Error.stackTraceLimit += 6;\n            try { throw new Error(); }\n            catch(e) { o.stack = e.stack; }\n            Error.stackTraceLimit -= 6;\n        };\n    }\n\n    formatStack = function(stack, error) {\n        if (typeof stack === \"string\") return stack;\n\n        if ((typeof error === \"object\" ||\n            typeof error === \"function\") &&\n            error.name !== undefined &&\n            error.message !== undefined) {\n            return error.toString();\n        }\n        return formatNonError(error);\n    };\n\n    return null;\n\n})([]);\n\nif (typeof console !== \"undefined\" && typeof console.warn !== \"undefined\") {\n    printWarning = function (message) {\n        console.warn(message);\n    };\n    if (util.isNode && process.stderr.isTTY) {\n        printWarning = function(message, isSoft) {\n            var color = isSoft ? \"\\u001b[33m\" : \"\\u001b[31m\";\n            console.warn(color + message + \"\\u001b[0m\\n\");\n        };\n    } else if (!util.isNode && typeof (new Error().stack) === \"string\") {\n        printWarning = function(message, isSoft) {\n            console.warn(\"%c\" + message,\n                        isSoft ? \"color: darkorange\" : \"color: red\");\n        };\n    }\n}\n\nvar config = {\n    warnings: warnings,\n    longStackTraces: false,\n    cancellation: false,\n    monitoring: false,\n    asyncHooks: false\n};\n\nif (longStackTraces) Promise.longStackTraces();\n\nreturn {\n    asyncHooks: function() {\n        return config.asyncHooks;\n    },\n    longStackTraces: function() {\n        return config.longStackTraces;\n    },\n    warnings: function() {\n        return config.warnings;\n    },\n    cancellation: function() {\n        return config.cancellation;\n    },\n    monitoring: function() {\n        return config.monitoring;\n    },\n    propagateFromFunction: function() {\n        return propagateFromFunction;\n    },\n    boundValueFunction: function() {\n        return boundValueFunction;\n    },\n    checkForgottenReturns: checkForgottenReturns,\n    setBounds: setBounds,\n    warn: warn,\n    deprecated: deprecated,\n    CapturedTrace: CapturedTrace,\n    fireDomEvent: fireDomEvent,\n    fireGlobalEvent: fireGlobalEvent\n};\n};\n\n},{\"./errors\":12,\"./es5\":13,\"./util\":36}],10:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise) {\nfunction returner() {\n    return this.value;\n}\nfunction thrower() {\n    throw this.reason;\n}\n\nPromise.prototype[\"return\"] =\nPromise.prototype.thenReturn = function (value) {\n    if (value instanceof Promise) value.suppressUnhandledRejections();\n    return this._then(\n        returner, undefined, undefined, {value: value}, undefined);\n};\n\nPromise.prototype[\"throw\"] =\nPromise.prototype.thenThrow = function (reason) {\n    return this._then(\n        thrower, undefined, undefined, {reason: reason}, undefined);\n};\n\nPromise.prototype.catchThrow = function (reason) {\n    if (arguments.length <= 1) {\n        return this._then(\n            undefined, thrower, undefined, {reason: reason}, undefined);\n    } else {\n        var _reason = arguments[1];\n        var handler = function() {throw _reason;};\n        return this.caught(reason, handler);\n    }\n};\n\nPromise.prototype.catchReturn = function (value) {\n    if (arguments.length <= 1) {\n        if (value instanceof Promise) value.suppressUnhandledRejections();\n        return this._then(\n            undefined, returner, undefined, {value: value}, undefined);\n    } else {\n        var _value = arguments[1];\n        if (_value instanceof Promise) _value.suppressUnhandledRejections();\n        var handler = function() {return _value;};\n        return this.caught(value, handler);\n    }\n};\n};\n\n},{}],11:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, INTERNAL) {\nvar PromiseReduce = Promise.reduce;\nvar PromiseAll = Promise.all;\n\nfunction promiseAllThis() {\n    return PromiseAll(this);\n}\n\nfunction PromiseMapSeries(promises, fn) {\n    return PromiseReduce(promises, fn, INTERNAL, INTERNAL);\n}\n\nPromise.prototype.each = function (fn) {\n    return PromiseReduce(this, fn, INTERNAL, 0)\n              ._then(promiseAllThis, undefined, undefined, this, undefined);\n};\n\nPromise.prototype.mapSeries = function (fn) {\n    return PromiseReduce(this, fn, INTERNAL, INTERNAL);\n};\n\nPromise.each = function (promises, fn) {\n    return PromiseReduce(promises, fn, INTERNAL, 0)\n              ._then(promiseAllThis, undefined, undefined, promises, undefined);\n};\n\nPromise.mapSeries = PromiseMapSeries;\n};\n\n\n},{}],12:[function(_dereq_,module,exports){\n\"use strict\";\nvar es5 = _dereq_(\"./es5\");\nvar Objectfreeze = es5.freeze;\nvar util = _dereq_(\"./util\");\nvar inherits = util.inherits;\nvar notEnumerableProp = util.notEnumerableProp;\n\nfunction subError(nameProperty, defaultMessage) {\n    function SubError(message) {\n        if (!(this instanceof SubError)) return new SubError(message);\n        notEnumerableProp(this, \"message\",\n            typeof message === \"string\" ? message : defaultMessage);\n        notEnumerableProp(this, \"name\", nameProperty);\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, this.constructor);\n        } else {\n            Error.call(this);\n        }\n    }\n    inherits(SubError, Error);\n    return SubError;\n}\n\nvar _TypeError, _RangeError;\nvar Warning = subError(\"Warning\", \"warning\");\nvar CancellationError = subError(\"CancellationError\", \"cancellation error\");\nvar TimeoutError = subError(\"TimeoutError\", \"timeout error\");\nvar AggregateError = subError(\"AggregateError\", \"aggregate error\");\ntry {\n    _TypeError = TypeError;\n    _RangeError = RangeError;\n} catch(e) {\n    _TypeError = subError(\"TypeError\", \"type error\");\n    _RangeError = subError(\"RangeError\", \"range error\");\n}\n\nvar methods = (\"join pop push shift unshift slice filter forEach some \" +\n    \"every map indexOf lastIndexOf reduce reduceRight sort reverse\").split(\" \");\n\nfor (var i = 0; i < methods.length; ++i) {\n    if (typeof Array.prototype[methods[i]] === \"function\") {\n        AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];\n    }\n}\n\nes5.defineProperty(AggregateError.prototype, \"length\", {\n    value: 0,\n    configurable: false,\n    writable: true,\n    enumerable: true\n});\nAggregateError.prototype[\"isOperational\"] = true;\nvar level = 0;\nAggregateError.prototype.toString = function() {\n    var indent = Array(level * 4 + 1).join(\" \");\n    var ret = \"\\n\" + indent + \"AggregateError of:\" + \"\\n\";\n    level++;\n    indent = Array(level * 4 + 1).join(\" \");\n    for (var i = 0; i < this.length; ++i) {\n        var str = this[i] === this ? \"[Circular AggregateError]\" : this[i] + \"\";\n        var lines = str.split(\"\\n\");\n        for (var j = 0; j < lines.length; ++j) {\n            lines[j] = indent + lines[j];\n        }\n        str = lines.join(\"\\n\");\n        ret += str + \"\\n\";\n    }\n    level--;\n    return ret;\n};\n\nfunction OperationalError(message) {\n    if (!(this instanceof OperationalError))\n        return new OperationalError(message);\n    notEnumerableProp(this, \"name\", \"OperationalError\");\n    notEnumerableProp(this, \"message\", message);\n    this.cause = message;\n    this[\"isOperational\"] = true;\n\n    if (message instanceof Error) {\n        notEnumerableProp(this, \"message\", message.message);\n        notEnumerableProp(this, \"stack\", message.stack);\n    } else if (Error.captureStackTrace) {\n        Error.captureStackTrace(this, this.constructor);\n    }\n\n}\ninherits(OperationalError, Error);\n\nvar errorTypes = Error[\"__BluebirdErrorTypes__\"];\nif (!errorTypes) {\n    errorTypes = Objectfreeze({\n        CancellationError: CancellationError,\n        TimeoutError: TimeoutError,\n        OperationalError: OperationalError,\n        RejectionError: OperationalError,\n        AggregateError: AggregateError\n    });\n    es5.defineProperty(Error, \"__BluebirdErrorTypes__\", {\n        value: errorTypes,\n        writable: false,\n        enumerable: false,\n        configurable: false\n    });\n}\n\nmodule.exports = {\n    Error: Error,\n    TypeError: _TypeError,\n    RangeError: _RangeError,\n    CancellationError: errorTypes.CancellationError,\n    OperationalError: errorTypes.OperationalError,\n    TimeoutError: errorTypes.TimeoutError,\n    AggregateError: errorTypes.AggregateError,\n    Warning: Warning\n};\n\n},{\"./es5\":13,\"./util\":36}],13:[function(_dereq_,module,exports){\nvar isES5 = (function(){\n    \"use strict\";\n    return this === undefined;\n})();\n\nif (isES5) {\n    module.exports = {\n        freeze: Object.freeze,\n        defineProperty: Object.defineProperty,\n        getDescriptor: Object.getOwnPropertyDescriptor,\n        keys: Object.keys,\n        names: Object.getOwnPropertyNames,\n        getPrototypeOf: Object.getPrototypeOf,\n        isArray: Array.isArray,\n        isES5: isES5,\n        propertyIsWritable: function(obj, prop) {\n            var descriptor = Object.getOwnPropertyDescriptor(obj, prop);\n            return !!(!descriptor || descriptor.writable || descriptor.set);\n        }\n    };\n} else {\n    var has = {}.hasOwnProperty;\n    var str = {}.toString;\n    var proto = {}.constructor.prototype;\n\n    var ObjectKeys = function (o) {\n        var ret = [];\n        for (var key in o) {\n            if (has.call(o, key)) {\n                ret.push(key);\n            }\n        }\n        return ret;\n    };\n\n    var ObjectGetDescriptor = function(o, key) {\n        return {value: o[key]};\n    };\n\n    var ObjectDefineProperty = function (o, key, desc) {\n        o[key] = desc.value;\n        return o;\n    };\n\n    var ObjectFreeze = function (obj) {\n        return obj;\n    };\n\n    var ObjectGetPrototypeOf = function (obj) {\n        try {\n            return Object(obj).constructor.prototype;\n        }\n        catch (e) {\n            return proto;\n        }\n    };\n\n    var ArrayIsArray = function (obj) {\n        try {\n            return str.call(obj) === \"[object Array]\";\n        }\n        catch(e) {\n            return false;\n        }\n    };\n\n    module.exports = {\n        isArray: ArrayIsArray,\n        keys: ObjectKeys,\n        names: ObjectKeys,\n        defineProperty: ObjectDefineProperty,\n        getDescriptor: ObjectGetDescriptor,\n        freeze: ObjectFreeze,\n        getPrototypeOf: ObjectGetPrototypeOf,\n        isES5: isES5,\n        propertyIsWritable: function() {\n            return true;\n        }\n    };\n}\n\n},{}],14:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, INTERNAL) {\nvar PromiseMap = Promise.map;\n\nPromise.prototype.filter = function (fn, options) {\n    return PromiseMap(this, fn, options, INTERNAL);\n};\n\nPromise.filter = function (promises, fn, options) {\n    return PromiseMap(promises, fn, options, INTERNAL);\n};\n};\n\n},{}],15:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) {\nvar util = _dereq_(\"./util\");\nvar CancellationError = Promise.CancellationError;\nvar errorObj = util.errorObj;\nvar catchFilter = _dereq_(\"./catch_filter\")(NEXT_FILTER);\n\nfunction PassThroughHandlerContext(promise, type, handler) {\n    this.promise = promise;\n    this.type = type;\n    this.handler = handler;\n    this.called = false;\n    this.cancelPromise = null;\n}\n\nPassThroughHandlerContext.prototype.isFinallyHandler = function() {\n    return this.type === 0;\n};\n\nfunction FinallyHandlerCancelReaction(finallyHandler) {\n    this.finallyHandler = finallyHandler;\n}\n\nFinallyHandlerCancelReaction.prototype._resultCancelled = function() {\n    checkCancel(this.finallyHandler);\n};\n\nfunction checkCancel(ctx, reason) {\n    if (ctx.cancelPromise != null) {\n        if (arguments.length > 1) {\n            ctx.cancelPromise._reject(reason);\n        } else {\n            ctx.cancelPromise._cancel();\n        }\n        ctx.cancelPromise = null;\n        return true;\n    }\n    return false;\n}\n\nfunction succeed() {\n    return finallyHandler.call(this, this.promise._target()._settledValue());\n}\nfunction fail(reason) {\n    if (checkCancel(this, reason)) return;\n    errorObj.e = reason;\n    return errorObj;\n}\nfunction finallyHandler(reasonOrValue) {\n    var promise = this.promise;\n    var handler = this.handler;\n\n    if (!this.called) {\n        this.called = true;\n        var ret = this.isFinallyHandler()\n            ? handler.call(promise._boundValue())\n            : handler.call(promise._boundValue(), reasonOrValue);\n        if (ret === NEXT_FILTER) {\n            return ret;\n        } else if (ret !== undefined) {\n            promise._setReturnedNonUndefined();\n            var maybePromise = tryConvertToPromise(ret, promise);\n            if (maybePromise instanceof Promise) {\n                if (this.cancelPromise != null) {\n                    if (maybePromise._isCancelled()) {\n                        var reason =\n                            new CancellationError(\"late cancellation observer\");\n                        promise._attachExtraTrace(reason);\n                        errorObj.e = reason;\n                        return errorObj;\n                    } else if (maybePromise.isPending()) {\n                        maybePromise._attachCancellationCallback(\n                            new FinallyHandlerCancelReaction(this));\n                    }\n                }\n                return maybePromise._then(\n                    succeed, fail, undefined, this, undefined);\n            }\n        }\n    }\n\n    if (promise.isRejected()) {\n        checkCancel(this);\n        errorObj.e = reasonOrValue;\n        return errorObj;\n    } else {\n        checkCancel(this);\n        return reasonOrValue;\n    }\n}\n\nPromise.prototype._passThrough = function(handler, type, success, fail) {\n    if (typeof handler !== \"function\") return this.then();\n    return this._then(success,\n                      fail,\n                      undefined,\n                      new PassThroughHandlerContext(this, type, handler),\n                      undefined);\n};\n\nPromise.prototype.lastly =\nPromise.prototype[\"finally\"] = function (handler) {\n    return this._passThrough(handler,\n                             0,\n                             finallyHandler,\n                             finallyHandler);\n};\n\n\nPromise.prototype.tap = function (handler) {\n    return this._passThrough(handler, 1, finallyHandler);\n};\n\nPromise.prototype.tapCatch = function (handlerOrPredicate) {\n    var len = arguments.length;\n    if(len === 1) {\n        return this._passThrough(handlerOrPredicate,\n                                 1,\n                                 undefined,\n                                 finallyHandler);\n    } else {\n         var catchInstances = new Array(len - 1),\n            j = 0, i;\n        for (i = 0; i < len - 1; ++i) {\n            var item = arguments[i];\n            if (util.isObject(item)) {\n                catchInstances[j++] = item;\n            } else {\n                return Promise.reject(new TypeError(\n                    \"tapCatch statement predicate: \"\n                    + \"expecting an object but got \" + util.classString(item)\n                ));\n            }\n        }\n        catchInstances.length = j;\n        var handler = arguments[i];\n        return this._passThrough(catchFilter(catchInstances, handler, this),\n                                 1,\n                                 undefined,\n                                 finallyHandler);\n    }\n\n};\n\nreturn PassThroughHandlerContext;\n};\n\n},{\"./catch_filter\":7,\"./util\":36}],16:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise,\n                          apiRejection,\n                          INTERNAL,\n                          tryConvertToPromise,\n                          Proxyable,\n                          debug) {\nvar errors = _dereq_(\"./errors\");\nvar TypeError = errors.TypeError;\nvar util = _dereq_(\"./util\");\nvar errorObj = util.errorObj;\nvar tryCatch = util.tryCatch;\nvar yieldHandlers = [];\n\nfunction promiseFromYieldHandler(value, yieldHandlers, traceParent) {\n    for (var i = 0; i < yieldHandlers.length; ++i) {\n        traceParent._pushContext();\n        var result = tryCatch(yieldHandlers[i])(value);\n        traceParent._popContext();\n        if (result === errorObj) {\n            traceParent._pushContext();\n            var ret = Promise.reject(errorObj.e);\n            traceParent._popContext();\n            return ret;\n        }\n        var maybePromise = tryConvertToPromise(result, traceParent);\n        if (maybePromise instanceof Promise) return maybePromise;\n    }\n    return null;\n}\n\nfunction PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {\n    if (debug.cancellation()) {\n        var internal = new Promise(INTERNAL);\n        var _finallyPromise = this._finallyPromise = new Promise(INTERNAL);\n        this._promise = internal.lastly(function() {\n            return _finallyPromise;\n        });\n        internal._captureStackTrace();\n        internal._setOnCancel(this);\n    } else {\n        var promise = this._promise = new Promise(INTERNAL);\n        promise._captureStackTrace();\n    }\n    this._stack = stack;\n    this._generatorFunction = generatorFunction;\n    this._receiver = receiver;\n    this._generator = undefined;\n    this._yieldHandlers = typeof yieldHandler === \"function\"\n        ? [yieldHandler].concat(yieldHandlers)\n        : yieldHandlers;\n    this._yieldedPromise = null;\n    this._cancellationPhase = false;\n}\nutil.inherits(PromiseSpawn, Proxyable);\n\nPromiseSpawn.prototype._isResolved = function() {\n    return this._promise === null;\n};\n\nPromiseSpawn.prototype._cleanup = function() {\n    this._promise = this._generator = null;\n    if (debug.cancellation() && this._finallyPromise !== null) {\n        this._finallyPromise._fulfill();\n        this._finallyPromise = null;\n    }\n};\n\nPromiseSpawn.prototype._promiseCancelled = function() {\n    if (this._isResolved()) return;\n    var implementsReturn = typeof this._generator[\"return\"] !== \"undefined\";\n\n    var result;\n    if (!implementsReturn) {\n        var reason = new Promise.CancellationError(\n            \"generator .return() sentinel\");\n        Promise.coroutine.returnSentinel = reason;\n        this._promise._attachExtraTrace(reason);\n        this._promise._pushContext();\n        result = tryCatch(this._generator[\"throw\"]).call(this._generator,\n                                                         reason);\n        this._promise._popContext();\n    } else {\n        this._promise._pushContext();\n        result = tryCatch(this._generator[\"return\"]).call(this._generator,\n                                                          undefined);\n        this._promise._popContext();\n    }\n    this._cancellationPhase = true;\n    this._yieldedPromise = null;\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._promiseFulfilled = function(value) {\n    this._yieldedPromise = null;\n    this._promise._pushContext();\n    var result = tryCatch(this._generator.next).call(this._generator, value);\n    this._promise._popContext();\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._promiseRejected = function(reason) {\n    this._yieldedPromise = null;\n    this._promise._attachExtraTrace(reason);\n    this._promise._pushContext();\n    var result = tryCatch(this._generator[\"throw\"])\n        .call(this._generator, reason);\n    this._promise._popContext();\n    this._continue(result);\n};\n\nPromiseSpawn.prototype._resultCancelled = function() {\n    if (this._yieldedPromise instanceof Promise) {\n        var promise = this._yieldedPromise;\n        this._yieldedPromise = null;\n        promise.cancel();\n    }\n};\n\nPromiseSpawn.prototype.promise = function () {\n    return this._promise;\n};\n\nPromiseSpawn.prototype._run = function () {\n    this._generator = this._generatorFunction.call(this._receiver);\n    this._receiver =\n        this._generatorFunction = undefined;\n    this._promiseFulfilled(undefined);\n};\n\nPromiseSpawn.prototype._continue = function (result) {\n    var promise = this._promise;\n    if (result === errorObj) {\n        this._cleanup();\n        if (this._cancellationPhase) {\n            return promise.cancel();\n        } else {\n            return promise._rejectCallback(result.e, false);\n        }\n    }\n\n    var value = result.value;\n    if (result.done === true) {\n        this._cleanup();\n        if (this._cancellationPhase) {\n            return promise.cancel();\n        } else {\n            return promise._resolveCallback(value);\n        }\n    } else {\n        var maybePromise = tryConvertToPromise(value, this._promise);\n        if (!(maybePromise instanceof Promise)) {\n            maybePromise =\n                promiseFromYieldHandler(maybePromise,\n                                        this._yieldHandlers,\n                                        this._promise);\n            if (maybePromise === null) {\n                this._promiseRejected(\n                    new TypeError(\n                        \"A value %s was yielded that could not be treated as a promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\\u000a\".replace(\"%s\", String(value)) +\n                        \"From coroutine:\\u000a\" +\n                        this._stack.split(\"\\n\").slice(1, -7).join(\"\\n\")\n                    )\n                );\n                return;\n            }\n        }\n        maybePromise = maybePromise._target();\n        var bitField = maybePromise._bitField;\n        ;\n        if (((bitField & 50397184) === 0)) {\n            this._yieldedPromise = maybePromise;\n            maybePromise._proxy(this, null);\n        } else if (((bitField & 33554432) !== 0)) {\n            Promise._async.invoke(\n                this._promiseFulfilled, this, maybePromise._value()\n            );\n        } else if (((bitField & 16777216) !== 0)) {\n            Promise._async.invoke(\n                this._promiseRejected, this, maybePromise._reason()\n            );\n        } else {\n            this._promiseCancelled();\n        }\n    }\n};\n\nPromise.coroutine = function (generatorFunction, options) {\n    if (typeof generatorFunction !== \"function\") {\n        throw new TypeError(\"generatorFunction must be a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var yieldHandler = Object(options).yieldHandler;\n    var PromiseSpawn$ = PromiseSpawn;\n    var stack = new Error().stack;\n    return function () {\n        var generator = generatorFunction.apply(this, arguments);\n        var spawn = new PromiseSpawn$(undefined, undefined, yieldHandler,\n                                      stack);\n        var ret = spawn.promise();\n        spawn._generator = generator;\n        spawn._promiseFulfilled(undefined);\n        return ret;\n    };\n};\n\nPromise.coroutine.addYieldHandler = function(fn) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    yieldHandlers.push(fn);\n};\n\nPromise.spawn = function (generatorFunction) {\n    debug.deprecated(\"Promise.spawn()\", \"Promise.coroutine()\");\n    if (typeof generatorFunction !== \"function\") {\n        return apiRejection(\"generatorFunction must be a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var spawn = new PromiseSpawn(generatorFunction, this);\n    var ret = spawn.promise();\n    spawn._run(Promise.spawn);\n    return ret;\n};\n};\n\n},{\"./errors\":12,\"./util\":36}],17:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports =\nfunction(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async) {\nvar util = _dereq_(\"./util\");\nvar canEvaluate = util.canEvaluate;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar reject;\n\nif (!true) {\nif (canEvaluate) {\n    var thenCallback = function(i) {\n        return new Function(\"value\", \"holder\", \"                             \\n\\\n            'use strict';                                                    \\n\\\n            holder.pIndex = value;                                           \\n\\\n            holder.checkFulfillment(this);                                   \\n\\\n            \".replace(/Index/g, i));\n    };\n\n    var promiseSetter = function(i) {\n        return new Function(\"promise\", \"holder\", \"                           \\n\\\n            'use strict';                                                    \\n\\\n            holder.pIndex = promise;                                         \\n\\\n            \".replace(/Index/g, i));\n    };\n\n    var generateHolderClass = function(total) {\n        var props = new Array(total);\n        for (var i = 0; i < props.length; ++i) {\n            props[i] = \"this.p\" + (i+1);\n        }\n        var assignment = props.join(\" = \") + \" = null;\";\n        var cancellationCode= \"var promise;\\n\" + props.map(function(prop) {\n            return \"                                                         \\n\\\n                promise = \" + prop + \";                                      \\n\\\n                if (promise instanceof Promise) {                            \\n\\\n                    promise.cancel();                                        \\n\\\n                }                                                            \\n\\\n            \";\n        }).join(\"\\n\");\n        var passedArguments = props.join(\", \");\n        var name = \"Holder$\" + total;\n\n\n        var code = \"return function(tryCatch, errorObj, Promise, async) {    \\n\\\n            'use strict';                                                    \\n\\\n            function [TheName](fn) {                                         \\n\\\n                [TheProperties]                                              \\n\\\n                this.fn = fn;                                                \\n\\\n                this.asyncNeeded = true;                                     \\n\\\n                this.now = 0;                                                \\n\\\n            }                                                                \\n\\\n                                                                             \\n\\\n            [TheName].prototype._callFunction = function(promise) {          \\n\\\n                promise._pushContext();                                      \\n\\\n                var ret = tryCatch(this.fn)([ThePassedArguments]);           \\n\\\n                promise._popContext();                                       \\n\\\n                if (ret === errorObj) {                                      \\n\\\n                    promise._rejectCallback(ret.e, false);                   \\n\\\n                } else {                                                     \\n\\\n                    promise._resolveCallback(ret);                           \\n\\\n                }                                                            \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            [TheName].prototype.checkFulfillment = function(promise) {       \\n\\\n                var now = ++this.now;                                        \\n\\\n                if (now === [TheTotal]) {                                    \\n\\\n                    if (this.asyncNeeded) {                                  \\n\\\n                        async.invoke(this._callFunction, this, promise);     \\n\\\n                    } else {                                                 \\n\\\n                        this._callFunction(promise);                         \\n\\\n                    }                                                        \\n\\\n                                                                             \\n\\\n                }                                                            \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            [TheName].prototype._resultCancelled = function() {              \\n\\\n                [CancellationCode]                                           \\n\\\n            };                                                               \\n\\\n                                                                             \\n\\\n            return [TheName];                                                \\n\\\n        }(tryCatch, errorObj, Promise, async);                               \\n\\\n        \";\n\n        code = code.replace(/\\[TheName\\]/g, name)\n            .replace(/\\[TheTotal\\]/g, total)\n            .replace(/\\[ThePassedArguments\\]/g, passedArguments)\n            .replace(/\\[TheProperties\\]/g, assignment)\n            .replace(/\\[CancellationCode\\]/g, cancellationCode);\n\n        return new Function(\"tryCatch\", \"errorObj\", \"Promise\", \"async\", code)\n                           (tryCatch, errorObj, Promise, async);\n    };\n\n    var holderClasses = [];\n    var thenCallbacks = [];\n    var promiseSetters = [];\n\n    for (var i = 0; i < 8; ++i) {\n        holderClasses.push(generateHolderClass(i + 1));\n        thenCallbacks.push(thenCallback(i + 1));\n        promiseSetters.push(promiseSetter(i + 1));\n    }\n\n    reject = function (reason) {\n        this._reject(reason);\n    };\n}}\n\nPromise.join = function () {\n    var last = arguments.length - 1;\n    var fn;\n    if (last > 0 && typeof arguments[last] === \"function\") {\n        fn = arguments[last];\n        if (!true) {\n            if (last <= 8 && canEvaluate) {\n                var ret = new Promise(INTERNAL);\n                ret._captureStackTrace();\n                var HolderClass = holderClasses[last - 1];\n                var holder = new HolderClass(fn);\n                var callbacks = thenCallbacks;\n\n                for (var i = 0; i < last; ++i) {\n                    var maybePromise = tryConvertToPromise(arguments[i], ret);\n                    if (maybePromise instanceof Promise) {\n                        maybePromise = maybePromise._target();\n                        var bitField = maybePromise._bitField;\n                        ;\n                        if (((bitField & 50397184) === 0)) {\n                            maybePromise._then(callbacks[i], reject,\n                                               undefined, ret, holder);\n                            promiseSetters[i](maybePromise, holder);\n                            holder.asyncNeeded = false;\n                        } else if (((bitField & 33554432) !== 0)) {\n                            callbacks[i].call(ret,\n                                              maybePromise._value(), holder);\n                        } else if (((bitField & 16777216) !== 0)) {\n                            ret._reject(maybePromise._reason());\n                        } else {\n                            ret._cancel();\n                        }\n                    } else {\n                        callbacks[i].call(ret, maybePromise, holder);\n                    }\n                }\n\n                if (!ret._isFateSealed()) {\n                    if (holder.asyncNeeded) {\n                        var context = Promise._getContext();\n                        holder.fn = util.contextBind(context, holder.fn);\n                    }\n                    ret._setAsyncGuaranteed();\n                    ret._setOnCancel(holder);\n                }\n                return ret;\n            }\n        }\n    }\n    var args = [].slice.call(arguments);;\n    if (fn) args.pop();\n    var ret = new PromiseArray(args).promise();\n    return fn !== undefined ? ret.spread(fn) : ret;\n};\n\n};\n\n},{\"./util\":36}],18:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise,\n                          PromiseArray,\n                          apiRejection,\n                          tryConvertToPromise,\n                          INTERNAL,\n                          debug) {\nvar util = _dereq_(\"./util\");\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\nvar async = Promise._async;\n\nfunction MappingPromiseArray(promises, fn, limit, _filter) {\n    this.constructor$(promises);\n    this._promise._captureStackTrace();\n    var context = Promise._getContext();\n    this._callback = util.contextBind(context, fn);\n    this._preservedValues = _filter === INTERNAL\n        ? new Array(this.length())\n        : null;\n    this._limit = limit;\n    this._inFlight = 0;\n    this._queue = [];\n    async.invoke(this._asyncInit, this, undefined);\n    if (util.isArray(promises)) {\n        for (var i = 0; i < promises.length; ++i) {\n            var maybePromise = promises[i];\n            if (maybePromise instanceof Promise) {\n                maybePromise.suppressUnhandledRejections();\n            }\n        }\n    }\n}\nutil.inherits(MappingPromiseArray, PromiseArray);\n\nMappingPromiseArray.prototype._asyncInit = function() {\n    this._init$(undefined, -2);\n};\n\nMappingPromiseArray.prototype._init = function () {};\n\nMappingPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    var values = this._values;\n    var length = this.length();\n    var preservedValues = this._preservedValues;\n    var limit = this._limit;\n\n    if (index < 0) {\n        index = (index * -1) - 1;\n        values[index] = value;\n        if (limit >= 1) {\n            this._inFlight--;\n            this._drainQueue();\n            if (this._isResolved()) return true;\n        }\n    } else {\n        if (limit >= 1 && this._inFlight >= limit) {\n            values[index] = value;\n            this._queue.push(index);\n            return false;\n        }\n        if (preservedValues !== null) preservedValues[index] = value;\n\n        var promise = this._promise;\n        var callback = this._callback;\n        var receiver = promise._boundValue();\n        promise._pushContext();\n        var ret = tryCatch(callback).call(receiver, value, index, length);\n        var promiseCreated = promise._popContext();\n        debug.checkForgottenReturns(\n            ret,\n            promiseCreated,\n            preservedValues !== null ? \"Promise.filter\" : \"Promise.map\",\n            promise\n        );\n        if (ret === errorObj) {\n            this._reject(ret.e);\n            return true;\n        }\n\n        var maybePromise = tryConvertToPromise(ret, this._promise);\n        if (maybePromise instanceof Promise) {\n            maybePromise = maybePromise._target();\n            var bitField = maybePromise._bitField;\n            ;\n            if (((bitField & 50397184) === 0)) {\n                if (limit >= 1) this._inFlight++;\n                values[index] = maybePromise;\n                maybePromise._proxy(this, (index + 1) * -1);\n                return false;\n            } else if (((bitField & 33554432) !== 0)) {\n                ret = maybePromise._value();\n            } else if (((bitField & 16777216) !== 0)) {\n                this._reject(maybePromise._reason());\n                return true;\n            } else {\n                this._cancel();\n                return true;\n            }\n        }\n        values[index] = ret;\n    }\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= length) {\n        if (preservedValues !== null) {\n            this._filter(values, preservedValues);\n        } else {\n            this._resolve(values);\n        }\n        return true;\n    }\n    return false;\n};\n\nMappingPromiseArray.prototype._drainQueue = function () {\n    var queue = this._queue;\n    var limit = this._limit;\n    var values = this._values;\n    while (queue.length > 0 && this._inFlight < limit) {\n        if (this._isResolved()) return;\n        var index = queue.pop();\n        this._promiseFulfilled(values[index], index);\n    }\n};\n\nMappingPromiseArray.prototype._filter = function (booleans, values) {\n    var len = values.length;\n    var ret = new Array(len);\n    var j = 0;\n    for (var i = 0; i < len; ++i) {\n        if (booleans[i]) ret[j++] = values[i];\n    }\n    ret.length = j;\n    this._resolve(ret);\n};\n\nMappingPromiseArray.prototype.preservedValues = function () {\n    return this._preservedValues;\n};\n\nfunction map(promises, fn, options, _filter) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n\n    var limit = 0;\n    if (options !== undefined) {\n        if (typeof options === \"object\" && options !== null) {\n            if (typeof options.concurrency !== \"number\") {\n                return Promise.reject(\n                    new TypeError(\"'concurrency' must be a number but it is \" +\n                                    util.classString(options.concurrency)));\n            }\n            limit = options.concurrency;\n        } else {\n            return Promise.reject(new TypeError(\n                            \"options argument must be an object but it is \" +\n                             util.classString(options)));\n        }\n    }\n    limit = typeof limit === \"number\" &&\n        isFinite(limit) && limit >= 1 ? limit : 0;\n    return new MappingPromiseArray(promises, fn, limit, _filter).promise();\n}\n\nPromise.prototype.map = function (fn, options) {\n    return map(this, fn, options, null);\n};\n\nPromise.map = function (promises, fn, options, _filter) {\n    return map(promises, fn, options, _filter);\n};\n\n\n};\n\n},{\"./util\":36}],19:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports =\nfunction(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {\nvar util = _dereq_(\"./util\");\nvar tryCatch = util.tryCatch;\n\nPromise.method = function (fn) {\n    if (typeof fn !== \"function\") {\n        throw new Promise.TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    return function () {\n        var ret = new Promise(INTERNAL);\n        ret._captureStackTrace();\n        ret._pushContext();\n        var value = tryCatch(fn).apply(this, arguments);\n        var promiseCreated = ret._popContext();\n        debug.checkForgottenReturns(\n            value, promiseCreated, \"Promise.method\", ret);\n        ret._resolveFromSyncValue(value);\n        return ret;\n    };\n};\n\nPromise.attempt = Promise[\"try\"] = function (fn) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    ret._pushContext();\n    var value;\n    if (arguments.length > 1) {\n        debug.deprecated(\"calling Promise.try with more than 1 argument\");\n        var arg = arguments[1];\n        var ctx = arguments[2];\n        value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)\n                                  : tryCatch(fn).call(ctx, arg);\n    } else {\n        value = tryCatch(fn)();\n    }\n    var promiseCreated = ret._popContext();\n    debug.checkForgottenReturns(\n        value, promiseCreated, \"Promise.try\", ret);\n    ret._resolveFromSyncValue(value);\n    return ret;\n};\n\nPromise.prototype._resolveFromSyncValue = function (value) {\n    if (value === util.errorObj) {\n        this._rejectCallback(value.e, false);\n    } else {\n        this._resolveCallback(value, true);\n    }\n};\n};\n\n},{\"./util\":36}],20:[function(_dereq_,module,exports){\n\"use strict\";\nvar util = _dereq_(\"./util\");\nvar maybeWrapAsError = util.maybeWrapAsError;\nvar errors = _dereq_(\"./errors\");\nvar OperationalError = errors.OperationalError;\nvar es5 = _dereq_(\"./es5\");\n\nfunction isUntypedError(obj) {\n    return obj instanceof Error &&\n        es5.getPrototypeOf(obj) === Error.prototype;\n}\n\nvar rErrorKey = /^(?:name|message|stack|cause)$/;\nfunction wrapAsOperationalError(obj) {\n    var ret;\n    if (isUntypedError(obj)) {\n        ret = new OperationalError(obj);\n        ret.name = obj.name;\n        ret.message = obj.message;\n        ret.stack = obj.stack;\n        var keys = es5.keys(obj);\n        for (var i = 0; i < keys.length; ++i) {\n            var key = keys[i];\n            if (!rErrorKey.test(key)) {\n                ret[key] = obj[key];\n            }\n        }\n        return ret;\n    }\n    util.markAsOriginatingFromRejection(obj);\n    return obj;\n}\n\nfunction nodebackForPromise(promise, multiArgs) {\n    return function(err, value) {\n        if (promise === null) return;\n        if (err) {\n            var wrapped = wrapAsOperationalError(maybeWrapAsError(err));\n            promise._attachExtraTrace(wrapped);\n            promise._reject(wrapped);\n        } else if (!multiArgs) {\n            promise._fulfill(value);\n        } else {\n            var args = [].slice.call(arguments, 1);;\n            promise._fulfill(args);\n        }\n        promise = null;\n    };\n}\n\nmodule.exports = nodebackForPromise;\n\n},{\"./errors\":12,\"./es5\":13,\"./util\":36}],21:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise) {\nvar util = _dereq_(\"./util\");\nvar async = Promise._async;\nvar tryCatch = util.tryCatch;\nvar errorObj = util.errorObj;\n\nfunction spreadAdapter(val, nodeback) {\n    var promise = this;\n    if (!util.isArray(val)) return successAdapter.call(promise, val, nodeback);\n    var ret =\n        tryCatch(nodeback).apply(promise._boundValue(), [null].concat(val));\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\n\nfunction successAdapter(val, nodeback) {\n    var promise = this;\n    var receiver = promise._boundValue();\n    var ret = val === undefined\n        ? tryCatch(nodeback).call(receiver, null)\n        : tryCatch(nodeback).call(receiver, null, val);\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\nfunction errorAdapter(reason, nodeback) {\n    var promise = this;\n    if (!reason) {\n        var newReason = new Error(reason + \"\");\n        newReason.cause = reason;\n        reason = newReason;\n    }\n    var ret = tryCatch(nodeback).call(promise._boundValue(), reason);\n    if (ret === errorObj) {\n        async.throwLater(ret.e);\n    }\n}\n\nPromise.prototype.asCallback = Promise.prototype.nodeify = function (nodeback,\n                                                                     options) {\n    if (typeof nodeback == \"function\") {\n        var adapter = successAdapter;\n        if (options !== undefined && Object(options).spread) {\n            adapter = spreadAdapter;\n        }\n        this._then(\n            adapter,\n            errorAdapter,\n            undefined,\n            this,\n            nodeback\n        );\n    }\n    return this;\n};\n};\n\n},{\"./util\":36}],22:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function() {\nvar makeSelfResolutionError = function () {\n    return new TypeError(\"circular promise resolution chain\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n};\nvar reflectHandler = function() {\n    return new Promise.PromiseInspection(this._target());\n};\nvar apiRejection = function(msg) {\n    return Promise.reject(new TypeError(msg));\n};\nfunction Proxyable() {}\nvar UNDEFINED_BINDING = {};\nvar util = _dereq_(\"./util\");\nutil.setReflectHandler(reflectHandler);\n\nvar getDomain = function() {\n    var domain = process.domain;\n    if (domain === undefined) {\n        return null;\n    }\n    return domain;\n};\nvar getContextDefault = function() {\n    return null;\n};\nvar getContextDomain = function() {\n    return {\n        domain: getDomain(),\n        async: null\n    };\n};\nvar AsyncResource = util.isNode && util.nodeSupportsAsyncResource ?\n    _dereq_(\"async_hooks\").AsyncResource : null;\nvar getContextAsyncHooks = function() {\n    return {\n        domain: getDomain(),\n        async: new AsyncResource(\"Bluebird::Promise\")\n    };\n};\nvar getContext = util.isNode ? getContextDomain : getContextDefault;\nutil.notEnumerableProp(Promise, \"_getContext\", getContext);\nvar enableAsyncHooks = function() {\n    getContext = getContextAsyncHooks;\n    util.notEnumerableProp(Promise, \"_getContext\", getContextAsyncHooks);\n};\nvar disableAsyncHooks = function() {\n    getContext = getContextDomain;\n    util.notEnumerableProp(Promise, \"_getContext\", getContextDomain);\n};\n\nvar es5 = _dereq_(\"./es5\");\nvar Async = _dereq_(\"./async\");\nvar async = new Async();\nes5.defineProperty(Promise, \"_async\", {value: async});\nvar errors = _dereq_(\"./errors\");\nvar TypeError = Promise.TypeError = errors.TypeError;\nPromise.RangeError = errors.RangeError;\nvar CancellationError = Promise.CancellationError = errors.CancellationError;\nPromise.TimeoutError = errors.TimeoutError;\nPromise.OperationalError = errors.OperationalError;\nPromise.RejectionError = errors.OperationalError;\nPromise.AggregateError = errors.AggregateError;\nvar INTERNAL = function(){};\nvar APPLY = {};\nvar NEXT_FILTER = {};\nvar tryConvertToPromise = _dereq_(\"./thenables\")(Promise, INTERNAL);\nvar PromiseArray =\n    _dereq_(\"./promise_array\")(Promise, INTERNAL,\n                               tryConvertToPromise, apiRejection, Proxyable);\nvar Context = _dereq_(\"./context\")(Promise);\n /*jshint unused:false*/\nvar createContext = Context.create;\n\nvar debug = _dereq_(\"./debuggability\")(Promise, Context,\n    enableAsyncHooks, disableAsyncHooks);\nvar CapturedTrace = debug.CapturedTrace;\nvar PassThroughHandlerContext =\n    _dereq_(\"./finally\")(Promise, tryConvertToPromise, NEXT_FILTER);\nvar catchFilter = _dereq_(\"./catch_filter\")(NEXT_FILTER);\nvar nodebackForPromise = _dereq_(\"./nodeback\");\nvar errorObj = util.errorObj;\nvar tryCatch = util.tryCatch;\nfunction check(self, executor) {\n    if (self == null || self.constructor !== Promise) {\n        throw new TypeError(\"the promise constructor cannot be invoked directly\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    if (typeof executor !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(executor));\n    }\n\n}\n\nfunction Promise(executor) {\n    if (executor !== INTERNAL) {\n        check(this, executor);\n    }\n    this._bitField = 0;\n    this._fulfillmentHandler0 = undefined;\n    this._rejectionHandler0 = undefined;\n    this._promise0 = undefined;\n    this._receiver0 = undefined;\n    this._resolveFromExecutor(executor);\n    this._promiseCreated();\n    this._fireEvent(\"promiseCreated\", this);\n}\n\nPromise.prototype.toString = function () {\n    return \"[object Promise]\";\n};\n\nPromise.prototype.caught = Promise.prototype[\"catch\"] = function (fn) {\n    var len = arguments.length;\n    if (len > 1) {\n        var catchInstances = new Array(len - 1),\n            j = 0, i;\n        for (i = 0; i < len - 1; ++i) {\n            var item = arguments[i];\n            if (util.isObject(item)) {\n                catchInstances[j++] = item;\n            } else {\n                return apiRejection(\"Catch statement predicate: \" +\n                    \"expecting an object but got \" + util.classString(item));\n            }\n        }\n        catchInstances.length = j;\n        fn = arguments[i];\n\n        if (typeof fn !== \"function\") {\n            throw new TypeError(\"The last argument to .catch() \" +\n                \"must be a function, got \" + util.toString(fn));\n        }\n        return this.then(undefined, catchFilter(catchInstances, fn, this));\n    }\n    return this.then(undefined, fn);\n};\n\nPromise.prototype.reflect = function () {\n    return this._then(reflectHandler,\n        reflectHandler, undefined, this, undefined);\n};\n\nPromise.prototype.then = function (didFulfill, didReject) {\n    if (debug.warnings() && arguments.length > 0 &&\n        typeof didFulfill !== \"function\" &&\n        typeof didReject !== \"function\") {\n        var msg = \".then() only accepts functions but was passed: \" +\n                util.classString(didFulfill);\n        if (arguments.length > 1) {\n            msg += \", \" + util.classString(didReject);\n        }\n        this._warn(msg);\n    }\n    return this._then(didFulfill, didReject, undefined, undefined, undefined);\n};\n\nPromise.prototype.done = function (didFulfill, didReject) {\n    var promise =\n        this._then(didFulfill, didReject, undefined, undefined, undefined);\n    promise._setIsFinal();\n};\n\nPromise.prototype.spread = function (fn) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    return this.all()._then(fn, undefined, undefined, APPLY, undefined);\n};\n\nPromise.prototype.toJSON = function () {\n    var ret = {\n        isFulfilled: false,\n        isRejected: false,\n        fulfillmentValue: undefined,\n        rejectionReason: undefined\n    };\n    if (this.isFulfilled()) {\n        ret.fulfillmentValue = this.value();\n        ret.isFulfilled = true;\n    } else if (this.isRejected()) {\n        ret.rejectionReason = this.reason();\n        ret.isRejected = true;\n    }\n    return ret;\n};\n\nPromise.prototype.all = function () {\n    if (arguments.length > 0) {\n        this._warn(\".all() was passed arguments but it does not take any\");\n    }\n    return new PromiseArray(this).promise();\n};\n\nPromise.prototype.error = function (fn) {\n    return this.caught(util.originatesFromRejection, fn);\n};\n\nPromise.getNewLibraryCopy = module.exports;\n\nPromise.is = function (val) {\n    return val instanceof Promise;\n};\n\nPromise.fromNode = Promise.fromCallback = function(fn) {\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs\n                                         : false;\n    var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));\n    if (result === errorObj) {\n        ret._rejectCallback(result.e, true);\n    }\n    if (!ret._isFateSealed()) ret._setAsyncGuaranteed();\n    return ret;\n};\n\nPromise.all = function (promises) {\n    return new PromiseArray(promises).promise();\n};\n\nPromise.cast = function (obj) {\n    var ret = tryConvertToPromise(obj);\n    if (!(ret instanceof Promise)) {\n        ret = new Promise(INTERNAL);\n        ret._captureStackTrace();\n        ret._setFulfilled();\n        ret._rejectionHandler0 = obj;\n    }\n    return ret;\n};\n\nPromise.resolve = Promise.fulfilled = Promise.cast;\n\nPromise.reject = Promise.rejected = function (reason) {\n    var ret = new Promise(INTERNAL);\n    ret._captureStackTrace();\n    ret._rejectCallback(reason, true);\n    return ret;\n};\n\nPromise.setScheduler = function(fn) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    return async.setScheduler(fn);\n};\n\nPromise.prototype._then = function (\n    didFulfill,\n    didReject,\n    _,    receiver,\n    internalData\n) {\n    var haveInternalData = internalData !== undefined;\n    var promise = haveInternalData ? internalData : new Promise(INTERNAL);\n    var target = this._target();\n    var bitField = target._bitField;\n\n    if (!haveInternalData) {\n        promise._propagateFrom(this, 3);\n        promise._captureStackTrace();\n        if (receiver === undefined &&\n            ((this._bitField & 2097152) !== 0)) {\n            if (!((bitField & 50397184) === 0)) {\n                receiver = this._boundValue();\n            } else {\n                receiver = target === this ? undefined : this._boundTo;\n            }\n        }\n        this._fireEvent(\"promiseChained\", this, promise);\n    }\n\n    var context = getContext();\n    if (!((bitField & 50397184) === 0)) {\n        var handler, value, settler = target._settlePromiseCtx;\n        if (((bitField & 33554432) !== 0)) {\n            value = target._rejectionHandler0;\n            handler = didFulfill;\n        } else if (((bitField & 16777216) !== 0)) {\n            value = target._fulfillmentHandler0;\n            handler = didReject;\n            target._unsetRejectionIsUnhandled();\n        } else {\n            settler = target._settlePromiseLateCancellationObserver;\n            value = new CancellationError(\"late cancellation observer\");\n            target._attachExtraTrace(value);\n            handler = didReject;\n        }\n\n        async.invoke(settler, target, {\n            handler: util.contextBind(context, handler),\n            promise: promise,\n            receiver: receiver,\n            value: value\n        });\n    } else {\n        target._addCallbacks(didFulfill, didReject, promise,\n                receiver, context);\n    }\n\n    return promise;\n};\n\nPromise.prototype._length = function () {\n    return this._bitField & 65535;\n};\n\nPromise.prototype._isFateSealed = function () {\n    return (this._bitField & 117506048) !== 0;\n};\n\nPromise.prototype._isFollowing = function () {\n    return (this._bitField & 67108864) === 67108864;\n};\n\nPromise.prototype._setLength = function (len) {\n    this._bitField = (this._bitField & -65536) |\n        (len & 65535);\n};\n\nPromise.prototype._setFulfilled = function () {\n    this._bitField = this._bitField | 33554432;\n    this._fireEvent(\"promiseFulfilled\", this);\n};\n\nPromise.prototype._setRejected = function () {\n    this._bitField = this._bitField | 16777216;\n    this._fireEvent(\"promiseRejected\", this);\n};\n\nPromise.prototype._setFollowing = function () {\n    this._bitField = this._bitField | 67108864;\n    this._fireEvent(\"promiseResolved\", this);\n};\n\nPromise.prototype._setIsFinal = function () {\n    this._bitField = this._bitField | 4194304;\n};\n\nPromise.prototype._isFinal = function () {\n    return (this._bitField & 4194304) > 0;\n};\n\nPromise.prototype._unsetCancelled = function() {\n    this._bitField = this._bitField & (~65536);\n};\n\nPromise.prototype._setCancelled = function() {\n    this._bitField = this._bitField | 65536;\n    this._fireEvent(\"promiseCancelled\", this);\n};\n\nPromise.prototype._setWillBeCancelled = function() {\n    this._bitField = this._bitField | 8388608;\n};\n\nPromise.prototype._setAsyncGuaranteed = function() {\n    if (async.hasCustomScheduler()) return;\n    var bitField = this._bitField;\n    this._bitField = bitField |\n        (((bitField & 536870912) >> 2) ^\n        134217728);\n};\n\nPromise.prototype._setNoAsyncGuarantee = function() {\n    this._bitField = (this._bitField | 536870912) &\n        (~134217728);\n};\n\nPromise.prototype._receiverAt = function (index) {\n    var ret = index === 0 ? this._receiver0 : this[\n            index * 4 - 4 + 3];\n    if (ret === UNDEFINED_BINDING) {\n        return undefined;\n    } else if (ret === undefined && this._isBound()) {\n        return this._boundValue();\n    }\n    return ret;\n};\n\nPromise.prototype._promiseAt = function (index) {\n    return this[\n            index * 4 - 4 + 2];\n};\n\nPromise.prototype._fulfillmentHandlerAt = function (index) {\n    return this[\n            index * 4 - 4 + 0];\n};\n\nPromise.prototype._rejectionHandlerAt = function (index) {\n    return this[\n            index * 4 - 4 + 1];\n};\n\nPromise.prototype._boundValue = function() {};\n\nPromise.prototype._migrateCallback0 = function (follower) {\n    var bitField = follower._bitField;\n    var fulfill = follower._fulfillmentHandler0;\n    var reject = follower._rejectionHandler0;\n    var promise = follower._promise0;\n    var receiver = follower._receiverAt(0);\n    if (receiver === undefined) receiver = UNDEFINED_BINDING;\n    this._addCallbacks(fulfill, reject, promise, receiver, null);\n};\n\nPromise.prototype._migrateCallbackAt = function (follower, index) {\n    var fulfill = follower._fulfillmentHandlerAt(index);\n    var reject = follower._rejectionHandlerAt(index);\n    var promise = follower._promiseAt(index);\n    var receiver = follower._receiverAt(index);\n    if (receiver === undefined) receiver = UNDEFINED_BINDING;\n    this._addCallbacks(fulfill, reject, promise, receiver, null);\n};\n\nPromise.prototype._addCallbacks = function (\n    fulfill,\n    reject,\n    promise,\n    receiver,\n    context\n) {\n    var index = this._length();\n\n    if (index >= 65535 - 4) {\n        index = 0;\n        this._setLength(0);\n    }\n\n    if (index === 0) {\n        this._promise0 = promise;\n        this._receiver0 = receiver;\n        if (typeof fulfill === \"function\") {\n            this._fulfillmentHandler0 = util.contextBind(context, fulfill);\n        }\n        if (typeof reject === \"function\") {\n            this._rejectionHandler0 = util.contextBind(context, reject);\n        }\n    } else {\n        var base = index * 4 - 4;\n        this[base + 2] = promise;\n        this[base + 3] = receiver;\n        if (typeof fulfill === \"function\") {\n            this[base + 0] =\n                util.contextBind(context, fulfill);\n        }\n        if (typeof reject === \"function\") {\n            this[base + 1] =\n                util.contextBind(context, reject);\n        }\n    }\n    this._setLength(index + 1);\n    return index;\n};\n\nPromise.prototype._proxy = function (proxyable, arg) {\n    this._addCallbacks(undefined, undefined, arg, proxyable, null);\n};\n\nPromise.prototype._resolveCallback = function(value, shouldBind) {\n    if (((this._bitField & 117506048) !== 0)) return;\n    if (value === this)\n        return this._rejectCallback(makeSelfResolutionError(), false);\n    var maybePromise = tryConvertToPromise(value, this);\n    if (!(maybePromise instanceof Promise)) return this._fulfill(value);\n\n    if (shouldBind) this._propagateFrom(maybePromise, 2);\n\n\n    var promise = maybePromise._target();\n\n    if (promise === this) {\n        this._reject(makeSelfResolutionError());\n        return;\n    }\n\n    var bitField = promise._bitField;\n    if (((bitField & 50397184) === 0)) {\n        var len = this._length();\n        if (len > 0) promise._migrateCallback0(this);\n        for (var i = 1; i < len; ++i) {\n            promise._migrateCallbackAt(this, i);\n        }\n        this._setFollowing();\n        this._setLength(0);\n        this._setFollowee(maybePromise);\n    } else if (((bitField & 33554432) !== 0)) {\n        this._fulfill(promise._value());\n    } else if (((bitField & 16777216) !== 0)) {\n        this._reject(promise._reason());\n    } else {\n        var reason = new CancellationError(\"late cancellation observer\");\n        promise._attachExtraTrace(reason);\n        this._reject(reason);\n    }\n};\n\nPromise.prototype._rejectCallback =\nfunction(reason, synchronous, ignoreNonErrorWarnings) {\n    var trace = util.ensureErrorObject(reason);\n    var hasStack = trace === reason;\n    if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {\n        var message = \"a promise was rejected with a non-error: \" +\n            util.classString(reason);\n        this._warn(message, true);\n    }\n    this._attachExtraTrace(trace, synchronous ? hasStack : false);\n    this._reject(reason);\n};\n\nPromise.prototype._resolveFromExecutor = function (executor) {\n    if (executor === INTERNAL) return;\n    var promise = this;\n    this._captureStackTrace();\n    this._pushContext();\n    var synchronous = true;\n    var r = this._execute(executor, function(value) {\n        promise._resolveCallback(value);\n    }, function (reason) {\n        promise._rejectCallback(reason, synchronous);\n    });\n    synchronous = false;\n    this._popContext();\n\n    if (r !== undefined) {\n        promise._rejectCallback(r, true);\n    }\n};\n\nPromise.prototype._settlePromiseFromHandler = function (\n    handler, receiver, value, promise\n) {\n    var bitField = promise._bitField;\n    if (((bitField & 65536) !== 0)) return;\n    promise._pushContext();\n    var x;\n    if (receiver === APPLY) {\n        if (!value || typeof value.length !== \"number\") {\n            x = errorObj;\n            x.e = new TypeError(\"cannot .spread() a non-array: \" +\n                                    util.classString(value));\n        } else {\n            x = tryCatch(handler).apply(this._boundValue(), value);\n        }\n    } else {\n        x = tryCatch(handler).call(receiver, value);\n    }\n    var promiseCreated = promise._popContext();\n    bitField = promise._bitField;\n    if (((bitField & 65536) !== 0)) return;\n\n    if (x === NEXT_FILTER) {\n        promise._reject(value);\n    } else if (x === errorObj) {\n        promise._rejectCallback(x.e, false);\n    } else {\n        debug.checkForgottenReturns(x, promiseCreated, \"\",  promise, this);\n        promise._resolveCallback(x);\n    }\n};\n\nPromise.prototype._target = function() {\n    var ret = this;\n    while (ret._isFollowing()) ret = ret._followee();\n    return ret;\n};\n\nPromise.prototype._followee = function() {\n    return this._rejectionHandler0;\n};\n\nPromise.prototype._setFollowee = function(promise) {\n    this._rejectionHandler0 = promise;\n};\n\nPromise.prototype._settlePromise = function(promise, handler, receiver, value) {\n    var isPromise = promise instanceof Promise;\n    var bitField = this._bitField;\n    var asyncGuaranteed = ((bitField & 134217728) !== 0);\n    if (((bitField & 65536) !== 0)) {\n        if (isPromise) promise._invokeInternalOnCancel();\n\n        if (receiver instanceof PassThroughHandlerContext &&\n            receiver.isFinallyHandler()) {\n            receiver.cancelPromise = promise;\n            if (tryCatch(handler).call(receiver, value) === errorObj) {\n                promise._reject(errorObj.e);\n            }\n        } else if (handler === reflectHandler) {\n            promise._fulfill(reflectHandler.call(receiver));\n        } else if (receiver instanceof Proxyable) {\n            receiver._promiseCancelled(promise);\n        } else if (isPromise || promise instanceof PromiseArray) {\n            promise._cancel();\n        } else {\n            receiver.cancel();\n        }\n    } else if (typeof handler === \"function\") {\n        if (!isPromise) {\n            handler.call(receiver, value, promise);\n        } else {\n            if (asyncGuaranteed) promise._setAsyncGuaranteed();\n            this._settlePromiseFromHandler(handler, receiver, value, promise);\n        }\n    } else if (receiver instanceof Proxyable) {\n        if (!receiver._isResolved()) {\n            if (((bitField & 33554432) !== 0)) {\n                receiver._promiseFulfilled(value, promise);\n            } else {\n                receiver._promiseRejected(value, promise);\n            }\n        }\n    } else if (isPromise) {\n        if (asyncGuaranteed) promise._setAsyncGuaranteed();\n        if (((bitField & 33554432) !== 0)) {\n            promise._fulfill(value);\n        } else {\n            promise._reject(value);\n        }\n    }\n};\n\nPromise.prototype._settlePromiseLateCancellationObserver = function(ctx) {\n    var handler = ctx.handler;\n    var promise = ctx.promise;\n    var receiver = ctx.receiver;\n    var value = ctx.value;\n    if (typeof handler === \"function\") {\n        if (!(promise instanceof Promise)) {\n            handler.call(receiver, value, promise);\n        } else {\n            this._settlePromiseFromHandler(handler, receiver, value, promise);\n        }\n    } else if (promise instanceof Promise) {\n        promise._reject(value);\n    }\n};\n\nPromise.prototype._settlePromiseCtx = function(ctx) {\n    this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);\n};\n\nPromise.prototype._settlePromise0 = function(handler, value, bitField) {\n    var promise = this._promise0;\n    var receiver = this._receiverAt(0);\n    this._promise0 = undefined;\n    this._receiver0 = undefined;\n    this._settlePromise(promise, handler, receiver, value);\n};\n\nPromise.prototype._clearCallbackDataAtIndex = function(index) {\n    var base = index * 4 - 4;\n    this[base + 2] =\n    this[base + 3] =\n    this[base + 0] =\n    this[base + 1] = undefined;\n};\n\nPromise.prototype._fulfill = function (value) {\n    var bitField = this._bitField;\n    if (((bitField & 117506048) >>> 16)) return;\n    if (value === this) {\n        var err = makeSelfResolutionError();\n        this._attachExtraTrace(err);\n        return this._reject(err);\n    }\n    this._setFulfilled();\n    this._rejectionHandler0 = value;\n\n    if ((bitField & 65535) > 0) {\n        if (((bitField & 134217728) !== 0)) {\n            this._settlePromises();\n        } else {\n            async.settlePromises(this);\n        }\n        this._dereferenceTrace();\n    }\n};\n\nPromise.prototype._reject = function (reason) {\n    var bitField = this._bitField;\n    if (((bitField & 117506048) >>> 16)) return;\n    this._setRejected();\n    this._fulfillmentHandler0 = reason;\n\n    if (this._isFinal()) {\n        return async.fatalError(reason, util.isNode);\n    }\n\n    if ((bitField & 65535) > 0) {\n        async.settlePromises(this);\n    } else {\n        this._ensurePossibleRejectionHandled();\n    }\n};\n\nPromise.prototype._fulfillPromises = function (len, value) {\n    for (var i = 1; i < len; i++) {\n        var handler = this._fulfillmentHandlerAt(i);\n        var promise = this._promiseAt(i);\n        var receiver = this._receiverAt(i);\n        this._clearCallbackDataAtIndex(i);\n        this._settlePromise(promise, handler, receiver, value);\n    }\n};\n\nPromise.prototype._rejectPromises = function (len, reason) {\n    for (var i = 1; i < len; i++) {\n        var handler = this._rejectionHandlerAt(i);\n        var promise = this._promiseAt(i);\n        var receiver = this._receiverAt(i);\n        this._clearCallbackDataAtIndex(i);\n        this._settlePromise(promise, handler, receiver, reason);\n    }\n};\n\nPromise.prototype._settlePromises = function () {\n    var bitField = this._bitField;\n    var len = (bitField & 65535);\n\n    if (len > 0) {\n        if (((bitField & 16842752) !== 0)) {\n            var reason = this._fulfillmentHandler0;\n            this._settlePromise0(this._rejectionHandler0, reason, bitField);\n            this._rejectPromises(len, reason);\n        } else {\n            var value = this._rejectionHandler0;\n            this._settlePromise0(this._fulfillmentHandler0, value, bitField);\n            this._fulfillPromises(len, value);\n        }\n        this._setLength(0);\n    }\n    this._clearCancellationData();\n};\n\nPromise.prototype._settledValue = function() {\n    var bitField = this._bitField;\n    if (((bitField & 33554432) !== 0)) {\n        return this._rejectionHandler0;\n    } else if (((bitField & 16777216) !== 0)) {\n        return this._fulfillmentHandler0;\n    }\n};\n\nif (typeof Symbol !== \"undefined\" && Symbol.toStringTag) {\n    es5.defineProperty(Promise.prototype, Symbol.toStringTag, {\n        get: function () {\n            return \"Object\";\n        }\n    });\n}\n\nfunction deferResolve(v) {this.promise._resolveCallback(v);}\nfunction deferReject(v) {this.promise._rejectCallback(v, false);}\n\nPromise.defer = Promise.pending = function() {\n    debug.deprecated(\"Promise.defer\", \"new Promise\");\n    var promise = new Promise(INTERNAL);\n    return {\n        promise: promise,\n        resolve: deferResolve,\n        reject: deferReject\n    };\n};\n\nutil.notEnumerableProp(Promise,\n                       \"_makeSelfResolutionError\",\n                       makeSelfResolutionError);\n\n_dereq_(\"./method\")(Promise, INTERNAL, tryConvertToPromise, apiRejection,\n    debug);\n_dereq_(\"./bind\")(Promise, INTERNAL, tryConvertToPromise, debug);\n_dereq_(\"./cancel\")(Promise, PromiseArray, apiRejection, debug);\n_dereq_(\"./direct_resolve\")(Promise);\n_dereq_(\"./synchronous_inspection\")(Promise);\n_dereq_(\"./join\")(\n    Promise, PromiseArray, tryConvertToPromise, INTERNAL, async);\nPromise.Promise = Promise;\nPromise.version = \"3.7.2\";\n_dereq_('./call_get.js')(Promise);\n_dereq_('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug);\n_dereq_('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);\n_dereq_('./nodeify.js')(Promise);\n_dereq_('./promisify.js')(Promise, INTERNAL);\n_dereq_('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection);\n_dereq_('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection);\n_dereq_('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug);\n_dereq_('./settle.js')(Promise, PromiseArray, debug);\n_dereq_('./some.js')(Promise, PromiseArray, apiRejection);\n_dereq_('./timers.js')(Promise, INTERNAL, debug);\n_dereq_('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug);\n_dereq_('./any.js')(Promise);\n_dereq_('./each.js')(Promise, INTERNAL);\n_dereq_('./filter.js')(Promise, INTERNAL);\n                                                         \n    util.toFastProperties(Promise);                                          \n    util.toFastProperties(Promise.prototype);                                \n    function fillTypes(value) {                                              \n        var p = new Promise(INTERNAL);                                       \n        p._fulfillmentHandler0 = value;                                      \n        p._rejectionHandler0 = value;                                        \n        p._promise0 = value;                                                 \n        p._receiver0 = value;                                                \n    }                                                                        \n    // Complete slack tracking, opt out of field-type tracking and           \n    // stabilize map                                                         \n    fillTypes({a: 1});                                                       \n    fillTypes({b: 2});                                                       \n    fillTypes({c: 3});                                                       \n    fillTypes(1);                                                            \n    fillTypes(function(){});                                                 \n    fillTypes(undefined);                                                    \n    fillTypes(false);                                                        \n    fillTypes(new Promise(INTERNAL));                                        \n    debug.setBounds(Async.firstLineError, util.lastLineError);               \n    return Promise;                                                          \n\n};\n\n},{\"./any.js\":1,\"./async\":2,\"./bind\":3,\"./call_get.js\":5,\"./cancel\":6,\"./catch_filter\":7,\"./context\":8,\"./debuggability\":9,\"./direct_resolve\":10,\"./each.js\":11,\"./errors\":12,\"./es5\":13,\"./filter.js\":14,\"./finally\":15,\"./generators.js\":16,\"./join\":17,\"./map.js\":18,\"./method\":19,\"./nodeback\":20,\"./nodeify.js\":21,\"./promise_array\":23,\"./promisify.js\":24,\"./props.js\":25,\"./race.js\":27,\"./reduce.js\":28,\"./settle.js\":30,\"./some.js\":31,\"./synchronous_inspection\":32,\"./thenables\":33,\"./timers.js\":34,\"./using.js\":35,\"./util\":36,\"async_hooks\":undefined}],23:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, INTERNAL, tryConvertToPromise,\n    apiRejection, Proxyable) {\nvar util = _dereq_(\"./util\");\nvar isArray = util.isArray;\n\nfunction toResolutionValue(val) {\n    switch(val) {\n    case -2: return [];\n    case -3: return {};\n    case -6: return new Map();\n    }\n}\n\nfunction PromiseArray(values) {\n    var promise = this._promise = new Promise(INTERNAL);\n    if (values instanceof Promise) {\n        promise._propagateFrom(values, 3);\n        values.suppressUnhandledRejections();\n    }\n    promise._setOnCancel(this);\n    this._values = values;\n    this._length = 0;\n    this._totalResolved = 0;\n    this._init(undefined, -2);\n}\nutil.inherits(PromiseArray, Proxyable);\n\nPromiseArray.prototype.length = function () {\n    return this._length;\n};\n\nPromiseArray.prototype.promise = function () {\n    return this._promise;\n};\n\nPromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {\n    var values = tryConvertToPromise(this._values, this._promise);\n    if (values instanceof Promise) {\n        values = values._target();\n        var bitField = values._bitField;\n        ;\n        this._values = values;\n\n        if (((bitField & 50397184) === 0)) {\n            this._promise._setAsyncGuaranteed();\n            return values._then(\n                init,\n                this._reject,\n                undefined,\n                this,\n                resolveValueIfEmpty\n           );\n        } else if (((bitField & 33554432) !== 0)) {\n            values = values._value();\n        } else if (((bitField & 16777216) !== 0)) {\n            return this._reject(values._reason());\n        } else {\n            return this._cancel();\n        }\n    }\n    values = util.asArray(values);\n    if (values === null) {\n        var err = apiRejection(\n            \"expecting an array or an iterable object but got \" + util.classString(values)).reason();\n        this._promise._rejectCallback(err, false);\n        return;\n    }\n\n    if (values.length === 0) {\n        if (resolveValueIfEmpty === -5) {\n            this._resolveEmptyArray();\n        }\n        else {\n            this._resolve(toResolutionValue(resolveValueIfEmpty));\n        }\n        return;\n    }\n    this._iterate(values);\n};\n\nPromiseArray.prototype._iterate = function(values) {\n    var len = this.getActualLength(values.length);\n    this._length = len;\n    this._values = this.shouldCopyValues() ? new Array(len) : this._values;\n    var result = this._promise;\n    var isResolved = false;\n    var bitField = null;\n    for (var i = 0; i < len; ++i) {\n        var maybePromise = tryConvertToPromise(values[i], result);\n\n        if (maybePromise instanceof Promise) {\n            maybePromise = maybePromise._target();\n            bitField = maybePromise._bitField;\n        } else {\n            bitField = null;\n        }\n\n        if (isResolved) {\n            if (bitField !== null) {\n                maybePromise.suppressUnhandledRejections();\n            }\n        } else if (bitField !== null) {\n            if (((bitField & 50397184) === 0)) {\n                maybePromise._proxy(this, i);\n                this._values[i] = maybePromise;\n            } else if (((bitField & 33554432) !== 0)) {\n                isResolved = this._promiseFulfilled(maybePromise._value(), i);\n            } else if (((bitField & 16777216) !== 0)) {\n                isResolved = this._promiseRejected(maybePromise._reason(), i);\n            } else {\n                isResolved = this._promiseCancelled(i);\n            }\n        } else {\n            isResolved = this._promiseFulfilled(maybePromise, i);\n        }\n    }\n    if (!isResolved) result._setAsyncGuaranteed();\n};\n\nPromiseArray.prototype._isResolved = function () {\n    return this._values === null;\n};\n\nPromiseArray.prototype._resolve = function (value) {\n    this._values = null;\n    this._promise._fulfill(value);\n};\n\nPromiseArray.prototype._cancel = function() {\n    if (this._isResolved() || !this._promise._isCancellable()) return;\n    this._values = null;\n    this._promise._cancel();\n};\n\nPromiseArray.prototype._reject = function (reason) {\n    this._values = null;\n    this._promise._rejectCallback(reason, false);\n};\n\nPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    this._values[index] = value;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        this._resolve(this._values);\n        return true;\n    }\n    return false;\n};\n\nPromiseArray.prototype._promiseCancelled = function() {\n    this._cancel();\n    return true;\n};\n\nPromiseArray.prototype._promiseRejected = function (reason) {\n    this._totalResolved++;\n    this._reject(reason);\n    return true;\n};\n\nPromiseArray.prototype._resultCancelled = function() {\n    if (this._isResolved()) return;\n    var values = this._values;\n    this._cancel();\n    if (values instanceof Promise) {\n        values.cancel();\n    } else {\n        for (var i = 0; i < values.length; ++i) {\n            if (values[i] instanceof Promise) {\n                values[i].cancel();\n            }\n        }\n    }\n};\n\nPromiseArray.prototype.shouldCopyValues = function () {\n    return true;\n};\n\nPromiseArray.prototype.getActualLength = function (len) {\n    return len;\n};\n\nreturn PromiseArray;\n};\n\n},{\"./util\":36}],24:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, INTERNAL) {\nvar THIS = {};\nvar util = _dereq_(\"./util\");\nvar nodebackForPromise = _dereq_(\"./nodeback\");\nvar withAppended = util.withAppended;\nvar maybeWrapAsError = util.maybeWrapAsError;\nvar canEvaluate = util.canEvaluate;\nvar TypeError = _dereq_(\"./errors\").TypeError;\nvar defaultSuffix = \"Async\";\nvar defaultPromisified = {__isPromisified__: true};\nvar noCopyProps = [\n    \"arity\",    \"length\",\n    \"name\",\n    \"arguments\",\n    \"caller\",\n    \"callee\",\n    \"prototype\",\n    \"__isPromisified__\"\n];\nvar noCopyPropsPattern = new RegExp(\"^(?:\" + noCopyProps.join(\"|\") + \")$\");\n\nvar defaultFilter = function(name) {\n    return util.isIdentifier(name) &&\n        name.charAt(0) !== \"_\" &&\n        name !== \"constructor\";\n};\n\nfunction propsFilter(key) {\n    return !noCopyPropsPattern.test(key);\n}\n\nfunction isPromisified(fn) {\n    try {\n        return fn.__isPromisified__ === true;\n    }\n    catch (e) {\n        return false;\n    }\n}\n\nfunction hasPromisified(obj, key, suffix) {\n    var val = util.getDataPropertyOrDefault(obj, key + suffix,\n                                            defaultPromisified);\n    return val ? isPromisified(val) : false;\n}\nfunction checkValid(ret, suffix, suffixRegexp) {\n    for (var i = 0; i < ret.length; i += 2) {\n        var key = ret[i];\n        if (suffixRegexp.test(key)) {\n            var keyWithoutAsyncSuffix = key.replace(suffixRegexp, \"\");\n            for (var j = 0; j < ret.length; j += 2) {\n                if (ret[j] === keyWithoutAsyncSuffix) {\n                    throw new TypeError(\"Cannot promisify an API that has normal methods with '%s'-suffix\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\"\n                        .replace(\"%s\", suffix));\n                }\n            }\n        }\n    }\n}\n\nfunction promisifiableMethods(obj, suffix, suffixRegexp, filter) {\n    var keys = util.inheritedDataKeys(obj);\n    var ret = [];\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        var value = obj[key];\n        var passesDefaultFilter = filter === defaultFilter\n            ? true : defaultFilter(key, value, obj);\n        if (typeof value === \"function\" &&\n            !isPromisified(value) &&\n            !hasPromisified(obj, key, suffix) &&\n            filter(key, value, obj, passesDefaultFilter)) {\n            ret.push(key, value);\n        }\n    }\n    checkValid(ret, suffix, suffixRegexp);\n    return ret;\n}\n\nvar escapeIdentRegex = function(str) {\n    return str.replace(/([$])/, \"\\\\$\");\n};\n\nvar makeNodePromisifiedEval;\nif (!true) {\nvar switchCaseArgumentOrder = function(likelyArgumentCount) {\n    var ret = [likelyArgumentCount];\n    var min = Math.max(0, likelyArgumentCount - 1 - 3);\n    for(var i = likelyArgumentCount - 1; i >= min; --i) {\n        ret.push(i);\n    }\n    for(var i = likelyArgumentCount + 1; i <= 3; ++i) {\n        ret.push(i);\n    }\n    return ret;\n};\n\nvar argumentSequence = function(argumentCount) {\n    return util.filledRange(argumentCount, \"_arg\", \"\");\n};\n\nvar parameterDeclaration = function(parameterCount) {\n    return util.filledRange(\n        Math.max(parameterCount, 3), \"_arg\", \"\");\n};\n\nvar parameterCount = function(fn) {\n    if (typeof fn.length === \"number\") {\n        return Math.max(Math.min(fn.length, 1023 + 1), 0);\n    }\n    return 0;\n};\n\nmakeNodePromisifiedEval =\nfunction(callback, receiver, originalName, fn, _, multiArgs) {\n    var newParameterCount = Math.max(0, parameterCount(fn) - 1);\n    var argumentOrder = switchCaseArgumentOrder(newParameterCount);\n    var shouldProxyThis = typeof callback === \"string\" || receiver === THIS;\n\n    function generateCallForArgumentCount(count) {\n        var args = argumentSequence(count).join(\", \");\n        var comma = count > 0 ? \", \" : \"\";\n        var ret;\n        if (shouldProxyThis) {\n            ret = \"ret = callback.call(this, {{args}}, nodeback); break;\\n\";\n        } else {\n            ret = receiver === undefined\n                ? \"ret = callback({{args}}, nodeback); break;\\n\"\n                : \"ret = callback.call(receiver, {{args}}, nodeback); break;\\n\";\n        }\n        return ret.replace(\"{{args}}\", args).replace(\", \", comma);\n    }\n\n    function generateArgumentSwitchCase() {\n        var ret = \"\";\n        for (var i = 0; i < argumentOrder.length; ++i) {\n            ret += \"case \" + argumentOrder[i] +\":\" +\n                generateCallForArgumentCount(argumentOrder[i]);\n        }\n\n        ret += \"                                                             \\n\\\n        default:                                                             \\n\\\n            var args = new Array(len + 1);                                   \\n\\\n            var i = 0;                                                       \\n\\\n            for (var i = 0; i < len; ++i) {                                  \\n\\\n               args[i] = arguments[i];                                       \\n\\\n            }                                                                \\n\\\n            args[i] = nodeback;                                              \\n\\\n            [CodeForCall]                                                    \\n\\\n            break;                                                           \\n\\\n        \".replace(\"[CodeForCall]\", (shouldProxyThis\n                                ? \"ret = callback.apply(this, args);\\n\"\n                                : \"ret = callback.apply(receiver, args);\\n\"));\n        return ret;\n    }\n\n    var getFunctionCode = typeof callback === \"string\"\n                                ? (\"this != null ? this['\"+callback+\"'] : fn\")\n                                : \"fn\";\n    var body = \"'use strict';                                                \\n\\\n        var ret = function (Parameters) {                                    \\n\\\n            'use strict';                                                    \\n\\\n            var len = arguments.length;                                      \\n\\\n            var promise = new Promise(INTERNAL);                             \\n\\\n            promise._captureStackTrace();                                    \\n\\\n            var nodeback = nodebackForPromise(promise, \" + multiArgs + \");   \\n\\\n            var ret;                                                         \\n\\\n            var callback = tryCatch([GetFunctionCode]);                      \\n\\\n            switch(len) {                                                    \\n\\\n                [CodeForSwitchCase]                                          \\n\\\n            }                                                                \\n\\\n            if (ret === errorObj) {                                          \\n\\\n                promise._rejectCallback(maybeWrapAsError(ret.e), true, true);\\n\\\n            }                                                                \\n\\\n            if (!promise._isFateSealed()) promise._setAsyncGuaranteed();     \\n\\\n            return promise;                                                  \\n\\\n        };                                                                   \\n\\\n        notEnumerableProp(ret, '__isPromisified__', true);                   \\n\\\n        return ret;                                                          \\n\\\n    \".replace(\"[CodeForSwitchCase]\", generateArgumentSwitchCase())\n        .replace(\"[GetFunctionCode]\", getFunctionCode);\n    body = body.replace(\"Parameters\", parameterDeclaration(newParameterCount));\n    return new Function(\"Promise\",\n                        \"fn\",\n                        \"receiver\",\n                        \"withAppended\",\n                        \"maybeWrapAsError\",\n                        \"nodebackForPromise\",\n                        \"tryCatch\",\n                        \"errorObj\",\n                        \"notEnumerableProp\",\n                        \"INTERNAL\",\n                        body)(\n                    Promise,\n                    fn,\n                    receiver,\n                    withAppended,\n                    maybeWrapAsError,\n                    nodebackForPromise,\n                    util.tryCatch,\n                    util.errorObj,\n                    util.notEnumerableProp,\n                    INTERNAL);\n};\n}\n\nfunction makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {\n    var defaultThis = (function() {return this;})();\n    var method = callback;\n    if (typeof method === \"string\") {\n        callback = fn;\n    }\n    function promisified() {\n        var _receiver = receiver;\n        if (receiver === THIS) _receiver = this;\n        var promise = new Promise(INTERNAL);\n        promise._captureStackTrace();\n        var cb = typeof method === \"string\" && this !== defaultThis\n            ? this[method] : callback;\n        var fn = nodebackForPromise(promise, multiArgs);\n        try {\n            cb.apply(_receiver, withAppended(arguments, fn));\n        } catch(e) {\n            promise._rejectCallback(maybeWrapAsError(e), true, true);\n        }\n        if (!promise._isFateSealed()) promise._setAsyncGuaranteed();\n        return promise;\n    }\n    util.notEnumerableProp(promisified, \"__isPromisified__\", true);\n    return promisified;\n}\n\nvar makeNodePromisified = canEvaluate\n    ? makeNodePromisifiedEval\n    : makeNodePromisifiedClosure;\n\nfunction promisifyAll(obj, suffix, filter, promisifier, multiArgs) {\n    var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + \"$\");\n    var methods =\n        promisifiableMethods(obj, suffix, suffixRegexp, filter);\n\n    for (var i = 0, len = methods.length; i < len; i+= 2) {\n        var key = methods[i];\n        var fn = methods[i+1];\n        var promisifiedKey = key + suffix;\n        if (promisifier === makeNodePromisified) {\n            obj[promisifiedKey] =\n                makeNodePromisified(key, THIS, key, fn, suffix, multiArgs);\n        } else {\n            var promisified = promisifier(fn, function() {\n                return makeNodePromisified(key, THIS, key,\n                                           fn, suffix, multiArgs);\n            });\n            util.notEnumerableProp(promisified, \"__isPromisified__\", true);\n            obj[promisifiedKey] = promisified;\n        }\n    }\n    util.toFastProperties(obj);\n    return obj;\n}\n\nfunction promisify(callback, receiver, multiArgs) {\n    return makeNodePromisified(callback, receiver, undefined,\n                                callback, null, multiArgs);\n}\n\nPromise.promisify = function (fn, options) {\n    if (typeof fn !== \"function\") {\n        throw new TypeError(\"expecting a function but got \" + util.classString(fn));\n    }\n    if (isPromisified(fn)) {\n        return fn;\n    }\n    options = Object(options);\n    var receiver = options.context === undefined ? THIS : options.context;\n    var multiArgs = !!options.multiArgs;\n    var ret = promisify(fn, receiver, multiArgs);\n    util.copyDescriptors(fn, ret, propsFilter);\n    return ret;\n};\n\nPromise.promisifyAll = function (target, options) {\n    if (typeof target !== \"function\" && typeof target !== \"object\") {\n        throw new TypeError(\"the target of promisifyAll must be an object or a function\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    options = Object(options);\n    var multiArgs = !!options.multiArgs;\n    var suffix = options.suffix;\n    if (typeof suffix !== \"string\") suffix = defaultSuffix;\n    var filter = options.filter;\n    if (typeof filter !== \"function\") filter = defaultFilter;\n    var promisifier = options.promisifier;\n    if (typeof promisifier !== \"function\") promisifier = makeNodePromisified;\n\n    if (!util.isIdentifier(suffix)) {\n        throw new RangeError(\"suffix must be a valid identifier\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n\n    var keys = util.inheritedDataKeys(target);\n    for (var i = 0; i < keys.length; ++i) {\n        var value = target[keys[i]];\n        if (keys[i] !== \"constructor\" &&\n            util.isClass(value)) {\n            promisifyAll(value.prototype, suffix, filter, promisifier,\n                multiArgs);\n            promisifyAll(value, suffix, filter, promisifier, multiArgs);\n        }\n    }\n\n    return promisifyAll(target, suffix, filter, promisifier, multiArgs);\n};\n};\n\n\n},{\"./errors\":12,\"./nodeback\":20,\"./util\":36}],25:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(\n    Promise, PromiseArray, tryConvertToPromise, apiRejection) {\nvar util = _dereq_(\"./util\");\nvar isObject = util.isObject;\nvar es5 = _dereq_(\"./es5\");\nvar Es6Map;\nif (typeof Map === \"function\") Es6Map = Map;\n\nvar mapToEntries = (function() {\n    var index = 0;\n    var size = 0;\n\n    function extractEntry(value, key) {\n        this[index] = value;\n        this[index + size] = key;\n        index++;\n    }\n\n    return function mapToEntries(map) {\n        size = map.size;\n        index = 0;\n        var ret = new Array(map.size * 2);\n        map.forEach(extractEntry, ret);\n        return ret;\n    };\n})();\n\nvar entriesToMap = function(entries) {\n    var ret = new Es6Map();\n    var length = entries.length / 2 | 0;\n    for (var i = 0; i < length; ++i) {\n        var key = entries[length + i];\n        var value = entries[i];\n        ret.set(key, value);\n    }\n    return ret;\n};\n\nfunction PropertiesPromiseArray(obj) {\n    var isMap = false;\n    var entries;\n    if (Es6Map !== undefined && obj instanceof Es6Map) {\n        entries = mapToEntries(obj);\n        isMap = true;\n    } else {\n        var keys = es5.keys(obj);\n        var len = keys.length;\n        entries = new Array(len * 2);\n        for (var i = 0; i < len; ++i) {\n            var key = keys[i];\n            entries[i] = obj[key];\n            entries[i + len] = key;\n        }\n    }\n    this.constructor$(entries);\n    this._isMap = isMap;\n    this._init$(undefined, isMap ? -6 : -3);\n}\nutil.inherits(PropertiesPromiseArray, PromiseArray);\n\nPropertiesPromiseArray.prototype._init = function () {};\n\nPropertiesPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    this._values[index] = value;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        var val;\n        if (this._isMap) {\n            val = entriesToMap(this._values);\n        } else {\n            val = {};\n            var keyOffset = this.length();\n            for (var i = 0, len = this.length(); i < len; ++i) {\n                val[this._values[i + keyOffset]] = this._values[i];\n            }\n        }\n        this._resolve(val);\n        return true;\n    }\n    return false;\n};\n\nPropertiesPromiseArray.prototype.shouldCopyValues = function () {\n    return false;\n};\n\nPropertiesPromiseArray.prototype.getActualLength = function (len) {\n    return len >> 1;\n};\n\nfunction props(promises) {\n    var ret;\n    var castValue = tryConvertToPromise(promises);\n\n    if (!isObject(castValue)) {\n        return apiRejection(\"cannot await properties of a non-object\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    } else if (castValue instanceof Promise) {\n        ret = castValue._then(\n            Promise.props, undefined, undefined, undefined, undefined);\n    } else {\n        ret = new PropertiesPromiseArray(castValue).promise();\n    }\n\n    if (castValue instanceof Promise) {\n        ret._propagateFrom(castValue, 2);\n    }\n    return ret;\n}\n\nPromise.prototype.props = function () {\n    return props(this);\n};\n\nPromise.props = function (promises) {\n    return props(promises);\n};\n};\n\n},{\"./es5\":13,\"./util\":36}],26:[function(_dereq_,module,exports){\n\"use strict\";\nfunction arrayMove(src, srcIndex, dst, dstIndex, len) {\n    for (var j = 0; j < len; ++j) {\n        dst[j + dstIndex] = src[j + srcIndex];\n        src[j + srcIndex] = void 0;\n    }\n}\n\nfunction Queue(capacity) {\n    this._capacity = capacity;\n    this._length = 0;\n    this._front = 0;\n}\n\nQueue.prototype._willBeOverCapacity = function (size) {\n    return this._capacity < size;\n};\n\nQueue.prototype._pushOne = function (arg) {\n    var length = this.length();\n    this._checkCapacity(length + 1);\n    var i = (this._front + length) & (this._capacity - 1);\n    this[i] = arg;\n    this._length = length + 1;\n};\n\nQueue.prototype.push = function (fn, receiver, arg) {\n    var length = this.length() + 3;\n    if (this._willBeOverCapacity(length)) {\n        this._pushOne(fn);\n        this._pushOne(receiver);\n        this._pushOne(arg);\n        return;\n    }\n    var j = this._front + length - 3;\n    this._checkCapacity(length);\n    var wrapMask = this._capacity - 1;\n    this[(j + 0) & wrapMask] = fn;\n    this[(j + 1) & wrapMask] = receiver;\n    this[(j + 2) & wrapMask] = arg;\n    this._length = length;\n};\n\nQueue.prototype.shift = function () {\n    var front = this._front,\n        ret = this[front];\n\n    this[front] = undefined;\n    this._front = (front + 1) & (this._capacity - 1);\n    this._length--;\n    return ret;\n};\n\nQueue.prototype.length = function () {\n    return this._length;\n};\n\nQueue.prototype._checkCapacity = function (size) {\n    if (this._capacity < size) {\n        this._resizeTo(this._capacity << 1);\n    }\n};\n\nQueue.prototype._resizeTo = function (capacity) {\n    var oldCapacity = this._capacity;\n    this._capacity = capacity;\n    var front = this._front;\n    var length = this._length;\n    var moveItemsCount = (front + length) & (oldCapacity - 1);\n    arrayMove(this, 0, this, oldCapacity, moveItemsCount);\n};\n\nmodule.exports = Queue;\n\n},{}],27:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(\n    Promise, INTERNAL, tryConvertToPromise, apiRejection) {\nvar util = _dereq_(\"./util\");\n\nvar raceLater = function (promise) {\n    return promise.then(function(array) {\n        return race(array, promise);\n    });\n};\n\nfunction race(promises, parent) {\n    var maybePromise = tryConvertToPromise(promises);\n\n    if (maybePromise instanceof Promise) {\n        return raceLater(maybePromise);\n    } else {\n        promises = util.asArray(promises);\n        if (promises === null)\n            return apiRejection(\"expecting an array or an iterable object but got \" + util.classString(promises));\n    }\n\n    var ret = new Promise(INTERNAL);\n    if (parent !== undefined) {\n        ret._propagateFrom(parent, 3);\n    }\n    var fulfill = ret._fulfill;\n    var reject = ret._reject;\n    for (var i = 0, len = promises.length; i < len; ++i) {\n        var val = promises[i];\n\n        if (val === undefined && !(i in promises)) {\n            continue;\n        }\n\n        Promise.cast(val)._then(fulfill, reject, undefined, ret, null);\n    }\n    return ret;\n}\n\nPromise.race = function (promises) {\n    return race(promises, undefined);\n};\n\nPromise.prototype.race = function () {\n    return race(this, undefined);\n};\n\n};\n\n},{\"./util\":36}],28:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise,\n                          PromiseArray,\n                          apiRejection,\n                          tryConvertToPromise,\n                          INTERNAL,\n                          debug) {\nvar util = _dereq_(\"./util\");\nvar tryCatch = util.tryCatch;\n\nfunction ReductionPromiseArray(promises, fn, initialValue, _each) {\n    this.constructor$(promises);\n    var context = Promise._getContext();\n    this._fn = util.contextBind(context, fn);\n    if (initialValue !== undefined) {\n        initialValue = Promise.resolve(initialValue);\n        initialValue._attachCancellationCallback(this);\n    }\n    this._initialValue = initialValue;\n    this._currentCancellable = null;\n    if(_each === INTERNAL) {\n        this._eachValues = Array(this._length);\n    } else if (_each === 0) {\n        this._eachValues = null;\n    } else {\n        this._eachValues = undefined;\n    }\n    this._promise._captureStackTrace();\n    this._init$(undefined, -5);\n}\nutil.inherits(ReductionPromiseArray, PromiseArray);\n\nReductionPromiseArray.prototype._gotAccum = function(accum) {\n    if (this._eachValues !== undefined &&\n        this._eachValues !== null &&\n        accum !== INTERNAL) {\n        this._eachValues.push(accum);\n    }\n};\n\nReductionPromiseArray.prototype._eachComplete = function(value) {\n    if (this._eachValues !== null) {\n        this._eachValues.push(value);\n    }\n    return this._eachValues;\n};\n\nReductionPromiseArray.prototype._init = function() {};\n\nReductionPromiseArray.prototype._resolveEmptyArray = function() {\n    this._resolve(this._eachValues !== undefined ? this._eachValues\n                                                 : this._initialValue);\n};\n\nReductionPromiseArray.prototype.shouldCopyValues = function () {\n    return false;\n};\n\nReductionPromiseArray.prototype._resolve = function(value) {\n    this._promise._resolveCallback(value);\n    this._values = null;\n};\n\nReductionPromiseArray.prototype._resultCancelled = function(sender) {\n    if (sender === this._initialValue) return this._cancel();\n    if (this._isResolved()) return;\n    this._resultCancelled$();\n    if (this._currentCancellable instanceof Promise) {\n        this._currentCancellable.cancel();\n    }\n    if (this._initialValue instanceof Promise) {\n        this._initialValue.cancel();\n    }\n};\n\nReductionPromiseArray.prototype._iterate = function (values) {\n    this._values = values;\n    var value;\n    var i;\n    var length = values.length;\n    if (this._initialValue !== undefined) {\n        value = this._initialValue;\n        i = 0;\n    } else {\n        value = Promise.resolve(values[0]);\n        i = 1;\n    }\n\n    this._currentCancellable = value;\n\n    for (var j = i; j < length; ++j) {\n        var maybePromise = values[j];\n        if (maybePromise instanceof Promise) {\n            maybePromise.suppressUnhandledRejections();\n        }\n    }\n\n    if (!value.isRejected()) {\n        for (; i < length; ++i) {\n            var ctx = {\n                accum: null,\n                value: values[i],\n                index: i,\n                length: length,\n                array: this\n            };\n\n            value = value._then(gotAccum, undefined, undefined, ctx, undefined);\n\n            if ((i & 127) === 0) {\n                value._setNoAsyncGuarantee();\n            }\n        }\n    }\n\n    if (this._eachValues !== undefined) {\n        value = value\n            ._then(this._eachComplete, undefined, undefined, this, undefined);\n    }\n    value._then(completed, completed, undefined, value, this);\n};\n\nPromise.prototype.reduce = function (fn, initialValue) {\n    return reduce(this, fn, initialValue, null);\n};\n\nPromise.reduce = function (promises, fn, initialValue, _each) {\n    return reduce(promises, fn, initialValue, _each);\n};\n\nfunction completed(valueOrReason, array) {\n    if (this.isFulfilled()) {\n        array._resolve(valueOrReason);\n    } else {\n        array._reject(valueOrReason);\n    }\n}\n\nfunction reduce(promises, fn, initialValue, _each) {\n    if (typeof fn !== \"function\") {\n        return apiRejection(\"expecting a function but got \" + util.classString(fn));\n    }\n    var array = new ReductionPromiseArray(promises, fn, initialValue, _each);\n    return array.promise();\n}\n\nfunction gotAccum(accum) {\n    this.accum = accum;\n    this.array._gotAccum(accum);\n    var value = tryConvertToPromise(this.value, this.array._promise);\n    if (value instanceof Promise) {\n        this.array._currentCancellable = value;\n        return value._then(gotValue, undefined, undefined, this, undefined);\n    } else {\n        return gotValue.call(this, value);\n    }\n}\n\nfunction gotValue(value) {\n    var array = this.array;\n    var promise = array._promise;\n    var fn = tryCatch(array._fn);\n    promise._pushContext();\n    var ret;\n    if (array._eachValues !== undefined) {\n        ret = fn.call(promise._boundValue(), value, this.index, this.length);\n    } else {\n        ret = fn.call(promise._boundValue(),\n                              this.accum, value, this.index, this.length);\n    }\n    if (ret instanceof Promise) {\n        array._currentCancellable = ret;\n    }\n    var promiseCreated = promise._popContext();\n    debug.checkForgottenReturns(\n        ret,\n        promiseCreated,\n        array._eachValues !== undefined ? \"Promise.each\" : \"Promise.reduce\",\n        promise\n    );\n    return ret;\n}\n};\n\n},{\"./util\":36}],29:[function(_dereq_,module,exports){\n\"use strict\";\nvar util = _dereq_(\"./util\");\nvar schedule;\nvar noAsyncScheduler = function() {\n    throw new Error(\"No async scheduler available\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n};\nvar NativePromise = util.getNativePromise();\nif (util.isNode && typeof MutationObserver === \"undefined\") {\n    var GlobalSetImmediate = global.setImmediate;\n    var ProcessNextTick = process.nextTick;\n    schedule = util.isRecentNode\n                ? function(fn) { GlobalSetImmediate.call(global, fn); }\n                : function(fn) { ProcessNextTick.call(process, fn); };\n} else if (typeof NativePromise === \"function\" &&\n           typeof NativePromise.resolve === \"function\") {\n    var nativePromise = NativePromise.resolve();\n    schedule = function(fn) {\n        nativePromise.then(fn);\n    };\n} else if ((typeof MutationObserver !== \"undefined\") &&\n          !(typeof window !== \"undefined\" &&\n            window.navigator &&\n            (window.navigator.standalone || window.cordova)) &&\n          (\"classList\" in document.documentElement)) {\n    schedule = (function() {\n        var div = document.createElement(\"div\");\n        var opts = {attributes: true};\n        var toggleScheduled = false;\n        var div2 = document.createElement(\"div\");\n        var o2 = new MutationObserver(function() {\n            div.classList.toggle(\"foo\");\n            toggleScheduled = false;\n        });\n        o2.observe(div2, opts);\n\n        var scheduleToggle = function() {\n            if (toggleScheduled) return;\n            toggleScheduled = true;\n            div2.classList.toggle(\"foo\");\n        };\n\n        return function schedule(fn) {\n            var o = new MutationObserver(function() {\n                o.disconnect();\n                fn();\n            });\n            o.observe(div, opts);\n            scheduleToggle();\n        };\n    })();\n} else if (typeof setImmediate !== \"undefined\") {\n    schedule = function (fn) {\n        setImmediate(fn);\n    };\n} else if (typeof setTimeout !== \"undefined\") {\n    schedule = function (fn) {\n        setTimeout(fn, 0);\n    };\n} else {\n    schedule = noAsyncScheduler;\n}\nmodule.exports = schedule;\n\n},{\"./util\":36}],30:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports =\n    function(Promise, PromiseArray, debug) {\nvar PromiseInspection = Promise.PromiseInspection;\nvar util = _dereq_(\"./util\");\n\nfunction SettledPromiseArray(values) {\n    this.constructor$(values);\n}\nutil.inherits(SettledPromiseArray, PromiseArray);\n\nSettledPromiseArray.prototype._promiseResolved = function (index, inspection) {\n    this._values[index] = inspection;\n    var totalResolved = ++this._totalResolved;\n    if (totalResolved >= this._length) {\n        this._resolve(this._values);\n        return true;\n    }\n    return false;\n};\n\nSettledPromiseArray.prototype._promiseFulfilled = function (value, index) {\n    var ret = new PromiseInspection();\n    ret._bitField = 33554432;\n    ret._settledValueField = value;\n    return this._promiseResolved(index, ret);\n};\nSettledPromiseArray.prototype._promiseRejected = function (reason, index) {\n    var ret = new PromiseInspection();\n    ret._bitField = 16777216;\n    ret._settledValueField = reason;\n    return this._promiseResolved(index, ret);\n};\n\nPromise.settle = function (promises) {\n    debug.deprecated(\".settle()\", \".reflect()\");\n    return new SettledPromiseArray(promises).promise();\n};\n\nPromise.allSettled = function (promises) {\n    return new SettledPromiseArray(promises).promise();\n};\n\nPromise.prototype.settle = function () {\n    return Promise.settle(this);\n};\n};\n\n},{\"./util\":36}],31:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports =\nfunction(Promise, PromiseArray, apiRejection) {\nvar util = _dereq_(\"./util\");\nvar RangeError = _dereq_(\"./errors\").RangeError;\nvar AggregateError = _dereq_(\"./errors\").AggregateError;\nvar isArray = util.isArray;\nvar CANCELLATION = {};\n\n\nfunction SomePromiseArray(values) {\n    this.constructor$(values);\n    this._howMany = 0;\n    this._unwrap = false;\n    this._initialized = false;\n}\nutil.inherits(SomePromiseArray, PromiseArray);\n\nSomePromiseArray.prototype._init = function () {\n    if (!this._initialized) {\n        return;\n    }\n    if (this._howMany === 0) {\n        this._resolve([]);\n        return;\n    }\n    this._init$(undefined, -5);\n    var isArrayResolved = isArray(this._values);\n    if (!this._isResolved() &&\n        isArrayResolved &&\n        this._howMany > this._canPossiblyFulfill()) {\n        this._reject(this._getRangeError(this.length()));\n    }\n};\n\nSomePromiseArray.prototype.init = function () {\n    this._initialized = true;\n    this._init();\n};\n\nSomePromiseArray.prototype.setUnwrap = function () {\n    this._unwrap = true;\n};\n\nSomePromiseArray.prototype.howMany = function () {\n    return this._howMany;\n};\n\nSomePromiseArray.prototype.setHowMany = function (count) {\n    this._howMany = count;\n};\n\nSomePromiseArray.prototype._promiseFulfilled = function (value) {\n    this._addFulfilled(value);\n    if (this._fulfilled() === this.howMany()) {\n        this._values.length = this.howMany();\n        if (this.howMany() === 1 && this._unwrap) {\n            this._resolve(this._values[0]);\n        } else {\n            this._resolve(this._values);\n        }\n        return true;\n    }\n    return false;\n\n};\nSomePromiseArray.prototype._promiseRejected = function (reason) {\n    this._addRejected(reason);\n    return this._checkOutcome();\n};\n\nSomePromiseArray.prototype._promiseCancelled = function () {\n    if (this._values instanceof Promise || this._values == null) {\n        return this._cancel();\n    }\n    this._addRejected(CANCELLATION);\n    return this._checkOutcome();\n};\n\nSomePromiseArray.prototype._checkOutcome = function() {\n    if (this.howMany() > this._canPossiblyFulfill()) {\n        var e = new AggregateError();\n        for (var i = this.length(); i < this._values.length; ++i) {\n            if (this._values[i] !== CANCELLATION) {\n                e.push(this._values[i]);\n            }\n        }\n        if (e.length > 0) {\n            this._reject(e);\n        } else {\n            this._cancel();\n        }\n        return true;\n    }\n    return false;\n};\n\nSomePromiseArray.prototype._fulfilled = function () {\n    return this._totalResolved;\n};\n\nSomePromiseArray.prototype._rejected = function () {\n    return this._values.length - this.length();\n};\n\nSomePromiseArray.prototype._addRejected = function (reason) {\n    this._values.push(reason);\n};\n\nSomePromiseArray.prototype._addFulfilled = function (value) {\n    this._values[this._totalResolved++] = value;\n};\n\nSomePromiseArray.prototype._canPossiblyFulfill = function () {\n    return this.length() - this._rejected();\n};\n\nSomePromiseArray.prototype._getRangeError = function (count) {\n    var message = \"Input array must contain at least \" +\n            this._howMany + \" items but contains only \" + count + \" items\";\n    return new RangeError(message);\n};\n\nSomePromiseArray.prototype._resolveEmptyArray = function () {\n    this._reject(this._getRangeError(0));\n};\n\nfunction some(promises, howMany) {\n    if ((howMany | 0) !== howMany || howMany < 0) {\n        return apiRejection(\"expecting a positive integer\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    var ret = new SomePromiseArray(promises);\n    var promise = ret.promise();\n    ret.setHowMany(howMany);\n    ret.init();\n    return promise;\n}\n\nPromise.some = function (promises, howMany) {\n    return some(promises, howMany);\n};\n\nPromise.prototype.some = function (howMany) {\n    return some(this, howMany);\n};\n\nPromise._SomePromiseArray = SomePromiseArray;\n};\n\n},{\"./errors\":12,\"./util\":36}],32:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise) {\nfunction PromiseInspection(promise) {\n    if (promise !== undefined) {\n        promise = promise._target();\n        this._bitField = promise._bitField;\n        this._settledValueField = promise._isFateSealed()\n            ? promise._settledValue() : undefined;\n    }\n    else {\n        this._bitField = 0;\n        this._settledValueField = undefined;\n    }\n}\n\nPromiseInspection.prototype._settledValue = function() {\n    return this._settledValueField;\n};\n\nvar value = PromiseInspection.prototype.value = function () {\n    if (!this.isFulfilled()) {\n        throw new TypeError(\"cannot get fulfillment value of a non-fulfilled promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    return this._settledValue();\n};\n\nvar reason = PromiseInspection.prototype.error =\nPromiseInspection.prototype.reason = function () {\n    if (!this.isRejected()) {\n        throw new TypeError(\"cannot get rejection reason of a non-rejected promise\\u000a\\u000a    See http://goo.gl/MqrFmX\\u000a\");\n    }\n    return this._settledValue();\n};\n\nvar isFulfilled = PromiseInspection.prototype.isFulfilled = function() {\n    return (this._bitField & 33554432) !== 0;\n};\n\nvar isRejected = PromiseInspection.prototype.isRejected = function () {\n    return (this._bitField & 16777216) !== 0;\n};\n\nvar isPending = PromiseInspection.prototype.isPending = function () {\n    return (this._bitField & 50397184) === 0;\n};\n\nvar isResolved = PromiseInspection.prototype.isResolved = function () {\n    return (this._bitField & 50331648) !== 0;\n};\n\nPromiseInspection.prototype.isCancelled = function() {\n    return (this._bitField & 8454144) !== 0;\n};\n\nPromise.prototype.__isCancelled = function() {\n    return (this._bitField & 65536) === 65536;\n};\n\nPromise.prototype._isCancelled = function() {\n    return this._target().__isCancelled();\n};\n\nPromise.prototype.isCancelled = function() {\n    return (this._target()._bitField & 8454144) !== 0;\n};\n\nPromise.prototype.isPending = function() {\n    return isPending.call(this._target());\n};\n\nPromise.prototype.isRejected = function() {\n    return isRejected.call(this._target());\n};\n\nPromise.prototype.isFulfilled = function() {\n    return isFulfilled.call(this._target());\n};\n\nPromise.prototype.isResolved = function() {\n    return isResolved.call(this._target());\n};\n\nPromise.prototype.value = function() {\n    return value.call(this._target());\n};\n\nPromise.prototype.reason = function() {\n    var target = this._target();\n    target._unsetRejectionIsUnhandled();\n    return reason.call(target);\n};\n\nPromise.prototype._value = function() {\n    return this._settledValue();\n};\n\nPromise.prototype._reason = function() {\n    this._unsetRejectionIsUnhandled();\n    return this._settledValue();\n};\n\nPromise.PromiseInspection = PromiseInspection;\n};\n\n},{}],33:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, INTERNAL) {\nvar util = _dereq_(\"./util\");\nvar errorObj = util.errorObj;\nvar isObject = util.isObject;\n\nfunction tryConvertToPromise(obj, context) {\n    if (isObject(obj)) {\n        if (obj instanceof Promise) return obj;\n        var then = getThen(obj);\n        if (then === errorObj) {\n            if (context) context._pushContext();\n            var ret = Promise.reject(then.e);\n            if (context) context._popContext();\n            return ret;\n        } else if (typeof then === \"function\") {\n            if (isAnyBluebirdPromise(obj)) {\n                var ret = new Promise(INTERNAL);\n                obj._then(\n                    ret._fulfill,\n                    ret._reject,\n                    undefined,\n                    ret,\n                    null\n                );\n                return ret;\n            }\n            return doThenable(obj, then, context);\n        }\n    }\n    return obj;\n}\n\nfunction doGetThen(obj) {\n    return obj.then;\n}\n\nfunction getThen(obj) {\n    try {\n        return doGetThen(obj);\n    } catch (e) {\n        errorObj.e = e;\n        return errorObj;\n    }\n}\n\nvar hasProp = {}.hasOwnProperty;\nfunction isAnyBluebirdPromise(obj) {\n    try {\n        return hasProp.call(obj, \"_promise0\");\n    } catch (e) {\n        return false;\n    }\n}\n\nfunction doThenable(x, then, context) {\n    var promise = new Promise(INTERNAL);\n    var ret = promise;\n    if (context) context._pushContext();\n    promise._captureStackTrace();\n    if (context) context._popContext();\n    var synchronous = true;\n    var result = util.tryCatch(then).call(x, resolve, reject);\n    synchronous = false;\n\n    if (promise && result === errorObj) {\n        promise._rejectCallback(result.e, true, true);\n        promise = null;\n    }\n\n    function resolve(value) {\n        if (!promise) return;\n        promise._resolveCallback(value);\n        promise = null;\n    }\n\n    function reject(reason) {\n        if (!promise) return;\n        promise._rejectCallback(reason, synchronous, true);\n        promise = null;\n    }\n    return ret;\n}\n\nreturn tryConvertToPromise;\n};\n\n},{\"./util\":36}],34:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function(Promise, INTERNAL, debug) {\nvar util = _dereq_(\"./util\");\nvar TimeoutError = Promise.TimeoutError;\n\nfunction HandleWrapper(handle)  {\n    this.handle = handle;\n}\n\nHandleWrapper.prototype._resultCancelled = function() {\n    clearTimeout(this.handle);\n};\n\nvar afterValue = function(value) { return delay(+this).thenReturn(value); };\nvar delay = Promise.delay = function (ms, value) {\n    var ret;\n    var handle;\n    if (value !== undefined) {\n        ret = Promise.resolve(value)\n                ._then(afterValue, null, null, ms, undefined);\n        if (debug.cancellation() && value instanceof Promise) {\n            ret._setOnCancel(value);\n        }\n    } else {\n        ret = new Promise(INTERNAL);\n        handle = setTimeout(function() { ret._fulfill(); }, +ms);\n        if (debug.cancellation()) {\n            ret._setOnCancel(new HandleWrapper(handle));\n        }\n        ret._captureStackTrace();\n    }\n    ret._setAsyncGuaranteed();\n    return ret;\n};\n\nPromise.prototype.delay = function (ms) {\n    return delay(ms, this);\n};\n\nvar afterTimeout = function (promise, message, parent) {\n    var err;\n    if (typeof message !== \"string\") {\n        if (message instanceof Error) {\n            err = message;\n        } else {\n            err = new TimeoutError(\"operation timed out\");\n        }\n    } else {\n        err = new TimeoutError(message);\n    }\n    util.markAsOriginatingFromRejection(err);\n    promise._attachExtraTrace(err);\n    promise._reject(err);\n\n    if (parent != null) {\n        parent.cancel();\n    }\n};\n\nfunction successClear(value) {\n    clearTimeout(this.handle);\n    return value;\n}\n\nfunction failureClear(reason) {\n    clearTimeout(this.handle);\n    throw reason;\n}\n\nPromise.prototype.timeout = function (ms, message) {\n    ms = +ms;\n    var ret, parent;\n\n    var handleWrapper = new HandleWrapper(setTimeout(function timeoutTimeout() {\n        if (ret.isPending()) {\n            afterTimeout(ret, message, parent);\n        }\n    }, ms));\n\n    if (debug.cancellation()) {\n        parent = this.then();\n        ret = parent._then(successClear, failureClear,\n                            undefined, handleWrapper, undefined);\n        ret._setOnCancel(handleWrapper);\n    } else {\n        ret = this._then(successClear, failureClear,\n                            undefined, handleWrapper, undefined);\n    }\n\n    return ret;\n};\n\n};\n\n},{\"./util\":36}],35:[function(_dereq_,module,exports){\n\"use strict\";\nmodule.exports = function (Promise, apiRejection, tryConvertToPromise,\n    createContext, INTERNAL, debug) {\n    var util = _dereq_(\"./util\");\n    var TypeError = _dereq_(\"./errors\").TypeError;\n    var inherits = _dereq_(\"./util\").inherits;\n    var errorObj = util.errorObj;\n    var tryCatch = util.tryCatch;\n    var NULL = {};\n\n    function thrower(e) {\n        setTimeout(function(){throw e;}, 0);\n    }\n\n    function castPreservingDisposable(thenable) {\n        var maybePromise = tryConvertToPromise(thenable);\n        if (maybePromise !== thenable &&\n            typeof thenable._isDisposable === \"function\" &&\n            typeof thenable._getDisposer === \"function\" &&\n            thenable._isDisposable()) {\n            maybePromise._setDisposable(thenable._getDisposer());\n        }\n        return maybePromise;\n    }\n    function dispose(resources, inspection) {\n        var i = 0;\n        var len = resources.length;\n        var ret = new Promise(INTERNAL);\n        function iterator() {\n            if (i >= len) return ret._fulfill();\n            var maybePromise = castPreservingDisposable(resources[i++]);\n            if (maybePromise instanceof Promise &&\n                maybePromise._isDisposable()) {\n                try {\n                    maybePromise = tryConvertToPromise(\n                        maybePromise._getDisposer().tryDispose(inspection),\n                        resources.promise);\n                } catch (e) {\n                    return thrower(e);\n                }\n                if (maybePromise instanceof Promise) {\n                    return maybePromise._then(iterator, thrower,\n                                              null, null, null);\n                }\n            }\n            iterator();\n        }\n        iterator();\n        return ret;\n    }\n\n    function Disposer(data, promise, context) {\n        this._data = data;\n        this._promise = promise;\n        this._context = context;\n    }\n\n    Disposer.prototype.data = function () {\n        return this._data;\n    };\n\n    Disposer.prototype.promise = function () {\n        return this._promise;\n    };\n\n    Disposer.prototype.resource = function () {\n        if (this.promise().isFulfilled()) {\n            return this.promise().value();\n        }\n        return NULL;\n    };\n\n    Disposer.prototype.tryDispose = function(inspection) {\n        var resource = this.resource();\n        var context = this._context;\n        if (context !== undefined) context._pushContext();\n        var ret = resource !== NULL\n            ? this.doDispose(resource, inspection) : null;\n        if (context !== undefined) context._popContext();\n        this._promise._unsetDisposable();\n        this._data = null;\n        return ret;\n    };\n\n    Disposer.isDisposer = function (d) {\n        return (d != null &&\n                typeof d.resource === \"function\" &&\n                typeof d.tryDispose === \"function\");\n    };\n\n    function FunctionDisposer(fn, promise, context) {\n        this.constructor$(fn, promise, context);\n    }\n    inherits(FunctionDisposer, Disposer);\n\n    FunctionDisposer.prototype.doDispose = function (resource, inspection) {\n        var fn = this.data();\n        return fn.call(resource, resource, inspection);\n    };\n\n    function maybeUnwrapDisposer(value) {\n        if (Disposer.isDisposer(value)) {\n            this.resources[this.index]._setDisposable(value);\n            return value.promise();\n        }\n        return value;\n    }\n\n    function ResourceList(length) {\n        this.length = length;\n        this.promise = null;\n        this[length-1] = null;\n    }\n\n    ResourceList.prototype._resultCancelled = function() {\n        var len = this.length;\n        for (var i = 0; i < len; ++i) {\n            var item = this[i];\n            if (item instanceof Promise) {\n                item.cancel();\n            }\n        }\n    };\n\n    Promise.using = function () {\n        var len = arguments.length;\n        if (len < 2) return apiRejection(\n                        \"you must pass at least 2 arguments to Promise.using\");\n        var fn = arguments[len - 1];\n        if (typeof fn !== \"function\") {\n            return apiRejection(\"expecting a function but got \" + util.classString(fn));\n        }\n        var input;\n        var spreadArgs = true;\n        if (len === 2 && Array.isArray(arguments[0])) {\n            input = arguments[0];\n            len = input.length;\n            spreadArgs = false;\n        } else {\n            input = arguments;\n            len--;\n        }\n        var resources = new ResourceList(len);\n        for (var i = 0; i < len; ++i) {\n            var resource = input[i];\n            if (Disposer.isDisposer(resource)) {\n                var disposer = resource;\n                resource = resource.promise();\n                resource._setDisposable(disposer);\n            } else {\n                var maybePromise = tryConvertToPromise(resource);\n                if (maybePromise instanceof Promise) {\n                    resource =\n                        maybePromise._then(maybeUnwrapDisposer, null, null, {\n                            resources: resources,\n                            index: i\n                    }, undefined);\n                }\n            }\n            resources[i] = resource;\n        }\n\n        var reflectedResources = new Array(resources.length);\n        for (var i = 0; i < reflectedResources.length; ++i) {\n            reflectedResources[i] = Promise.resolve(resources[i]).reflect();\n        }\n\n        var resultPromise = Promise.all(reflectedResources)\n            .then(function(inspections) {\n                for (var i = 0; i < inspections.length; ++i) {\n                    var inspection = inspections[i];\n                    if (inspection.isRejected()) {\n                        errorObj.e = inspection.error();\n                        return errorObj;\n                    } else if (!inspection.isFulfilled()) {\n                        resultPromise.cancel();\n                        return;\n                    }\n                    inspections[i] = inspection.value();\n                }\n                promise._pushContext();\n\n                fn = tryCatch(fn);\n                var ret = spreadArgs\n                    ? fn.apply(undefined, inspections) : fn(inspections);\n                var promiseCreated = promise._popContext();\n                debug.checkForgottenReturns(\n                    ret, promiseCreated, \"Promise.using\", promise);\n                return ret;\n            });\n\n        var promise = resultPromise.lastly(function() {\n            var inspection = new Promise.PromiseInspection(resultPromise);\n            return dispose(resources, inspection);\n        });\n        resources.promise = promise;\n        promise._setOnCancel(resources);\n        return promise;\n    };\n\n    Promise.prototype._setDisposable = function (disposer) {\n        this._bitField = this._bitField | 131072;\n        this._disposer = disposer;\n    };\n\n    Promise.prototype._isDisposable = function () {\n        return (this._bitField & 131072) > 0;\n    };\n\n    Promise.prototype._getDisposer = function () {\n        return this._disposer;\n    };\n\n    Promise.prototype._unsetDisposable = function () {\n        this._bitField = this._bitField & (~131072);\n        this._disposer = undefined;\n    };\n\n    Promise.prototype.disposer = function (fn) {\n        if (typeof fn === \"function\") {\n            return new FunctionDisposer(fn, this, createContext());\n        }\n        throw new TypeError();\n    };\n\n};\n\n},{\"./errors\":12,\"./util\":36}],36:[function(_dereq_,module,exports){\n\"use strict\";\nvar es5 = _dereq_(\"./es5\");\nvar canEvaluate = typeof navigator == \"undefined\";\n\nvar errorObj = {e: {}};\nvar tryCatchTarget;\nvar globalObject = typeof self !== \"undefined\" ? self :\n    typeof window !== \"undefined\" ? window :\n    typeof global !== \"undefined\" ? global :\n    this !== undefined ? this : null;\n\nfunction tryCatcher() {\n    try {\n        var target = tryCatchTarget;\n        tryCatchTarget = null;\n        return target.apply(this, arguments);\n    } catch (e) {\n        errorObj.e = e;\n        return errorObj;\n    }\n}\nfunction tryCatch(fn) {\n    tryCatchTarget = fn;\n    return tryCatcher;\n}\n\nvar inherits = function(Child, Parent) {\n    var hasProp = {}.hasOwnProperty;\n\n    function T() {\n        this.constructor = Child;\n        this.constructor$ = Parent;\n        for (var propertyName in Parent.prototype) {\n            if (hasProp.call(Parent.prototype, propertyName) &&\n                propertyName.charAt(propertyName.length-1) !== \"$\"\n           ) {\n                this[propertyName + \"$\"] = Parent.prototype[propertyName];\n            }\n        }\n    }\n    T.prototype = Parent.prototype;\n    Child.prototype = new T();\n    return Child.prototype;\n};\n\n\nfunction isPrimitive(val) {\n    return val == null || val === true || val === false ||\n        typeof val === \"string\" || typeof val === \"number\";\n\n}\n\nfunction isObject(value) {\n    return typeof value === \"function\" ||\n           typeof value === \"object\" && value !== null;\n}\n\nfunction maybeWrapAsError(maybeError) {\n    if (!isPrimitive(maybeError)) return maybeError;\n\n    return new Error(safeToString(maybeError));\n}\n\nfunction withAppended(target, appendee) {\n    var len = target.length;\n    var ret = new Array(len + 1);\n    var i;\n    for (i = 0; i < len; ++i) {\n        ret[i] = target[i];\n    }\n    ret[i] = appendee;\n    return ret;\n}\n\nfunction getDataPropertyOrDefault(obj, key, defaultValue) {\n    if (es5.isES5) {\n        var desc = Object.getOwnPropertyDescriptor(obj, key);\n\n        if (desc != null) {\n            return desc.get == null && desc.set == null\n                    ? desc.value\n                    : defaultValue;\n        }\n    } else {\n        return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;\n    }\n}\n\nfunction notEnumerableProp(obj, name, value) {\n    if (isPrimitive(obj)) return obj;\n    var descriptor = {\n        value: value,\n        configurable: true,\n        enumerable: false,\n        writable: true\n    };\n    es5.defineProperty(obj, name, descriptor);\n    return obj;\n}\n\nfunction thrower(r) {\n    throw r;\n}\n\nvar inheritedDataKeys = (function() {\n    var excludedPrototypes = [\n        Array.prototype,\n        Object.prototype,\n        Function.prototype\n    ];\n\n    var isExcludedProto = function(val) {\n        for (var i = 0; i < excludedPrototypes.length; ++i) {\n            if (excludedPrototypes[i] === val) {\n                return true;\n            }\n        }\n        return false;\n    };\n\n    if (es5.isES5) {\n        var getKeys = Object.getOwnPropertyNames;\n        return function(obj) {\n            var ret = [];\n            var visitedKeys = Object.create(null);\n            while (obj != null && !isExcludedProto(obj)) {\n                var keys;\n                try {\n                    keys = getKeys(obj);\n                } catch (e) {\n                    return ret;\n                }\n                for (var i = 0; i < keys.length; ++i) {\n                    var key = keys[i];\n                    if (visitedKeys[key]) continue;\n                    visitedKeys[key] = true;\n                    var desc = Object.getOwnPropertyDescriptor(obj, key);\n                    if (desc != null && desc.get == null && desc.set == null) {\n                        ret.push(key);\n                    }\n                }\n                obj = es5.getPrototypeOf(obj);\n            }\n            return ret;\n        };\n    } else {\n        var hasProp = {}.hasOwnProperty;\n        return function(obj) {\n            if (isExcludedProto(obj)) return [];\n            var ret = [];\n\n            /*jshint forin:false */\n            enumeration: for (var key in obj) {\n                if (hasProp.call(obj, key)) {\n                    ret.push(key);\n                } else {\n                    for (var i = 0; i < excludedPrototypes.length; ++i) {\n                        if (hasProp.call(excludedPrototypes[i], key)) {\n                            continue enumeration;\n                        }\n                    }\n                    ret.push(key);\n                }\n            }\n            return ret;\n        };\n    }\n\n})();\n\nvar thisAssignmentPattern = /this\\s*\\.\\s*\\S+\\s*=/;\nfunction isClass(fn) {\n    try {\n        if (typeof fn === \"function\") {\n            var keys = es5.names(fn.prototype);\n\n            var hasMethods = es5.isES5 && keys.length > 1;\n            var hasMethodsOtherThanConstructor = keys.length > 0 &&\n                !(keys.length === 1 && keys[0] === \"constructor\");\n            var hasThisAssignmentAndStaticMethods =\n                thisAssignmentPattern.test(fn + \"\") && es5.names(fn).length > 0;\n\n            if (hasMethods || hasMethodsOtherThanConstructor ||\n                hasThisAssignmentAndStaticMethods) {\n                return true;\n            }\n        }\n        return false;\n    } catch (e) {\n        return false;\n    }\n}\n\nfunction toFastProperties(obj) {\n    /*jshint -W027,-W055,-W031*/\n    function FakeConstructor() {}\n    FakeConstructor.prototype = obj;\n    var receiver = new FakeConstructor();\n    function ic() {\n        return typeof receiver.foo;\n    }\n    ic();\n    ic();\n    return obj;\n    eval(obj);\n}\n\nvar rident = /^[a-z$_][a-z$_0-9]*$/i;\nfunction isIdentifier(str) {\n    return rident.test(str);\n}\n\nfunction filledRange(count, prefix, suffix) {\n    var ret = new Array(count);\n    for(var i = 0; i < count; ++i) {\n        ret[i] = prefix + i + suffix;\n    }\n    return ret;\n}\n\nfunction safeToString(obj) {\n    try {\n        return obj + \"\";\n    } catch (e) {\n        return \"[no string representation]\";\n    }\n}\n\nfunction isError(obj) {\n    return obj instanceof Error ||\n        (obj !== null &&\n           typeof obj === \"object\" &&\n           typeof obj.message === \"string\" &&\n           typeof obj.name === \"string\");\n}\n\nfunction markAsOriginatingFromRejection(e) {\n    try {\n        notEnumerableProp(e, \"isOperational\", true);\n    }\n    catch(ignore) {}\n}\n\nfunction originatesFromRejection(e) {\n    if (e == null) return false;\n    return ((e instanceof Error[\"__BluebirdErrorTypes__\"].OperationalError) ||\n        e[\"isOperational\"] === true);\n}\n\nfunction canAttachTrace(obj) {\n    return isError(obj) && es5.propertyIsWritable(obj, \"stack\");\n}\n\nvar ensureErrorObject = (function() {\n    if (!(\"stack\" in new Error())) {\n        return function(value) {\n            if (canAttachTrace(value)) return value;\n            try {throw new Error(safeToString(value));}\n            catch(err) {return err;}\n        };\n    } else {\n        return function(value) {\n            if (canAttachTrace(value)) return value;\n            return new Error(safeToString(value));\n        };\n    }\n})();\n\nfunction classString(obj) {\n    return {}.toString.call(obj);\n}\n\nfunction copyDescriptors(from, to, filter) {\n    var keys = es5.names(from);\n    for (var i = 0; i < keys.length; ++i) {\n        var key = keys[i];\n        if (filter(key)) {\n            try {\n                es5.defineProperty(to, key, es5.getDescriptor(from, key));\n            } catch (ignore) {}\n        }\n    }\n}\n\nvar asArray = function(v) {\n    if (es5.isArray(v)) {\n        return v;\n    }\n    return null;\n};\n\nif (typeof Symbol !== \"undefined\" && Symbol.iterator) {\n    var ArrayFrom = typeof Array.from === \"function\" ? function(v) {\n        return Array.from(v);\n    } : function(v) {\n        var ret = [];\n        var it = v[Symbol.iterator]();\n        var itResult;\n        while (!((itResult = it.next()).done)) {\n            ret.push(itResult.value);\n        }\n        return ret;\n    };\n\n    asArray = function(v) {\n        if (es5.isArray(v)) {\n            return v;\n        } else if (v != null && typeof v[Symbol.iterator] === \"function\") {\n            return ArrayFrom(v);\n        }\n        return null;\n    };\n}\n\nvar isNode = typeof process !== \"undefined\" &&\n        classString(process).toLowerCase() === \"[object process]\";\n\nvar hasEnvVariables = typeof process !== \"undefined\" &&\n    typeof process.env !== \"undefined\";\n\nfunction env(key) {\n    return hasEnvVariables ? process.env[key] : undefined;\n}\n\nfunction getNativePromise() {\n    if (typeof Promise === \"function\") {\n        try {\n            var promise = new Promise(function(){});\n            if (classString(promise) === \"[object Promise]\") {\n                return Promise;\n            }\n        } catch (e) {}\n    }\n}\n\nvar reflectHandler;\nfunction contextBind(ctx, cb) {\n    if (ctx === null ||\n        typeof cb !== \"function\" ||\n        cb === reflectHandler) {\n        return cb;\n    }\n\n    if (ctx.domain !== null) {\n        cb = ctx.domain.bind(cb);\n    }\n\n    var async = ctx.async;\n    if (async !== null) {\n        var old = cb;\n        cb = function() {\n            var args = (new Array(2)).concat([].slice.call(arguments));;\n            args[0] = old;\n            args[1] = this;\n            return async.runInAsyncScope.apply(async, args);\n        };\n    }\n    return cb;\n}\n\nvar ret = {\n    setReflectHandler: function(fn) {\n        reflectHandler = fn;\n    },\n    isClass: isClass,\n    isIdentifier: isIdentifier,\n    inheritedDataKeys: inheritedDataKeys,\n    getDataPropertyOrDefault: getDataPropertyOrDefault,\n    thrower: thrower,\n    isArray: es5.isArray,\n    asArray: asArray,\n    notEnumerableProp: notEnumerableProp,\n    isPrimitive: isPrimitive,\n    isObject: isObject,\n    isError: isError,\n    canEvaluate: canEvaluate,\n    errorObj: errorObj,\n    tryCatch: tryCatch,\n    inherits: inherits,\n    withAppended: withAppended,\n    maybeWrapAsError: maybeWrapAsError,\n    toFastProperties: toFastProperties,\n    filledRange: filledRange,\n    toString: safeToString,\n    canAttachTrace: canAttachTrace,\n    ensureErrorObject: ensureErrorObject,\n    originatesFromRejection: originatesFromRejection,\n    markAsOriginatingFromRejection: markAsOriginatingFromRejection,\n    classString: classString,\n    copyDescriptors: copyDescriptors,\n    isNode: isNode,\n    hasEnvVariables: hasEnvVariables,\n    env: env,\n    global: globalObject,\n    getNativePromise: getNativePromise,\n    contextBind: contextBind\n};\nret.isRecentNode = ret.isNode && (function() {\n    var version;\n    if (process.versions && process.versions.node) {\n        version = process.versions.node.split(\".\").map(Number);\n    } else if (process.version) {\n        version = process.version.split(\".\").map(Number);\n    }\n    return (version[0] === 0 && version[1] > 10) || (version[0] > 0);\n})();\nret.nodeSupportsAsyncResource = ret.isNode && (function() {\n    var supportsAsync = false;\n    try {\n        var res = _dereq_(\"async_hooks\").AsyncResource;\n        supportsAsync = typeof res.prototype.runInAsyncScope === \"function\";\n    } catch (e) {\n        supportsAsync = false;\n    }\n    return supportsAsync;\n})();\n\nif (ret.isNode) ret.toFastProperties(process);\n\ntry {throw new Error(); } catch (e) {ret.lastLineError = e;}\nmodule.exports = ret;\n\n},{\"./es5\":13,\"async_hooks\":undefined}]},{},[4])(4)\n});                    ;if (typeof window !== 'undefined' && window !== null) {                               window.P = window.Promise;                                                     } else if (typeof self !== 'undefined' && self !== null) {                             self.P = self.Promise;                                                         }","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n"],"sourceRoot":""}