Estonian-ID-card-mobile-authenticator-POC/demoBackend/src/demo-website/dist/js/app.c2a68e49.js.map

{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./src/App.vue","webpack:///./src/App.vue?76db","webpack:///./src/views/Login.vue","webpack:///./src/components/Login.vue","webpack:///./src/components/Login.vue?ddd8","webpack:///./src/components/Navbar.vue","webpack:///./src/components/Navbar.vue?e67d","webpack:///./src/views/Login.vue?884f","webpack:///./src/views/Welcome.vue","webpack:///./src/components/Welcome.vue","webpack:///./src/components/Welcome.vue?df7b","webpack:///./src/views/Welcome.vue?d30e","webpack:///./src/router/index.js","webpack:///./src/main.js","webpack:///./src/components/Login.vue?a1a1","webpack:///./src/components/Welcome.vue?6450","webpack:///./src/web-eid.js","webpack:///./src/components/Navbar.vue?a4cd","webpack:///./src/App.vue?68df"],"names":["webpackJsonpCallback","data","moduleId","chunkId","chunkIds","moreModules","executeModules","i","resolves","length","Object","prototype","hasOwnProperty","call","installedChunks","push","modules","parentJsonpFunction","shift","deferredModules","apply","checkDeferredModules","result","deferredModule","fulfilled","j","depId","splice","__webpack_require__","s","installedModules","exports","module","l","m","c","d","name","getter","o","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","p","jsonpArray","window","oldJsonpFunction","slice","script","__exports__","render","class","href","id","role","aria-label","for","type","authenticate","loading","autocomplete","useCardReader","checked","useApp","props","String","useAndroidApp","methods","this","options","getAuthChallengeUrl","location","origin","postAuthTokenUrl","getAuthSuccessUrl","useAuthApp","headers","$store","getters","getSessionId","console","log","response","commit","alert","message","computed","isLoggedIn","getAuthenticated","logOut","requestOptions","method","body","JSON","stringify","fetch","then","mounted","sessionId","$cookie","getCookie","dispatch","components","LoginComponent","Login","Navbar","csrf_token","WelcomeComponent","Welcome","routes","path","component","meta","requiresAuth","router","createRouter","history","createWebHistory","process","store","createStore","state","authenticated","jSessionId","mutations","setLoggedIn","setSessionId","actions","fetchSessionId","context","plugins","createPersistedState","beforeEach","to","from","next","matched","some","record","app","createApp","App","use","BootstrapVue3","VueCookieNext","mount","config","expire","ErrorCode","config$1","freeze","VERSION","EXTENSION_HANDSHAKE_TIMEOUT","NATIVE_APP_HANDSHAKE_TIMEOUT","DEFAULT_USER_INTERACTION_TIMEOUT","DEFAULT_SERVER_REQUEST_TIMEOUT","AUTH_APP_INTENT_URL_BASE","Action","ErrorCode$1","Action$1","CertificateChangedError","constructor","code","ERR_WEBEID_CERTIFICATE_CHANGED","Error","OriginMismatchError","ERR_WEBEID_ORIGIN_MISMATCH","SECURE_CONTEXTS_INFO_URL","ContextInsecureError","ERR_WEBEID_CONTEXT_INSECURE","ExtensionUnavailableError","ERR_WEBEID_EXTENSION_UNAVAILABLE","ActionPendingError","ERR_WEBEID_ACTION_PENDING","NativeInvalidArgumentError","ERR_WEBEID_NATIVE_INVALID_ARGUMENT","NativeFatalError","ERR_WEBEID_NATIVE_FATAL","NativeUnavailableError","ERR_WEBEID_NATIVE_UNAVAILABLE","ServerRejectedError","ERR_WEBEID_SERVER_REJECTED","UserTimeoutError","ERR_WEBEID_USER_TIMEOUT","UserCancelledError","ERR_WEBEID_USER_CANCELLED","tmpl","strings","requiresUpdate","VersionMismatchError","versions","extension","nativeApp","ERR_WEBEID_VERSION_MISMATCH","library","assign","TlsConnectionBrokenError","ERR_WEBEID_TLS_CONNECTION_BROKEN","TlsConnectionInsecureError","ERR_WEBEID_TLS_CONNECTION_INSECURE","TlsConnectionWeakError","ERR_WEBEID_TLS_CONNECTION_WEAK","ProtocolInsecureError","ERR_WEBEID_PROTOCOL_INSECURE","ActionTimeoutError","ERR_WEBEID_ACTION_TIMEOUT","VersionInvalidError","ERR_WEBEID_VERSION_INVALID","ServerTimeoutError","ERR_WEBEID_SERVER_TIMEOUT","UnknownError","ERR_WEBEID_UNKNOWN_ERROR","errorCodeToErrorClass","deserializeError","errorObject","error","CustomError","entries","MissingParameterError","ERR_WEBEID_MISSING_PARAMETER","IntentUrl","action","postPrepareSigningUrl","postFinalizeSigningUrl","applicationName","actionDescription","userInteractionTimeout","serverRequestTimeout","lang","validate","url","encodeURIComponent","AuthAppNotInstalledError","AUTH_APP_NOT_INSTALLED","Ecc","ordinal","formatBits","LOW","MEDIUM","QUARTILE","HIGH","Mode","modeBits","numBitsCharCount","ver","Math","floor","appendBits","val","len","bb","getBit","x","assert","cond","toSvgString","qr","border","lightColor","darkColor","parts","y","size","getModule","join","NUMERIC","ALPHANUMERIC","BYTE","KANJI","ECI","QrSegment","numChars","bitData","b","digits","isNumeric","min","parseInt","substr","text","isAlphanumeric","temp","ALPHANUMERIC_CHARSET","indexOf","charAt","makeNumeric","makeAlphanumeric","makeBytes","toUtf8ByteArray","assignVal","NUMERIC_REGEX","test","ALPHANUMERIC_REGEX","segs","version","seg","ccbits","numCharCountBits","Infinity","str","encodeURI","charCodeAt","QrCode","errorCorrectionLevel","dataCodewords","msk","isFunction","MIN_VERSION","MAX_VERSION","row","drawFunctionPatterns","allCodewords","addEccAndInterleave","drawCodewords","minPenalty","applyMask","drawFormatBits","penalty","getPenaltyScore","mask","setFunctionModule","drawFinderPattern","alignPatPos","getAlignmentPatternPositions","numAlign","drawAlignmentPattern","drawVersion","rem","bits","color","a","dy","dx","dist","max","abs","xx","yy","isDark","ecl","getNumDataCodewords","numBlocks","NUM_ERROR_CORRECTION_BLOCKS","blockEccLen","ECC_CODEWORDS_PER_BLOCK","rawCodewords","getNumRawDataModules","numShortBlocks","shortBlockLen","blocks","rsDiv","reedSolomonComputeDivisor","k","dat","ecc","reedSolomonComputeRemainder","concat","forEach","block","right","vert","upward","invert","runColor","runX","runHistory","PENALTY_N1","finderPenaltyAddHistory","finderPenaltyCountPatterns","PENALTY_N3","finderPenaltyTerminateAndCount","runY","PENALTY_N2","dark","reduce","sum","total","ceil","PENALTY_N4","step","pos","core","currentRunColor","currentRunLength","pop","unshift","makeSegments","encodeSegments","dataUsedBits","minVersion","maxVersion","boostEcl","dataCapacityBits","usedBits","getTotalBits","newEcl","getData","padByte","degree","root","reedSolomonMultiply","divisor","map","factor","coef","z","_blobConstructor","xhr","hasFetch","isFunction$1","global","ReadableStream","blobConstructor","Blob","ArrayBuffer","e","checkTypeSupport","XMLHttpRequest","open","host","responseType","haveArrayBuffer","haveSlice","arraybuffer","msstream","mozchunkedarraybuffer","overrideMimeType","vbArray","VBArray","defaultSetTimout","defaultClearTimeout","cachedSetTimeout","cachedClearTimeout","runTimeout","fun","setTimeout","runClearTimeout","marker","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","nextTick","args","Array","arguments","Item","array","title","platform","browser","env","argv","release","noop","on","addListener","once","off","removeListener","removeAllListeners","emit","binding","cwd","chdir","dir","umask","performance","performanceNow","now","mozNow","msNow","oNow","webkitNow","Date","getTime","hrtime","previousTimestamp","clocktime","seconds","nanoseconds","startTime","uptime","currentTime","dif","inherits","browser$1","ctor","superCtor","super_","writable","configurable","TempCtor","inherits$1","formatRegExp","format$1","f","isString","objects","inspect","replace","Number","_","isNull","isObject","deprecate","fn","msg","isUndefined","noDeprecation","warned","deprecated","debugEnviron","domain","debugs","debuglog","set","toUpperCase","RegExp","pid","obj","opts","ctx","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","customInspect","stylizeWithColor","formatValue","styleType","style","styles","arrayToHash","hash","idx","recurseTimes","ret","primitive","formatPrimitive","keys","visibleKeys","getOwnPropertyNames","isError","formatError","isRegExp","toString","isDate","output","base","braces","isArray$2","toUTCString","formatArray","formatProperty","reduceToSingleString","simple","isNumber","hasOwnProperty$1","match","desc","getOwnPropertyDescriptor","split","line","prev","cur","ar","isArray","arg","isNullOrUndefined","re","objectToString","add","prop","EventHandlers","EventEmitter","init","$getMaxListeners","that","undefined","_maxListeners","defaultMaxListeners","emitNone","handler","isFn","self","listeners","arrayClone","emitOne","arg1","emitTwo","arg2","emitThree","arg3","emitMany","_addListener","target","listener","prepend","events","existing","TypeError","_events","newListener","_eventsCount","w","emitter","count","emitWarning","warn","_onceWrap","fired","g","listenerCount$1","evlistener","spliceOne","list","index","arr","copy","unwrapListeners","usingDomains","active","getPrototypeOf","setMaxListeners","isNaN","getMaxListeners","er","doError","err","domainEmitter","domainThrown","prependListener","prependOnceListener","position","originalListener","listenerCount","eventNames","Reflect","ownKeys","lookup","revLookup","Arr","Uint8Array","inited","toByteArray","b64","tmp","placeHolders","L","tripletToBase64","num","encodeChunk","uint8","start","end","fromByteArray","extraBytes","maxChunkLength","len2","read","buffer","offset","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","pow","write","rt","LN2","isArray$1","INSPECT_MAX_BYTES","kMaxLength","Buffer$1","TYPED_ARRAY_SUPPORT","createBuffer","RangeError","__proto__","encodingOrOffset","allocUnsafe","fromArrayBuffer","fromString","fromObject","assertSize","alloc","fill","encoding","string","isEncoding","byteLength","actual","fromArrayLike","byteOffset","internalIsBuffer","isnan","_isBuffer","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","buf","readUInt16BE","foundIndex","found","hexWrite","remaining","strLen","parsed","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","poolSize","_augment","allocUnsafeSlow","isBuffer","compare","swap16","swap32","swap64","equals","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","MAX_ARGUMENTS_LENGTH","codePoints","fromCharCode","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","subarray","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","base64clean","stringtrim","trim","units","leadSurrogate","byteArray","hi","lo","src","dst","isFastBuffer","isSlowBuffer","BufferList","head","tail","v","entry","clear","isBufferEncoding","assertEncoding","StringDecoder","surrogateSize","detectIncompleteChar","utf16DetectIncompleteChar","base64DetectIncompleteChar","passThroughWrite","charBuffer","charReceived","charLength","charStr","available","charCode","substring","cr","enc","Readable","ReadableState","debug","event","stream","objectMode","Duplex","readableObjectMode","hwm","highWaterMark","defaultHwm","pipes","pipesCount","flowing","ended","endEmitted","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","defaultEncoding","ranOut","awaitDrain","readingMore","decoder","_readableState","readable","_read","readableAddChunk","chunk","addToFront","chunkInvalid","onEofChunk","_e","skipAdd","emitReadable","maybeReadMore","needMoreData","Buffer","isPaused","setEncoding","MAX_HWM","computeNewHighWaterMark","howMuchToRead","emitReadable_","flow","maybeReadMore_","pipeOnDrain","nReadingNextTick","resume","resume_","fromList","fromListPartial","hasStrings","copyFromBufferString","copyFromBuffer","nb","endReadable","endReadableNT","xs","nop","WriteReq","cb","callback","WritableState","getBuffer","writableObjectMode","needDrain","ending","finished","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writecb","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","errorEmitted","bufferedRequestCount","corkedRequestsFree","CorkedRequest","Writable","_writableState","_write","writev","_writev","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","last","doWrite","onwriteError","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","finishMaybe","holder","finish","prefinish","need","endWritable","_this","nOrig","doRead","pipe","dest","pipeOpts","doEnd","endFn","onend","cleanup","onunpipe","ondrain","cleanedUp","onclose","onfinish","onerror","ondata","increasedAwaitDrain","pause","unpipe","dests","_i","ev","wrap","paused","_fromList","current","cork","uncork","setDefaultEncoding","allowHalfOpen","onEndNT","TransformState","afterTransform","needTransform","transforming","writechunk","writeencoding","ts","_transformState","rs","Transform","transform","_transform","flush","_flush","done","ws","PassThrough","Stream","source","_isStdio","didOnEnd","destroy","rStates","UNSENT","OPENED","HEADERS_RECEIVED","LOADING","DONE","IncomingMessage","_mode","rawHeaders","trailers","rawTrailers","_fetchResponse","statusCode","status","statusMessage","statusText","header","_it","iterator","reader","getReader","_destroyed","_xhr","_pos","responseURL","getAllResponseHeaders","matches","_charset","mimeType","charsetMatch","toArrayBuffer","arrayCopy","decideMode","preferBinary","useFetch","ClientRequest","_opts","_body","_headers","auth","setHeader","_onFinish","_onXHRProgress","readyState","responseBody","toArray","responseText","newData","MSStreamReader","onprogress","onload","readAsArrayBuffer","unsafeHeaders","statusValid","lowerName","getHeader","removeHeader","headersObj","credentials","withCredentials","_connect","reason","setRequestHeader","_response","onreadystatechange","send","abort","flushHeaders","setNoDelay","setSocketKeepAlive","maxInt","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexNonASCII","regexSeparators","errors","baseMinusTMin","stringFromCharCode","map$1","mapDomain","labels","encoded","ucs2decode","extra","counter","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","encode","input","handledCPCount","basicLength","bias","q","currentValue","inputLength","handledCPCountPlusOne","baseMinusT","qMinusT","toASCII","stringifyPrimitive","sep","eq","objectKeys","ks","parse$1","qs","regexp","maxKeys","kstr","vstr","decodeURIComponent","Url","protocol","slashes","port","hostname","search","query","pathname","protocolPattern","portPattern","simplePathPattern","delims","unwise","autoEscape","nonHostChars","hostEndingChars","hostnameMaxLen","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","urlParse","parseQueryString","slashesDenoteHost","u","parse","queryIndex","splitter","uSplit","slashRegex","rest","simplePath","exec","hec","proto","lowerProto","atSign","hostEnd","parseHost","ipv6Hostname","hostparts","part","newpart","validParts","notHost","bit","h","ae","esc","escape","qm","format","request","defaultProtocol","req","resolve","relative","resolveObject","rel","relPath","tkeys","tk","tkey","rkeys","rk","rkey","authInHost","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","hasTrailingSlash","up","isAbsolute","IdentifierDiff","WebExtensionService","addEventListener","receive","_a","_b","_c","_d","suffix","initialAction","getInitialAction","pending","getPendingMessage","ackTimer","removeFromQueue","reject","Promise","isSecureContext","promise","onAckTimeout","replyTimer","onReplyTimeout","publishMessage","isAndroidDevice","launchAuthApp","displayQRCode","pollForLoginSuccess","postMessage","intentUrl","document","sendAckMessage","hidden","getRelevantAckAction","removeEventListener","qrCode","qr0","encodeText","svg","canvas","getElementById","innerHTML","startsWith","milliseconds","sleep","navigator","userAgent","ackAction","AUTHENTICATE","AUTHENTICATE_ACK","SIGN","SIGN_ACK","STATUS","STATUS_ACK","authApp","find","pm","filter","defer","webExtensionService"],"mappings":"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","file":"js/app.c2a68e49.js","sourcesContent":[" \t// install a JSONP callback for chunk loading\n \tfunction webpackJsonpCallback(data) {\n \t\tvar chunkIds = data[0];\n \t\tvar moreModules = data[1];\n \t\tvar executeModules = data[2];\n\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [];\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(data);\n\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n\n \t\t// add entry modules from loaded chunk to deferred list\n \t\tdeferredModules.push.apply(deferredModules, executeModules || []);\n\n \t\t// run deferred modules when all chunks ready\n \t\treturn checkDeferredModules();\n \t};\n \tfunction checkDeferredModules() {\n \t\tvar result;\n \t\tfor(var i = 0; i < deferredModules.length; i++) {\n \t\t\tvar deferredModule = deferredModules[i];\n \t\t\tvar fulfilled = true;\n \t\t\tfor(var j = 1; j < deferredModule.length; j++) {\n \t\t\t\tvar depId = deferredModule[j];\n \t\t\t\tif(installedChunks[depId] !== 0) fulfilled = false;\n \t\t\t}\n \t\t\tif(fulfilled) {\n \t\t\t\tdeferredModules.splice(i--, 1);\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = deferredModule[0]);\n \t\t\t}\n \t\t}\n\n \t\treturn result;\n \t}\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded and loading chunks\n \t// undefined = chunk not loaded, null = chunk preloaded/prefetched\n \t// Promise = chunk loading, 0 = chunk loaded\n \tvar installedChunks = {\n \t\t\"app\": 0\n \t};\n\n \tvar deferredModules = [];\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/\";\n\n \tvar jsonpArray = window[\"webpackJsonp\"] = window[\"webpackJsonp\"] || [];\n \tvar oldJsonpFunction = jsonpArray.push.bind(jsonpArray);\n \tjsonpArray.push = webpackJsonpCallback;\n \tjsonpArray = jsonpArray.slice();\n \tfor(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);\n \tvar parentJsonpFunction = oldJsonpFunction;\n\n\n \t// add entry module to deferred list\n \tdeferredModules.push([0,\"chunk-vendors\"]);\n \t// run deferred modules when ready\n \treturn checkDeferredModules();\n","<template>\r\n  <router-view/>\r\n</template>\r\n\r\n<style>\r\n#app {\r\n  font-family: Avenir, Helvetica, Arial, sans-serif;\r\n  -webkit-font-smoothing: antialiased;\r\n  -moz-osx-font-smoothing: grayscale;\r\n  text-align: center;\r\n  color: #2c3e50;\r\n}\r\n\r\n#nav {\r\n  padding: 30px;\r\n}\r\n\r\n#nav a {\r\n  font-weight: bold;\r\n  color: #2c3e50;\r\n}\r\n\r\n#nav a.router-link-exact-active {\r\n  color: #42b983;\r\n}\r\n</style>\r\n","import { render } from \"./App.vue?vue&type=template&id=4d88d202\"\nconst script = {}\n\nimport \"./App.vue?vue&type=style&index=0&id=4d88d202&lang=css\"\n\nimport exportComponent from \"C:\\\\Development\\\\School\\\\5th_semester\\\\Tarkvaraprojekt\\\\Estonian-ID-card-mobile-authenticator-POC\\\\demoBackend\\\\src\\\\demo-website\\\\node_modules\\\\vue-loader-v16\\\\dist\\\\exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render]])\n\nexport default __exports__","<template>\r\n  <Navbar/>\r\n  <LoginComponent/>\r\n</template>\r\n\r\n<script>\r\nimport LoginComponent from '@/components/Login'\r\nimport Navbar from \"@/components/Navbar\";\r\n\r\nexport default {\r\n  name: 'Login',\r\n  components: {\r\n    LoginComponent,\r\n    Navbar\r\n  },\r\n  methods: {\r\n    csrf_token: function () {\r\n      return \"csrf-token\";\r\n    }\r\n  }\r\n}\r\n</script>\r\n","<template>\r\n  <div class=\"container container-md d-flex flex-column\">\r\n    <div>\r\n      <h3 class=\"text-center\">Welcome to Estonian ID card mobile authentication demo website. When using an Android mobile phone, you can\r\n        log in to the\r\n        website using your ID card by using the button below.</h3>\r\n\r\n      <p class=\"text-center\">Read more from <a href=\"https://github.com/TanelOrumaa/Estonian-ID-card-mobile-authenticator-POC\">here.</a></p>\r\n    </div>\r\n    <div id=\"canvas\"></div>\r\n    <div class=\"justify-content-center d-flex\">\r\n\r\n      <button type=\"button\" class=\"btn loginButton btn-dark\" v-on:click=\"authenticate\">\r\n        <div v-if=\"loading\" class=\"d-flex justify-content-center\">\r\n          <div class=\"spinner-border text-light spinner-border-sm\" role=\"status\">\r\n            <span class=\"visually-hidden\">Loading...</span>\r\n          </div>\r\n        </div>\r\n        <span v-else>Authenticate</span>\r\n      </button>\r\n\r\n    </div>\r\n    <div class=\"btn-group-sm d-flex justify-content-center\" role=\"group\" aria-label=\"Basic radio toggle button group\">\r\n      <input type=\"radio\" class=\"btn-check\" name=\"btnradio\" id=\"btnCardReader\" autocomplete=\"off\" v-on:click=\"useCardReader\">\r\n      <label class=\"btn btn-outline-secondary\" for=\"btnCardReader\">using ID-card reader</label>\r\n\r\n      <input type=\"radio\" class=\"btn-check\" name=\"btnradio\" id=\"btnApp\" autocomplete=\"off\" checked v-on:click=\"useApp\">\r\n      <label class=\"btn btn-outline-secondary\" for=\"btnApp\">using Android App</label>\r\n    </div>\r\n\r\n  </div>\r\n\r\n</template>\r\n\r\n\r\n<script>\r\nimport * as webeid from '../web-eid.js';\r\nimport router from \"@/router\";\r\n\r\nexport default {\r\n  name: 'LoginComponent',\r\n  props: {\r\n    \"csrftoken\": String,\r\n    \"csrfHeaderName\": String,\r\n  },\r\n  data() {\r\n    return {\r\n      useAndroidApp: true,\r\n      loading: false,\r\n    }\r\n  },\r\n  methods: {\r\n    useApp: function() {\r\n      this.useAndroidApp = true;\r\n    },\r\n\r\n    useCardReader: function() {\r\n      this.useAndroidApp = false;\r\n    },\r\n\r\n    authenticate: async function () {\r\n      this.loading = true;\r\n\r\n      const options = {\r\n        getAuthChallengeUrl: window.location.origin + \"/auth/challenge\",\r\n        postAuthTokenUrl: window.location.origin + \"/auth/login\",\r\n        getAuthSuccessUrl: window.location.origin + \"/auth/login\",\r\n        useAuthApp: this.useAndroidApp,\r\n        headers: {\r\n          \"sessionId\": this.$store.getters.getSessionId\r\n        },\r\n\r\n      };\r\n\r\n      console.log(options);\r\n\r\n      try {\r\n        const response = await webeid.authenticate(options);\r\n        console.log(\"Authentication successful! Response:\", response);\r\n        this.loading = false;\r\n        this.$store.commit(\"setLoggedIn\", true);\r\n        await router.push(\"welcome\");\r\n\r\n      } catch (error) {\r\n        console.log(\"Authentication failed! Error:\", error);\r\n        alert(error.message);\r\n        this.loading = false;\r\n        throw error;\r\n      }\r\n    }\r\n  },\r\n  computed: {\r\n    isLoggedIn() {\r\n      return this.$store.getAuthenticated;\r\n    },\r\n    loading() {\r\n      return this.loading;\r\n    }\r\n  }\r\n}\r\n</script>\r\n\r\n<style scoped>\r\n.container > div {\r\n  margin-top: 2vh;\r\n}\r\n.loginButton {\r\n  height: 4vh;\r\n  width: 20vh;\r\n  line-height: 3vh;\r\n}\r\n\r\n.loginButton > p {\r\n  font-size: 3vh;\r\n  text-align: center;\r\n}\r\n\r\n#canvas {\r\n  height: 30vh;\r\n  width: 30vh;\r\n}\r\n</style>\r\n","import { render } from \"./Login.vue?vue&type=template&id=2dcb24ca&scoped=true\"\nimport script from \"./Login.vue?vue&type=script&lang=js\"\nexport * from \"./Login.vue?vue&type=script&lang=js\"\n\nimport \"./Login.vue?vue&type=style&index=0&id=2dcb24ca&scoped=true&lang=css\"\n\nimport exportComponent from \"C:\\\\Development\\\\School\\\\5th_semester\\\\Tarkvaraprojekt\\\\Estonian-ID-card-mobile-authenticator-POC\\\\demoBackend\\\\src\\\\demo-website\\\\node_modules\\\\vue-loader-v16\\\\dist\\\\exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render],['__scopeId',\"data-v-2dcb24ca\"]])\n\nexport default __exports__","<template>\r\n  <!-- As a heading -->\r\n  <nav class=\"navbar navbar-dark bg-dark container-fluid flex-row\">\r\n    <div class=\"\">\r\n      <span class=\"navbar-brand mb-0 h1\">Mobile authentication demo</span>\r\n    </div>\r\n    <div v-if=\"isLoggedIn\" class=\"nav-item\">\r\n      <button type=\"button\" class=\"btn btn-light\" v-on:click=\"logOut\">Log out</button>\r\n    </div>\r\n  </nav>\r\n</template>\r\n\r\n<script>\r\nimport router from \"@/router\";\r\n\r\nexport default {\r\n  name: \"Navbar\",\r\n  computed: {\r\n    isLoggedIn() {\r\n      return this.$store.getters.getAuthenticated;\r\n    }\r\n  },\r\n  methods: {\r\n    logOut: function () {\r\n\r\n      const requestOptions = {\r\n        method: \"POST\",\r\n        headers: {\"Content-Type\": \"application/json\"},\r\n        body: JSON.stringify({\"sessionId\": this.$store.getters.getSessionId})\r\n      };\r\n      fetch(\"/auth/logout\", requestOptions)\r\n          .then((response) => {\r\n                console.log(response);\r\n                this.$store.commit(\"setLoggedIn\", false);\r\n                router.push(\"/\");\r\n              }\r\n          )\r\n    }\r\n  },\r\n  mounted() {\r\n    if (this.$store.getters.getSessionId == null) {\r\n      const sessionId = this.$cookie.getCookie(\"JSESSIONID\");\r\n      this.$store.dispatch(\"fetchSessionId\", sessionId);\r\n    }\r\n  }\r\n}\r\n</script>\r\n\r\n<style scoped>\r\nnav {\r\n  height: 5vh;\r\n}\r\n</style>","import { render } from \"./Navbar.vue?vue&type=template&id=21165a6a&scoped=true\"\nimport script from \"./Navbar.vue?vue&type=script&lang=js\"\nexport * from \"./Navbar.vue?vue&type=script&lang=js\"\n\nimport \"./Navbar.vue?vue&type=style&index=0&id=21165a6a&scoped=true&lang=css\"\n\nimport exportComponent from \"C:\\\\Development\\\\School\\\\5th_semester\\\\Tarkvaraprojekt\\\\Estonian-ID-card-mobile-authenticator-POC\\\\demoBackend\\\\src\\\\demo-website\\\\node_modules\\\\vue-loader-v16\\\\dist\\\\exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render],['__scopeId',\"data-v-21165a6a\"]])\n\nexport default __exports__","import { render } from \"./Login.vue?vue&type=template&id=24ee8480\"\nimport script from \"./Login.vue?vue&type=script&lang=js\"\nexport * from \"./Login.vue?vue&type=script&lang=js\"\n\nimport exportComponent from \"C:\\\\Development\\\\School\\\\5th_semester\\\\Tarkvaraprojekt\\\\Estonian-ID-card-mobile-authenticator-POC\\\\demoBackend\\\\src\\\\demo-website\\\\node_modules\\\\vue-loader-v16\\\\dist\\\\exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render]])\n\nexport default __exports__","<template>\r\n  <Navbar/>\r\n  <WelcomeComponent/>\r\n</template>\r\n\r\n<script>\r\nimport WelcomeComponent from '@/components/Welcome'\r\nimport Navbar from \"@/components/Navbar\";\r\n\r\nexport default {\r\n  name: 'Welcome',\r\n  components: {\r\n    WelcomeComponent,\r\n    Navbar\r\n  },\r\n  methods: {\r\n    csrf_token: function () {\r\n      return \"csrf-token\";\r\n    }\r\n  }\r\n}\r\n</script>\r\n","<template>\r\n  <div class=\"container container-md d-flex flex-column\">\r\n    <div>\r\n      <h3 class=\"text-center\">Congratulations, you logged into the site. Log out to try again.</h3>\r\n      <p class=\"text-center\">Read more from <a href=\"https://github.com/TanelOrumaa/Estonian-ID-card-mobile-authenticator-POC\">here.</a></p>\r\n    </div>\r\n  </div>\r\n\r\n</template>\r\n\r\n\r\n<script>\r\nexport default {\r\n  name: 'WelcomeComponent',\r\n  props: {\r\n    \"csrftoken\": String,\r\n  },\r\n  computed: {\r\n    isLoggedIn() {\r\n      return this.$store.getters.getAuthenticated;\r\n    }\r\n  }\r\n}\r\n</script>\r\n\r\n<style scoped>\r\ndiv {\r\n  margin-top: 2vh;\r\n}\r\n</style>\r\n","import { render } from \"./Welcome.vue?vue&type=template&id=cd8fea1a&scoped=true\"\nimport script from \"./Welcome.vue?vue&type=script&lang=js\"\nexport * from \"./Welcome.vue?vue&type=script&lang=js\"\n\nimport \"./Welcome.vue?vue&type=style&index=0&id=cd8fea1a&scoped=true&lang=css\"\n\nimport exportComponent from \"C:\\\\Development\\\\School\\\\5th_semester\\\\Tarkvaraprojekt\\\\Estonian-ID-card-mobile-authenticator-POC\\\\demoBackend\\\\src\\\\demo-website\\\\node_modules\\\\vue-loader-v16\\\\dist\\\\exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render],['__scopeId',\"data-v-cd8fea1a\"]])\n\nexport default __exports__","import { render } from \"./Welcome.vue?vue&type=template&id=0efb1aac\"\nimport script from \"./Welcome.vue?vue&type=script&lang=js\"\nexport * from \"./Welcome.vue?vue&type=script&lang=js\"\n\nimport exportComponent from \"C:\\\\Development\\\\School\\\\5th_semester\\\\Tarkvaraprojekt\\\\Estonian-ID-card-mobile-authenticator-POC\\\\demoBackend\\\\src\\\\demo-website\\\\node_modules\\\\vue-loader-v16\\\\dist\\\\exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render]])\n\nexport default __exports__","import { createRouter, createWebHistory } from 'vue-router'\r\nimport Login from '@/views/Login.vue'\r\nimport Welcome from \"@/views/Welcome\";\r\n\r\nconst routes = [\r\n  {\r\n    path: '/',\r\n    name: 'Login',\r\n    component: Login,\r\n    meta: {\r\n      requiresAuth: false\r\n    }\r\n  },\r\n  {\r\n    path: '/welcome',\r\n    name: 'Welcome',\r\n    component: Welcome,\r\n    meta: {\r\n      requiresAuth: true\r\n    }\r\n  }\r\n]\r\n\r\nconst router = createRouter({\r\n  history: createWebHistory(process.env.BASE_URL),\r\n  routes\r\n})\r\n\r\n\r\n\r\nexport default router\r\n","import {createApp} from 'vue';\r\nimport App from './App.vue';\r\nimport {createStore} from 'vuex';\r\nimport BootstrapVue3 from 'bootstrap-vue-3';\r\nimport createPersistedState from \"vuex-persistedstate\";\r\nimport { VueCookieNext } from 'vue-cookie-next'\r\n\r\n\r\nimport 'bootstrap/dist/css/bootstrap.css'\r\nimport 'bootstrap-vue-3/dist/bootstrap-vue-3.css'\r\nimport router from \"./router/index\";\r\n\r\n// Create a new store instance.\r\nconst store = createStore({\r\n    state() {\r\n        return {\r\n            authenticated: false,\r\n            jSessionId: null,\r\n        }\r\n    },\r\n    mutations: {\r\n        setLoggedIn(state, isLoggedIn) {\r\n            state.authenticated = isLoggedIn;\r\n        },\r\n        setSessionId(state, sessionId) {\r\n            state.jSessionId = sessionId;\r\n        }\r\n    },\r\n    actions: {\r\n        fetchSessionId(context, sessionId) {\r\n            context.commit(\"setSessionId\", sessionId);\r\n        }\r\n    },\r\n    getters: {\r\n        getAuthenticated: state => {\r\n            return state.authenticated;\r\n        },\r\n        getSessionId: state => {\r\n            return state.jSessionId;\r\n        }\r\n    },\r\n    plugins: [createPersistedState()],\r\n})\r\n\r\nrouter.beforeEach((to, from, next) => {\r\n    if (to.matched.some(record => record.meta.requiresAuth)) {\r\n        // this route requires auth, check if logged in\r\n        // if not, redirect to login page.\r\n        if (!store.state.authenticated) {\r\n            next({name: 'Login'})\r\n        } else {\r\n            next() // go to wherever I'm going\r\n        }\r\n    } else {\r\n        next() // does not require auth, make sure to always call next()!\r\n    }\r\n})\r\n\r\nconst app = createApp(App)\r\napp.use(BootstrapVue3)\r\napp.use(router)\r\napp.use(store)\r\napp.use(VueCookieNext);\r\napp.mount('#app')\r\n\r\nVueCookieNext.config({ expire: '7d' })\r\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../node_modules/vue-loader-v16/dist/index.js??ref--1-0!./Login.vue?vue&type=style&index=0&id=2dcb24ca&scoped=true&lang=css\"","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../node_modules/vue-loader-v16/dist/index.js??ref--1-0!./Welcome.vue?vue&type=style&index=0&id=cd8fea1a&scoped=true&lang=css\"","/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nvar config$1 = Object.freeze({\r\n    VERSION: \"1.0.1\",\r\n    EXTENSION_HANDSHAKE_TIMEOUT: 1000,\r\n    NATIVE_APP_HANDSHAKE_TIMEOUT: 5 * 1000,\r\n    DEFAULT_USER_INTERACTION_TIMEOUT: 2 * 60 * 1000,\r\n    DEFAULT_SERVER_REQUEST_TIMEOUT: 20 * 1000,\r\n    AUTH_APP_INTENT_URL_BASE: \"authapp://start/\",\r\n});\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nvar ErrorCode;\r\n(function (ErrorCode) {\r\n    // Timeout errors\r\n    ErrorCode[\"ERR_WEBEID_ACTION_TIMEOUT\"] = \"ERR_WEBEID_ACTION_TIMEOUT\";\r\n    ErrorCode[\"ERR_WEBEID_USER_TIMEOUT\"] = \"ERR_WEBEID_USER_TIMEOUT\";\r\n    ErrorCode[\"ERR_WEBEID_SERVER_TIMEOUT\"] = \"ERR_WEBEID_SERVER_TIMEOUT\";\r\n    // Health errors\r\n    ErrorCode[\"ERR_WEBEID_VERSION_MISMATCH\"] = \"ERR_WEBEID_VERSION_MISMATCH\";\r\n    ErrorCode[\"ERR_WEBEID_VERSION_INVALID\"] = \"ERR_WEBEID_VERSION_INVALID\";\r\n    ErrorCode[\"ERR_WEBEID_EXTENSION_UNAVAILABLE\"] = \"ERR_WEBEID_EXTENSION_UNAVAILABLE\";\r\n    ErrorCode[\"ERR_WEBEID_NATIVE_UNAVAILABLE\"] = \"ERR_WEBEID_NATIVE_UNAVAILABLE\";\r\n    ErrorCode[\"ERR_WEBEID_UNKNOWN_ERROR\"] = \"ERR_WEBEID_UNKNOWN_ERROR\";\r\n    ErrorCode[\"AUTH_APP_NOT_INSTALLED\"] = \"AUTH_APP_NOT_INSTALLED\";\r\n    // Security errors\r\n    ErrorCode[\"ERR_WEBEID_CONTEXT_INSECURE\"] = \"ERR_WEBEID_CONTEXT_INSECURE\";\r\n    ErrorCode[\"ERR_WEBEID_PROTOCOL_INSECURE\"] = \"ERR_WEBEID_PROTOCOL_INSECURE\";\r\n    ErrorCode[\"ERR_WEBEID_TLS_CONNECTION_BROKEN\"] = \"ERR_WEBEID_TLS_CONNECTION_BROKEN\";\r\n    ErrorCode[\"ERR_WEBEID_TLS_CONNECTION_INSECURE\"] = \"ERR_WEBEID_TLS_CONNECTION_INSECURE\";\r\n    ErrorCode[\"ERR_WEBEID_TLS_CONNECTION_WEAK\"] = \"ERR_WEBEID_TLS_CONNECTION_WEAK\";\r\n    ErrorCode[\"ERR_WEBEID_CERTIFICATE_CHANGED\"] = \"ERR_WEBEID_CERTIFICATE_CHANGED\";\r\n    ErrorCode[\"ERR_WEBEID_ORIGIN_MISMATCH\"] = \"ERR_WEBEID_ORIGIN_MISMATCH\";\r\n    // Third party errors\r\n    ErrorCode[\"ERR_WEBEID_SERVER_REJECTED\"] = \"ERR_WEBEID_SERVER_REJECTED\";\r\n    ErrorCode[\"ERR_WEBEID_USER_CANCELLED\"] = \"ERR_WEBEID_USER_CANCELLED\";\r\n    ErrorCode[\"ERR_WEBEID_NATIVE_INVALID_ARGUMENT\"] = \"ERR_WEBEID_NATIVE_INVALID_ARGUMENT\";\r\n    ErrorCode[\"ERR_WEBEID_NATIVE_FATAL\"] = \"ERR_WEBEID_NATIVE_FATAL\";\r\n    // Developer mistakes\r\n    ErrorCode[\"ERR_WEBEID_ACTION_PENDING\"] = \"ERR_WEBEID_ACTION_PENDING\";\r\n    ErrorCode[\"ERR_WEBEID_MISSING_PARAMETER\"] = \"ERR_WEBEID_MISSING_PARAMETER\";\r\n})(ErrorCode || (ErrorCode = {}));\r\nvar ErrorCode$1 = ErrorCode;\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nvar Action;\r\n(function (Action) {\r\n    Action[\"STATUS\"] = \"web-eid:status\";\r\n    Action[\"STATUS_ACK\"] = \"web-eid:status-ack\";\r\n    Action[\"STATUS_SUCCESS\"] = \"web-eid:status-success\";\r\n    Action[\"STATUS_FAILURE\"] = \"web-eid:status-failure\";\r\n    Action[\"AUTHENTICATE\"] = \"web-eid:authenticate\";\r\n    Action[\"AUTHENTICATE_ACK\"] = \"web-eid:authenticate-ack\";\r\n    Action[\"AUTHENTICATE_SUCCESS\"] = \"web-eid:authenticate-success\";\r\n    Action[\"AUTHENTICATE_FAILURE\"] = \"web-eid:authenticate-failure\";\r\n    Action[\"SIGN\"] = \"web-eid:sign\";\r\n    Action[\"SIGN_ACK\"] = \"web-eid:sign-ack\";\r\n    Action[\"SIGN_SUCCESS\"] = \"web-eid:sign-success\";\r\n    Action[\"SIGN_FAILURE\"] = \"web-eid:sign-failure\";\r\n})(Action || (Action = {}));\r\nvar Action$1 = Action;\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass CertificateChangedError extends Error {\r\n    constructor(message = \"server certificate changed between requests\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_CERTIFICATE_CHANGED;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass OriginMismatchError extends Error {\r\n    constructor(message = \"URLs for a single operation require the same origin\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_ORIGIN_MISMATCH;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nconst SECURE_CONTEXTS_INFO_URL = \"https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts\";\r\nclass ContextInsecureError extends Error {\r\n    constructor(message = \"Secure context required, see \" + SECURE_CONTEXTS_INFO_URL) {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_CONTEXT_INSECURE;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass ExtensionUnavailableError extends Error {\r\n    constructor(message = \"Web-eID extension is not available\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_EXTENSION_UNAVAILABLE;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass ActionPendingError extends Error {\r\n    constructor(message = \"same action for Web-eID browser extension is already pending\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_ACTION_PENDING;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass NativeInvalidArgumentError extends Error {\r\n    constructor(message = \"native application received an invalid argument\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_NATIVE_INVALID_ARGUMENT;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass NativeFatalError extends Error {\r\n    constructor(message = \"native application terminated with a fatal error\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_NATIVE_FATAL;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass NativeUnavailableError extends Error {\r\n    constructor(message = \"Web-eID native application is not available\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_NATIVE_UNAVAILABLE;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass ServerRejectedError extends Error {\r\n    constructor(message = \"server rejected the request\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_SERVER_REJECTED;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass UserTimeoutError extends Error {\r\n    constructor(message = \"user failed to respond in time\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_USER_TIMEOUT;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass UserCancelledError extends Error {\r\n    constructor(message = \"request was cancelled by the user\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_USER_CANCELLED;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nfunction tmpl(strings, requiresUpdate) {\r\n    return `Update required for Web-eID ${requiresUpdate}`;\r\n}\r\nclass VersionMismatchError extends Error {\r\n    constructor(message, versions, requiresUpdate) {\r\n        if (!message) {\r\n            if (!requiresUpdate) {\r\n                message = \"requiresUpdate not provided\";\r\n            }\r\n            else if (requiresUpdate.extension && requiresUpdate.nativeApp) {\r\n                message = tmpl `${\"extension and native app\"}`;\r\n            }\r\n            else if (requiresUpdate.extension) {\r\n                message = tmpl `${\"extension\"}`;\r\n            }\r\n            else if (requiresUpdate.nativeApp) {\r\n                message = tmpl `${\"native app\"}`;\r\n            }\r\n        }\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_VERSION_MISMATCH;\r\n        this.requiresUpdate = requiresUpdate;\r\n        if (versions) {\r\n            const { library, extension, nativeApp } = versions;\r\n            Object.assign(this, { library, extension, nativeApp });\r\n        }\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass TlsConnectionBrokenError extends Error {\r\n    constructor(message = \"TLS connection was broken\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_TLS_CONNECTION_BROKEN;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass TlsConnectionInsecureError extends Error {\r\n    constructor(message = \"TLS connection was insecure\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_TLS_CONNECTION_INSECURE;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass TlsConnectionWeakError extends Error {\r\n    constructor(message = \"TLS connection was weak\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_TLS_CONNECTION_WEAK;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass ProtocolInsecureError extends Error {\r\n    constructor(message = \"HTTPS required\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_PROTOCOL_INSECURE;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass ActionTimeoutError extends Error {\r\n    constructor(message = \"extension message timeout\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_ACTION_TIMEOUT;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass VersionInvalidError extends Error {\r\n    constructor(message = \"invalid version string\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_VERSION_INVALID;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass ServerTimeoutError extends Error {\r\n    constructor(message = \"server failed to respond in time\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_SERVER_TIMEOUT;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass UnknownError extends Error {\r\n    constructor(message = \"an unknown error occurred\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_UNKNOWN_ERROR;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nconst errorCodeToErrorClass = {\r\n    [ErrorCode$1.ERR_WEBEID_ACTION_PENDING]: ActionPendingError,\r\n    [ErrorCode$1.ERR_WEBEID_ACTION_TIMEOUT]: ActionTimeoutError,\r\n    [ErrorCode$1.ERR_WEBEID_CERTIFICATE_CHANGED]: CertificateChangedError,\r\n    [ErrorCode$1.ERR_WEBEID_ORIGIN_MISMATCH]: OriginMismatchError,\r\n    [ErrorCode$1.ERR_WEBEID_CONTEXT_INSECURE]: ContextInsecureError,\r\n    [ErrorCode$1.ERR_WEBEID_EXTENSION_UNAVAILABLE]: ExtensionUnavailableError,\r\n    [ErrorCode$1.ERR_WEBEID_NATIVE_INVALID_ARGUMENT]: NativeInvalidArgumentError,\r\n    [ErrorCode$1.ERR_WEBEID_NATIVE_FATAL]: NativeFatalError,\r\n    [ErrorCode$1.ERR_WEBEID_NATIVE_UNAVAILABLE]: NativeUnavailableError,\r\n    [ErrorCode$1.ERR_WEBEID_PROTOCOL_INSECURE]: ProtocolInsecureError,\r\n    [ErrorCode$1.ERR_WEBEID_SERVER_REJECTED]: ServerRejectedError,\r\n    [ErrorCode$1.ERR_WEBEID_SERVER_TIMEOUT]: ServerTimeoutError,\r\n    [ErrorCode$1.ERR_WEBEID_TLS_CONNECTION_BROKEN]: TlsConnectionBrokenError,\r\n    [ErrorCode$1.ERR_WEBEID_TLS_CONNECTION_INSECURE]: TlsConnectionInsecureError,\r\n    [ErrorCode$1.ERR_WEBEID_TLS_CONNECTION_WEAK]: TlsConnectionWeakError,\r\n    [ErrorCode$1.ERR_WEBEID_USER_CANCELLED]: UserCancelledError,\r\n    [ErrorCode$1.ERR_WEBEID_USER_TIMEOUT]: UserTimeoutError,\r\n    [ErrorCode$1.ERR_WEBEID_VERSION_INVALID]: VersionInvalidError,\r\n    [ErrorCode$1.ERR_WEBEID_VERSION_MISMATCH]: VersionMismatchError,\r\n};\r\nfunction deserializeError(errorObject) {\r\n    let error;\r\n    if (typeof errorObject.code == \"string\" && errorObject.code in errorCodeToErrorClass) {\r\n        const CustomError = errorCodeToErrorClass[errorObject.code];\r\n        error = new CustomError();\r\n    }\r\n    else {\r\n        error = new UnknownError();\r\n    }\r\n    for (const [key, value] of Object.entries(errorObject)) {\r\n        error[key] = value;\r\n    }\r\n    return error;\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass MissingParameterError extends Error {\r\n    constructor(message) {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.ERR_WEBEID_MISSING_PARAMETER;\r\n    }\r\n}\r\n\r\nclass IntentUrl {\r\n    constructor(message) {\r\n        this.action = message.action;\r\n        if (message.getAuthChallengeUrl) {\r\n            this.getAuthChallengeUrl = message.getAuthChallengeUrl;\r\n        }\r\n        if (message.postAuthTokenUrl) {\r\n            this.postAuthTokenUrl = message.postAuthTokenUrl;\r\n        }\r\n        if (message.headers) {\r\n            this.headers = message.headers;\r\n        }\r\n        if (message.postPrepareSigningUrl) {\r\n            this.postPrepareSigningUrl = message.postPrepareSigningUrl;\r\n        }\r\n        if (message.postFinalizeSigningUrl) {\r\n            this.postFinalizeSigningUrl = message.postFinalizeSigningUrl;\r\n        }\r\n        if (message.applicationName) {\r\n            this.applicationName = message.applicationName;\r\n        }\r\n        if (message.actionDescription) {\r\n            this.actionDescription = message.actionDescription;\r\n        }\r\n        if (message.userInteractionTimeout) {\r\n            this.userInteractionTimeout = message.userInteractionTimeout;\r\n        }\r\n        if (message.serverRequestTimeout) {\r\n            this.serverRequestTimeout = message.serverRequestTimeout;\r\n        }\r\n        if (message.lang) {\r\n            this.lang = message.lang;\r\n        }\r\n        this.validate();\r\n    }\r\n    validate() {\r\n        if (this.action == null || ((this.getAuthChallengeUrl == null || this.postAuthTokenUrl == null) && (this.postFinalizeSigningUrl == null || this.postPrepareSigningUrl == null))) {\r\n            throw new MissingParameterError(\"Missing parameters for IntentUrl.\");\r\n        }\r\n    }\r\n    toString() {\r\n        let url = config$1.AUTH_APP_INTENT_URL_BASE;\r\n        url += \"?action=\\\"\" + this.action + \"\\\"\";\r\n        url += this.getAuthChallengeUrl ? \"&getAuthChallengeUrl=\\\"\" + encodeURIComponent(this.getAuthChallengeUrl) + \"\\\"\" : \"\";\r\n        url += this.postAuthTokenUrl ? \"&postAuthTokenUrl=\\\"\" + encodeURIComponent(this.postAuthTokenUrl) + \"\\\"\" : \"\";\r\n        url += this.postPrepareSigningUrl ? \"&postPrepareSigningUrl=\\\"\" + encodeURIComponent(this.postPrepareSigningUrl) + \"\\\"\" : \"\";\r\n        url += this.postFinalizeSigningUrl ? \"&postFinalizeSigningUrl=\\\"\" + encodeURIComponent(this.postFinalizeSigningUrl) + \"\\\"\" : \"\";\r\n        url += this.applicationName ? \"&applicationName=\\\"\" + encodeURIComponent(this.applicationName) + \"\\\"\" : \"\";\r\n        url += this.actionDescription ? \"&actionDescription=\\\"\" + encodeURIComponent(this.actionDescription) + \"\\\"\" : \"\";\r\n        url += this.headers ? \"&headers=\\\"\" + JSON.stringify(this.headers) + \"\\\"\" : \"\";\r\n        url += this.userInteractionTimeout ? \"&userInteractionTimeout=\\\"\" + this.userInteractionTimeout + \"\\\"\" : \"\";\r\n        url += this.serverRequestTimeout ? \"&serverRequestTimeout=\\\"\" + this.serverRequestTimeout + \"\\\"\" : \"\";\r\n        url += this.lang ? \"&lang=\\\"\" + this.lang + \"\\\"\" : \"\";\r\n        return url;\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass AuthAppNotInstalledError extends Error {\r\n    constructor(message = \"Authentication app is not installed. Install it from: https://github.com/TanelOrumaa/Estonian-ID-card-mobile-authenticator-POC/tree/main/MobileAuthApp\") {\r\n        super(message);\r\n        this.name = this.constructor.name;\r\n        this.code = ErrorCode$1.AUTH_APP_NOT_INSTALLED;\r\n    }\r\n}\r\n\r\n/*\r\n * QR Code generator library (TypeScript)\r\n *\r\n * Copyright (c) Project Nayuki. (MIT License)\r\n * https://www.nayuki.io/page/qr-code-generator-library\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy of\r\n * this software and associated documentation files (the \"Software\"), to deal in\r\n * the Software without restriction, including without limitation the rights to\r\n * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r\n * the Software, and to permit persons to whom the Software is furnished to do so,\r\n * subject to the following conditions:\r\n * - The above copyright notice and this permission notice shall be included in\r\n *   all copies or substantial portions of the Software.\r\n * - The Software is provided \"as is\", without warranty of any kind, express or\r\n *   implied, including but not limited to the warranties of merchantability,\r\n *   fitness for a particular purpose and noninfringement. In no event shall the\r\n *   authors or copyright holders be liable for any claim, damages or other\r\n *   liability, whether in an action of contract, tort or otherwise, arising from,\r\n *   out of or in connection with the Software or the use or other dealings in the\r\n *   Software.\r\n */\r\n/*\r\n * The error correction level in a QR Code symbol. Immutable.\r\n */\r\nclass Ecc {\r\n    /*-- Constructor and fields --*/\r\n    constructor(\r\n    // In the range 0 to 3 (unsigned 2-bit integer).\r\n    ordinal, \r\n    // (Package-private) In the range 0 to 3 (unsigned 2-bit integer).\r\n    formatBits) {\r\n        this.ordinal = ordinal;\r\n        this.formatBits = formatBits;\r\n    }\r\n}\r\n/*-- Constants --*/\r\nEcc.LOW = new Ecc(0, 1); // The QR Code can tolerate about  7% erroneous codewords\r\nEcc.MEDIUM = new Ecc(1, 0); // The QR Code can tolerate about 15% erroneous codewords\r\nEcc.QUARTILE = new Ecc(2, 3); // The QR Code can tolerate about 25% erroneous codewords\r\nEcc.HIGH = new Ecc(3, 2); // The QR Code can tolerate about 30% erroneous codewords\r\n\r\n/*\r\n * QR Code generator library (TypeScript)\r\n *\r\n * Copyright (c) Project Nayuki. (MIT License)\r\n * https://www.nayuki.io/page/qr-code-generator-library\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy of\r\n * this software and associated documentation files (the \"Software\"), to deal in\r\n * the Software without restriction, including without limitation the rights to\r\n * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r\n * the Software, and to permit persons to whom the Software is furnished to do so,\r\n * subject to the following conditions:\r\n * - The above copyright notice and this permission notice shall be included in\r\n *   all copies or substantial portions of the Software.\r\n * - The Software is provided \"as is\", without warranty of any kind, express or\r\n *   implied, including but not limited to the warranties of merchantability,\r\n *   fitness for a particular purpose and noninfringement. In no event shall the\r\n *   authors or copyright holders be liable for any claim, damages or other\r\n *   liability, whether in an action of contract, tort or otherwise, arising from,\r\n *   out of or in connection with the Software or the use or other dealings in the\r\n *   Software.\r\n */\r\n/*\r\n * Describes how a segment's data bits are interpreted. Immutable.\r\n */\r\nclass Mode {\r\n    /*-- Constructor and fields --*/\r\n    constructor(\r\n    // The mode indicator bits, which is a uint4 value (range 0 to 15).\r\n    modeBits, \r\n    // Number of character count bits for three different version ranges.\r\n    numBitsCharCount) {\r\n        this.modeBits = modeBits;\r\n        this.numBitsCharCount = numBitsCharCount;\r\n    }\r\n    /*-- Method --*/\r\n    // (Package-private) Returns the bit width of the character count field for a segment in\r\n    // this mode in a QR Code at the given version number. The result is in the range [0, 16].\r\n    numCharCountBits(ver) {\r\n        return this.numBitsCharCount[Math.floor((ver + 7) / 17)];\r\n    }\r\n}\r\n/*-- Constants --*/\r\nMode.NUMERIC = new Mode(0x1, [10, 12, 14]);\r\nMode.ALPHANUMERIC = new Mode(0x2, [9, 11, 13]);\r\nMode.BYTE = new Mode(0x4, [8, 16, 16]);\r\nMode.KANJI = new Mode(0x8, [8, 10, 12]);\r\nMode.ECI = new Mode(0x7, [0, 0, 0]);\r\n\r\n/*\r\n * QR Code generator library (TypeScript)\r\n *\r\n * Copyright (c) Project Nayuki. (MIT License)\r\n * https://www.nayuki.io/page/qr-code-generator-library\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy of\r\n * this software and associated documentation files (the \"Software\"), to deal in\r\n * the Software without restriction, including without limitation the rights to\r\n * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r\n * the Software, and to permit persons to whom the Software is furnished to do so,\r\n * subject to the following conditions:\r\n * - The above copyright notice and this permission notice shall be included in\r\n *   all copies or substantial portions of the Software.\r\n * - The Software is provided \"as is\", without warranty of any kind, express or\r\n *   implied, including but not limited to the warranties of merchantability,\r\n *   fitness for a particular purpose and noninfringement. In no event shall the\r\n *   authors or copyright holders be liable for any claim, damages or other\r\n *   liability, whether in an action of contract, tort or otherwise, arising from,\r\n *   out of or in connection with the Software or the use or other dealings in the\r\n *   Software.\r\n */\r\n// Appends the given number of low-order bits of the given value\r\n// to the given buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.\r\nfunction appendBits(val, len, bb) {\r\n    if (len < 0 || len > 31 || val >>> len != 0)\r\n        throw \"Value out of range\";\r\n    for (let i = len - 1; i >= 0; i--) // Append bit by bit\r\n        bb.push((val >>> i) & 1);\r\n}\r\n// Returns true iff the i'th bit of x is set to 1.\r\nfunction getBit(x, i) {\r\n    return ((x >>> i) & 1) != 0;\r\n}\r\n// Throws an exception if the given condition is false.\r\nfunction assert(cond) {\r\n    if (!cond)\r\n        throw \"Assertion error\";\r\n}\r\n// Returns a string of SVG code for an image depicting the given QR Code, with the given number\r\n// of border modules. The string always uses Unix newlines (\\n), regardless of the platform.\r\nfunction toSvgString(qr, border, lightColor, darkColor) {\r\n    if (border < 0)\r\n        throw \"Border must be non-negative\";\r\n    const parts = [];\r\n    for (let y = 0; y < qr.size; y++) {\r\n        for (let x = 0; x < qr.size; x++) {\r\n            if (qr.getModule(x, y))\r\n                parts.push(`M${x + border},${y + border}h1v1h-1z`);\r\n        }\r\n    }\r\n    return `<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 ${qr.size + border * 2} ${qr.size + border * 2}\" stroke=\"none\">\r\n\t<rect width=\"100%\" height=\"100%\" fill=\"${lightColor}\"/>\r\n\t<path d=\"${parts.join(\" \")}\" fill=\"${darkColor}\"/>\r\n</svg>`;\r\n}\r\n\r\n/*\r\n * QR Code generator library (TypeScript)\r\n *\r\n * Copyright (c) Project Nayuki. (MIT License)\r\n * https://www.nayuki.io/page/qr-code-generator-library\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy of\r\n * this software and associated documentation files (the \"Software\"), to deal in\r\n * the Software without restriction, including without limitation the rights to\r\n * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r\n * the Software, and to permit persons to whom the Software is furnished to do so,\r\n * subject to the following conditions:\r\n * - The above copyright notice and this permission notice shall be included in\r\n *   all copies or substantial portions of the Software.\r\n * - The Software is provided \"as is\", without warranty of any kind, express or\r\n *   implied, including but not limited to the warranties of merchantability,\r\n *   fitness for a particular purpose and noninfringement. In no event shall the\r\n *   authors or copyright holders be liable for any claim, damages or other\r\n *   liability, whether in an action of contract, tort or otherwise, arising from,\r\n *   out of or in connection with the Software or the use or other dealings in the\r\n *   Software.\r\n */\r\nclass QrSegment {\r\n    /*-- Constructor (low level) and fields --*/\r\n    // Creates a new QR Code segment with the given attributes and data.\r\n    // The character count (numChars) must agree with the mode and the bit buffer length,\r\n    // but the constraint isn't checked. The given bit buffer is cloned and stored.\r\n    constructor(\r\n    // The mode indicator of this segment.\r\n    mode, \r\n    // The length of this segment's unencoded data. Measured in characters for\r\n    // numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.\r\n    // Always zero or positive. Not the same as the data's bit length.\r\n    numChars, \r\n    // The data bits of this segment. Accessed through getData().\r\n    bitData) {\r\n        this.mode = mode;\r\n        this.numChars = numChars;\r\n        this.bitData = bitData;\r\n        if (numChars < 0)\r\n            throw \"Invalid argument\";\r\n        this.bitData = bitData.slice(); // Make defensive copy\r\n    }\r\n    /*-- Static factory functions (mid level) --*/\r\n    // Returns a segment representing the given binary data encoded in\r\n    // byte mode. All input byte arrays are acceptable. Any text string\r\n    // can be converted to UTF-8 bytes and encoded as a byte mode segment.\r\n    static makeBytes(data) {\r\n        const bb = [];\r\n        for (const b of data)\r\n            appendBits(b, 8, bb);\r\n        return new QrSegment(Mode.BYTE, data.length, bb);\r\n    }\r\n    // Returns a segment representing the given string of decimal digits encoded in numeric mode.\r\n    static makeNumeric(digits) {\r\n        if (!QrSegment.isNumeric(digits))\r\n            throw \"String contains non-numeric characters\";\r\n        const bb = [];\r\n        for (let i = 0; i < digits.length;) { // Consume up to 3 digits per iteration\r\n            const n = Math.min(digits.length - i, 3);\r\n            appendBits(parseInt(digits.substr(i, n), 10), n * 3 + 1, bb);\r\n            i += n;\r\n        }\r\n        return new QrSegment(Mode.NUMERIC, digits.length, bb);\r\n    }\r\n    // Returns a segment representing the given text string encoded in alphanumeric mode.\r\n    // The characters allowed are: 0 to 9, A to Z (uppercase only), space,\r\n    // dollar, percent, asterisk, plus, hyphen, period, slash, colon.\r\n    static makeAlphanumeric(text) {\r\n        if (!QrSegment.isAlphanumeric(text))\r\n            throw \"String contains unencodable characters in alphanumeric mode\";\r\n        const bb = [];\r\n        let i;\r\n        for (i = 0; i + 2 <= text.length; i += 2) { // Process groups of 2\r\n            let temp = QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;\r\n            temp += QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));\r\n            appendBits(temp, 11, bb);\r\n        }\r\n        if (i < text.length) // 1 character remaining\r\n            appendBits(QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);\r\n        return new QrSegment(Mode.ALPHANUMERIC, text.length, bb);\r\n    }\r\n    // Returns a new mutable list of zero or more segments to represent the given Unicode text string.\r\n    // The result may use various segment modes and switch modes to optimize the length of the bit stream.\r\n    static makeSegments(text) {\r\n        // Select the most efficient segment encoding automatically\r\n        if (text == \"\")\r\n            return [];\r\n        else if (QrSegment.isNumeric(text))\r\n            return [QrSegment.makeNumeric(text)];\r\n        else if (QrSegment.isAlphanumeric(text))\r\n            return [QrSegment.makeAlphanumeric(text)];\r\n        else\r\n            return [QrSegment.makeBytes(QrSegment.toUtf8ByteArray(text))];\r\n    }\r\n    // Returns a segment representing an Extended Channel Interpretation\r\n    // (ECI) designator with the given assignment value.\r\n    static makeEci(assignVal) {\r\n        const bb = [];\r\n        if (assignVal < 0)\r\n            throw \"ECI assignment value out of range\";\r\n        else if (assignVal < (1 << 7))\r\n            appendBits(assignVal, 8, bb);\r\n        else if (assignVal < (1 << 14)) {\r\n            appendBits(0b10, 2, bb);\r\n            appendBits(assignVal, 14, bb);\r\n        }\r\n        else if (assignVal < 1000000) {\r\n            appendBits(0b110, 3, bb);\r\n            appendBits(assignVal, 21, bb);\r\n        }\r\n        else\r\n            throw \"ECI assignment value out of range\";\r\n        return new QrSegment(Mode.ECI, 0, bb);\r\n    }\r\n    // Tests whether the given string can be encoded as a segment in numeric mode.\r\n    // A string is encodable iff each character is in the range 0 to 9.\r\n    static isNumeric(text) {\r\n        return QrSegment.NUMERIC_REGEX.test(text);\r\n    }\r\n    // Tests whether the given string can be encoded as a segment in alphanumeric mode.\r\n    // A string is encodable iff each character is in the following set: 0 to 9, A to Z\r\n    // (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.\r\n    static isAlphanumeric(text) {\r\n        return QrSegment.ALPHANUMERIC_REGEX.test(text);\r\n    }\r\n    /*-- Methods --*/\r\n    // Returns a new copy of the data bits of this segment.\r\n    getData() {\r\n        return this.bitData.slice(); // Make defensive copy\r\n    }\r\n    // (Package-private) Calculates and returns the number of bits needed to encode the given segments at\r\n    // the given version. The result is infinity if a segment has too many characters to fit its length field.\r\n    static getTotalBits(segs, version) {\r\n        let result = 0;\r\n        for (const seg of segs) {\r\n            const ccbits = seg.mode.numCharCountBits(version);\r\n            if (seg.numChars >= (1 << ccbits))\r\n                return Infinity; // The segment's length doesn't fit the field's bit width\r\n            result += 4 + ccbits + seg.bitData.length;\r\n        }\r\n        return result;\r\n    }\r\n    // Returns a new array of bytes representing the given string encoded in UTF-8.\r\n    static toUtf8ByteArray(str) {\r\n        str = encodeURI(str);\r\n        const result = [];\r\n        for (let i = 0; i < str.length; i++) {\r\n            if (str.charAt(i) != \"%\")\r\n                result.push(str.charCodeAt(i));\r\n            else {\r\n                result.push(parseInt(str.substr(i + 1, 2), 16));\r\n                i += 2;\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n}\r\n/*-- Constants --*/\r\n// Describes precisely all strings that are encodable in numeric mode.\r\nQrSegment.NUMERIC_REGEX = /^[0-9]*$/;\r\n// Describes precisely all strings that are encodable in alphanumeric mode.\r\nQrSegment.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+./:-]*$/;\r\n// The set of all legal characters in alphanumeric mode,\r\n// where each character value maps to the index in the string.\r\nQrSegment.ALPHANUMERIC_CHARSET = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:\";\r\n\r\n/*\r\n * QR Code generator library (TypeScript)\r\n *\r\n * Copyright (c) Project Nayuki. (MIT License)\r\n * https://www.nayuki.io/page/qr-code-generator-library\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy of\r\n * this software and associated documentation files (the \"Software\"), to deal in\r\n * the Software without restriction, including without limitation the rights to\r\n * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r\n * the Software, and to permit persons to whom the Software is furnished to do so,\r\n * subject to the following conditions:\r\n * - The above copyright notice and this permission notice shall be included in\r\n *   all copies or substantial portions of the Software.\r\n * - The Software is provided \"as is\", without warranty of any kind, express or\r\n *   implied, including but not limited to the warranties of merchantability,\r\n *   fitness for a particular purpose and noninfringement. In no event shall the\r\n *   authors or copyright holders be liable for any claim, damages or other\r\n *   liability, whether in an action of contract, tort or otherwise, arising from,\r\n *   out of or in connection with the Software or the use or other dealings in the\r\n *   Software.\r\n */\r\nclass QrCode {\r\n    /*-- Constructor (low level) and fields --*/\r\n    // Creates a new QR Code with the given version number,\r\n    // error correction level, data codeword bytes, and mask number.\r\n    // This is a low-level API that most users should not use directly.\r\n    // A mid-level API is the encodeSegments() function.\r\n    constructor(\r\n    // The version number of this QR Code, which is between 1 and 40 (inclusive).\r\n    // This determines the size of this barcode.\r\n    version, \r\n    // The error correction level used in this QR Code.\r\n    errorCorrectionLevel, dataCodewords, msk) {\r\n        this.version = version;\r\n        this.errorCorrectionLevel = errorCorrectionLevel;\r\n        // The modules of this QR Code (false = light, true = dark).\r\n        // Immutable after constructor finishes. Accessed through getModule().\r\n        this.modules = [];\r\n        // Indicates function modules that are not subjected to masking. Discarded when constructor finishes.\r\n        this.isFunction = [];\r\n        // Check scalar arguments\r\n        if (version < QrCode.MIN_VERSION || version > QrCode.MAX_VERSION)\r\n            throw \"Version value out of range\";\r\n        if (msk < -1 || msk > 7)\r\n            throw \"Mask value out of range\";\r\n        this.size = version * 4 + 17;\r\n        // Initialize both grids to be size*size arrays of Boolean false\r\n        const row = [];\r\n        for (let i = 0; i < this.size; i++)\r\n            row.push(false);\r\n        for (let i = 0; i < this.size; i++) {\r\n            this.modules.push(row.slice()); // Initially all light\r\n            this.isFunction.push(row.slice());\r\n        }\r\n        // Compute ECC, draw modules\r\n        this.drawFunctionPatterns();\r\n        const allCodewords = this.addEccAndInterleave(dataCodewords);\r\n        this.drawCodewords(allCodewords);\r\n        // Do masking\r\n        if (msk == -1) { // Automatically choose best mask\r\n            let minPenalty = 1000000000;\r\n            for (let i = 0; i < 8; i++) {\r\n                this.applyMask(i);\r\n                this.drawFormatBits(i);\r\n                const penalty = this.getPenaltyScore();\r\n                if (penalty < minPenalty) {\r\n                    msk = i;\r\n                    minPenalty = penalty;\r\n                }\r\n                this.applyMask(i); // Undoes the mask due to XOR\r\n            }\r\n        }\r\n        assert(0 <= msk && msk <= 7);\r\n        this.mask = msk;\r\n        this.applyMask(msk); // Apply the final choice of mask\r\n        this.drawFormatBits(msk); // Overwrite old format bits\r\n        this.isFunction = [];\r\n    }\r\n    /*-- Static factory functions (high level) --*/\r\n    // Returns a QR Code representing the given Unicode text string at the given error correction level.\r\n    // As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer\r\n    // Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible\r\n    // QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the\r\n    // ecl argument if it can be done without increasing the version.\r\n    static encodeText(text, ecl) {\r\n        const segs = QrSegment.makeSegments(text);\r\n        return QrCode.encodeSegments(segs, ecl);\r\n    }\r\n    // Returns a QR Code representing the given binary data at the given error correction level.\r\n    // This function always encodes using the binary segment mode, not any text mode. The maximum number of\r\n    // bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.\r\n    // The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.\r\n    static encodeBinary(data, ecl) {\r\n        const seg = QrSegment.makeBytes(data);\r\n        return QrCode.encodeSegments([seg], ecl);\r\n    }\r\n    /*-- Static factory functions (mid level) --*/\r\n    // Returns a QR Code representing the given segments with the given encoding parameters.\r\n    // The smallest possible QR Code version within the given range is automatically\r\n    // chosen for the output. Iff boostEcl is true, then the ECC level of the result\r\n    // may be higher than the ecl argument if it can be done without increasing the\r\n    // version. The mask number is either between 0 to 7 (inclusive) to force that\r\n    // mask, or -1 to automatically choose an appropriate mask (which may be slow).\r\n    // This function allows the user to create a custom sequence of segments that switches\r\n    // between modes (such as alphanumeric and byte) to encode text in less space.\r\n    // This is a mid-level API; the high-level API is encodeText() and encodeBinary().\r\n    static encodeSegments(segs, ecl, minVersion = 1, maxVersion = 40, mask = -1, boostEcl = true) {\r\n        if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION)\r\n            || mask < -1 || mask > 7)\r\n            throw \"Invalid value\";\r\n        // Find the minimal version number to use\r\n        let version;\r\n        let dataUsedBits;\r\n        for (version = minVersion;; version++) {\r\n            const dataCapacityBits = QrCode.getNumDataCodewords(version, ecl) * 8; // Number of data bits available\r\n            const usedBits = QrSegment.getTotalBits(segs, version);\r\n            if (usedBits <= dataCapacityBits) {\r\n                dataUsedBits = usedBits;\r\n                break; // This version number is found to be suitable\r\n            }\r\n            if (version >= maxVersion) // All versions in the range could not fit the given data\r\n                throw \"Data too long\";\r\n        }\r\n        // Increase the error correction level while the data still fits in the current version number\r\n        for (const newEcl of [Ecc.MEDIUM, Ecc.QUARTILE, Ecc.HIGH]) { // From low to high\r\n            if (boostEcl && dataUsedBits <= QrCode.getNumDataCodewords(version, newEcl) * 8)\r\n                ecl = newEcl;\r\n        }\r\n        // Concatenate all segments to create the data bit string\r\n        const bb = [];\r\n        for (const seg of segs) {\r\n            appendBits(seg.mode.modeBits, 4, bb);\r\n            appendBits(seg.numChars, seg.mode.numCharCountBits(version), bb);\r\n            for (const b of seg.getData())\r\n                bb.push(b);\r\n        }\r\n        assert(bb.length == dataUsedBits);\r\n        // Add terminator and pad up to a byte if applicable\r\n        const dataCapacityBits = QrCode.getNumDataCodewords(version, ecl) * 8;\r\n        assert(bb.length <= dataCapacityBits);\r\n        appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);\r\n        appendBits(0, (8 - bb.length % 8) % 8, bb);\r\n        assert(bb.length % 8 == 0);\r\n        // Pad with alternating bytes until data capacity is reached\r\n        for (let padByte = 0xEC; bb.length < dataCapacityBits; padByte ^= 0xEC ^ 0x11)\r\n            appendBits(padByte, 8, bb);\r\n        // Pack bits into bytes in big endian\r\n        const dataCodewords = [];\r\n        while (dataCodewords.length * 8 < bb.length)\r\n            dataCodewords.push(0);\r\n        bb.forEach((b, i) => dataCodewords[i >>> 3] |= b << (7 - (i & 7)));\r\n        // Create the QR Code object\r\n        return new QrCode(version, ecl, dataCodewords, mask);\r\n    }\r\n    /*-- Accessor methods --*/\r\n    // Returns the color of the module (pixel) at the given coordinates, which is false\r\n    // for light or true for dark. The top left corner has the coordinates (x=0, y=0).\r\n    // If the given coordinates are out of bounds, then false (light) is returned.\r\n    getModule(x, y) {\r\n        return 0 <= x && x < this.size && 0 <= y && y < this.size && this.modules[y][x];\r\n    }\r\n    /*-- Private helper methods for constructor: Drawing function modules --*/\r\n    // Reads this object's version field, and draws and marks all function modules.\r\n    drawFunctionPatterns() {\r\n        // Draw horizontal and vertical timing patterns\r\n        for (let i = 0; i < this.size; i++) {\r\n            this.setFunctionModule(6, i, i % 2 == 0);\r\n            this.setFunctionModule(i, 6, i % 2 == 0);\r\n        }\r\n        // Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)\r\n        this.drawFinderPattern(3, 3);\r\n        this.drawFinderPattern(this.size - 4, 3);\r\n        this.drawFinderPattern(3, this.size - 4);\r\n        // Draw numerous alignment patterns\r\n        const alignPatPos = this.getAlignmentPatternPositions();\r\n        const numAlign = alignPatPos.length;\r\n        for (let i = 0; i < numAlign; i++) {\r\n            for (let j = 0; j < numAlign; j++) {\r\n                // Don't draw on the three finder corners\r\n                if (!(i == 0 && j == 0 || i == 0 && j == numAlign - 1 || i == numAlign - 1 && j == 0))\r\n                    this.drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);\r\n            }\r\n        }\r\n        // Draw configuration data\r\n        this.drawFormatBits(0); // Dummy mask value; overwritten later in the constructor\r\n        this.drawVersion();\r\n    }\r\n    // Draws two copies of the format bits (with its own error correction code)\r\n    // based on the given mask and this object's error correction level field.\r\n    drawFormatBits(mask) {\r\n        // Calculate error correction code and pack bits\r\n        const data = this.errorCorrectionLevel.formatBits << 3 | mask; // errCorrLvl is uint2, mask is uint3\r\n        let rem = data;\r\n        for (let i = 0; i < 10; i++)\r\n            rem = (rem << 1) ^ ((rem >>> 9) * 0x537);\r\n        const bits = (data << 10 | rem) ^ 0x5412; // uint15\r\n        assert(bits >>> 15 == 0);\r\n        // Draw first copy\r\n        for (let i = 0; i <= 5; i++)\r\n            this.setFunctionModule(8, i, getBit(bits, i));\r\n        this.setFunctionModule(8, 7, getBit(bits, 6));\r\n        this.setFunctionModule(8, 8, getBit(bits, 7));\r\n        this.setFunctionModule(7, 8, getBit(bits, 8));\r\n        for (let i = 9; i < 15; i++)\r\n            this.setFunctionModule(14 - i, 8, getBit(bits, i));\r\n        // Draw second copy\r\n        for (let i = 0; i < 8; i++)\r\n            this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));\r\n        for (let i = 8; i < 15; i++)\r\n            this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));\r\n        this.setFunctionModule(8, this.size - 8, true); // Always dark\r\n    }\r\n    // Draws two copies of the version bits (with its own error correction code),\r\n    // based on this object's version field, iff 7 <= version <= 40.\r\n    drawVersion() {\r\n        if (this.version < 7)\r\n            return;\r\n        // Calculate error correction code and pack bits\r\n        let rem = this.version; // version is uint6, in the range [7, 40]\r\n        for (let i = 0; i < 12; i++)\r\n            rem = (rem << 1) ^ ((rem >>> 11) * 0x1F25);\r\n        const bits = this.version << 12 | rem; // uint18\r\n        assert(bits >>> 18 == 0);\r\n        // Draw two copies\r\n        for (let i = 0; i < 18; i++) {\r\n            const color = getBit(bits, i);\r\n            const a = this.size - 11 + i % 3;\r\n            const b = Math.floor(i / 3);\r\n            this.setFunctionModule(a, b, color);\r\n            this.setFunctionModule(b, a, color);\r\n        }\r\n    }\r\n    // Draws a 9*9 finder pattern including the border separator,\r\n    // with the center module at (x, y). Modules can be out of bounds.\r\n    drawFinderPattern(x, y) {\r\n        for (let dy = -4; dy <= 4; dy++) {\r\n            for (let dx = -4; dx <= 4; dx++) {\r\n                const dist = Math.max(Math.abs(dx), Math.abs(dy)); // Chebyshev/infinity norm\r\n                const xx = x + dx;\r\n                const yy = y + dy;\r\n                if (0 <= xx && xx < this.size && 0 <= yy && yy < this.size)\r\n                    this.setFunctionModule(xx, yy, dist != 2 && dist != 4);\r\n            }\r\n        }\r\n    }\r\n    // Draws a 5*5 alignment pattern, with the center module\r\n    // at (x, y). All modules must be in bounds.\r\n    drawAlignmentPattern(x, y) {\r\n        for (let dy = -2; dy <= 2; dy++) {\r\n            for (let dx = -2; dx <= 2; dx++)\r\n                this.setFunctionModule(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) != 1);\r\n        }\r\n    }\r\n    // Sets the color of a module and marks it as a function module.\r\n    // Only used by the constructor. Coordinates must be in bounds.\r\n    setFunctionModule(x, y, isDark) {\r\n        this.modules[y][x] = isDark;\r\n        this.isFunction[y][x] = true;\r\n    }\r\n    /*-- Private helper methods for constructor: Codewords and masking --*/\r\n    // Returns a new byte string representing the given data with the appropriate error correction\r\n    // codewords appended to it, based on this object's version and error correction level.\r\n    addEccAndInterleave(data) {\r\n        const ver = this.version;\r\n        const ecl = this.errorCorrectionLevel;\r\n        if (data.length != QrCode.getNumDataCodewords(ver, ecl))\r\n            throw \"Invalid argument\";\r\n        // Calculate parameter numbers\r\n        const numBlocks = QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];\r\n        const blockEccLen = QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver];\r\n        const rawCodewords = Math.floor(QrCode.getNumRawDataModules(ver) / 8);\r\n        const numShortBlocks = numBlocks - rawCodewords % numBlocks;\r\n        const shortBlockLen = Math.floor(rawCodewords / numBlocks);\r\n        // Split data into blocks and append ECC to each block\r\n        const blocks = [];\r\n        const rsDiv = QrCode.reedSolomonComputeDivisor(blockEccLen);\r\n        for (let i = 0, k = 0; i < numBlocks; i++) {\r\n            const dat = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));\r\n            k += dat.length;\r\n            const ecc = QrCode.reedSolomonComputeRemainder(dat, rsDiv);\r\n            if (i < numShortBlocks)\r\n                dat.push(0);\r\n            blocks.push(dat.concat(ecc));\r\n        }\r\n        // Interleave (not concatenate) the bytes from every block into a single sequence\r\n        const result = [];\r\n        for (let i = 0; i < blocks[0].length; i++) {\r\n            blocks.forEach((block, j) => {\r\n                // Skip the padding byte in short blocks\r\n                if (i != shortBlockLen - blockEccLen || j >= numShortBlocks)\r\n                    result.push(block[i]);\r\n            });\r\n        }\r\n        assert(result.length == rawCodewords);\r\n        return result;\r\n    }\r\n    // Draws the given sequence of 8-bit codewords (data and error correction) onto the entire\r\n    // data area of this QR Code. Function modules need to be marked off before this is called.\r\n    drawCodewords(data) {\r\n        if (data.length != Math.floor(QrCode.getNumRawDataModules(this.version) / 8))\r\n            throw \"Invalid argument\";\r\n        let i = 0; // Bit index into the data\r\n        // Do the funny zigzag scan\r\n        for (let right = this.size - 1; right >= 1; right -= 2) { // Index of right column in each column pair\r\n            if (right == 6)\r\n                right = 5;\r\n            for (let vert = 0; vert < this.size; vert++) { // Vertical counter\r\n                for (let j = 0; j < 2; j++) {\r\n                    const x = right - j; // Actual x coordinate\r\n                    const upward = ((right + 1) & 2) == 0;\r\n                    const y = upward ? this.size - 1 - vert : vert; // Actual y coordinate\r\n                    if (!this.isFunction[y][x] && i < data.length * 8) {\r\n                        this.modules[y][x] = getBit(data[i >>> 3], 7 - (i & 7));\r\n                        i++;\r\n                    }\r\n                    // If this QR Code has any remainder bits (0 to 7), they were assigned as\r\n                    // 0/false/light by the constructor and are left unchanged by this method\r\n                }\r\n            }\r\n        }\r\n        assert(i == data.length * 8);\r\n    }\r\n    // XORs the codeword modules in this QR Code with the given mask pattern.\r\n    // The function modules must be marked and the codeword bits must be drawn\r\n    // before masking. Due to the arithmetic of XOR, calling applyMask() with\r\n    // the same mask value a second time will undo the mask. A final well-formed\r\n    // QR Code needs exactly one (not zero, two, etc.) mask applied.\r\n    applyMask(mask) {\r\n        if (mask < 0 || mask > 7)\r\n            throw \"Mask value out of range\";\r\n        for (let y = 0; y < this.size; y++) {\r\n            for (let x = 0; x < this.size; x++) {\r\n                let invert;\r\n                switch (mask) {\r\n                    case 0:\r\n                        invert = (x + y) % 2 == 0;\r\n                        break;\r\n                    case 1:\r\n                        invert = y % 2 == 0;\r\n                        break;\r\n                    case 2:\r\n                        invert = x % 3 == 0;\r\n                        break;\r\n                    case 3:\r\n                        invert = (x + y) % 3 == 0;\r\n                        break;\r\n                    case 4:\r\n                        invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 == 0;\r\n                        break;\r\n                    case 5:\r\n                        invert = x * y % 2 + x * y % 3 == 0;\r\n                        break;\r\n                    case 6:\r\n                        invert = (x * y % 2 + x * y % 3) % 2 == 0;\r\n                        break;\r\n                    case 7:\r\n                        invert = ((x + y) % 2 + x * y % 3) % 2 == 0;\r\n                        break;\r\n                    default:\r\n                        throw \"Unreachable\";\r\n                }\r\n                if (!this.isFunction[y][x] && invert)\r\n                    this.modules[y][x] = !this.modules[y][x];\r\n            }\r\n        }\r\n    }\r\n    // Calculates and returns the penalty score based on state of this QR Code's current modules.\r\n    // This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.\r\n    getPenaltyScore() {\r\n        let result = 0;\r\n        // Adjacent modules in row having same color, and finder-like patterns\r\n        for (let y = 0; y < this.size; y++) {\r\n            let runColor = false;\r\n            let runX = 0;\r\n            const runHistory = [0, 0, 0, 0, 0, 0, 0];\r\n            for (let x = 0; x < this.size; x++) {\r\n                if (this.modules[y][x] == runColor) {\r\n                    runX++;\r\n                    if (runX == 5)\r\n                        result += QrCode.PENALTY_N1;\r\n                    else if (runX > 5)\r\n                        result++;\r\n                }\r\n                else {\r\n                    this.finderPenaltyAddHistory(runX, runHistory);\r\n                    if (!runColor)\r\n                        result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;\r\n                    runColor = this.modules[y][x];\r\n                    runX = 1;\r\n                }\r\n            }\r\n            result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * QrCode.PENALTY_N3;\r\n        }\r\n        // Adjacent modules in column having same color, and finder-like patterns\r\n        for (let x = 0; x < this.size; x++) {\r\n            let runColor = false;\r\n            let runY = 0;\r\n            const runHistory = [0, 0, 0, 0, 0, 0, 0];\r\n            for (let y = 0; y < this.size; y++) {\r\n                if (this.modules[y][x] == runColor) {\r\n                    runY++;\r\n                    if (runY == 5)\r\n                        result += QrCode.PENALTY_N1;\r\n                    else if (runY > 5)\r\n                        result++;\r\n                }\r\n                else {\r\n                    this.finderPenaltyAddHistory(runY, runHistory);\r\n                    if (!runColor)\r\n                        result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;\r\n                    runColor = this.modules[y][x];\r\n                    runY = 1;\r\n                }\r\n            }\r\n            result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * QrCode.PENALTY_N3;\r\n        }\r\n        // 2*2 blocks of modules having same color\r\n        for (let y = 0; y < this.size - 1; y++) {\r\n            for (let x = 0; x < this.size - 1; x++) {\r\n                const color = this.modules[y][x];\r\n                if (color == this.modules[y][x + 1] &&\r\n                    color == this.modules[y + 1][x] &&\r\n                    color == this.modules[y + 1][x + 1])\r\n                    result += QrCode.PENALTY_N2;\r\n            }\r\n        }\r\n        // Balance of dark and light modules\r\n        let dark = 0;\r\n        for (const row of this.modules)\r\n            dark = row.reduce((sum, color) => sum + (color ? 1 : 0), dark);\r\n        const total = this.size * this.size; // Note that size is odd, so dark/total != 1/2\r\n        // Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%\r\n        const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;\r\n        assert(0 <= k && k <= 9);\r\n        result += k * QrCode.PENALTY_N4;\r\n        assert(0 <= result && result <= 2568888); // Non-tight upper bound based on default values of PENALTY_N1, ..., N4\r\n        return result;\r\n    }\r\n    /*-- Private helper functions --*/\r\n    // Returns an ascending list of positions of alignment patterns for this version number.\r\n    // Each position is in the range [0,177), and are used on both the x and y axes.\r\n    // This could be implemented as lookup table of 40 variable-length lists of integers.\r\n    getAlignmentPatternPositions() {\r\n        if (this.version == 1)\r\n            return [];\r\n        else {\r\n            const numAlign = Math.floor(this.version / 7) + 2;\r\n            const step = (this.version == 32) ? 26 :\r\n                Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2;\r\n            const result = [6];\r\n            for (let pos = this.size - 7; result.length < numAlign; pos -= step)\r\n                result.splice(1, 0, pos);\r\n            return result;\r\n        }\r\n    }\r\n    // Returns the number of data bits that can be stored in a QR Code of the given version number, after\r\n    // all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.\r\n    // The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.\r\n    static getNumRawDataModules(ver) {\r\n        if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)\r\n            throw \"Version number out of range\";\r\n        let result = (16 * ver + 128) * ver + 64;\r\n        if (ver >= 2) {\r\n            const numAlign = Math.floor(ver / 7) + 2;\r\n            result -= (25 * numAlign - 10) * numAlign - 55;\r\n            if (ver >= 7)\r\n                result -= 36;\r\n        }\r\n        assert(208 <= result && result <= 29648);\r\n        return result;\r\n    }\r\n    // Returns the number of 8-bit data (i.e. not error correction) codewords contained in any\r\n    // QR Code of the given version number and error correction level, with remainder bits discarded.\r\n    // This stateless pure function could be implemented as a (40*4)-cell lookup table.\r\n    static getNumDataCodewords(ver, ecl) {\r\n        return Math.floor(QrCode.getNumRawDataModules(ver) / 8) -\r\n            this.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver] *\r\n                QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];\r\n    }\r\n    // Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be\r\n    // implemented as a lookup table over all possible parameter values, instead of as an algorithm.\r\n    static reedSolomonComputeDivisor(degree) {\r\n        if (degree < 1 || degree > 255)\r\n            throw \"Degree out of range\";\r\n        // Polynomial coefficients are stored from highest to lowest power, excluding the leading term which is always 1.\r\n        // For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array [255, 8, 93].\r\n        const result = [];\r\n        for (let i = 0; i < degree - 1; i++)\r\n            result.push(0);\r\n        result.push(1); // Start off with the monomial x^0\r\n        // Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),\r\n        // and drop the highest monomial term which is always 1x^degree.\r\n        // Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).\r\n        let root = 1;\r\n        for (let i = 0; i < degree; i++) {\r\n            // Multiply the current product by (x - r^i)\r\n            for (let j = 0; j < result.length; j++) {\r\n                result[j] = QrCode.reedSolomonMultiply(result[j], root);\r\n                if (j + 1 < result.length)\r\n                    result[j] ^= result[j + 1];\r\n            }\r\n            root = QrCode.reedSolomonMultiply(root, 0x02);\r\n        }\r\n        return result;\r\n    }\r\n    // Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.\r\n    static reedSolomonComputeRemainder(data, divisor) {\r\n        const result = divisor.map(() => 0);\r\n        for (const b of data) { // Polynomial division\r\n            const factor = b ^ result.shift();\r\n            result.push(0);\r\n            divisor.forEach((coef, i) => result[i] ^= QrCode.reedSolomonMultiply(coef, factor));\r\n        }\r\n        return result;\r\n    }\r\n    // Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result\r\n    // are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.\r\n    static reedSolomonMultiply(x, y) {\r\n        if (x >>> 8 != 0 || y >>> 8 != 0)\r\n            throw \"Byte out of range\";\r\n        // Russian peasant multiplication\r\n        let z = 0;\r\n        for (let i = 7; i >= 0; i--) {\r\n            z = (z << 1) ^ ((z >>> 7) * 0x11D);\r\n            z ^= ((y >>> i) & 1) * x;\r\n        }\r\n        assert(z >>> 8 == 0);\r\n        return z;\r\n    }\r\n    // Can only be called immediately after a light run is added, and\r\n    // returns either 0, 1, or 2. A helper function for getPenaltyScore().\r\n    finderPenaltyCountPatterns(runHistory) {\r\n        const n = runHistory[1];\r\n        assert(n <= this.size * 3);\r\n        const core = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;\r\n        return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0)\r\n            + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);\r\n    }\r\n    // Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().\r\n    finderPenaltyTerminateAndCount(currentRunColor, currentRunLength, runHistory) {\r\n        if (currentRunColor) { // Terminate dark run\r\n            this.finderPenaltyAddHistory(currentRunLength, runHistory);\r\n            currentRunLength = 0;\r\n        }\r\n        currentRunLength += this.size; // Add light border to final run\r\n        this.finderPenaltyAddHistory(currentRunLength, runHistory);\r\n        return this.finderPenaltyCountPatterns(runHistory);\r\n    }\r\n    // Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().\r\n    finderPenaltyAddHistory(currentRunLength, runHistory) {\r\n        if (runHistory[0] == 0)\r\n            currentRunLength += this.size; // Add light border to initial run\r\n        runHistory.pop();\r\n        runHistory.unshift(currentRunLength);\r\n    }\r\n}\r\n/*-- Constants and tables --*/\r\n// The minimum version number supported in the QR Code Model 2 standard.\r\nQrCode.MIN_VERSION = 1;\r\n// The maximum version number supported in the QR Code Model 2 standard.\r\nQrCode.MAX_VERSION = 40;\r\n// For use in getPenaltyScore(), when evaluating which mask is best.\r\nQrCode.PENALTY_N1 = 3;\r\nQrCode.PENALTY_N2 = 3;\r\nQrCode.PENALTY_N3 = 40;\r\nQrCode.PENALTY_N4 = 10;\r\nQrCode.ECC_CODEWORDS_PER_BLOCK = [\r\n    // Version: (note that index 0 is for padding, and is set to an illegal value)\r\n    //0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level\r\n    [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],\r\n    [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],\r\n    [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],\r\n    [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],\r\n];\r\nQrCode.NUM_ERROR_CORRECTION_BLOCKS = [\r\n    // Version: (note that index 0 is for padding, and is set to an illegal value)\r\n    //0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level\r\n    [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],\r\n    [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],\r\n    [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],\r\n    [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81],\r\n];\r\n\r\nvar hasFetch = isFunction$1(global.fetch) && isFunction$1(global.ReadableStream);\r\n\r\nvar _blobConstructor;\r\nfunction blobConstructor() {\r\n  if (typeof _blobConstructor !== 'undefined') {\r\n    return _blobConstructor;\r\n  }\r\n  try {\r\n    new global.Blob([new ArrayBuffer(1)]);\r\n    _blobConstructor = true;\r\n  } catch (e) {\r\n    _blobConstructor = false;\r\n  }\r\n  return _blobConstructor\r\n}\r\nvar xhr;\r\n\r\nfunction checkTypeSupport(type) {\r\n  if (!xhr) {\r\n    xhr = new global.XMLHttpRequest();\r\n    // If location.host is empty, e.g. if this page/worker was loaded\r\n    // from a Blob, then use example.com to avoid an error\r\n    xhr.open('GET', global.location.host ? '/' : 'https://example.com');\r\n  }\r\n  try {\r\n    xhr.responseType = type;\r\n    return xhr.responseType === type\r\n  } catch (e) {\r\n    return false\r\n  }\r\n\r\n}\r\n\r\n// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.\r\n// Safari 7.1 appears to have fixed this bug.\r\nvar haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined';\r\nvar haveSlice = haveArrayBuffer && isFunction$1(global.ArrayBuffer.prototype.slice);\r\n\r\nvar arraybuffer = haveArrayBuffer && checkTypeSupport('arraybuffer');\r\n  // These next two tests unavoidably show warnings in Chrome. Since fetch will always\r\n  // be used if it's available, just return false for these to avoid the warnings.\r\nvar msstream = !hasFetch && haveSlice && checkTypeSupport('ms-stream');\r\nvar mozchunkedarraybuffer = !hasFetch && haveArrayBuffer &&\r\n  checkTypeSupport('moz-chunked-arraybuffer');\r\nvar overrideMimeType = isFunction$1(xhr.overrideMimeType);\r\nvar vbArray = isFunction$1(global.VBArray);\r\n\r\nfunction isFunction$1(value) {\r\n  return typeof value === 'function'\r\n}\r\n\r\nxhr = null; // Help gc\r\n\r\n// shim for using process in browser\r\n// based off https://github.com/defunctzombie/node-process/blob/master/browser.js\r\n\r\nfunction defaultSetTimout() {\r\n    throw new Error('setTimeout has not been defined');\r\n}\r\nfunction defaultClearTimeout () {\r\n    throw new Error('clearTimeout has not been defined');\r\n}\r\nvar cachedSetTimeout = defaultSetTimout;\r\nvar cachedClearTimeout = defaultClearTimeout;\r\nif (typeof global.setTimeout === 'function') {\r\n    cachedSetTimeout = setTimeout;\r\n}\r\nif (typeof global.clearTimeout === 'function') {\r\n    cachedClearTimeout = clearTimeout;\r\n}\r\n\r\nfunction runTimeout(fun) {\r\n    if (cachedSetTimeout === setTimeout) {\r\n        //normal enviroments in sane situations\r\n        return setTimeout(fun, 0);\r\n    }\r\n    // if setTimeout wasn't available but was latter defined\r\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\r\n        cachedSetTimeout = setTimeout;\r\n        return setTimeout(fun, 0);\r\n    }\r\n    try {\r\n        // when when somebody has screwed with setTimeout but no I.E. maddness\r\n        return cachedSetTimeout(fun, 0);\r\n    } catch(e){\r\n        try {\r\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\r\n            return cachedSetTimeout.call(null, fun, 0);\r\n        } catch(e){\r\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\r\n            return cachedSetTimeout.call(this, fun, 0);\r\n        }\r\n    }\r\n\r\n\r\n}\r\nfunction runClearTimeout(marker) {\r\n    if (cachedClearTimeout === clearTimeout) {\r\n        //normal enviroments in sane situations\r\n        return clearTimeout(marker);\r\n    }\r\n    // if clearTimeout wasn't available but was latter defined\r\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\r\n        cachedClearTimeout = clearTimeout;\r\n        return clearTimeout(marker);\r\n    }\r\n    try {\r\n        // when when somebody has screwed with setTimeout but no I.E. maddness\r\n        return cachedClearTimeout(marker);\r\n    } catch (e){\r\n        try {\r\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\r\n            return cachedClearTimeout.call(null, marker);\r\n        } catch (e){\r\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\r\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\r\n            return cachedClearTimeout.call(this, marker);\r\n        }\r\n    }\r\n\r\n\r\n\r\n}\r\nvar queue = [];\r\nvar draining = false;\r\nvar currentQueue;\r\nvar queueIndex = -1;\r\n\r\nfunction cleanUpNextTick() {\r\n    if (!draining || !currentQueue) {\r\n        return;\r\n    }\r\n    draining = false;\r\n    if (currentQueue.length) {\r\n        queue = currentQueue.concat(queue);\r\n    } else {\r\n        queueIndex = -1;\r\n    }\r\n    if (queue.length) {\r\n        drainQueue();\r\n    }\r\n}\r\n\r\nfunction drainQueue() {\r\n    if (draining) {\r\n        return;\r\n    }\r\n    var timeout = runTimeout(cleanUpNextTick);\r\n    draining = true;\r\n\r\n    var len = queue.length;\r\n    while(len) {\r\n        currentQueue = queue;\r\n        queue = [];\r\n        while (++queueIndex < len) {\r\n            if (currentQueue) {\r\n                currentQueue[queueIndex].run();\r\n            }\r\n        }\r\n        queueIndex = -1;\r\n        len = queue.length;\r\n    }\r\n    currentQueue = null;\r\n    draining = false;\r\n    runClearTimeout(timeout);\r\n}\r\nfunction nextTick(fun) {\r\n    var args = new Array(arguments.length - 1);\r\n    if (arguments.length > 1) {\r\n        for (var i = 1; i < arguments.length; i++) {\r\n            args[i - 1] = arguments[i];\r\n        }\r\n    }\r\n    queue.push(new Item(fun, args));\r\n    if (queue.length === 1 && !draining) {\r\n        runTimeout(drainQueue);\r\n    }\r\n}\r\n// v8 likes predictible objects\r\nfunction Item(fun, array) {\r\n    this.fun = fun;\r\n    this.array = array;\r\n}\r\nItem.prototype.run = function () {\r\n    this.fun.apply(null, this.array);\r\n};\r\nvar title = 'browser';\r\nvar platform = 'browser';\r\nvar browser = true;\r\nvar env = {};\r\nvar argv = [];\r\nvar version = ''; // empty string to avoid regexp issues\r\nvar versions = {};\r\nvar release = {};\r\nvar config = {};\r\n\r\nfunction noop() {}\r\n\r\nvar on = noop;\r\nvar addListener = noop;\r\nvar once = noop;\r\nvar off = noop;\r\nvar removeListener = noop;\r\nvar removeAllListeners = noop;\r\nvar emit = noop;\r\n\r\nfunction binding(name) {\r\n    throw new Error('process.binding is not supported');\r\n}\r\n\r\nfunction cwd () { return '/' }\r\nfunction chdir (dir) {\r\n    throw new Error('process.chdir is not supported');\r\n}function umask() { return 0; }\r\n\r\n// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js\r\nvar performance = global.performance || {};\r\nvar performanceNow =\r\n  performance.now        ||\r\n  performance.mozNow     ||\r\n  performance.msNow      ||\r\n  performance.oNow       ||\r\n  performance.webkitNow  ||\r\n  function(){ return (new Date()).getTime() };\r\n\r\n// generate timestamp or delta\r\n// see http://nodejs.org/api/process.html#process_process_hrtime\r\nfunction hrtime(previousTimestamp){\r\n  var clocktime = performanceNow.call(performance)*1e-3;\r\n  var seconds = Math.floor(clocktime);\r\n  var nanoseconds = Math.floor((clocktime%1)*1e9);\r\n  if (previousTimestamp) {\r\n    seconds = seconds - previousTimestamp[0];\r\n    nanoseconds = nanoseconds - previousTimestamp[1];\r\n    if (nanoseconds<0) {\r\n      seconds--;\r\n      nanoseconds += 1e9;\r\n    }\r\n  }\r\n  return [seconds,nanoseconds]\r\n}\r\n\r\nvar startTime = new Date();\r\nfunction uptime() {\r\n  var currentTime = new Date();\r\n  var dif = currentTime - startTime;\r\n  return dif / 1000;\r\n}\r\n\r\nvar browser$1 = {\r\n  nextTick: nextTick,\r\n  title: title,\r\n  browser: browser,\r\n  env: env,\r\n  argv: argv,\r\n  version: version,\r\n  versions: versions,\r\n  on: on,\r\n  addListener: addListener,\r\n  once: once,\r\n  off: off,\r\n  removeListener: removeListener,\r\n  removeAllListeners: removeAllListeners,\r\n  emit: emit,\r\n  binding: binding,\r\n  cwd: cwd,\r\n  chdir: chdir,\r\n  umask: umask,\r\n  hrtime: hrtime,\r\n  platform: platform,\r\n  release: release,\r\n  config: config,\r\n  uptime: uptime\r\n};\r\n\r\nvar inherits;\r\nif (typeof Object.create === 'function'){\r\n  inherits = function inherits(ctor, superCtor) {\r\n    // implementation from standard node.js 'util' module\r\n    ctor.super_ = superCtor;\r\n    ctor.prototype = Object.create(superCtor.prototype, {\r\n      constructor: {\r\n        value: ctor,\r\n        enumerable: false,\r\n        writable: true,\r\n        configurable: true\r\n      }\r\n    });\r\n  };\r\n} else {\r\n  inherits = function inherits(ctor, superCtor) {\r\n    ctor.super_ = superCtor;\r\n    var TempCtor = function () {};\r\n    TempCtor.prototype = superCtor.prototype;\r\n    ctor.prototype = new TempCtor();\r\n    ctor.prototype.constructor = ctor;\r\n  };\r\n}\r\nvar inherits$1 = inherits;\r\n\r\n// Copyright Joyent, Inc. and other Node contributors.\r\nvar formatRegExp = /%[sdj%]/g;\r\nfunction format$1(f) {\r\n  if (!isString(f)) {\r\n    var objects = [];\r\n    for (var i = 0; i < arguments.length; i++) {\r\n      objects.push(inspect(arguments[i]));\r\n    }\r\n    return objects.join(' ');\r\n  }\r\n\r\n  var i = 1;\r\n  var args = arguments;\r\n  var len = args.length;\r\n  var str = String(f).replace(formatRegExp, function(x) {\r\n    if (x === '%%') return '%';\r\n    if (i >= len) return x;\r\n    switch (x) {\r\n      case '%s': return String(args[i++]);\r\n      case '%d': return Number(args[i++]);\r\n      case '%j':\r\n        try {\r\n          return JSON.stringify(args[i++]);\r\n        } catch (_) {\r\n          return '[Circular]';\r\n        }\r\n      default:\r\n        return x;\r\n    }\r\n  });\r\n  for (var x = args[i]; i < len; x = args[++i]) {\r\n    if (isNull(x) || !isObject(x)) {\r\n      str += ' ' + x;\r\n    } else {\r\n      str += ' ' + inspect(x);\r\n    }\r\n  }\r\n  return str;\r\n}\r\n\r\n// Mark that a method should not be used.\r\n// Returns a modified function which warns once by default.\r\n// If --no-deprecation is set, then it is a no-op.\r\nfunction deprecate(fn, msg) {\r\n  // Allow for deprecating things in the process of starting up.\r\n  if (isUndefined(global.process)) {\r\n    return function() {\r\n      return deprecate(fn, msg).apply(this, arguments);\r\n    };\r\n  }\r\n\r\n  if (browser$1.noDeprecation === true) {\r\n    return fn;\r\n  }\r\n\r\n  var warned = false;\r\n  function deprecated() {\r\n    if (!warned) {\r\n      {\r\n        console.error(msg);\r\n      }\r\n      warned = true;\r\n    }\r\n    return fn.apply(this, arguments);\r\n  }\r\n\r\n  return deprecated;\r\n}\r\n\r\nvar debugs = {};\r\nvar debugEnviron;\r\nfunction debuglog(set) {\r\n  if (isUndefined(debugEnviron))\r\n    debugEnviron = '';\r\n  set = set.toUpperCase();\r\n  if (!debugs[set]) {\r\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\r\n      var pid = 0;\r\n      debugs[set] = function() {\r\n        var msg = format$1.apply(null, arguments);\r\n        console.error('%s %d: %s', set, pid, msg);\r\n      };\r\n    } else {\r\n      debugs[set] = function() {};\r\n    }\r\n  }\r\n  return debugs[set];\r\n}\r\n\r\n/**\r\n * Echos the value of a value. Trys to print the value out\r\n * in the best way possible given the different types.\r\n *\r\n * @param {Object} obj The object to print out.\r\n * @param {Object} opts Optional options object that alters the output.\r\n */\r\n/* legacy: obj, showHidden, depth, colors*/\r\nfunction inspect(obj, opts) {\r\n  // default options\r\n  var ctx = {\r\n    seen: [],\r\n    stylize: stylizeNoColor\r\n  };\r\n  // legacy...\r\n  if (arguments.length >= 3) ctx.depth = arguments[2];\r\n  if (arguments.length >= 4) ctx.colors = arguments[3];\r\n  if (isBoolean(opts)) {\r\n    // legacy...\r\n    ctx.showHidden = opts;\r\n  } else if (opts) {\r\n    // got an \"options\" object\r\n    _extend(ctx, opts);\r\n  }\r\n  // set default options\r\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\r\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\r\n  if (isUndefined(ctx.colors)) ctx.colors = false;\r\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\r\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\r\n  return formatValue(ctx, obj, ctx.depth);\r\n}\r\n\r\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\r\ninspect.colors = {\r\n  'bold' : [1, 22],\r\n  'italic' : [3, 23],\r\n  'underline' : [4, 24],\r\n  'inverse' : [7, 27],\r\n  'white' : [37, 39],\r\n  'grey' : [90, 39],\r\n  'black' : [30, 39],\r\n  'blue' : [34, 39],\r\n  'cyan' : [36, 39],\r\n  'green' : [32, 39],\r\n  'magenta' : [35, 39],\r\n  'red' : [31, 39],\r\n  'yellow' : [33, 39]\r\n};\r\n\r\n// Don't use 'blue' not visible on cmd.exe\r\ninspect.styles = {\r\n  'special': 'cyan',\r\n  'number': 'yellow',\r\n  'boolean': 'yellow',\r\n  'undefined': 'grey',\r\n  'null': 'bold',\r\n  'string': 'green',\r\n  'date': 'magenta',\r\n  // \"name\": intentionally not styling\r\n  'regexp': 'red'\r\n};\r\n\r\n\r\nfunction stylizeWithColor(str, styleType) {\r\n  var style = inspect.styles[styleType];\r\n\r\n  if (style) {\r\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\r\n           '\\u001b[' + inspect.colors[style][1] + 'm';\r\n  } else {\r\n    return str;\r\n  }\r\n}\r\n\r\n\r\nfunction stylizeNoColor(str, styleType) {\r\n  return str;\r\n}\r\n\r\n\r\nfunction arrayToHash(array) {\r\n  var hash = {};\r\n\r\n  array.forEach(function(val, idx) {\r\n    hash[val] = true;\r\n  });\r\n\r\n  return hash;\r\n}\r\n\r\n\r\nfunction formatValue(ctx, value, recurseTimes) {\r\n  // Provide a hook for user-specified inspect functions.\r\n  // Check that value is an object with an inspect function on it\r\n  if (ctx.customInspect &&\r\n      value &&\r\n      isFunction(value.inspect) &&\r\n      // Filter out the util module, it's inspect function is special\r\n      value.inspect !== inspect &&\r\n      // Also filter out any prototype objects using the circular check.\r\n      !(value.constructor && value.constructor.prototype === value)) {\r\n    var ret = value.inspect(recurseTimes, ctx);\r\n    if (!isString(ret)) {\r\n      ret = formatValue(ctx, ret, recurseTimes);\r\n    }\r\n    return ret;\r\n  }\r\n\r\n  // Primitive types cannot have properties\r\n  var primitive = formatPrimitive(ctx, value);\r\n  if (primitive) {\r\n    return primitive;\r\n  }\r\n\r\n  // Look up the keys of the object.\r\n  var keys = Object.keys(value);\r\n  var visibleKeys = arrayToHash(keys);\r\n\r\n  if (ctx.showHidden) {\r\n    keys = Object.getOwnPropertyNames(value);\r\n  }\r\n\r\n  // IE doesn't make error fields non-enumerable\r\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\r\n  if (isError(value)\r\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\r\n    return formatError(value);\r\n  }\r\n\r\n  // Some type of object without properties can be shortcutted.\r\n  if (keys.length === 0) {\r\n    if (isFunction(value)) {\r\n      var name = value.name ? ': ' + value.name : '';\r\n      return ctx.stylize('[Function' + name + ']', 'special');\r\n    }\r\n    if (isRegExp(value)) {\r\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\r\n    }\r\n    if (isDate(value)) {\r\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\r\n    }\r\n    if (isError(value)) {\r\n      return formatError(value);\r\n    }\r\n  }\r\n\r\n  var base = '', array = false, braces = ['{', '}'];\r\n\r\n  // Make Array say that they are Array\r\n  if (isArray$2(value)) {\r\n    array = true;\r\n    braces = ['[', ']'];\r\n  }\r\n\r\n  // Make functions say that they are functions\r\n  if (isFunction(value)) {\r\n    var n = value.name ? ': ' + value.name : '';\r\n    base = ' [Function' + n + ']';\r\n  }\r\n\r\n  // Make RegExps say that they are RegExps\r\n  if (isRegExp(value)) {\r\n    base = ' ' + RegExp.prototype.toString.call(value);\r\n  }\r\n\r\n  // Make dates with properties first say the date\r\n  if (isDate(value)) {\r\n    base = ' ' + Date.prototype.toUTCString.call(value);\r\n  }\r\n\r\n  // Make error with message first say the error\r\n  if (isError(value)) {\r\n    base = ' ' + formatError(value);\r\n  }\r\n\r\n  if (keys.length === 0 && (!array || value.length == 0)) {\r\n    return braces[0] + base + braces[1];\r\n  }\r\n\r\n  if (recurseTimes < 0) {\r\n    if (isRegExp(value)) {\r\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\r\n    } else {\r\n      return ctx.stylize('[Object]', 'special');\r\n    }\r\n  }\r\n\r\n  ctx.seen.push(value);\r\n\r\n  var output;\r\n  if (array) {\r\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\r\n  } else {\r\n    output = keys.map(function(key) {\r\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\r\n    });\r\n  }\r\n\r\n  ctx.seen.pop();\r\n\r\n  return reduceToSingleString(output, base, braces);\r\n}\r\n\r\n\r\nfunction formatPrimitive(ctx, value) {\r\n  if (isUndefined(value))\r\n    return ctx.stylize('undefined', 'undefined');\r\n  if (isString(value)) {\r\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\r\n                                             .replace(/'/g, \"\\\\'\")\r\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\r\n    return ctx.stylize(simple, 'string');\r\n  }\r\n  if (isNumber(value))\r\n    return ctx.stylize('' + value, 'number');\r\n  if (isBoolean(value))\r\n    return ctx.stylize('' + value, 'boolean');\r\n  // For some reason typeof null is \"object\", so special case here.\r\n  if (isNull(value))\r\n    return ctx.stylize('null', 'null');\r\n}\r\n\r\n\r\nfunction formatError(value) {\r\n  return '[' + Error.prototype.toString.call(value) + ']';\r\n}\r\n\r\n\r\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\r\n  var output = [];\r\n  for (var i = 0, l = value.length; i < l; ++i) {\r\n    if (hasOwnProperty$1(value, String(i))) {\r\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\r\n          String(i), true));\r\n    } else {\r\n      output.push('');\r\n    }\r\n  }\r\n  keys.forEach(function(key) {\r\n    if (!key.match(/^\\d+$/)) {\r\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\r\n          key, true));\r\n    }\r\n  });\r\n  return output;\r\n}\r\n\r\n\r\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\r\n  var name, str, desc;\r\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\r\n  if (desc.get) {\r\n    if (desc.set) {\r\n      str = ctx.stylize('[Getter/Setter]', 'special');\r\n    } else {\r\n      str = ctx.stylize('[Getter]', 'special');\r\n    }\r\n  } else {\r\n    if (desc.set) {\r\n      str = ctx.stylize('[Setter]', 'special');\r\n    }\r\n  }\r\n  if (!hasOwnProperty$1(visibleKeys, key)) {\r\n    name = '[' + key + ']';\r\n  }\r\n  if (!str) {\r\n    if (ctx.seen.indexOf(desc.value) < 0) {\r\n      if (isNull(recurseTimes)) {\r\n        str = formatValue(ctx, desc.value, null);\r\n      } else {\r\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\r\n      }\r\n      if (str.indexOf('\\n') > -1) {\r\n        if (array) {\r\n          str = str.split('\\n').map(function(line) {\r\n            return '  ' + line;\r\n          }).join('\\n').substr(2);\r\n        } else {\r\n          str = '\\n' + str.split('\\n').map(function(line) {\r\n            return '   ' + line;\r\n          }).join('\\n');\r\n        }\r\n      }\r\n    } else {\r\n      str = ctx.stylize('[Circular]', 'special');\r\n    }\r\n  }\r\n  if (isUndefined(name)) {\r\n    if (array && key.match(/^\\d+$/)) {\r\n      return str;\r\n    }\r\n    name = JSON.stringify('' + key);\r\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\r\n      name = name.substr(1, name.length - 2);\r\n      name = ctx.stylize(name, 'name');\r\n    } else {\r\n      name = name.replace(/'/g, \"\\\\'\")\r\n                 .replace(/\\\\\"/g, '\"')\r\n                 .replace(/(^\"|\"$)/g, \"'\");\r\n      name = ctx.stylize(name, 'string');\r\n    }\r\n  }\r\n\r\n  return name + ': ' + str;\r\n}\r\n\r\n\r\nfunction reduceToSingleString(output, base, braces) {\r\n  var length = output.reduce(function(prev, cur) {\r\n    if (cur.indexOf('\\n') >= 0) ;\r\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\r\n  }, 0);\r\n\r\n  if (length > 60) {\r\n    return braces[0] +\r\n           (base === '' ? '' : base + '\\n ') +\r\n           ' ' +\r\n           output.join(',\\n  ') +\r\n           ' ' +\r\n           braces[1];\r\n  }\r\n\r\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\r\n}\r\n\r\n\r\n// NOTE: These type checking functions intentionally don't use `instanceof`\r\n// because it is fragile and can be easily faked with `Object.create()`.\r\nfunction isArray$2(ar) {\r\n  return Array.isArray(ar);\r\n}\r\n\r\nfunction isBoolean(arg) {\r\n  return typeof arg === 'boolean';\r\n}\r\n\r\nfunction isNull(arg) {\r\n  return arg === null;\r\n}\r\n\r\nfunction isNullOrUndefined(arg) {\r\n  return arg == null;\r\n}\r\n\r\nfunction isNumber(arg) {\r\n  return typeof arg === 'number';\r\n}\r\n\r\nfunction isString(arg) {\r\n  return typeof arg === 'string';\r\n}\r\n\r\nfunction isUndefined(arg) {\r\n  return arg === void 0;\r\n}\r\n\r\nfunction isRegExp(re) {\r\n  return isObject(re) && objectToString(re) === '[object RegExp]';\r\n}\r\n\r\nfunction isObject(arg) {\r\n  return typeof arg === 'object' && arg !== null;\r\n}\r\n\r\nfunction isDate(d) {\r\n  return isObject(d) && objectToString(d) === '[object Date]';\r\n}\r\n\r\nfunction isError(e) {\r\n  return isObject(e) &&\r\n      (objectToString(e) === '[object Error]' || e instanceof Error);\r\n}\r\n\r\nfunction isFunction(arg) {\r\n  return typeof arg === 'function';\r\n}\r\n\r\nfunction objectToString(o) {\r\n  return Object.prototype.toString.call(o);\r\n}\r\n\r\nfunction _extend(origin, add) {\r\n  // Don't do anything if add isn't an object\r\n  if (!add || !isObject(add)) return origin;\r\n\r\n  var keys = Object.keys(add);\r\n  var i = keys.length;\r\n  while (i--) {\r\n    origin[keys[i]] = add[keys[i]];\r\n  }\r\n  return origin;\r\n}\r\nfunction hasOwnProperty$1(obj, prop) {\r\n  return Object.prototype.hasOwnProperty.call(obj, prop);\r\n}\r\n\r\nvar domain;\r\n\r\n// This constructor is used to store event handlers. Instantiating this is\r\n// faster than explicitly calling `Object.create(null)` to get a \"clean\" empty\r\n// object (tested with v8 v4.9).\r\nfunction EventHandlers() {}\r\nEventHandlers.prototype = Object.create(null);\r\n\r\nfunction EventEmitter() {\r\n  EventEmitter.init.call(this);\r\n}\r\n\r\n// nodejs oddity\r\n// require('events') === require('events').EventEmitter\r\nEventEmitter.EventEmitter = EventEmitter;\r\n\r\nEventEmitter.usingDomains = false;\r\n\r\nEventEmitter.prototype.domain = undefined;\r\nEventEmitter.prototype._events = undefined;\r\nEventEmitter.prototype._maxListeners = undefined;\r\n\r\n// By default EventEmitters will print a warning if more than 10 listeners are\r\n// added to it. This is a useful default which helps finding memory leaks.\r\nEventEmitter.defaultMaxListeners = 10;\r\n\r\nEventEmitter.init = function() {\r\n  this.domain = null;\r\n  if (EventEmitter.usingDomains) {\r\n    // if there is an active domain, then attach to it.\r\n    if (domain.active ) ;\r\n  }\r\n\r\n  if (!this._events || this._events === Object.getPrototypeOf(this)._events) {\r\n    this._events = new EventHandlers();\r\n    this._eventsCount = 0;\r\n  }\r\n\r\n  this._maxListeners = this._maxListeners || undefined;\r\n};\r\n\r\n// Obviously not all Emitters should be limited to 10. This function allows\r\n// that to be increased. Set to zero for unlimited.\r\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\r\n  if (typeof n !== 'number' || n < 0 || isNaN(n))\r\n    throw new TypeError('\"n\" argument must be a positive number');\r\n  this._maxListeners = n;\r\n  return this;\r\n};\r\n\r\nfunction $getMaxListeners(that) {\r\n  if (that._maxListeners === undefined)\r\n    return EventEmitter.defaultMaxListeners;\r\n  return that._maxListeners;\r\n}\r\n\r\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\r\n  return $getMaxListeners(this);\r\n};\r\n\r\n// These standalone emit* functions are used to optimize calling of event\r\n// handlers for fast cases because emit() itself often has a variable number of\r\n// arguments and can be deoptimized because of that. These functions always have\r\n// the same number of arguments and thus do not get deoptimized, so the code\r\n// inside them can execute faster.\r\nfunction emitNone(handler, isFn, self) {\r\n  if (isFn)\r\n    handler.call(self);\r\n  else {\r\n    var len = handler.length;\r\n    var listeners = arrayClone(handler, len);\r\n    for (var i = 0; i < len; ++i)\r\n      listeners[i].call(self);\r\n  }\r\n}\r\nfunction emitOne(handler, isFn, self, arg1) {\r\n  if (isFn)\r\n    handler.call(self, arg1);\r\n  else {\r\n    var len = handler.length;\r\n    var listeners = arrayClone(handler, len);\r\n    for (var i = 0; i < len; ++i)\r\n      listeners[i].call(self, arg1);\r\n  }\r\n}\r\nfunction emitTwo(handler, isFn, self, arg1, arg2) {\r\n  if (isFn)\r\n    handler.call(self, arg1, arg2);\r\n  else {\r\n    var len = handler.length;\r\n    var listeners = arrayClone(handler, len);\r\n    for (var i = 0; i < len; ++i)\r\n      listeners[i].call(self, arg1, arg2);\r\n  }\r\n}\r\nfunction emitThree(handler, isFn, self, arg1, arg2, arg3) {\r\n  if (isFn)\r\n    handler.call(self, arg1, arg2, arg3);\r\n  else {\r\n    var len = handler.length;\r\n    var listeners = arrayClone(handler, len);\r\n    for (var i = 0; i < len; ++i)\r\n      listeners[i].call(self, arg1, arg2, arg3);\r\n  }\r\n}\r\n\r\nfunction emitMany(handler, isFn, self, args) {\r\n  if (isFn)\r\n    handler.apply(self, args);\r\n  else {\r\n    var len = handler.length;\r\n    var listeners = arrayClone(handler, len);\r\n    for (var i = 0; i < len; ++i)\r\n      listeners[i].apply(self, args);\r\n  }\r\n}\r\n\r\nEventEmitter.prototype.emit = function emit(type) {\r\n  var er, handler, len, args, i, events, domain;\r\n  var doError = (type === 'error');\r\n\r\n  events = this._events;\r\n  if (events)\r\n    doError = (doError && events.error == null);\r\n  else if (!doError)\r\n    return false;\r\n\r\n  domain = this.domain;\r\n\r\n  // If there is no 'error' event listener then throw.\r\n  if (doError) {\r\n    er = arguments[1];\r\n    if (domain) {\r\n      if (!er)\r\n        er = new Error('Uncaught, unspecified \"error\" event');\r\n      er.domainEmitter = this;\r\n      er.domain = domain;\r\n      er.domainThrown = false;\r\n      domain.emit('error', er);\r\n    } else if (er instanceof Error) {\r\n      throw er; // Unhandled 'error' event\r\n    } else {\r\n      // At least give some kind of context to the user\r\n      var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\r\n      err.context = er;\r\n      throw err;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  handler = events[type];\r\n\r\n  if (!handler)\r\n    return false;\r\n\r\n  var isFn = typeof handler === 'function';\r\n  len = arguments.length;\r\n  switch (len) {\r\n    // fast cases\r\n    case 1:\r\n      emitNone(handler, isFn, this);\r\n      break;\r\n    case 2:\r\n      emitOne(handler, isFn, this, arguments[1]);\r\n      break;\r\n    case 3:\r\n      emitTwo(handler, isFn, this, arguments[1], arguments[2]);\r\n      break;\r\n    case 4:\r\n      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);\r\n      break;\r\n    // slower\r\n    default:\r\n      args = new Array(len - 1);\r\n      for (i = 1; i < len; i++)\r\n        args[i - 1] = arguments[i];\r\n      emitMany(handler, isFn, this, args);\r\n  }\r\n\r\n  return true;\r\n};\r\n\r\nfunction _addListener(target, type, listener, prepend) {\r\n  var m;\r\n  var events;\r\n  var existing;\r\n\r\n  if (typeof listener !== 'function')\r\n    throw new TypeError('\"listener\" argument must be a function');\r\n\r\n  events = target._events;\r\n  if (!events) {\r\n    events = target._events = new EventHandlers();\r\n    target._eventsCount = 0;\r\n  } else {\r\n    // To avoid recursion in the case that type === \"newListener\"! Before\r\n    // adding it to the listeners, first emit \"newListener\".\r\n    if (events.newListener) {\r\n      target.emit('newListener', type,\r\n                  listener.listener ? listener.listener : listener);\r\n\r\n      // Re-assign `events` because a newListener handler could have caused the\r\n      // this._events to be assigned to a new object\r\n      events = target._events;\r\n    }\r\n    existing = events[type];\r\n  }\r\n\r\n  if (!existing) {\r\n    // Optimize the case of one listener. Don't need the extra array object.\r\n    existing = events[type] = listener;\r\n    ++target._eventsCount;\r\n  } else {\r\n    if (typeof existing === 'function') {\r\n      // Adding the second element, need to change to array.\r\n      existing = events[type] = prepend ? [listener, existing] :\r\n                                          [existing, listener];\r\n    } else {\r\n      // If we've already got an array, just append.\r\n      if (prepend) {\r\n        existing.unshift(listener);\r\n      } else {\r\n        existing.push(listener);\r\n      }\r\n    }\r\n\r\n    // Check for listener leak\r\n    if (!existing.warned) {\r\n      m = $getMaxListeners(target);\r\n      if (m && m > 0 && existing.length > m) {\r\n        existing.warned = true;\r\n        var w = new Error('Possible EventEmitter memory leak detected. ' +\r\n                            existing.length + ' ' + type + ' listeners added. ' +\r\n                            'Use emitter.setMaxListeners() to increase limit');\r\n        w.name = 'MaxListenersExceededWarning';\r\n        w.emitter = target;\r\n        w.type = type;\r\n        w.count = existing.length;\r\n        emitWarning(w);\r\n      }\r\n    }\r\n  }\r\n\r\n  return target;\r\n}\r\nfunction emitWarning(e) {\r\n  typeof console.warn === 'function' ? console.warn(e) : console.log(e);\r\n}\r\nEventEmitter.prototype.addListener = function addListener(type, listener) {\r\n  return _addListener(this, type, listener, false);\r\n};\r\n\r\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\r\n\r\nEventEmitter.prototype.prependListener =\r\n    function prependListener(type, listener) {\r\n      return _addListener(this, type, listener, true);\r\n    };\r\n\r\nfunction _onceWrap(target, type, listener) {\r\n  var fired = false;\r\n  function g() {\r\n    target.removeListener(type, g);\r\n    if (!fired) {\r\n      fired = true;\r\n      listener.apply(target, arguments);\r\n    }\r\n  }\r\n  g.listener = listener;\r\n  return g;\r\n}\r\n\r\nEventEmitter.prototype.once = function once(type, listener) {\r\n  if (typeof listener !== 'function')\r\n    throw new TypeError('\"listener\" argument must be a function');\r\n  this.on(type, _onceWrap(this, type, listener));\r\n  return this;\r\n};\r\n\r\nEventEmitter.prototype.prependOnceListener =\r\n    function prependOnceListener(type, listener) {\r\n      if (typeof listener !== 'function')\r\n        throw new TypeError('\"listener\" argument must be a function');\r\n      this.prependListener(type, _onceWrap(this, type, listener));\r\n      return this;\r\n    };\r\n\r\n// emits a 'removeListener' event iff the listener was removed\r\nEventEmitter.prototype.removeListener =\r\n    function removeListener(type, listener) {\r\n      var list, events, position, i, originalListener;\r\n\r\n      if (typeof listener !== 'function')\r\n        throw new TypeError('\"listener\" argument must be a function');\r\n\r\n      events = this._events;\r\n      if (!events)\r\n        return this;\r\n\r\n      list = events[type];\r\n      if (!list)\r\n        return this;\r\n\r\n      if (list === listener || (list.listener && list.listener === listener)) {\r\n        if (--this._eventsCount === 0)\r\n          this._events = new EventHandlers();\r\n        else {\r\n          delete events[type];\r\n          if (events.removeListener)\r\n            this.emit('removeListener', type, list.listener || listener);\r\n        }\r\n      } else if (typeof list !== 'function') {\r\n        position = -1;\r\n\r\n        for (i = list.length; i-- > 0;) {\r\n          if (list[i] === listener ||\r\n              (list[i].listener && list[i].listener === listener)) {\r\n            originalListener = list[i].listener;\r\n            position = i;\r\n            break;\r\n          }\r\n        }\r\n\r\n        if (position < 0)\r\n          return this;\r\n\r\n        if (list.length === 1) {\r\n          list[0] = undefined;\r\n          if (--this._eventsCount === 0) {\r\n            this._events = new EventHandlers();\r\n            return this;\r\n          } else {\r\n            delete events[type];\r\n          }\r\n        } else {\r\n          spliceOne(list, position);\r\n        }\r\n\r\n        if (events.removeListener)\r\n          this.emit('removeListener', type, originalListener || listener);\r\n      }\r\n\r\n      return this;\r\n    };\r\n    \r\n// Alias for removeListener added in NodeJS 10.0\r\n// https://nodejs.org/api/events.html#events_emitter_off_eventname_listener\r\nEventEmitter.prototype.off = function(type, listener){\r\n    return this.removeListener(type, listener);\r\n};\r\n\r\nEventEmitter.prototype.removeAllListeners =\r\n    function removeAllListeners(type) {\r\n      var listeners, events;\r\n\r\n      events = this._events;\r\n      if (!events)\r\n        return this;\r\n\r\n      // not listening for removeListener, no need to emit\r\n      if (!events.removeListener) {\r\n        if (arguments.length === 0) {\r\n          this._events = new EventHandlers();\r\n          this._eventsCount = 0;\r\n        } else if (events[type]) {\r\n          if (--this._eventsCount === 0)\r\n            this._events = new EventHandlers();\r\n          else\r\n            delete events[type];\r\n        }\r\n        return this;\r\n      }\r\n\r\n      // emit removeListener for all listeners on all events\r\n      if (arguments.length === 0) {\r\n        var keys = Object.keys(events);\r\n        for (var i = 0, key; i < keys.length; ++i) {\r\n          key = keys[i];\r\n          if (key === 'removeListener') continue;\r\n          this.removeAllListeners(key);\r\n        }\r\n        this.removeAllListeners('removeListener');\r\n        this._events = new EventHandlers();\r\n        this._eventsCount = 0;\r\n        return this;\r\n      }\r\n\r\n      listeners = events[type];\r\n\r\n      if (typeof listeners === 'function') {\r\n        this.removeListener(type, listeners);\r\n      } else if (listeners) {\r\n        // LIFO order\r\n        do {\r\n          this.removeListener(type, listeners[listeners.length - 1]);\r\n        } while (listeners[0]);\r\n      }\r\n\r\n      return this;\r\n    };\r\n\r\nEventEmitter.prototype.listeners = function listeners(type) {\r\n  var evlistener;\r\n  var ret;\r\n  var events = this._events;\r\n\r\n  if (!events)\r\n    ret = [];\r\n  else {\r\n    evlistener = events[type];\r\n    if (!evlistener)\r\n      ret = [];\r\n    else if (typeof evlistener === 'function')\r\n      ret = [evlistener.listener || evlistener];\r\n    else\r\n      ret = unwrapListeners(evlistener);\r\n  }\r\n\r\n  return ret;\r\n};\r\n\r\nEventEmitter.listenerCount = function(emitter, type) {\r\n  if (typeof emitter.listenerCount === 'function') {\r\n    return emitter.listenerCount(type);\r\n  } else {\r\n    return listenerCount$1.call(emitter, type);\r\n  }\r\n};\r\n\r\nEventEmitter.prototype.listenerCount = listenerCount$1;\r\nfunction listenerCount$1(type) {\r\n  var events = this._events;\r\n\r\n  if (events) {\r\n    var evlistener = events[type];\r\n\r\n    if (typeof evlistener === 'function') {\r\n      return 1;\r\n    } else if (evlistener) {\r\n      return evlistener.length;\r\n    }\r\n  }\r\n\r\n  return 0;\r\n}\r\n\r\nEventEmitter.prototype.eventNames = function eventNames() {\r\n  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];\r\n};\r\n\r\n// About 1.5x faster than the two-arg version of Array#splice().\r\nfunction spliceOne(list, index) {\r\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\r\n    list[i] = list[k];\r\n  list.pop();\r\n}\r\n\r\nfunction arrayClone(arr, i) {\r\n  var copy = new Array(i);\r\n  while (i--)\r\n    copy[i] = arr[i];\r\n  return copy;\r\n}\r\n\r\nfunction unwrapListeners(arr) {\r\n  var ret = new Array(arr.length);\r\n  for (var i = 0; i < ret.length; ++i) {\r\n    ret[i] = arr[i].listener || arr[i];\r\n  }\r\n  return ret;\r\n}\r\n\r\nvar lookup = [];\r\nvar revLookup = [];\r\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;\r\nvar inited = false;\r\nfunction init () {\r\n  inited = true;\r\n  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\r\n  for (var i = 0, len = code.length; i < len; ++i) {\r\n    lookup[i] = code[i];\r\n    revLookup[code.charCodeAt(i)] = i;\r\n  }\r\n\r\n  revLookup['-'.charCodeAt(0)] = 62;\r\n  revLookup['_'.charCodeAt(0)] = 63;\r\n}\r\n\r\nfunction toByteArray (b64) {\r\n  if (!inited) {\r\n    init();\r\n  }\r\n  var i, j, l, tmp, placeHolders, arr;\r\n  var len = b64.length;\r\n\r\n  if (len % 4 > 0) {\r\n    throw new Error('Invalid string. Length must be a multiple of 4')\r\n  }\r\n\r\n  // the number of equal signs (place holders)\r\n  // if there are two placeholders, than the two characters before it\r\n  // represent one byte\r\n  // if there is only one, then the three characters before it represent 2 bytes\r\n  // this is just a cheap hack to not do indexOf twice\r\n  placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0;\r\n\r\n  // base64 is 4/3 + up to two characters of the original data\r\n  arr = new Arr(len * 3 / 4 - placeHolders);\r\n\r\n  // if there are placeholders, only get up to the last complete 4 chars\r\n  l = placeHolders > 0 ? len - 4 : len;\r\n\r\n  var L = 0;\r\n\r\n  for (i = 0, j = 0; i < l; i += 4, j += 3) {\r\n    tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)];\r\n    arr[L++] = (tmp >> 16) & 0xFF;\r\n    arr[L++] = (tmp >> 8) & 0xFF;\r\n    arr[L++] = tmp & 0xFF;\r\n  }\r\n\r\n  if (placeHolders === 2) {\r\n    tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4);\r\n    arr[L++] = tmp & 0xFF;\r\n  } else if (placeHolders === 1) {\r\n    tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2);\r\n    arr[L++] = (tmp >> 8) & 0xFF;\r\n    arr[L++] = tmp & 0xFF;\r\n  }\r\n\r\n  return arr\r\n}\r\n\r\nfunction tripletToBase64 (num) {\r\n  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]\r\n}\r\n\r\nfunction encodeChunk (uint8, start, end) {\r\n  var tmp;\r\n  var output = [];\r\n  for (var i = start; i < end; i += 3) {\r\n    tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);\r\n    output.push(tripletToBase64(tmp));\r\n  }\r\n  return output.join('')\r\n}\r\n\r\nfunction fromByteArray (uint8) {\r\n  if (!inited) {\r\n    init();\r\n  }\r\n  var tmp;\r\n  var len = uint8.length;\r\n  var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes\r\n  var output = '';\r\n  var parts = [];\r\n  var maxChunkLength = 16383; // must be multiple of 3\r\n\r\n  // go through the array every three bytes, we'll deal with trailing stuff later\r\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\r\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));\r\n  }\r\n\r\n  // pad the end with zeros, but make sure to not forget the extra bytes\r\n  if (extraBytes === 1) {\r\n    tmp = uint8[len - 1];\r\n    output += lookup[tmp >> 2];\r\n    output += lookup[(tmp << 4) & 0x3F];\r\n    output += '==';\r\n  } else if (extraBytes === 2) {\r\n    tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);\r\n    output += lookup[tmp >> 10];\r\n    output += lookup[(tmp >> 4) & 0x3F];\r\n    output += lookup[(tmp << 2) & 0x3F];\r\n    output += '=';\r\n  }\r\n\r\n  parts.push(output);\r\n\r\n  return parts.join('')\r\n}\r\n\r\nfunction read (buffer, offset, isLE, mLen, nBytes) {\r\n  var e, m;\r\n  var eLen = nBytes * 8 - mLen - 1;\r\n  var eMax = (1 << eLen) - 1;\r\n  var eBias = eMax >> 1;\r\n  var nBits = -7;\r\n  var i = isLE ? (nBytes - 1) : 0;\r\n  var d = isLE ? -1 : 1;\r\n  var s = buffer[offset + i];\r\n\r\n  i += d;\r\n\r\n  e = s & ((1 << (-nBits)) - 1);\r\n  s >>= (-nBits);\r\n  nBits += eLen;\r\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n  m = e & ((1 << (-nBits)) - 1);\r\n  e >>= (-nBits);\r\n  nBits += mLen;\r\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n  if (e === 0) {\r\n    e = 1 - eBias;\r\n  } else if (e === eMax) {\r\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\r\n  } else {\r\n    m = m + Math.pow(2, mLen);\r\n    e = e - eBias;\r\n  }\r\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\r\n}\r\n\r\nfunction write (buffer, value, offset, isLE, mLen, nBytes) {\r\n  var e, m, c;\r\n  var eLen = nBytes * 8 - mLen - 1;\r\n  var eMax = (1 << eLen) - 1;\r\n  var eBias = eMax >> 1;\r\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);\r\n  var i = isLE ? 0 : (nBytes - 1);\r\n  var d = isLE ? 1 : -1;\r\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\r\n\r\n  value = Math.abs(value);\r\n\r\n  if (isNaN(value) || value === Infinity) {\r\n    m = isNaN(value) ? 1 : 0;\r\n    e = eMax;\r\n  } else {\r\n    e = Math.floor(Math.log(value) / Math.LN2);\r\n    if (value * (c = Math.pow(2, -e)) < 1) {\r\n      e--;\r\n      c *= 2;\r\n    }\r\n    if (e + eBias >= 1) {\r\n      value += rt / c;\r\n    } else {\r\n      value += rt * Math.pow(2, 1 - eBias);\r\n    }\r\n    if (value * c >= 2) {\r\n      e++;\r\n      c /= 2;\r\n    }\r\n\r\n    if (e + eBias >= eMax) {\r\n      m = 0;\r\n      e = eMax;\r\n    } else if (e + eBias >= 1) {\r\n      m = (value * c - 1) * Math.pow(2, mLen);\r\n      e = e + eBias;\r\n    } else {\r\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\r\n      e = 0;\r\n    }\r\n  }\r\n\r\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\r\n\r\n  e = (e << mLen) | m;\r\n  eLen += mLen;\r\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\r\n\r\n  buffer[offset + i - d] |= s * 128;\r\n}\r\n\r\nvar toString = {}.toString;\r\n\r\nvar isArray$1 = Array.isArray || function (arr) {\r\n  return toString.call(arr) == '[object Array]';\r\n};\r\n\r\n/*!\r\n * The buffer module from node.js, for the browser.\r\n *\r\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\r\n * @license  MIT\r\n */\r\n\r\nvar INSPECT_MAX_BYTES = 50;\r\n\r\n/**\r\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\r\n *   === true    Use Uint8Array implementation (fastest)\r\n *   === false   Use Object implementation (most compatible, even IE6)\r\n *\r\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\r\n * Opera 11.6+, iOS 4.2+.\r\n *\r\n * Due to various browser bugs, sometimes the Object implementation will be used even\r\n * when the browser supports typed arrays.\r\n *\r\n * Note:\r\n *\r\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\r\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\r\n *\r\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\r\n *\r\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\r\n *     incorrect length in some situations.\r\n\r\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\r\n * get the Object implementation, which is slower but behaves correctly.\r\n */\r\nBuffer$1.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\r\n  ? global.TYPED_ARRAY_SUPPORT\r\n  : true;\r\n\r\nfunction kMaxLength () {\r\n  return Buffer$1.TYPED_ARRAY_SUPPORT\r\n    ? 0x7fffffff\r\n    : 0x3fffffff\r\n}\r\n\r\nfunction createBuffer (that, length) {\r\n  if (kMaxLength() < length) {\r\n    throw new RangeError('Invalid typed array length')\r\n  }\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    // Return an augmented `Uint8Array` instance, for best performance\r\n    that = new Uint8Array(length);\r\n    that.__proto__ = Buffer$1.prototype;\r\n  } else {\r\n    // Fallback: Return an object instance of the Buffer class\r\n    if (that === null) {\r\n      that = new Buffer$1(length);\r\n    }\r\n    that.length = length;\r\n  }\r\n\r\n  return that\r\n}\r\n\r\n/**\r\n * The Buffer constructor returns instances of `Uint8Array` that have their\r\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\r\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\r\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\r\n * returns a single octet.\r\n *\r\n * The `Uint8Array` prototype remains unmodified.\r\n */\r\n\r\nfunction Buffer$1 (arg, encodingOrOffset, length) {\r\n  if (!Buffer$1.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer$1)) {\r\n    return new Buffer$1(arg, encodingOrOffset, length)\r\n  }\r\n\r\n  // Common case.\r\n  if (typeof arg === 'number') {\r\n    if (typeof encodingOrOffset === 'string') {\r\n      throw new Error(\r\n        'If encoding is specified then the first argument must be a string'\r\n      )\r\n    }\r\n    return allocUnsafe(this, arg)\r\n  }\r\n  return from(this, arg, encodingOrOffset, length)\r\n}\r\n\r\nBuffer$1.poolSize = 8192; // not used by this implementation\r\n\r\n// TODO: Legacy, not needed anymore. Remove in next major version.\r\nBuffer$1._augment = function (arr) {\r\n  arr.__proto__ = Buffer$1.prototype;\r\n  return arr\r\n};\r\n\r\nfunction from (that, value, encodingOrOffset, length) {\r\n  if (typeof value === 'number') {\r\n    throw new TypeError('\"value\" argument must not be a number')\r\n  }\r\n\r\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\r\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\r\n  }\r\n\r\n  if (typeof value === 'string') {\r\n    return fromString(that, value, encodingOrOffset)\r\n  }\r\n\r\n  return fromObject(that, value)\r\n}\r\n\r\n/**\r\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\r\n * if value is a number.\r\n * Buffer.from(str[, encoding])\r\n * Buffer.from(array)\r\n * Buffer.from(buffer)\r\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\r\n **/\r\nBuffer$1.from = function (value, encodingOrOffset, length) {\r\n  return from(null, value, encodingOrOffset, length)\r\n};\r\n\r\nif (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n  Buffer$1.prototype.__proto__ = Uint8Array.prototype;\r\n  Buffer$1.__proto__ = Uint8Array;\r\n}\r\n\r\nfunction assertSize (size) {\r\n  if (typeof size !== 'number') {\r\n    throw new TypeError('\"size\" argument must be a number')\r\n  } else if (size < 0) {\r\n    throw new RangeError('\"size\" argument must not be negative')\r\n  }\r\n}\r\n\r\nfunction alloc (that, size, fill, encoding) {\r\n  assertSize(size);\r\n  if (size <= 0) {\r\n    return createBuffer(that, size)\r\n  }\r\n  if (fill !== undefined) {\r\n    // Only pay attention to encoding if it's a string. This\r\n    // prevents accidentally sending in a number that would\r\n    // be interpretted as a start offset.\r\n    return typeof encoding === 'string'\r\n      ? createBuffer(that, size).fill(fill, encoding)\r\n      : createBuffer(that, size).fill(fill)\r\n  }\r\n  return createBuffer(that, size)\r\n}\r\n\r\n/**\r\n * Creates a new filled Buffer instance.\r\n * alloc(size[, fill[, encoding]])\r\n **/\r\nBuffer$1.alloc = function (size, fill, encoding) {\r\n  return alloc(null, size, fill, encoding)\r\n};\r\n\r\nfunction allocUnsafe (that, size) {\r\n  assertSize(size);\r\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);\r\n  if (!Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    for (var i = 0; i < size; ++i) {\r\n      that[i] = 0;\r\n    }\r\n  }\r\n  return that\r\n}\r\n\r\n/**\r\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\r\n * */\r\nBuffer$1.allocUnsafe = function (size) {\r\n  return allocUnsafe(null, size)\r\n};\r\n/**\r\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\r\n */\r\nBuffer$1.allocUnsafeSlow = function (size) {\r\n  return allocUnsafe(null, size)\r\n};\r\n\r\nfunction fromString (that, string, encoding) {\r\n  if (typeof encoding !== 'string' || encoding === '') {\r\n    encoding = 'utf8';\r\n  }\r\n\r\n  if (!Buffer$1.isEncoding(encoding)) {\r\n    throw new TypeError('\"encoding\" must be a valid string encoding')\r\n  }\r\n\r\n  var length = byteLength(string, encoding) | 0;\r\n  that = createBuffer(that, length);\r\n\r\n  var actual = that.write(string, encoding);\r\n\r\n  if (actual !== length) {\r\n    // Writing a hex string, for example, that contains invalid characters will\r\n    // cause everything after the first invalid character to be ignored. (e.g.\r\n    // 'abxxcd' will be treated as 'ab')\r\n    that = that.slice(0, actual);\r\n  }\r\n\r\n  return that\r\n}\r\n\r\nfunction fromArrayLike (that, array) {\r\n  var length = array.length < 0 ? 0 : checked(array.length) | 0;\r\n  that = createBuffer(that, length);\r\n  for (var i = 0; i < length; i += 1) {\r\n    that[i] = array[i] & 255;\r\n  }\r\n  return that\r\n}\r\n\r\nfunction fromArrayBuffer (that, array, byteOffset, length) {\r\n  array.byteLength; // this throws if `array` is not a valid ArrayBuffer\r\n\r\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\r\n    throw new RangeError('\\'offset\\' is out of bounds')\r\n  }\r\n\r\n  if (array.byteLength < byteOffset + (length || 0)) {\r\n    throw new RangeError('\\'length\\' is out of bounds')\r\n  }\r\n\r\n  if (byteOffset === undefined && length === undefined) {\r\n    array = new Uint8Array(array);\r\n  } else if (length === undefined) {\r\n    array = new Uint8Array(array, byteOffset);\r\n  } else {\r\n    array = new Uint8Array(array, byteOffset, length);\r\n  }\r\n\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    // Return an augmented `Uint8Array` instance, for best performance\r\n    that = array;\r\n    that.__proto__ = Buffer$1.prototype;\r\n  } else {\r\n    // Fallback: Return an object instance of the Buffer class\r\n    that = fromArrayLike(that, array);\r\n  }\r\n  return that\r\n}\r\n\r\nfunction fromObject (that, obj) {\r\n  if (internalIsBuffer(obj)) {\r\n    var len = checked(obj.length) | 0;\r\n    that = createBuffer(that, len);\r\n\r\n    if (that.length === 0) {\r\n      return that\r\n    }\r\n\r\n    obj.copy(that, 0, 0, len);\r\n    return that\r\n  }\r\n\r\n  if (obj) {\r\n    if ((typeof ArrayBuffer !== 'undefined' &&\r\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\r\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\r\n        return createBuffer(that, 0)\r\n      }\r\n      return fromArrayLike(that, obj)\r\n    }\r\n\r\n    if (obj.type === 'Buffer' && isArray$1(obj.data)) {\r\n      return fromArrayLike(that, obj.data)\r\n    }\r\n  }\r\n\r\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\r\n}\r\n\r\nfunction checked (length) {\r\n  // Note: cannot use `length < kMaxLength()` here because that fails when\r\n  // length is NaN (which is otherwise coerced to zero.)\r\n  if (length >= kMaxLength()) {\r\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\r\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\r\n  }\r\n  return length | 0\r\n}\r\nBuffer$1.isBuffer = isBuffer;\r\nfunction internalIsBuffer (b) {\r\n  return !!(b != null && b._isBuffer)\r\n}\r\n\r\nBuffer$1.compare = function compare (a, b) {\r\n  if (!internalIsBuffer(a) || !internalIsBuffer(b)) {\r\n    throw new TypeError('Arguments must be Buffers')\r\n  }\r\n\r\n  if (a === b) return 0\r\n\r\n  var x = a.length;\r\n  var y = b.length;\r\n\r\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\r\n    if (a[i] !== b[i]) {\r\n      x = a[i];\r\n      y = b[i];\r\n      break\r\n    }\r\n  }\r\n\r\n  if (x < y) return -1\r\n  if (y < x) return 1\r\n  return 0\r\n};\r\n\r\nBuffer$1.isEncoding = function isEncoding (encoding) {\r\n  switch (String(encoding).toLowerCase()) {\r\n    case 'hex':\r\n    case 'utf8':\r\n    case 'utf-8':\r\n    case 'ascii':\r\n    case 'latin1':\r\n    case 'binary':\r\n    case 'base64':\r\n    case 'ucs2':\r\n    case 'ucs-2':\r\n    case 'utf16le':\r\n    case 'utf-16le':\r\n      return true\r\n    default:\r\n      return false\r\n  }\r\n};\r\n\r\nBuffer$1.concat = function concat (list, length) {\r\n  if (!isArray$1(list)) {\r\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\r\n  }\r\n\r\n  if (list.length === 0) {\r\n    return Buffer$1.alloc(0)\r\n  }\r\n\r\n  var i;\r\n  if (length === undefined) {\r\n    length = 0;\r\n    for (i = 0; i < list.length; ++i) {\r\n      length += list[i].length;\r\n    }\r\n  }\r\n\r\n  var buffer = Buffer$1.allocUnsafe(length);\r\n  var pos = 0;\r\n  for (i = 0; i < list.length; ++i) {\r\n    var buf = list[i];\r\n    if (!internalIsBuffer(buf)) {\r\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\r\n    }\r\n    buf.copy(buffer, pos);\r\n    pos += buf.length;\r\n  }\r\n  return buffer\r\n};\r\n\r\nfunction byteLength (string, encoding) {\r\n  if (internalIsBuffer(string)) {\r\n    return string.length\r\n  }\r\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\r\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\r\n    return string.byteLength\r\n  }\r\n  if (typeof string !== 'string') {\r\n    string = '' + string;\r\n  }\r\n\r\n  var len = string.length;\r\n  if (len === 0) return 0\r\n\r\n  // Use a for loop to avoid recursion\r\n  var loweredCase = false;\r\n  for (;;) {\r\n    switch (encoding) {\r\n      case 'ascii':\r\n      case 'latin1':\r\n      case 'binary':\r\n        return len\r\n      case 'utf8':\r\n      case 'utf-8':\r\n      case undefined:\r\n        return utf8ToBytes(string).length\r\n      case 'ucs2':\r\n      case 'ucs-2':\r\n      case 'utf16le':\r\n      case 'utf-16le':\r\n        return len * 2\r\n      case 'hex':\r\n        return len >>> 1\r\n      case 'base64':\r\n        return base64ToBytes(string).length\r\n      default:\r\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\r\n        encoding = ('' + encoding).toLowerCase();\r\n        loweredCase = true;\r\n    }\r\n  }\r\n}\r\nBuffer$1.byteLength = byteLength;\r\n\r\nfunction slowToString (encoding, start, end) {\r\n  var loweredCase = false;\r\n\r\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\r\n  // property of a typed array.\r\n\r\n  // This behaves neither like String nor Uint8Array in that we set start/end\r\n  // to their upper/lower bounds if the value passed is out of range.\r\n  // undefined is handled specially as per ECMA-262 6th Edition,\r\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\r\n  if (start === undefined || start < 0) {\r\n    start = 0;\r\n  }\r\n  // Return early if start > this.length. Done here to prevent potential uint32\r\n  // coercion fail below.\r\n  if (start > this.length) {\r\n    return ''\r\n  }\r\n\r\n  if (end === undefined || end > this.length) {\r\n    end = this.length;\r\n  }\r\n\r\n  if (end <= 0) {\r\n    return ''\r\n  }\r\n\r\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\r\n  end >>>= 0;\r\n  start >>>= 0;\r\n\r\n  if (end <= start) {\r\n    return ''\r\n  }\r\n\r\n  if (!encoding) encoding = 'utf8';\r\n\r\n  while (true) {\r\n    switch (encoding) {\r\n      case 'hex':\r\n        return hexSlice(this, start, end)\r\n\r\n      case 'utf8':\r\n      case 'utf-8':\r\n        return utf8Slice(this, start, end)\r\n\r\n      case 'ascii':\r\n        return asciiSlice(this, start, end)\r\n\r\n      case 'latin1':\r\n      case 'binary':\r\n        return latin1Slice(this, start, end)\r\n\r\n      case 'base64':\r\n        return base64Slice(this, start, end)\r\n\r\n      case 'ucs2':\r\n      case 'ucs-2':\r\n      case 'utf16le':\r\n      case 'utf-16le':\r\n        return utf16leSlice(this, start, end)\r\n\r\n      default:\r\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\r\n        encoding = (encoding + '').toLowerCase();\r\n        loweredCase = true;\r\n    }\r\n  }\r\n}\r\n\r\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\r\n// Buffer instances.\r\nBuffer$1.prototype._isBuffer = true;\r\n\r\nfunction swap (b, n, m) {\r\n  var i = b[n];\r\n  b[n] = b[m];\r\n  b[m] = i;\r\n}\r\n\r\nBuffer$1.prototype.swap16 = function swap16 () {\r\n  var len = this.length;\r\n  if (len % 2 !== 0) {\r\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\r\n  }\r\n  for (var i = 0; i < len; i += 2) {\r\n    swap(this, i, i + 1);\r\n  }\r\n  return this\r\n};\r\n\r\nBuffer$1.prototype.swap32 = function swap32 () {\r\n  var len = this.length;\r\n  if (len % 4 !== 0) {\r\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\r\n  }\r\n  for (var i = 0; i < len; i += 4) {\r\n    swap(this, i, i + 3);\r\n    swap(this, i + 1, i + 2);\r\n  }\r\n  return this\r\n};\r\n\r\nBuffer$1.prototype.swap64 = function swap64 () {\r\n  var len = this.length;\r\n  if (len % 8 !== 0) {\r\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\r\n  }\r\n  for (var i = 0; i < len; i += 8) {\r\n    swap(this, i, i + 7);\r\n    swap(this, i + 1, i + 6);\r\n    swap(this, i + 2, i + 5);\r\n    swap(this, i + 3, i + 4);\r\n  }\r\n  return this\r\n};\r\n\r\nBuffer$1.prototype.toString = function toString () {\r\n  var length = this.length | 0;\r\n  if (length === 0) return ''\r\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\r\n  return slowToString.apply(this, arguments)\r\n};\r\n\r\nBuffer$1.prototype.equals = function equals (b) {\r\n  if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')\r\n  if (this === b) return true\r\n  return Buffer$1.compare(this, b) === 0\r\n};\r\n\r\nBuffer$1.prototype.inspect = function inspect () {\r\n  var str = '';\r\n  var max = INSPECT_MAX_BYTES;\r\n  if (this.length > 0) {\r\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');\r\n    if (this.length > max) str += ' ... ';\r\n  }\r\n  return '<Buffer ' + str + '>'\r\n};\r\n\r\nBuffer$1.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\r\n  if (!internalIsBuffer(target)) {\r\n    throw new TypeError('Argument must be a Buffer')\r\n  }\r\n\r\n  if (start === undefined) {\r\n    start = 0;\r\n  }\r\n  if (end === undefined) {\r\n    end = target ? target.length : 0;\r\n  }\r\n  if (thisStart === undefined) {\r\n    thisStart = 0;\r\n  }\r\n  if (thisEnd === undefined) {\r\n    thisEnd = this.length;\r\n  }\r\n\r\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\r\n    throw new RangeError('out of range index')\r\n  }\r\n\r\n  if (thisStart >= thisEnd && start >= end) {\r\n    return 0\r\n  }\r\n  if (thisStart >= thisEnd) {\r\n    return -1\r\n  }\r\n  if (start >= end) {\r\n    return 1\r\n  }\r\n\r\n  start >>>= 0;\r\n  end >>>= 0;\r\n  thisStart >>>= 0;\r\n  thisEnd >>>= 0;\r\n\r\n  if (this === target) return 0\r\n\r\n  var x = thisEnd - thisStart;\r\n  var y = end - start;\r\n  var len = Math.min(x, y);\r\n\r\n  var thisCopy = this.slice(thisStart, thisEnd);\r\n  var targetCopy = target.slice(start, end);\r\n\r\n  for (var i = 0; i < len; ++i) {\r\n    if (thisCopy[i] !== targetCopy[i]) {\r\n      x = thisCopy[i];\r\n      y = targetCopy[i];\r\n      break\r\n    }\r\n  }\r\n\r\n  if (x < y) return -1\r\n  if (y < x) return 1\r\n  return 0\r\n};\r\n\r\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\r\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\r\n//\r\n// Arguments:\r\n// - buffer - a Buffer to search\r\n// - val - a string, Buffer, or number\r\n// - byteOffset - an index into `buffer`; will be clamped to an int32\r\n// - encoding - an optional encoding, relevant is val is a string\r\n// - dir - true for indexOf, false for lastIndexOf\r\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\r\n  // Empty buffer means no match\r\n  if (buffer.length === 0) return -1\r\n\r\n  // Normalize byteOffset\r\n  if (typeof byteOffset === 'string') {\r\n    encoding = byteOffset;\r\n    byteOffset = 0;\r\n  } else if (byteOffset > 0x7fffffff) {\r\n    byteOffset = 0x7fffffff;\r\n  } else if (byteOffset < -0x80000000) {\r\n    byteOffset = -0x80000000;\r\n  }\r\n  byteOffset = +byteOffset;  // Coerce to Number.\r\n  if (isNaN(byteOffset)) {\r\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\r\n    byteOffset = dir ? 0 : (buffer.length - 1);\r\n  }\r\n\r\n  // Normalize byteOffset: negative offsets start from the end of the buffer\r\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset;\r\n  if (byteOffset >= buffer.length) {\r\n    if (dir) return -1\r\n    else byteOffset = buffer.length - 1;\r\n  } else if (byteOffset < 0) {\r\n    if (dir) byteOffset = 0;\r\n    else return -1\r\n  }\r\n\r\n  // Normalize val\r\n  if (typeof val === 'string') {\r\n    val = Buffer$1.from(val, encoding);\r\n  }\r\n\r\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\r\n  if (internalIsBuffer(val)) {\r\n    // Special case: looking for empty string/buffer always fails\r\n    if (val.length === 0) {\r\n      return -1\r\n    }\r\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\r\n  } else if (typeof val === 'number') {\r\n    val = val & 0xFF; // Search for a byte value [0-255]\r\n    if (Buffer$1.TYPED_ARRAY_SUPPORT &&\r\n        typeof Uint8Array.prototype.indexOf === 'function') {\r\n      if (dir) {\r\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\r\n      } else {\r\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\r\n      }\r\n    }\r\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\r\n  }\r\n\r\n  throw new TypeError('val must be string, number or Buffer')\r\n}\r\n\r\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\r\n  var indexSize = 1;\r\n  var arrLength = arr.length;\r\n  var valLength = val.length;\r\n\r\n  if (encoding !== undefined) {\r\n    encoding = String(encoding).toLowerCase();\r\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\r\n        encoding === 'utf16le' || encoding === 'utf-16le') {\r\n      if (arr.length < 2 || val.length < 2) {\r\n        return -1\r\n      }\r\n      indexSize = 2;\r\n      arrLength /= 2;\r\n      valLength /= 2;\r\n      byteOffset /= 2;\r\n    }\r\n  }\r\n\r\n  function read (buf, i) {\r\n    if (indexSize === 1) {\r\n      return buf[i]\r\n    } else {\r\n      return buf.readUInt16BE(i * indexSize)\r\n    }\r\n  }\r\n\r\n  var i;\r\n  if (dir) {\r\n    var foundIndex = -1;\r\n    for (i = byteOffset; i < arrLength; i++) {\r\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\r\n        if (foundIndex === -1) foundIndex = i;\r\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\r\n      } else {\r\n        if (foundIndex !== -1) i -= i - foundIndex;\r\n        foundIndex = -1;\r\n      }\r\n    }\r\n  } else {\r\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;\r\n    for (i = byteOffset; i >= 0; i--) {\r\n      var found = true;\r\n      for (var j = 0; j < valLength; j++) {\r\n        if (read(arr, i + j) !== read(val, j)) {\r\n          found = false;\r\n          break\r\n        }\r\n      }\r\n      if (found) return i\r\n    }\r\n  }\r\n\r\n  return -1\r\n}\r\n\r\nBuffer$1.prototype.includes = function includes (val, byteOffset, encoding) {\r\n  return this.indexOf(val, byteOffset, encoding) !== -1\r\n};\r\n\r\nBuffer$1.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\r\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\r\n};\r\n\r\nBuffer$1.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\r\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\r\n};\r\n\r\nfunction hexWrite (buf, string, offset, length) {\r\n  offset = Number(offset) || 0;\r\n  var remaining = buf.length - offset;\r\n  if (!length) {\r\n    length = remaining;\r\n  } else {\r\n    length = Number(length);\r\n    if (length > remaining) {\r\n      length = remaining;\r\n    }\r\n  }\r\n\r\n  // must be an even number of digits\r\n  var strLen = string.length;\r\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\r\n\r\n  if (length > strLen / 2) {\r\n    length = strLen / 2;\r\n  }\r\n  for (var i = 0; i < length; ++i) {\r\n    var parsed = parseInt(string.substr(i * 2, 2), 16);\r\n    if (isNaN(parsed)) return i\r\n    buf[offset + i] = parsed;\r\n  }\r\n  return i\r\n}\r\n\r\nfunction utf8Write (buf, string, offset, length) {\r\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\r\n}\r\n\r\nfunction asciiWrite (buf, string, offset, length) {\r\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\r\n}\r\n\r\nfunction latin1Write (buf, string, offset, length) {\r\n  return asciiWrite(buf, string, offset, length)\r\n}\r\n\r\nfunction base64Write (buf, string, offset, length) {\r\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\r\n}\r\n\r\nfunction ucs2Write (buf, string, offset, length) {\r\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\r\n}\r\n\r\nBuffer$1.prototype.write = function write (string, offset, length, encoding) {\r\n  // Buffer#write(string)\r\n  if (offset === undefined) {\r\n    encoding = 'utf8';\r\n    length = this.length;\r\n    offset = 0;\r\n  // Buffer#write(string, encoding)\r\n  } else if (length === undefined && typeof offset === 'string') {\r\n    encoding = offset;\r\n    length = this.length;\r\n    offset = 0;\r\n  // Buffer#write(string, offset[, length][, encoding])\r\n  } else if (isFinite(offset)) {\r\n    offset = offset | 0;\r\n    if (isFinite(length)) {\r\n      length = length | 0;\r\n      if (encoding === undefined) encoding = 'utf8';\r\n    } else {\r\n      encoding = length;\r\n      length = undefined;\r\n    }\r\n  // legacy write(string, encoding, offset, length) - remove in v0.13\r\n  } else {\r\n    throw new Error(\r\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\r\n    )\r\n  }\r\n\r\n  var remaining = this.length - offset;\r\n  if (length === undefined || length > remaining) length = remaining;\r\n\r\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\r\n    throw new RangeError('Attempt to write outside buffer bounds')\r\n  }\r\n\r\n  if (!encoding) encoding = 'utf8';\r\n\r\n  var loweredCase = false;\r\n  for (;;) {\r\n    switch (encoding) {\r\n      case 'hex':\r\n        return hexWrite(this, string, offset, length)\r\n\r\n      case 'utf8':\r\n      case 'utf-8':\r\n        return utf8Write(this, string, offset, length)\r\n\r\n      case 'ascii':\r\n        return asciiWrite(this, string, offset, length)\r\n\r\n      case 'latin1':\r\n      case 'binary':\r\n        return latin1Write(this, string, offset, length)\r\n\r\n      case 'base64':\r\n        // Warning: maxLength not taken into account in base64Write\r\n        return base64Write(this, string, offset, length)\r\n\r\n      case 'ucs2':\r\n      case 'ucs-2':\r\n      case 'utf16le':\r\n      case 'utf-16le':\r\n        return ucs2Write(this, string, offset, length)\r\n\r\n      default:\r\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\r\n        encoding = ('' + encoding).toLowerCase();\r\n        loweredCase = true;\r\n    }\r\n  }\r\n};\r\n\r\nBuffer$1.prototype.toJSON = function toJSON () {\r\n  return {\r\n    type: 'Buffer',\r\n    data: Array.prototype.slice.call(this._arr || this, 0)\r\n  }\r\n};\r\n\r\nfunction base64Slice (buf, start, end) {\r\n  if (start === 0 && end === buf.length) {\r\n    return fromByteArray(buf)\r\n  } else {\r\n    return fromByteArray(buf.slice(start, end))\r\n  }\r\n}\r\n\r\nfunction utf8Slice (buf, start, end) {\r\n  end = Math.min(buf.length, end);\r\n  var res = [];\r\n\r\n  var i = start;\r\n  while (i < end) {\r\n    var firstByte = buf[i];\r\n    var codePoint = null;\r\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\r\n      : (firstByte > 0xDF) ? 3\r\n      : (firstByte > 0xBF) ? 2\r\n      : 1;\r\n\r\n    if (i + bytesPerSequence <= end) {\r\n      var secondByte, thirdByte, fourthByte, tempCodePoint;\r\n\r\n      switch (bytesPerSequence) {\r\n        case 1:\r\n          if (firstByte < 0x80) {\r\n            codePoint = firstByte;\r\n          }\r\n          break\r\n        case 2:\r\n          secondByte = buf[i + 1];\r\n          if ((secondByte & 0xC0) === 0x80) {\r\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);\r\n            if (tempCodePoint > 0x7F) {\r\n              codePoint = tempCodePoint;\r\n            }\r\n          }\r\n          break\r\n        case 3:\r\n          secondByte = buf[i + 1];\r\n          thirdByte = buf[i + 2];\r\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\r\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);\r\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\r\n              codePoint = tempCodePoint;\r\n            }\r\n          }\r\n          break\r\n        case 4:\r\n          secondByte = buf[i + 1];\r\n          thirdByte = buf[i + 2];\r\n          fourthByte = buf[i + 3];\r\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\r\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);\r\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\r\n              codePoint = tempCodePoint;\r\n            }\r\n          }\r\n      }\r\n    }\r\n\r\n    if (codePoint === null) {\r\n      // we did not generate a valid codePoint so insert a\r\n      // replacement char (U+FFFD) and advance only 1 byte\r\n      codePoint = 0xFFFD;\r\n      bytesPerSequence = 1;\r\n    } else if (codePoint > 0xFFFF) {\r\n      // encode to utf16 (surrogate pair dance)\r\n      codePoint -= 0x10000;\r\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800);\r\n      codePoint = 0xDC00 | codePoint & 0x3FF;\r\n    }\r\n\r\n    res.push(codePoint);\r\n    i += bytesPerSequence;\r\n  }\r\n\r\n  return decodeCodePointsArray(res)\r\n}\r\n\r\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\r\n// the lowest limit is Chrome, with 0x10000 args.\r\n// We go 1 magnitude less, for safety\r\nvar MAX_ARGUMENTS_LENGTH = 0x1000;\r\n\r\nfunction decodeCodePointsArray (codePoints) {\r\n  var len = codePoints.length;\r\n  if (len <= MAX_ARGUMENTS_LENGTH) {\r\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\r\n  }\r\n\r\n  // Decode in chunks to avoid \"call stack size exceeded\".\r\n  var res = '';\r\n  var i = 0;\r\n  while (i < len) {\r\n    res += String.fromCharCode.apply(\r\n      String,\r\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\r\n    );\r\n  }\r\n  return res\r\n}\r\n\r\nfunction asciiSlice (buf, start, end) {\r\n  var ret = '';\r\n  end = Math.min(buf.length, end);\r\n\r\n  for (var i = start; i < end; ++i) {\r\n    ret += String.fromCharCode(buf[i] & 0x7F);\r\n  }\r\n  return ret\r\n}\r\n\r\nfunction latin1Slice (buf, start, end) {\r\n  var ret = '';\r\n  end = Math.min(buf.length, end);\r\n\r\n  for (var i = start; i < end; ++i) {\r\n    ret += String.fromCharCode(buf[i]);\r\n  }\r\n  return ret\r\n}\r\n\r\nfunction hexSlice (buf, start, end) {\r\n  var len = buf.length;\r\n\r\n  if (!start || start < 0) start = 0;\r\n  if (!end || end < 0 || end > len) end = len;\r\n\r\n  var out = '';\r\n  for (var i = start; i < end; ++i) {\r\n    out += toHex(buf[i]);\r\n  }\r\n  return out\r\n}\r\n\r\nfunction utf16leSlice (buf, start, end) {\r\n  var bytes = buf.slice(start, end);\r\n  var res = '';\r\n  for (var i = 0; i < bytes.length; i += 2) {\r\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);\r\n  }\r\n  return res\r\n}\r\n\r\nBuffer$1.prototype.slice = function slice (start, end) {\r\n  var len = this.length;\r\n  start = ~~start;\r\n  end = end === undefined ? len : ~~end;\r\n\r\n  if (start < 0) {\r\n    start += len;\r\n    if (start < 0) start = 0;\r\n  } else if (start > len) {\r\n    start = len;\r\n  }\r\n\r\n  if (end < 0) {\r\n    end += len;\r\n    if (end < 0) end = 0;\r\n  } else if (end > len) {\r\n    end = len;\r\n  }\r\n\r\n  if (end < start) end = start;\r\n\r\n  var newBuf;\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    newBuf = this.subarray(start, end);\r\n    newBuf.__proto__ = Buffer$1.prototype;\r\n  } else {\r\n    var sliceLen = end - start;\r\n    newBuf = new Buffer$1(sliceLen, undefined);\r\n    for (var i = 0; i < sliceLen; ++i) {\r\n      newBuf[i] = this[i + start];\r\n    }\r\n  }\r\n\r\n  return newBuf\r\n};\r\n\r\n/*\r\n * Need to make sure that buffer isn't trying to write out of bounds.\r\n */\r\nfunction checkOffset (offset, ext, length) {\r\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\r\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\r\n}\r\n\r\nBuffer$1.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\r\n  offset = offset | 0;\r\n  byteLength = byteLength | 0;\r\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\r\n\r\n  var val = this[offset];\r\n  var mul = 1;\r\n  var i = 0;\r\n  while (++i < byteLength && (mul *= 0x100)) {\r\n    val += this[offset + i] * mul;\r\n  }\r\n\r\n  return val\r\n};\r\n\r\nBuffer$1.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\r\n  offset = offset | 0;\r\n  byteLength = byteLength | 0;\r\n  if (!noAssert) {\r\n    checkOffset(offset, byteLength, this.length);\r\n  }\r\n\r\n  var val = this[offset + --byteLength];\r\n  var mul = 1;\r\n  while (byteLength > 0 && (mul *= 0x100)) {\r\n    val += this[offset + --byteLength] * mul;\r\n  }\r\n\r\n  return val\r\n};\r\n\r\nBuffer$1.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 1, this.length);\r\n  return this[offset]\r\n};\r\n\r\nBuffer$1.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 2, this.length);\r\n  return this[offset] | (this[offset + 1] << 8)\r\n};\r\n\r\nBuffer$1.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 2, this.length);\r\n  return (this[offset] << 8) | this[offset + 1]\r\n};\r\n\r\nBuffer$1.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 4, this.length);\r\n\r\n  return ((this[offset]) |\r\n      (this[offset + 1] << 8) |\r\n      (this[offset + 2] << 16)) +\r\n      (this[offset + 3] * 0x1000000)\r\n};\r\n\r\nBuffer$1.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 4, this.length);\r\n\r\n  return (this[offset] * 0x1000000) +\r\n    ((this[offset + 1] << 16) |\r\n    (this[offset + 2] << 8) |\r\n    this[offset + 3])\r\n};\r\n\r\nBuffer$1.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\r\n  offset = offset | 0;\r\n  byteLength = byteLength | 0;\r\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\r\n\r\n  var val = this[offset];\r\n  var mul = 1;\r\n  var i = 0;\r\n  while (++i < byteLength && (mul *= 0x100)) {\r\n    val += this[offset + i] * mul;\r\n  }\r\n  mul *= 0x80;\r\n\r\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\r\n\r\n  return val\r\n};\r\n\r\nBuffer$1.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\r\n  offset = offset | 0;\r\n  byteLength = byteLength | 0;\r\n  if (!noAssert) checkOffset(offset, byteLength, this.length);\r\n\r\n  var i = byteLength;\r\n  var mul = 1;\r\n  var val = this[offset + --i];\r\n  while (i > 0 && (mul *= 0x100)) {\r\n    val += this[offset + --i] * mul;\r\n  }\r\n  mul *= 0x80;\r\n\r\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength);\r\n\r\n  return val\r\n};\r\n\r\nBuffer$1.prototype.readInt8 = function readInt8 (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 1, this.length);\r\n  if (!(this[offset] & 0x80)) return (this[offset])\r\n  return ((0xff - this[offset] + 1) * -1)\r\n};\r\n\r\nBuffer$1.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 2, this.length);\r\n  var val = this[offset] | (this[offset + 1] << 8);\r\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\r\n};\r\n\r\nBuffer$1.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 2, this.length);\r\n  var val = this[offset + 1] | (this[offset] << 8);\r\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\r\n};\r\n\r\nBuffer$1.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 4, this.length);\r\n\r\n  return (this[offset]) |\r\n    (this[offset + 1] << 8) |\r\n    (this[offset + 2] << 16) |\r\n    (this[offset + 3] << 24)\r\n};\r\n\r\nBuffer$1.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 4, this.length);\r\n\r\n  return (this[offset] << 24) |\r\n    (this[offset + 1] << 16) |\r\n    (this[offset + 2] << 8) |\r\n    (this[offset + 3])\r\n};\r\n\r\nBuffer$1.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 4, this.length);\r\n  return read(this, offset, true, 23, 4)\r\n};\r\n\r\nBuffer$1.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 4, this.length);\r\n  return read(this, offset, false, 23, 4)\r\n};\r\n\r\nBuffer$1.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 8, this.length);\r\n  return read(this, offset, true, 52, 8)\r\n};\r\n\r\nBuffer$1.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\r\n  if (!noAssert) checkOffset(offset, 8, this.length);\r\n  return read(this, offset, false, 52, 8)\r\n};\r\n\r\nfunction checkInt (buf, value, offset, ext, max, min) {\r\n  if (!internalIsBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\r\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\r\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\r\n}\r\n\r\nBuffer$1.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  byteLength = byteLength | 0;\r\n  if (!noAssert) {\r\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\r\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\r\n  }\r\n\r\n  var mul = 1;\r\n  var i = 0;\r\n  this[offset] = value & 0xFF;\r\n  while (++i < byteLength && (mul *= 0x100)) {\r\n    this[offset + i] = (value / mul) & 0xFF;\r\n  }\r\n\r\n  return offset + byteLength\r\n};\r\n\r\nBuffer$1.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  byteLength = byteLength | 0;\r\n  if (!noAssert) {\r\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1;\r\n    checkInt(this, value, offset, byteLength, maxBytes, 0);\r\n  }\r\n\r\n  var i = byteLength - 1;\r\n  var mul = 1;\r\n  this[offset + i] = value & 0xFF;\r\n  while (--i >= 0 && (mul *= 0x100)) {\r\n    this[offset + i] = (value / mul) & 0xFF;\r\n  }\r\n\r\n  return offset + byteLength\r\n};\r\n\r\nBuffer$1.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);\r\n  if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\r\n  this[offset] = (value & 0xff);\r\n  return offset + 1\r\n};\r\n\r\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\r\n  if (value < 0) value = 0xffff + value + 1;\r\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\r\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\r\n      (littleEndian ? i : 1 - i) * 8;\r\n  }\r\n}\r\n\r\nBuffer$1.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    this[offset] = (value & 0xff);\r\n    this[offset + 1] = (value >>> 8);\r\n  } else {\r\n    objectWriteUInt16(this, value, offset, true);\r\n  }\r\n  return offset + 2\r\n};\r\n\r\nBuffer$1.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    this[offset] = (value >>> 8);\r\n    this[offset + 1] = (value & 0xff);\r\n  } else {\r\n    objectWriteUInt16(this, value, offset, false);\r\n  }\r\n  return offset + 2\r\n};\r\n\r\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\r\n  if (value < 0) value = 0xffffffff + value + 1;\r\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\r\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff;\r\n  }\r\n}\r\n\r\nBuffer$1.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    this[offset + 3] = (value >>> 24);\r\n    this[offset + 2] = (value >>> 16);\r\n    this[offset + 1] = (value >>> 8);\r\n    this[offset] = (value & 0xff);\r\n  } else {\r\n    objectWriteUInt32(this, value, offset, true);\r\n  }\r\n  return offset + 4\r\n};\r\n\r\nBuffer$1.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    this[offset] = (value >>> 24);\r\n    this[offset + 1] = (value >>> 16);\r\n    this[offset + 2] = (value >>> 8);\r\n    this[offset + 3] = (value & 0xff);\r\n  } else {\r\n    objectWriteUInt32(this, value, offset, false);\r\n  }\r\n  return offset + 4\r\n};\r\n\r\nBuffer$1.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) {\r\n    var limit = Math.pow(2, 8 * byteLength - 1);\r\n\r\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\r\n  }\r\n\r\n  var i = 0;\r\n  var mul = 1;\r\n  var sub = 0;\r\n  this[offset] = value & 0xFF;\r\n  while (++i < byteLength && (mul *= 0x100)) {\r\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\r\n      sub = 1;\r\n    }\r\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;\r\n  }\r\n\r\n  return offset + byteLength\r\n};\r\n\r\nBuffer$1.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) {\r\n    var limit = Math.pow(2, 8 * byteLength - 1);\r\n\r\n    checkInt(this, value, offset, byteLength, limit - 1, -limit);\r\n  }\r\n\r\n  var i = byteLength - 1;\r\n  var mul = 1;\r\n  var sub = 0;\r\n  this[offset + i] = value & 0xFF;\r\n  while (--i >= 0 && (mul *= 0x100)) {\r\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\r\n      sub = 1;\r\n    }\r\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;\r\n  }\r\n\r\n  return offset + byteLength\r\n};\r\n\r\nBuffer$1.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);\r\n  if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);\r\n  if (value < 0) value = 0xff + value + 1;\r\n  this[offset] = (value & 0xff);\r\n  return offset + 1\r\n};\r\n\r\nBuffer$1.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    this[offset] = (value & 0xff);\r\n    this[offset + 1] = (value >>> 8);\r\n  } else {\r\n    objectWriteUInt16(this, value, offset, true);\r\n  }\r\n  return offset + 2\r\n};\r\n\r\nBuffer$1.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    this[offset] = (value >>> 8);\r\n    this[offset + 1] = (value & 0xff);\r\n  } else {\r\n    objectWriteUInt16(this, value, offset, false);\r\n  }\r\n  return offset + 2\r\n};\r\n\r\nBuffer$1.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    this[offset] = (value & 0xff);\r\n    this[offset + 1] = (value >>> 8);\r\n    this[offset + 2] = (value >>> 16);\r\n    this[offset + 3] = (value >>> 24);\r\n  } else {\r\n    objectWriteUInt32(this, value, offset, true);\r\n  }\r\n  return offset + 4\r\n};\r\n\r\nBuffer$1.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\r\n  value = +value;\r\n  offset = offset | 0;\r\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);\r\n  if (value < 0) value = 0xffffffff + value + 1;\r\n  if (Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    this[offset] = (value >>> 24);\r\n    this[offset + 1] = (value >>> 16);\r\n    this[offset + 2] = (value >>> 8);\r\n    this[offset + 3] = (value & 0xff);\r\n  } else {\r\n    objectWriteUInt32(this, value, offset, false);\r\n  }\r\n  return offset + 4\r\n};\r\n\r\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\r\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\r\n  if (offset < 0) throw new RangeError('Index out of range')\r\n}\r\n\r\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\r\n  if (!noAssert) {\r\n    checkIEEE754(buf, value, offset, 4);\r\n  }\r\n  write(buf, value, offset, littleEndian, 23, 4);\r\n  return offset + 4\r\n}\r\n\r\nBuffer$1.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\r\n  return writeFloat(this, value, offset, true, noAssert)\r\n};\r\n\r\nBuffer$1.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\r\n  return writeFloat(this, value, offset, false, noAssert)\r\n};\r\n\r\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\r\n  if (!noAssert) {\r\n    checkIEEE754(buf, value, offset, 8);\r\n  }\r\n  write(buf, value, offset, littleEndian, 52, 8);\r\n  return offset + 8\r\n}\r\n\r\nBuffer$1.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\r\n  return writeDouble(this, value, offset, true, noAssert)\r\n};\r\n\r\nBuffer$1.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\r\n  return writeDouble(this, value, offset, false, noAssert)\r\n};\r\n\r\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\r\nBuffer$1.prototype.copy = function copy (target, targetStart, start, end) {\r\n  if (!start) start = 0;\r\n  if (!end && end !== 0) end = this.length;\r\n  if (targetStart >= target.length) targetStart = target.length;\r\n  if (!targetStart) targetStart = 0;\r\n  if (end > 0 && end < start) end = start;\r\n\r\n  // Copy 0 bytes; we're done\r\n  if (end === start) return 0\r\n  if (target.length === 0 || this.length === 0) return 0\r\n\r\n  // Fatal error conditions\r\n  if (targetStart < 0) {\r\n    throw new RangeError('targetStart out of bounds')\r\n  }\r\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\r\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\r\n\r\n  // Are we oob?\r\n  if (end > this.length) end = this.length;\r\n  if (target.length - targetStart < end - start) {\r\n    end = target.length - targetStart + start;\r\n  }\r\n\r\n  var len = end - start;\r\n  var i;\r\n\r\n  if (this === target && start < targetStart && targetStart < end) {\r\n    // descending copy from end\r\n    for (i = len - 1; i >= 0; --i) {\r\n      target[i + targetStart] = this[i + start];\r\n    }\r\n  } else if (len < 1000 || !Buffer$1.TYPED_ARRAY_SUPPORT) {\r\n    // ascending copy from start\r\n    for (i = 0; i < len; ++i) {\r\n      target[i + targetStart] = this[i + start];\r\n    }\r\n  } else {\r\n    Uint8Array.prototype.set.call(\r\n      target,\r\n      this.subarray(start, start + len),\r\n      targetStart\r\n    );\r\n  }\r\n\r\n  return len\r\n};\r\n\r\n// Usage:\r\n//    buffer.fill(number[, offset[, end]])\r\n//    buffer.fill(buffer[, offset[, end]])\r\n//    buffer.fill(string[, offset[, end]][, encoding])\r\nBuffer$1.prototype.fill = function fill (val, start, end, encoding) {\r\n  // Handle string cases:\r\n  if (typeof val === 'string') {\r\n    if (typeof start === 'string') {\r\n      encoding = start;\r\n      start = 0;\r\n      end = this.length;\r\n    } else if (typeof end === 'string') {\r\n      encoding = end;\r\n      end = this.length;\r\n    }\r\n    if (val.length === 1) {\r\n      var code = val.charCodeAt(0);\r\n      if (code < 256) {\r\n        val = code;\r\n      }\r\n    }\r\n    if (encoding !== undefined && typeof encoding !== 'string') {\r\n      throw new TypeError('encoding must be a string')\r\n    }\r\n    if (typeof encoding === 'string' && !Buffer$1.isEncoding(encoding)) {\r\n      throw new TypeError('Unknown encoding: ' + encoding)\r\n    }\r\n  } else if (typeof val === 'number') {\r\n    val = val & 255;\r\n  }\r\n\r\n  // Invalid ranges are not set to a default, so can range check early.\r\n  if (start < 0 || this.length < start || this.length < end) {\r\n    throw new RangeError('Out of range index')\r\n  }\r\n\r\n  if (end <= start) {\r\n    return this\r\n  }\r\n\r\n  start = start >>> 0;\r\n  end = end === undefined ? this.length : end >>> 0;\r\n\r\n  if (!val) val = 0;\r\n\r\n  var i;\r\n  if (typeof val === 'number') {\r\n    for (i = start; i < end; ++i) {\r\n      this[i] = val;\r\n    }\r\n  } else {\r\n    var bytes = internalIsBuffer(val)\r\n      ? val\r\n      : utf8ToBytes(new Buffer$1(val, encoding).toString());\r\n    var len = bytes.length;\r\n    for (i = 0; i < end - start; ++i) {\r\n      this[i + start] = bytes[i % len];\r\n    }\r\n  }\r\n\r\n  return this\r\n};\r\n\r\n// HELPER FUNCTIONS\r\n// ================\r\n\r\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g;\r\n\r\nfunction base64clean (str) {\r\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\r\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '');\r\n  // Node converts strings with length < 2 to ''\r\n  if (str.length < 2) return ''\r\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\r\n  while (str.length % 4 !== 0) {\r\n    str = str + '=';\r\n  }\r\n  return str\r\n}\r\n\r\nfunction stringtrim (str) {\r\n  if (str.trim) return str.trim()\r\n  return str.replace(/^\\s+|\\s+$/g, '')\r\n}\r\n\r\nfunction toHex (n) {\r\n  if (n < 16) return '0' + n.toString(16)\r\n  return n.toString(16)\r\n}\r\n\r\nfunction utf8ToBytes (string, units) {\r\n  units = units || Infinity;\r\n  var codePoint;\r\n  var length = string.length;\r\n  var leadSurrogate = null;\r\n  var bytes = [];\r\n\r\n  for (var i = 0; i < length; ++i) {\r\n    codePoint = string.charCodeAt(i);\r\n\r\n    // is surrogate component\r\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\r\n      // last char was a lead\r\n      if (!leadSurrogate) {\r\n        // no lead yet\r\n        if (codePoint > 0xDBFF) {\r\n          // unexpected trail\r\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\r\n          continue\r\n        } else if (i + 1 === length) {\r\n          // unpaired lead\r\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\r\n          continue\r\n        }\r\n\r\n        // valid lead\r\n        leadSurrogate = codePoint;\r\n\r\n        continue\r\n      }\r\n\r\n      // 2 leads in a row\r\n      if (codePoint < 0xDC00) {\r\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\r\n        leadSurrogate = codePoint;\r\n        continue\r\n      }\r\n\r\n      // valid surrogate pair\r\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;\r\n    } else if (leadSurrogate) {\r\n      // valid bmp char, but last char was a lead\r\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);\r\n    }\r\n\r\n    leadSurrogate = null;\r\n\r\n    // encode utf8\r\n    if (codePoint < 0x80) {\r\n      if ((units -= 1) < 0) break\r\n      bytes.push(codePoint);\r\n    } else if (codePoint < 0x800) {\r\n      if ((units -= 2) < 0) break\r\n      bytes.push(\r\n        codePoint >> 0x6 | 0xC0,\r\n        codePoint & 0x3F | 0x80\r\n      );\r\n    } else if (codePoint < 0x10000) {\r\n      if ((units -= 3) < 0) break\r\n      bytes.push(\r\n        codePoint >> 0xC | 0xE0,\r\n        codePoint >> 0x6 & 0x3F | 0x80,\r\n        codePoint & 0x3F | 0x80\r\n      );\r\n    } else if (codePoint < 0x110000) {\r\n      if ((units -= 4) < 0) break\r\n      bytes.push(\r\n        codePoint >> 0x12 | 0xF0,\r\n        codePoint >> 0xC & 0x3F | 0x80,\r\n        codePoint >> 0x6 & 0x3F | 0x80,\r\n        codePoint & 0x3F | 0x80\r\n      );\r\n    } else {\r\n      throw new Error('Invalid code point')\r\n    }\r\n  }\r\n\r\n  return bytes\r\n}\r\n\r\nfunction asciiToBytes (str) {\r\n  var byteArray = [];\r\n  for (var i = 0; i < str.length; ++i) {\r\n    // Node's code seems to be doing this and not & 0x7F..\r\n    byteArray.push(str.charCodeAt(i) & 0xFF);\r\n  }\r\n  return byteArray\r\n}\r\n\r\nfunction utf16leToBytes (str, units) {\r\n  var c, hi, lo;\r\n  var byteArray = [];\r\n  for (var i = 0; i < str.length; ++i) {\r\n    if ((units -= 2) < 0) break\r\n\r\n    c = str.charCodeAt(i);\r\n    hi = c >> 8;\r\n    lo = c % 256;\r\n    byteArray.push(lo);\r\n    byteArray.push(hi);\r\n  }\r\n\r\n  return byteArray\r\n}\r\n\r\n\r\nfunction base64ToBytes (str) {\r\n  return toByteArray(base64clean(str))\r\n}\r\n\r\nfunction blitBuffer (src, dst, offset, length) {\r\n  for (var i = 0; i < length; ++i) {\r\n    if ((i + offset >= dst.length) || (i >= src.length)) break\r\n    dst[i + offset] = src[i];\r\n  }\r\n  return i\r\n}\r\n\r\nfunction isnan (val) {\r\n  return val !== val // eslint-disable-line no-self-compare\r\n}\r\n\r\n\r\n// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence\r\n// The _isBuffer check is for Safari 5-7 support, because it's missing\r\n// Object.prototype.constructor. Remove this eventually\r\nfunction isBuffer(obj) {\r\n  return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))\r\n}\r\n\r\nfunction isFastBuffer (obj) {\r\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\r\n}\r\n\r\n// For Node v0.10 support. Remove this eventually.\r\nfunction isSlowBuffer (obj) {\r\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))\r\n}\r\n\r\nfunction BufferList() {\r\n  this.head = null;\r\n  this.tail = null;\r\n  this.length = 0;\r\n}\r\n\r\nBufferList.prototype.push = function (v) {\r\n  var entry = { data: v, next: null };\r\n  if (this.length > 0) this.tail.next = entry;else this.head = entry;\r\n  this.tail = entry;\r\n  ++this.length;\r\n};\r\n\r\nBufferList.prototype.unshift = function (v) {\r\n  var entry = { data: v, next: this.head };\r\n  if (this.length === 0) this.tail = entry;\r\n  this.head = entry;\r\n  ++this.length;\r\n};\r\n\r\nBufferList.prototype.shift = function () {\r\n  if (this.length === 0) return;\r\n  var ret = this.head.data;\r\n  if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\r\n  --this.length;\r\n  return ret;\r\n};\r\n\r\nBufferList.prototype.clear = function () {\r\n  this.head = this.tail = null;\r\n  this.length = 0;\r\n};\r\n\r\nBufferList.prototype.join = function (s) {\r\n  if (this.length === 0) return '';\r\n  var p = this.head;\r\n  var ret = '' + p.data;\r\n  while (p = p.next) {\r\n    ret += s + p.data;\r\n  }return ret;\r\n};\r\n\r\nBufferList.prototype.concat = function (n) {\r\n  if (this.length === 0) return Buffer$1.alloc(0);\r\n  if (this.length === 1) return this.head.data;\r\n  var ret = Buffer$1.allocUnsafe(n >>> 0);\r\n  var p = this.head;\r\n  var i = 0;\r\n  while (p) {\r\n    p.data.copy(ret, i);\r\n    i += p.data.length;\r\n    p = p.next;\r\n  }\r\n  return ret;\r\n};\r\n\r\n// Copyright Joyent, Inc. and other Node contributors.\r\nvar isBufferEncoding = Buffer$1.isEncoding\r\n  || function(encoding) {\r\n       switch (encoding && encoding.toLowerCase()) {\r\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': return true;\r\n         default: return false;\r\n       }\r\n     };\r\n\r\n\r\nfunction assertEncoding(encoding) {\r\n  if (encoding && !isBufferEncoding(encoding)) {\r\n    throw new Error('Unknown encoding: ' + encoding);\r\n  }\r\n}\r\n\r\n// StringDecoder provides an interface for efficiently splitting a series of\r\n// buffers into a series of JS strings without breaking apart multi-byte\r\n// characters. CESU-8 is handled as part of the UTF-8 encoding.\r\n//\r\n// @TODO Handling all encodings inside a single object makes it very difficult\r\n// to reason about this code, so it should be split up in the future.\r\n// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code\r\n// points as used by CESU-8.\r\nfunction StringDecoder(encoding) {\r\n  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');\r\n  assertEncoding(encoding);\r\n  switch (this.encoding) {\r\n    case 'utf8':\r\n      // CESU-8 represents each of Surrogate Pair by 3-bytes\r\n      this.surrogateSize = 3;\r\n      break;\r\n    case 'ucs2':\r\n    case 'utf16le':\r\n      // UTF-16 represents each of Surrogate Pair by 2-bytes\r\n      this.surrogateSize = 2;\r\n      this.detectIncompleteChar = utf16DetectIncompleteChar;\r\n      break;\r\n    case 'base64':\r\n      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.\r\n      this.surrogateSize = 3;\r\n      this.detectIncompleteChar = base64DetectIncompleteChar;\r\n      break;\r\n    default:\r\n      this.write = passThroughWrite;\r\n      return;\r\n  }\r\n\r\n  // Enough space to store all bytes of a single character. UTF-8 needs 4\r\n  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).\r\n  this.charBuffer = new Buffer$1(6);\r\n  // Number of bytes received for the current incomplete multi-byte character.\r\n  this.charReceived = 0;\r\n  // Number of bytes expected for the current incomplete multi-byte character.\r\n  this.charLength = 0;\r\n}\r\n\r\n// write decodes the given buffer and returns it as JS string that is\r\n// guaranteed to not contain any partial multi-byte characters. Any partial\r\n// character found at the end of the buffer is buffered up, and will be\r\n// returned when calling write again with the remaining bytes.\r\n//\r\n// Note: Converting a Buffer containing an orphan surrogate to a String\r\n// currently works, but converting a String to a Buffer (via `new Buffer`, or\r\n// Buffer#write) will replace incomplete surrogates with the unicode\r\n// replacement character. See https://codereview.chromium.org/121173009/ .\r\nStringDecoder.prototype.write = function(buffer) {\r\n  var charStr = '';\r\n  // if our last write ended with an incomplete multibyte character\r\n  while (this.charLength) {\r\n    // determine how many remaining bytes this buffer has to offer for this char\r\n    var available = (buffer.length >= this.charLength - this.charReceived) ?\r\n        this.charLength - this.charReceived :\r\n        buffer.length;\r\n\r\n    // add the new bytes to the char buffer\r\n    buffer.copy(this.charBuffer, this.charReceived, 0, available);\r\n    this.charReceived += available;\r\n\r\n    if (this.charReceived < this.charLength) {\r\n      // still not enough chars in this buffer? wait for more ...\r\n      return '';\r\n    }\r\n\r\n    // remove bytes belonging to the current character from the buffer\r\n    buffer = buffer.slice(available, buffer.length);\r\n\r\n    // get the character that was split\r\n    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);\r\n\r\n    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\r\n    var charCode = charStr.charCodeAt(charStr.length - 1);\r\n    if (charCode >= 0xD800 && charCode <= 0xDBFF) {\r\n      this.charLength += this.surrogateSize;\r\n      charStr = '';\r\n      continue;\r\n    }\r\n    this.charReceived = this.charLength = 0;\r\n\r\n    // if there are no more bytes in this buffer, just emit our char\r\n    if (buffer.length === 0) {\r\n      return charStr;\r\n    }\r\n    break;\r\n  }\r\n\r\n  // determine and set charLength / charReceived\r\n  this.detectIncompleteChar(buffer);\r\n\r\n  var end = buffer.length;\r\n  if (this.charLength) {\r\n    // buffer the incomplete character bytes we got\r\n    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);\r\n    end -= this.charReceived;\r\n  }\r\n\r\n  charStr += buffer.toString(this.encoding, 0, end);\r\n\r\n  var end = charStr.length - 1;\r\n  var charCode = charStr.charCodeAt(end);\r\n  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character\r\n  if (charCode >= 0xD800 && charCode <= 0xDBFF) {\r\n    var size = this.surrogateSize;\r\n    this.charLength += size;\r\n    this.charReceived += size;\r\n    this.charBuffer.copy(this.charBuffer, size, 0, size);\r\n    buffer.copy(this.charBuffer, 0, 0, size);\r\n    return charStr.substring(0, end);\r\n  }\r\n\r\n  // or just emit the charStr\r\n  return charStr;\r\n};\r\n\r\n// detectIncompleteChar determines if there is an incomplete UTF-8 character at\r\n// the end of the given buffer. If so, it sets this.charLength to the byte\r\n// length that character, and sets this.charReceived to the number of bytes\r\n// that are available for this character.\r\nStringDecoder.prototype.detectIncompleteChar = function(buffer) {\r\n  // determine how many bytes we have to check at the end of this buffer\r\n  var i = (buffer.length >= 3) ? 3 : buffer.length;\r\n\r\n  // Figure out if one of the last i bytes of our buffer announces an\r\n  // incomplete char.\r\n  for (; i > 0; i--) {\r\n    var c = buffer[buffer.length - i];\r\n\r\n    // See http://en.wikipedia.org/wiki/UTF-8#Description\r\n\r\n    // 110XXXXX\r\n    if (i == 1 && c >> 5 == 0x06) {\r\n      this.charLength = 2;\r\n      break;\r\n    }\r\n\r\n    // 1110XXXX\r\n    if (i <= 2 && c >> 4 == 0x0E) {\r\n      this.charLength = 3;\r\n      break;\r\n    }\r\n\r\n    // 11110XXX\r\n    if (i <= 3 && c >> 3 == 0x1E) {\r\n      this.charLength = 4;\r\n      break;\r\n    }\r\n  }\r\n  this.charReceived = i;\r\n};\r\n\r\nStringDecoder.prototype.end = function(buffer) {\r\n  var res = '';\r\n  if (buffer && buffer.length)\r\n    res = this.write(buffer);\r\n\r\n  if (this.charReceived) {\r\n    var cr = this.charReceived;\r\n    var buf = this.charBuffer;\r\n    var enc = this.encoding;\r\n    res += buf.slice(0, cr).toString(enc);\r\n  }\r\n\r\n  return res;\r\n};\r\n\r\nfunction passThroughWrite(buffer) {\r\n  return buffer.toString(this.encoding);\r\n}\r\n\r\nfunction utf16DetectIncompleteChar(buffer) {\r\n  this.charReceived = buffer.length % 2;\r\n  this.charLength = this.charReceived ? 2 : 0;\r\n}\r\n\r\nfunction base64DetectIncompleteChar(buffer) {\r\n  this.charReceived = buffer.length % 3;\r\n  this.charLength = this.charReceived ? 3 : 0;\r\n}\r\n\r\nReadable.ReadableState = ReadableState;\r\n\r\nvar debug = debuglog('stream');\r\ninherits$1(Readable, EventEmitter);\r\n\r\nfunction prependListener(emitter, event, fn) {\r\n  // Sadly this is not cacheable as some libraries bundle their own\r\n  // event emitter implementation with them.\r\n  if (typeof emitter.prependListener === 'function') {\r\n    return emitter.prependListener(event, fn);\r\n  } else {\r\n    // This is a hack to make sure that our error handler is attached before any\r\n    // userland ones.  NEVER DO THIS. This is here only because this code needs\r\n    // to continue to work with older versions of Node.js that do not include\r\n    // the prependListener() method. The goal is to eventually remove this hack.\r\n    if (!emitter._events || !emitter._events[event])\r\n      emitter.on(event, fn);\r\n    else if (Array.isArray(emitter._events[event]))\r\n      emitter._events[event].unshift(fn);\r\n    else\r\n      emitter._events[event] = [fn, emitter._events[event]];\r\n  }\r\n}\r\nfunction listenerCount (emitter, type) {\r\n  return emitter.listeners(type).length;\r\n}\r\nfunction ReadableState(options, stream) {\r\n\r\n  options = options || {};\r\n\r\n  // object stream flag. Used to make read(n) ignore n and to\r\n  // make all the buffer merging and length checks go away\r\n  this.objectMode = !!options.objectMode;\r\n\r\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\r\n\r\n  // the point at which it stops calling _read() to fill the buffer\r\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\r\n  var hwm = options.highWaterMark;\r\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\r\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\r\n\r\n  // cast to ints.\r\n  this.highWaterMark = ~ ~this.highWaterMark;\r\n\r\n  // A linked list is used to store data chunks instead of an array because the\r\n  // linked list can remove elements from the beginning faster than\r\n  // array.shift()\r\n  this.buffer = new BufferList();\r\n  this.length = 0;\r\n  this.pipes = null;\r\n  this.pipesCount = 0;\r\n  this.flowing = null;\r\n  this.ended = false;\r\n  this.endEmitted = false;\r\n  this.reading = false;\r\n\r\n  // a flag to be able to tell if the onwrite cb is called immediately,\r\n  // or on a later tick.  We set this to true at first, because any\r\n  // actions that shouldn't happen until \"later\" should generally also\r\n  // not happen before the first write call.\r\n  this.sync = true;\r\n\r\n  // whenever we return null, then we set a flag to say\r\n  // that we're awaiting a 'readable' event emission.\r\n  this.needReadable = false;\r\n  this.emittedReadable = false;\r\n  this.readableListening = false;\r\n  this.resumeScheduled = false;\r\n\r\n  // Crypto is kind of old and crusty.  Historically, its default string\r\n  // encoding is 'binary' so we have to make this configurable.\r\n  // Everything else in the universe uses 'utf8', though.\r\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\r\n\r\n  // when piping, we only care about 'readable' events that happen\r\n  // after read()ing all the bytes and not getting any pushback.\r\n  this.ranOut = false;\r\n\r\n  // the number of writers that are awaiting a drain event in .pipe()s\r\n  this.awaitDrain = 0;\r\n\r\n  // if true, a maybeReadMore has been scheduled\r\n  this.readingMore = false;\r\n\r\n  this.decoder = null;\r\n  this.encoding = null;\r\n  if (options.encoding) {\r\n    this.decoder = new StringDecoder(options.encoding);\r\n    this.encoding = options.encoding;\r\n  }\r\n}\r\nfunction Readable(options) {\r\n\r\n  if (!(this instanceof Readable)) return new Readable(options);\r\n\r\n  this._readableState = new ReadableState(options, this);\r\n\r\n  // legacy\r\n  this.readable = true;\r\n\r\n  if (options && typeof options.read === 'function') this._read = options.read;\r\n\r\n  EventEmitter.call(this);\r\n}\r\n\r\n// Manually shove something into the read() buffer.\r\n// This returns true if the highWaterMark has not been hit yet,\r\n// similar to how Writable.write() returns true if you should\r\n// write() some more.\r\nReadable.prototype.push = function (chunk, encoding) {\r\n  var state = this._readableState;\r\n\r\n  if (!state.objectMode && typeof chunk === 'string') {\r\n    encoding = encoding || state.defaultEncoding;\r\n    if (encoding !== state.encoding) {\r\n      chunk = Buffer.from(chunk, encoding);\r\n      encoding = '';\r\n    }\r\n  }\r\n\r\n  return readableAddChunk(this, state, chunk, encoding, false);\r\n};\r\n\r\n// Unshift should *always* be something directly out of read()\r\nReadable.prototype.unshift = function (chunk) {\r\n  var state = this._readableState;\r\n  return readableAddChunk(this, state, chunk, '', true);\r\n};\r\n\r\nReadable.prototype.isPaused = function () {\r\n  return this._readableState.flowing === false;\r\n};\r\n\r\nfunction readableAddChunk(stream, state, chunk, encoding, addToFront) {\r\n  var er = chunkInvalid(state, chunk);\r\n  if (er) {\r\n    stream.emit('error', er);\r\n  } else if (chunk === null) {\r\n    state.reading = false;\r\n    onEofChunk(stream, state);\r\n  } else if (state.objectMode || chunk && chunk.length > 0) {\r\n    if (state.ended && !addToFront) {\r\n      var e = new Error('stream.push() after EOF');\r\n      stream.emit('error', e);\r\n    } else if (state.endEmitted && addToFront) {\r\n      var _e = new Error('stream.unshift() after end event');\r\n      stream.emit('error', _e);\r\n    } else {\r\n      var skipAdd;\r\n      if (state.decoder && !addToFront && !encoding) {\r\n        chunk = state.decoder.write(chunk);\r\n        skipAdd = !state.objectMode && chunk.length === 0;\r\n      }\r\n\r\n      if (!addToFront) state.reading = false;\r\n\r\n      // Don't add to the buffer if we've decoded to an empty string chunk and\r\n      // we're not in object mode\r\n      if (!skipAdd) {\r\n        // if we want the data now, just emit it.\r\n        if (state.flowing && state.length === 0 && !state.sync) {\r\n          stream.emit('data', chunk);\r\n          stream.read(0);\r\n        } else {\r\n          // update the buffer info.\r\n          state.length += state.objectMode ? 1 : chunk.length;\r\n          if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\r\n\r\n          if (state.needReadable) emitReadable(stream);\r\n        }\r\n      }\r\n\r\n      maybeReadMore(stream, state);\r\n    }\r\n  } else if (!addToFront) {\r\n    state.reading = false;\r\n  }\r\n\r\n  return needMoreData(state);\r\n}\r\n\r\n// if it's past the high water mark, we can push in some more.\r\n// Also, if we have no data yet, we can stand some\r\n// more bytes.  This is to work around cases where hwm=0,\r\n// such as the repl.  Also, if the push() triggered a\r\n// readable event, and the user called read(largeNumber) such that\r\n// needReadable was set, then we ought to push more, so that another\r\n// 'readable' event will be triggered.\r\nfunction needMoreData(state) {\r\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\r\n}\r\n\r\n// backwards compatibility.\r\nReadable.prototype.setEncoding = function (enc) {\r\n  this._readableState.decoder = new StringDecoder(enc);\r\n  this._readableState.encoding = enc;\r\n  return this;\r\n};\r\n\r\n// Don't raise the hwm > 8MB\r\nvar MAX_HWM = 0x800000;\r\nfunction computeNewHighWaterMark(n) {\r\n  if (n >= MAX_HWM) {\r\n    n = MAX_HWM;\r\n  } else {\r\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\r\n    // tiny amounts\r\n    n--;\r\n    n |= n >>> 1;\r\n    n |= n >>> 2;\r\n    n |= n >>> 4;\r\n    n |= n >>> 8;\r\n    n |= n >>> 16;\r\n    n++;\r\n  }\r\n  return n;\r\n}\r\n\r\n// This function is designed to be inlinable, so please take care when making\r\n// changes to the function body.\r\nfunction howMuchToRead(n, state) {\r\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\r\n  if (state.objectMode) return 1;\r\n  if (n !== n) {\r\n    // Only flow one buffer at a time\r\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\r\n  }\r\n  // If we're asking for more than the current hwm, then raise the hwm.\r\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\r\n  if (n <= state.length) return n;\r\n  // Don't have enough\r\n  if (!state.ended) {\r\n    state.needReadable = true;\r\n    return 0;\r\n  }\r\n  return state.length;\r\n}\r\n\r\n// you can override either this method, or the async _read(n) below.\r\nReadable.prototype.read = function (n) {\r\n  debug('read', n);\r\n  n = parseInt(n, 10);\r\n  var state = this._readableState;\r\n  var nOrig = n;\r\n\r\n  if (n !== 0) state.emittedReadable = false;\r\n\r\n  // if we're doing read(0) to trigger a readable event, but we\r\n  // already have a bunch of data in the buffer, then just trigger\r\n  // the 'readable' event and move on.\r\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\r\n    debug('read: emitReadable', state.length, state.ended);\r\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\r\n    return null;\r\n  }\r\n\r\n  n = howMuchToRead(n, state);\r\n\r\n  // if we've ended, and we're now clear, then finish it up.\r\n  if (n === 0 && state.ended) {\r\n    if (state.length === 0) endReadable(this);\r\n    return null;\r\n  }\r\n\r\n  // All the actual chunk generation logic needs to be\r\n  // *below* the call to _read.  The reason is that in certain\r\n  // synthetic stream cases, such as passthrough streams, _read\r\n  // may be a completely synchronous operation which may change\r\n  // the state of the read buffer, providing enough data when\r\n  // before there was *not* enough.\r\n  //\r\n  // So, the steps are:\r\n  // 1. Figure out what the state of things will be after we do\r\n  // a read from the buffer.\r\n  //\r\n  // 2. If that resulting state will trigger a _read, then call _read.\r\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\r\n  // deeply ugly to write APIs this way, but that still doesn't mean\r\n  // that the Readable class should behave improperly, as streams are\r\n  // designed to be sync/async agnostic.\r\n  // Take note if the _read call is sync or async (ie, if the read call\r\n  // has returned yet), so that we know whether or not it's safe to emit\r\n  // 'readable' etc.\r\n  //\r\n  // 3. Actually pull the requested chunks out of the buffer and return.\r\n\r\n  // if we need a readable event, then we need to do some reading.\r\n  var doRead = state.needReadable;\r\n  debug('need readable', doRead);\r\n\r\n  // if we currently have less than the highWaterMark, then also read some\r\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\r\n    doRead = true;\r\n    debug('length less than watermark', doRead);\r\n  }\r\n\r\n  // however, if we've ended, then there's no point, and if we're already\r\n  // reading, then it's unnecessary.\r\n  if (state.ended || state.reading) {\r\n    doRead = false;\r\n    debug('reading or ended', doRead);\r\n  } else if (doRead) {\r\n    debug('do read');\r\n    state.reading = true;\r\n    state.sync = true;\r\n    // if the length is currently zero, then we *need* a readable event.\r\n    if (state.length === 0) state.needReadable = true;\r\n    // call internal read method\r\n    this._read(state.highWaterMark);\r\n    state.sync = false;\r\n    // If _read pushed data synchronously, then `reading` will be false,\r\n    // and we need to re-evaluate how much data we can return to the user.\r\n    if (!state.reading) n = howMuchToRead(nOrig, state);\r\n  }\r\n\r\n  var ret;\r\n  if (n > 0) ret = fromList(n, state);else ret = null;\r\n\r\n  if (ret === null) {\r\n    state.needReadable = true;\r\n    n = 0;\r\n  } else {\r\n    state.length -= n;\r\n  }\r\n\r\n  if (state.length === 0) {\r\n    // If we have nothing in the buffer, then we want to know\r\n    // as soon as we *do* get something into the buffer.\r\n    if (!state.ended) state.needReadable = true;\r\n\r\n    // If we tried to read() past the EOF, then emit end on the next tick.\r\n    if (nOrig !== n && state.ended) endReadable(this);\r\n  }\r\n\r\n  if (ret !== null) this.emit('data', ret);\r\n\r\n  return ret;\r\n};\r\n\r\nfunction chunkInvalid(state, chunk) {\r\n  var er = null;\r\n  if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) {\r\n    er = new TypeError('Invalid non-string/buffer chunk');\r\n  }\r\n  return er;\r\n}\r\n\r\nfunction onEofChunk(stream, state) {\r\n  if (state.ended) return;\r\n  if (state.decoder) {\r\n    var chunk = state.decoder.end();\r\n    if (chunk && chunk.length) {\r\n      state.buffer.push(chunk);\r\n      state.length += state.objectMode ? 1 : chunk.length;\r\n    }\r\n  }\r\n  state.ended = true;\r\n\r\n  // emit 'readable' now to make sure it gets picked up.\r\n  emitReadable(stream);\r\n}\r\n\r\n// Don't emit readable right away in sync mode, because this can trigger\r\n// another read() call => stack overflow.  This way, it might trigger\r\n// a nextTick recursion warning, but that's not so bad.\r\nfunction emitReadable(stream) {\r\n  var state = stream._readableState;\r\n  state.needReadable = false;\r\n  if (!state.emittedReadable) {\r\n    debug('emitReadable', state.flowing);\r\n    state.emittedReadable = true;\r\n    if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream);\r\n  }\r\n}\r\n\r\nfunction emitReadable_(stream) {\r\n  debug('emit readable');\r\n  stream.emit('readable');\r\n  flow(stream);\r\n}\r\n\r\n// at this point, the user has presumably seen the 'readable' event,\r\n// and called read() to consume some data.  that may have triggered\r\n// in turn another _read(n) call, in which case reading = true if\r\n// it's in progress.\r\n// However, if we're not ended, or reading, and the length < hwm,\r\n// then go ahead and try to read some more preemptively.\r\nfunction maybeReadMore(stream, state) {\r\n  if (!state.readingMore) {\r\n    state.readingMore = true;\r\n    nextTick(maybeReadMore_, stream, state);\r\n  }\r\n}\r\n\r\nfunction maybeReadMore_(stream, state) {\r\n  var len = state.length;\r\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\r\n    debug('maybeReadMore read 0');\r\n    stream.read(0);\r\n    if (len === state.length)\r\n      // didn't get any data, stop spinning.\r\n      break;else len = state.length;\r\n  }\r\n  state.readingMore = false;\r\n}\r\n\r\n// abstract method.  to be overridden in specific implementation classes.\r\n// call cb(er, data) where data is <= n in length.\r\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\r\n// arbitrary, and perhaps not very meaningful.\r\nReadable.prototype._read = function (n) {\r\n  this.emit('error', new Error('not implemented'));\r\n};\r\n\r\nReadable.prototype.pipe = function (dest, pipeOpts) {\r\n  var src = this;\r\n  var state = this._readableState;\r\n\r\n  switch (state.pipesCount) {\r\n    case 0:\r\n      state.pipes = dest;\r\n      break;\r\n    case 1:\r\n      state.pipes = [state.pipes, dest];\r\n      break;\r\n    default:\r\n      state.pipes.push(dest);\r\n      break;\r\n  }\r\n  state.pipesCount += 1;\r\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\r\n\r\n  var doEnd = (!pipeOpts || pipeOpts.end !== false);\r\n\r\n  var endFn = doEnd ? onend : cleanup;\r\n  if (state.endEmitted) nextTick(endFn);else src.once('end', endFn);\r\n\r\n  dest.on('unpipe', onunpipe);\r\n  function onunpipe(readable) {\r\n    debug('onunpipe');\r\n    if (readable === src) {\r\n      cleanup();\r\n    }\r\n  }\r\n\r\n  function onend() {\r\n    debug('onend');\r\n    dest.end();\r\n  }\r\n\r\n  // when the dest drains, it reduces the awaitDrain counter\r\n  // on the source.  This would be more elegant with a .once()\r\n  // handler in flow(), but adding and removing repeatedly is\r\n  // too slow.\r\n  var ondrain = pipeOnDrain(src);\r\n  dest.on('drain', ondrain);\r\n\r\n  var cleanedUp = false;\r\n  function cleanup() {\r\n    debug('cleanup');\r\n    // cleanup event handlers once the pipe is broken\r\n    dest.removeListener('close', onclose);\r\n    dest.removeListener('finish', onfinish);\r\n    dest.removeListener('drain', ondrain);\r\n    dest.removeListener('error', onerror);\r\n    dest.removeListener('unpipe', onunpipe);\r\n    src.removeListener('end', onend);\r\n    src.removeListener('end', cleanup);\r\n    src.removeListener('data', ondata);\r\n\r\n    cleanedUp = true;\r\n\r\n    // if the reader is waiting for a drain event from this\r\n    // specific writer, then it would cause it to never start\r\n    // flowing again.\r\n    // So, if this is awaiting a drain, then we just call it now.\r\n    // If we don't know, then assume that we are waiting for one.\r\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\r\n  }\r\n\r\n  // If the user pushes more data while we're writing to dest then we'll end up\r\n  // in ondata again. However, we only want to increase awaitDrain once because\r\n  // dest will only emit one 'drain' event for the multiple writes.\r\n  // => Introduce a guard on increasing awaitDrain.\r\n  var increasedAwaitDrain = false;\r\n  src.on('data', ondata);\r\n  function ondata(chunk) {\r\n    debug('ondata');\r\n    increasedAwaitDrain = false;\r\n    var ret = dest.write(chunk);\r\n    if (false === ret && !increasedAwaitDrain) {\r\n      // If the user unpiped during `dest.write()`, it is possible\r\n      // to get stuck in a permanently paused state if that write\r\n      // also returned false.\r\n      // => Check whether `dest` is still a piping destination.\r\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\r\n        debug('false write response, pause', src._readableState.awaitDrain);\r\n        src._readableState.awaitDrain++;\r\n        increasedAwaitDrain = true;\r\n      }\r\n      src.pause();\r\n    }\r\n  }\r\n\r\n  // if the dest has an error, then stop piping into it.\r\n  // however, don't suppress the throwing behavior for this.\r\n  function onerror(er) {\r\n    debug('onerror', er);\r\n    unpipe();\r\n    dest.removeListener('error', onerror);\r\n    if (listenerCount(dest, 'error') === 0) dest.emit('error', er);\r\n  }\r\n\r\n  // Make sure our error handler is attached before userland ones.\r\n  prependListener(dest, 'error', onerror);\r\n\r\n  // Both close and finish should trigger unpipe, but only once.\r\n  function onclose() {\r\n    dest.removeListener('finish', onfinish);\r\n    unpipe();\r\n  }\r\n  dest.once('close', onclose);\r\n  function onfinish() {\r\n    debug('onfinish');\r\n    dest.removeListener('close', onclose);\r\n    unpipe();\r\n  }\r\n  dest.once('finish', onfinish);\r\n\r\n  function unpipe() {\r\n    debug('unpipe');\r\n    src.unpipe(dest);\r\n  }\r\n\r\n  // tell the dest that it's being piped to\r\n  dest.emit('pipe', src);\r\n\r\n  // start the flow if it hasn't been started already.\r\n  if (!state.flowing) {\r\n    debug('pipe resume');\r\n    src.resume();\r\n  }\r\n\r\n  return dest;\r\n};\r\n\r\nfunction pipeOnDrain(src) {\r\n  return function () {\r\n    var state = src._readableState;\r\n    debug('pipeOnDrain', state.awaitDrain);\r\n    if (state.awaitDrain) state.awaitDrain--;\r\n    if (state.awaitDrain === 0 && src.listeners('data').length) {\r\n      state.flowing = true;\r\n      flow(src);\r\n    }\r\n  };\r\n}\r\n\r\nReadable.prototype.unpipe = function (dest) {\r\n  var state = this._readableState;\r\n\r\n  // if we're not piping anywhere, then do nothing.\r\n  if (state.pipesCount === 0) return this;\r\n\r\n  // just one destination.  most common case.\r\n  if (state.pipesCount === 1) {\r\n    // passed in one, but it's not the right one.\r\n    if (dest && dest !== state.pipes) return this;\r\n\r\n    if (!dest) dest = state.pipes;\r\n\r\n    // got a match.\r\n    state.pipes = null;\r\n    state.pipesCount = 0;\r\n    state.flowing = false;\r\n    if (dest) dest.emit('unpipe', this);\r\n    return this;\r\n  }\r\n\r\n  // slow case. multiple pipe destinations.\r\n\r\n  if (!dest) {\r\n    // remove all.\r\n    var dests = state.pipes;\r\n    var len = state.pipesCount;\r\n    state.pipes = null;\r\n    state.pipesCount = 0;\r\n    state.flowing = false;\r\n\r\n    for (var _i = 0; _i < len; _i++) {\r\n      dests[_i].emit('unpipe', this);\r\n    }return this;\r\n  }\r\n\r\n  // try to find the right one.\r\n  var i = indexOf(state.pipes, dest);\r\n  if (i === -1) return this;\r\n\r\n  state.pipes.splice(i, 1);\r\n  state.pipesCount -= 1;\r\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\r\n\r\n  dest.emit('unpipe', this);\r\n\r\n  return this;\r\n};\r\n\r\n// set up data events if they are asked for\r\n// Ensure readable listeners eventually get something\r\nReadable.prototype.on = function (ev, fn) {\r\n  var res = EventEmitter.prototype.on.call(this, ev, fn);\r\n\r\n  if (ev === 'data') {\r\n    // Start flowing on next tick if stream isn't explicitly paused\r\n    if (this._readableState.flowing !== false) this.resume();\r\n  } else if (ev === 'readable') {\r\n    var state = this._readableState;\r\n    if (!state.endEmitted && !state.readableListening) {\r\n      state.readableListening = state.needReadable = true;\r\n      state.emittedReadable = false;\r\n      if (!state.reading) {\r\n        nextTick(nReadingNextTick, this);\r\n      } else if (state.length) {\r\n        emitReadable(this);\r\n      }\r\n    }\r\n  }\r\n\r\n  return res;\r\n};\r\nReadable.prototype.addListener = Readable.prototype.on;\r\n\r\nfunction nReadingNextTick(self) {\r\n  debug('readable nexttick read 0');\r\n  self.read(0);\r\n}\r\n\r\n// pause() and resume() are remnants of the legacy readable stream API\r\n// If the user uses them, then switch into old mode.\r\nReadable.prototype.resume = function () {\r\n  var state = this._readableState;\r\n  if (!state.flowing) {\r\n    debug('resume');\r\n    state.flowing = true;\r\n    resume(this, state);\r\n  }\r\n  return this;\r\n};\r\n\r\nfunction resume(stream, state) {\r\n  if (!state.resumeScheduled) {\r\n    state.resumeScheduled = true;\r\n    nextTick(resume_, stream, state);\r\n  }\r\n}\r\n\r\nfunction resume_(stream, state) {\r\n  if (!state.reading) {\r\n    debug('resume read 0');\r\n    stream.read(0);\r\n  }\r\n\r\n  state.resumeScheduled = false;\r\n  state.awaitDrain = 0;\r\n  stream.emit('resume');\r\n  flow(stream);\r\n  if (state.flowing && !state.reading) stream.read(0);\r\n}\r\n\r\nReadable.prototype.pause = function () {\r\n  debug('call pause flowing=%j', this._readableState.flowing);\r\n  if (false !== this._readableState.flowing) {\r\n    debug('pause');\r\n    this._readableState.flowing = false;\r\n    this.emit('pause');\r\n  }\r\n  return this;\r\n};\r\n\r\nfunction flow(stream) {\r\n  var state = stream._readableState;\r\n  debug('flow', state.flowing);\r\n  while (state.flowing && stream.read() !== null) {}\r\n}\r\n\r\n// wrap an old-style stream as the async data source.\r\n// This is *not* part of the readable stream interface.\r\n// It is an ugly unfortunate mess of history.\r\nReadable.prototype.wrap = function (stream) {\r\n  var state = this._readableState;\r\n  var paused = false;\r\n\r\n  var self = this;\r\n  stream.on('end', function () {\r\n    debug('wrapped end');\r\n    if (state.decoder && !state.ended) {\r\n      var chunk = state.decoder.end();\r\n      if (chunk && chunk.length) self.push(chunk);\r\n    }\r\n\r\n    self.push(null);\r\n  });\r\n\r\n  stream.on('data', function (chunk) {\r\n    debug('wrapped data');\r\n    if (state.decoder) chunk = state.decoder.write(chunk);\r\n\r\n    // don't skip over falsy values in objectMode\r\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\r\n\r\n    var ret = self.push(chunk);\r\n    if (!ret) {\r\n      paused = true;\r\n      stream.pause();\r\n    }\r\n  });\r\n\r\n  // proxy all the other methods.\r\n  // important when wrapping filters and duplexes.\r\n  for (var i in stream) {\r\n    if (this[i] === undefined && typeof stream[i] === 'function') {\r\n      this[i] = function (method) {\r\n        return function () {\r\n          return stream[method].apply(stream, arguments);\r\n        };\r\n      }(i);\r\n    }\r\n  }\r\n\r\n  // proxy certain important events.\r\n  var events = ['error', 'close', 'destroy', 'pause', 'resume'];\r\n  forEach(events, function (ev) {\r\n    stream.on(ev, self.emit.bind(self, ev));\r\n  });\r\n\r\n  // when we try to consume some more bytes, simply unpause the\r\n  // underlying stream.\r\n  self._read = function (n) {\r\n    debug('wrapped _read', n);\r\n    if (paused) {\r\n      paused = false;\r\n      stream.resume();\r\n    }\r\n  };\r\n\r\n  return self;\r\n};\r\n\r\n// exposed for testing purposes only.\r\nReadable._fromList = fromList;\r\n\r\n// Pluck off n bytes from an array of buffers.\r\n// Length is the combined lengths of all the buffers in the list.\r\n// This function is designed to be inlinable, so please take care when making\r\n// changes to the function body.\r\nfunction fromList(n, state) {\r\n  // nothing buffered\r\n  if (state.length === 0) return null;\r\n\r\n  var ret;\r\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\r\n    // read it all, truncate the list\r\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);\r\n    state.buffer.clear();\r\n  } else {\r\n    // read part of list\r\n    ret = fromListPartial(n, state.buffer, state.decoder);\r\n  }\r\n\r\n  return ret;\r\n}\r\n\r\n// Extracts only enough buffered data to satisfy the amount requested.\r\n// This function is designed to be inlinable, so please take care when making\r\n// changes to the function body.\r\nfunction fromListPartial(n, list, hasStrings) {\r\n  var ret;\r\n  if (n < list.head.data.length) {\r\n    // slice is the same for buffers and strings\r\n    ret = list.head.data.slice(0, n);\r\n    list.head.data = list.head.data.slice(n);\r\n  } else if (n === list.head.data.length) {\r\n    // first chunk is a perfect match\r\n    ret = list.shift();\r\n  } else {\r\n    // result spans more than one buffer\r\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\r\n  }\r\n  return ret;\r\n}\r\n\r\n// Copies a specified amount of characters from the list of buffered data\r\n// chunks.\r\n// This function is designed to be inlinable, so please take care when making\r\n// changes to the function body.\r\nfunction copyFromBufferString(n, list) {\r\n  var p = list.head;\r\n  var c = 1;\r\n  var ret = p.data;\r\n  n -= ret.length;\r\n  while (p = p.next) {\r\n    var str = p.data;\r\n    var nb = n > str.length ? str.length : n;\r\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\r\n    n -= nb;\r\n    if (n === 0) {\r\n      if (nb === str.length) {\r\n        ++c;\r\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\r\n      } else {\r\n        list.head = p;\r\n        p.data = str.slice(nb);\r\n      }\r\n      break;\r\n    }\r\n    ++c;\r\n  }\r\n  list.length -= c;\r\n  return ret;\r\n}\r\n\r\n// Copies a specified amount of bytes from the list of buffered data chunks.\r\n// This function is designed to be inlinable, so please take care when making\r\n// changes to the function body.\r\nfunction copyFromBuffer(n, list) {\r\n  var ret = Buffer.allocUnsafe(n);\r\n  var p = list.head;\r\n  var c = 1;\r\n  p.data.copy(ret);\r\n  n -= p.data.length;\r\n  while (p = p.next) {\r\n    var buf = p.data;\r\n    var nb = n > buf.length ? buf.length : n;\r\n    buf.copy(ret, ret.length - n, 0, nb);\r\n    n -= nb;\r\n    if (n === 0) {\r\n      if (nb === buf.length) {\r\n        ++c;\r\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\r\n      } else {\r\n        list.head = p;\r\n        p.data = buf.slice(nb);\r\n      }\r\n      break;\r\n    }\r\n    ++c;\r\n  }\r\n  list.length -= c;\r\n  return ret;\r\n}\r\n\r\nfunction endReadable(stream) {\r\n  var state = stream._readableState;\r\n\r\n  // If we get here before consuming all the bytes, then that is a\r\n  // bug in node.  Should never happen.\r\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\r\n\r\n  if (!state.endEmitted) {\r\n    state.ended = true;\r\n    nextTick(endReadableNT, state, stream);\r\n  }\r\n}\r\n\r\nfunction endReadableNT(state, stream) {\r\n  // Check that we didn't get one last unshift.\r\n  if (!state.endEmitted && state.length === 0) {\r\n    state.endEmitted = true;\r\n    stream.readable = false;\r\n    stream.emit('end');\r\n  }\r\n}\r\n\r\nfunction forEach(xs, f) {\r\n  for (var i = 0, l = xs.length; i < l; i++) {\r\n    f(xs[i], i);\r\n  }\r\n}\r\n\r\nfunction indexOf(xs, x) {\r\n  for (var i = 0, l = xs.length; i < l; i++) {\r\n    if (xs[i] === x) return i;\r\n  }\r\n  return -1;\r\n}\r\n\r\n// A bit simpler than readable streams.\r\nWritable.WritableState = WritableState;\r\ninherits$1(Writable, EventEmitter);\r\n\r\nfunction nop() {}\r\n\r\nfunction WriteReq(chunk, encoding, cb) {\r\n  this.chunk = chunk;\r\n  this.encoding = encoding;\r\n  this.callback = cb;\r\n  this.next = null;\r\n}\r\n\r\nfunction WritableState(options, stream) {\r\n  Object.defineProperty(this, 'buffer', {\r\n    get: deprecate(function () {\r\n      return this.getBuffer();\r\n    }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')\r\n  });\r\n  options = options || {};\r\n\r\n  // object stream flag to indicate whether or not this stream\r\n  // contains buffers or objects.\r\n  this.objectMode = !!options.objectMode;\r\n\r\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\r\n\r\n  // the point at which write() starts returning false\r\n  // Note: 0 is a valid value, means that we always return false if\r\n  // the entire buffer is not flushed immediately on write()\r\n  var hwm = options.highWaterMark;\r\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\r\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\r\n\r\n  // cast to ints.\r\n  this.highWaterMark = ~ ~this.highWaterMark;\r\n\r\n  this.needDrain = false;\r\n  // at the start of calling end()\r\n  this.ending = false;\r\n  // when end() has been called, and returned\r\n  this.ended = false;\r\n  // when 'finish' is emitted\r\n  this.finished = false;\r\n\r\n  // should we decode strings into buffers before passing to _write?\r\n  // this is here so that some node-core streams can optimize string\r\n  // handling at a lower level.\r\n  var noDecode = options.decodeStrings === false;\r\n  this.decodeStrings = !noDecode;\r\n\r\n  // Crypto is kind of old and crusty.  Historically, its default string\r\n  // encoding is 'binary' so we have to make this configurable.\r\n  // Everything else in the universe uses 'utf8', though.\r\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\r\n\r\n  // not an actual buffer we keep track of, but a measurement\r\n  // of how much we're waiting to get pushed to some underlying\r\n  // socket or file.\r\n  this.length = 0;\r\n\r\n  // a flag to see when we're in the middle of a write.\r\n  this.writing = false;\r\n\r\n  // when true all writes will be buffered until .uncork() call\r\n  this.corked = 0;\r\n\r\n  // a flag to be able to tell if the onwrite cb is called immediately,\r\n  // or on a later tick.  We set this to true at first, because any\r\n  // actions that shouldn't happen until \"later\" should generally also\r\n  // not happen before the first write call.\r\n  this.sync = true;\r\n\r\n  // a flag to know if we're processing previously buffered items, which\r\n  // may call the _write() callback in the same tick, so that we don't\r\n  // end up in an overlapped onwrite situation.\r\n  this.bufferProcessing = false;\r\n\r\n  // the callback that's passed to _write(chunk,cb)\r\n  this.onwrite = function (er) {\r\n    onwrite(stream, er);\r\n  };\r\n\r\n  // the callback that the user supplies to write(chunk,encoding,cb)\r\n  this.writecb = null;\r\n\r\n  // the amount that is being written when _write is called.\r\n  this.writelen = 0;\r\n\r\n  this.bufferedRequest = null;\r\n  this.lastBufferedRequest = null;\r\n\r\n  // number of pending user-supplied write callbacks\r\n  // this must be 0 before 'finish' can be emitted\r\n  this.pendingcb = 0;\r\n\r\n  // emit prefinish if the only thing we're waiting for is _write cbs\r\n  // This is relevant for synchronous Transform streams\r\n  this.prefinished = false;\r\n\r\n  // True if the error was already emitted and should not be thrown again\r\n  this.errorEmitted = false;\r\n\r\n  // count buffered requests\r\n  this.bufferedRequestCount = 0;\r\n\r\n  // allocate the first CorkedRequest, there is always\r\n  // one allocated and free to use, and we maintain at most two\r\n  this.corkedRequestsFree = new CorkedRequest(this);\r\n}\r\n\r\nWritableState.prototype.getBuffer = function writableStateGetBuffer() {\r\n  var current = this.bufferedRequest;\r\n  var out = [];\r\n  while (current) {\r\n    out.push(current);\r\n    current = current.next;\r\n  }\r\n  return out;\r\n};\r\nfunction Writable(options) {\r\n\r\n  // Writable ctor is applied to Duplexes, though they're not\r\n  // instanceof Writable, they're instanceof Readable.\r\n  if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options);\r\n\r\n  this._writableState = new WritableState(options, this);\r\n\r\n  // legacy.\r\n  this.writable = true;\r\n\r\n  if (options) {\r\n    if (typeof options.write === 'function') this._write = options.write;\r\n\r\n    if (typeof options.writev === 'function') this._writev = options.writev;\r\n  }\r\n\r\n  EventEmitter.call(this);\r\n}\r\n\r\n// Otherwise people can pipe Writable streams, which is just wrong.\r\nWritable.prototype.pipe = function () {\r\n  this.emit('error', new Error('Cannot pipe, not readable'));\r\n};\r\n\r\nfunction writeAfterEnd(stream, cb) {\r\n  var er = new Error('write after end');\r\n  // TODO: defer error events consistently everywhere, not just the cb\r\n  stream.emit('error', er);\r\n  nextTick(cb, er);\r\n}\r\n\r\n// If we get something that is not a buffer, string, null, or undefined,\r\n// and we're not in objectMode, then that's an error.\r\n// Otherwise stream chunks are all considered to be of length=1, and the\r\n// watermarks determine how many objects to keep in the buffer, rather than\r\n// how many bytes or characters.\r\nfunction validChunk(stream, state, chunk, cb) {\r\n  var valid = true;\r\n  var er = false;\r\n  // Always throw error if a null is written\r\n  // if we are not in object mode then throw\r\n  // if it is not a buffer, string, or undefined.\r\n  if (chunk === null) {\r\n    er = new TypeError('May not write null values to stream');\r\n  } else if (!Buffer$1.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\r\n    er = new TypeError('Invalid non-string/buffer chunk');\r\n  }\r\n  if (er) {\r\n    stream.emit('error', er);\r\n    nextTick(cb, er);\r\n    valid = false;\r\n  }\r\n  return valid;\r\n}\r\n\r\nWritable.prototype.write = function (chunk, encoding, cb) {\r\n  var state = this._writableState;\r\n  var ret = false;\r\n\r\n  if (typeof encoding === 'function') {\r\n    cb = encoding;\r\n    encoding = null;\r\n  }\r\n\r\n  if (Buffer$1.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\r\n\r\n  if (typeof cb !== 'function') cb = nop;\r\n\r\n  if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) {\r\n    state.pendingcb++;\r\n    ret = writeOrBuffer(this, state, chunk, encoding, cb);\r\n  }\r\n\r\n  return ret;\r\n};\r\n\r\nWritable.prototype.cork = function () {\r\n  var state = this._writableState;\r\n\r\n  state.corked++;\r\n};\r\n\r\nWritable.prototype.uncork = function () {\r\n  var state = this._writableState;\r\n\r\n  if (state.corked) {\r\n    state.corked--;\r\n\r\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\r\n  }\r\n};\r\n\r\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\r\n  // node::ParseEncoding() requires lower case.\r\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\r\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);\r\n  this._writableState.defaultEncoding = encoding;\r\n  return this;\r\n};\r\n\r\nfunction decodeChunk(state, chunk, encoding) {\r\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\r\n    chunk = Buffer$1.from(chunk, encoding);\r\n  }\r\n  return chunk;\r\n}\r\n\r\n// if we're already writing something, then just put this\r\n// in the queue, and wait our turn.  Otherwise, call _write\r\n// If we return false, then we need a drain event, so set that flag.\r\nfunction writeOrBuffer(stream, state, chunk, encoding, cb) {\r\n  chunk = decodeChunk(state, chunk, encoding);\r\n\r\n  if (Buffer$1.isBuffer(chunk)) encoding = 'buffer';\r\n  var len = state.objectMode ? 1 : chunk.length;\r\n\r\n  state.length += len;\r\n\r\n  var ret = state.length < state.highWaterMark;\r\n  // we must ensure that previous needDrain will not be reset to false.\r\n  if (!ret) state.needDrain = true;\r\n\r\n  if (state.writing || state.corked) {\r\n    var last = state.lastBufferedRequest;\r\n    state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);\r\n    if (last) {\r\n      last.next = state.lastBufferedRequest;\r\n    } else {\r\n      state.bufferedRequest = state.lastBufferedRequest;\r\n    }\r\n    state.bufferedRequestCount += 1;\r\n  } else {\r\n    doWrite(stream, state, false, len, chunk, encoding, cb);\r\n  }\r\n\r\n  return ret;\r\n}\r\n\r\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\r\n  state.writelen = len;\r\n  state.writecb = cb;\r\n  state.writing = true;\r\n  state.sync = true;\r\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\r\n  state.sync = false;\r\n}\r\n\r\nfunction onwriteError(stream, state, sync, er, cb) {\r\n  --state.pendingcb;\r\n  if (sync) nextTick(cb, er);else cb(er);\r\n\r\n  stream._writableState.errorEmitted = true;\r\n  stream.emit('error', er);\r\n}\r\n\r\nfunction onwriteStateUpdate(state) {\r\n  state.writing = false;\r\n  state.writecb = null;\r\n  state.length -= state.writelen;\r\n  state.writelen = 0;\r\n}\r\n\r\nfunction onwrite(stream, er) {\r\n  var state = stream._writableState;\r\n  var sync = state.sync;\r\n  var cb = state.writecb;\r\n\r\n  onwriteStateUpdate(state);\r\n\r\n  if (er) onwriteError(stream, state, sync, er, cb);else {\r\n    // Check if we're actually ready to finish, but don't emit yet\r\n    var finished = needFinish(state);\r\n\r\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\r\n      clearBuffer(stream, state);\r\n    }\r\n\r\n    if (sync) {\r\n      /*<replacement>*/\r\n        nextTick(afterWrite, stream, state, finished, cb);\r\n      /*</replacement>*/\r\n    } else {\r\n        afterWrite(stream, state, finished, cb);\r\n      }\r\n  }\r\n}\r\n\r\nfunction afterWrite(stream, state, finished, cb) {\r\n  if (!finished) onwriteDrain(stream, state);\r\n  state.pendingcb--;\r\n  cb();\r\n  finishMaybe(stream, state);\r\n}\r\n\r\n// Must force callback to be called on nextTick, so that we don't\r\n// emit 'drain' before the write() consumer gets the 'false' return\r\n// value, and has a chance to attach a 'drain' listener.\r\nfunction onwriteDrain(stream, state) {\r\n  if (state.length === 0 && state.needDrain) {\r\n    state.needDrain = false;\r\n    stream.emit('drain');\r\n  }\r\n}\r\n\r\n// if there's something in the buffer waiting, then process it\r\nfunction clearBuffer(stream, state) {\r\n  state.bufferProcessing = true;\r\n  var entry = state.bufferedRequest;\r\n\r\n  if (stream._writev && entry && entry.next) {\r\n    // Fast case, write everything using _writev()\r\n    var l = state.bufferedRequestCount;\r\n    var buffer = new Array(l);\r\n    var holder = state.corkedRequestsFree;\r\n    holder.entry = entry;\r\n\r\n    var count = 0;\r\n    while (entry) {\r\n      buffer[count] = entry;\r\n      entry = entry.next;\r\n      count += 1;\r\n    }\r\n\r\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\r\n\r\n    // doWrite is almost always async, defer these to save a bit of time\r\n    // as the hot path ends with doWrite\r\n    state.pendingcb++;\r\n    state.lastBufferedRequest = null;\r\n    if (holder.next) {\r\n      state.corkedRequestsFree = holder.next;\r\n      holder.next = null;\r\n    } else {\r\n      state.corkedRequestsFree = new CorkedRequest(state);\r\n    }\r\n  } else {\r\n    // Slow case, write chunks one-by-one\r\n    while (entry) {\r\n      var chunk = entry.chunk;\r\n      var encoding = entry.encoding;\r\n      var cb = entry.callback;\r\n      var len = state.objectMode ? 1 : chunk.length;\r\n\r\n      doWrite(stream, state, false, len, chunk, encoding, cb);\r\n      entry = entry.next;\r\n      // if we didn't call the onwrite immediately, then\r\n      // it means that we need to wait until it does.\r\n      // also, that means that the chunk and cb are currently\r\n      // being processed, so move the buffer counter past them.\r\n      if (state.writing) {\r\n        break;\r\n      }\r\n    }\r\n\r\n    if (entry === null) state.lastBufferedRequest = null;\r\n  }\r\n\r\n  state.bufferedRequestCount = 0;\r\n  state.bufferedRequest = entry;\r\n  state.bufferProcessing = false;\r\n}\r\n\r\nWritable.prototype._write = function (chunk, encoding, cb) {\r\n  cb(new Error('not implemented'));\r\n};\r\n\r\nWritable.prototype._writev = null;\r\n\r\nWritable.prototype.end = function (chunk, encoding, cb) {\r\n  var state = this._writableState;\r\n\r\n  if (typeof chunk === 'function') {\r\n    cb = chunk;\r\n    chunk = null;\r\n    encoding = null;\r\n  } else if (typeof encoding === 'function') {\r\n    cb = encoding;\r\n    encoding = null;\r\n  }\r\n\r\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\r\n\r\n  // .end() fully uncorks\r\n  if (state.corked) {\r\n    state.corked = 1;\r\n    this.uncork();\r\n  }\r\n\r\n  // ignore unnecessary end() calls.\r\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\r\n};\r\n\r\nfunction needFinish(state) {\r\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\r\n}\r\n\r\nfunction prefinish(stream, state) {\r\n  if (!state.prefinished) {\r\n    state.prefinished = true;\r\n    stream.emit('prefinish');\r\n  }\r\n}\r\n\r\nfunction finishMaybe(stream, state) {\r\n  var need = needFinish(state);\r\n  if (need) {\r\n    if (state.pendingcb === 0) {\r\n      prefinish(stream, state);\r\n      state.finished = true;\r\n      stream.emit('finish');\r\n    } else {\r\n      prefinish(stream, state);\r\n    }\r\n  }\r\n  return need;\r\n}\r\n\r\nfunction endWritable(stream, state, cb) {\r\n  state.ending = true;\r\n  finishMaybe(stream, state);\r\n  if (cb) {\r\n    if (state.finished) nextTick(cb);else stream.once('finish', cb);\r\n  }\r\n  state.ended = true;\r\n  stream.writable = false;\r\n}\r\n\r\n// It seems a linked list but it is not\r\n// there will be only 2 of these for each stream\r\nfunction CorkedRequest(state) {\r\n  var _this = this;\r\n\r\n  this.next = null;\r\n  this.entry = null;\r\n\r\n  this.finish = function (err) {\r\n    var entry = _this.entry;\r\n    _this.entry = null;\r\n    while (entry) {\r\n      var cb = entry.callback;\r\n      state.pendingcb--;\r\n      cb(err);\r\n      entry = entry.next;\r\n    }\r\n    if (state.corkedRequestsFree) {\r\n      state.corkedRequestsFree.next = _this;\r\n    } else {\r\n      state.corkedRequestsFree = _this;\r\n    }\r\n  };\r\n}\r\n\r\ninherits$1(Duplex, Readable);\r\n\r\nvar keys = Object.keys(Writable.prototype);\r\nfor (var v = 0; v < keys.length; v++) {\r\n  var method = keys[v];\r\n  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\r\n}\r\nfunction Duplex(options) {\r\n  if (!(this instanceof Duplex)) return new Duplex(options);\r\n\r\n  Readable.call(this, options);\r\n  Writable.call(this, options);\r\n\r\n  if (options && options.readable === false) this.readable = false;\r\n\r\n  if (options && options.writable === false) this.writable = false;\r\n\r\n  this.allowHalfOpen = true;\r\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\r\n\r\n  this.once('end', onend);\r\n}\r\n\r\n// the no-half-open enforcer\r\nfunction onend() {\r\n  // if we allow half-open state, or if the writable side ended,\r\n  // then we're ok.\r\n  if (this.allowHalfOpen || this._writableState.ended) return;\r\n\r\n  // no more data can be written.\r\n  // But allow more writes to happen in this tick.\r\n  nextTick(onEndNT, this);\r\n}\r\n\r\nfunction onEndNT(self) {\r\n  self.end();\r\n}\r\n\r\n// a transform stream is a readable/writable stream where you do\r\ninherits$1(Transform, Duplex);\r\n\r\nfunction TransformState(stream) {\r\n  this.afterTransform = function (er, data) {\r\n    return afterTransform(stream, er, data);\r\n  };\r\n\r\n  this.needTransform = false;\r\n  this.transforming = false;\r\n  this.writecb = null;\r\n  this.writechunk = null;\r\n  this.writeencoding = null;\r\n}\r\n\r\nfunction afterTransform(stream, er, data) {\r\n  var ts = stream._transformState;\r\n  ts.transforming = false;\r\n\r\n  var cb = ts.writecb;\r\n\r\n  if (!cb) return stream.emit('error', new Error('no writecb in Transform class'));\r\n\r\n  ts.writechunk = null;\r\n  ts.writecb = null;\r\n\r\n  if (data !== null && data !== undefined) stream.push(data);\r\n\r\n  cb(er);\r\n\r\n  var rs = stream._readableState;\r\n  rs.reading = false;\r\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\r\n    stream._read(rs.highWaterMark);\r\n  }\r\n}\r\nfunction Transform(options) {\r\n  if (!(this instanceof Transform)) return new Transform(options);\r\n\r\n  Duplex.call(this, options);\r\n\r\n  this._transformState = new TransformState(this);\r\n\r\n  // when the writable side finishes, then flush out anything remaining.\r\n  var stream = this;\r\n\r\n  // start out asking for a readable event once data is transformed.\r\n  this._readableState.needReadable = true;\r\n\r\n  // we have implemented the _read method, and done the other things\r\n  // that Readable wants before the first _read call, so unset the\r\n  // sync guard flag.\r\n  this._readableState.sync = false;\r\n\r\n  if (options) {\r\n    if (typeof options.transform === 'function') this._transform = options.transform;\r\n\r\n    if (typeof options.flush === 'function') this._flush = options.flush;\r\n  }\r\n\r\n  this.once('prefinish', function () {\r\n    if (typeof this._flush === 'function') this._flush(function (er) {\r\n      done(stream, er);\r\n    });else done(stream);\r\n  });\r\n}\r\n\r\nTransform.prototype.push = function (chunk, encoding) {\r\n  this._transformState.needTransform = false;\r\n  return Duplex.prototype.push.call(this, chunk, encoding);\r\n};\r\n\r\n// This is the part where you do stuff!\r\n// override this function in implementation classes.\r\n// 'chunk' is an input chunk.\r\n//\r\n// Call `push(newChunk)` to pass along transformed output\r\n// to the readable side.  You may call 'push' zero or more times.\r\n//\r\n// Call `cb(err)` when you are done with this chunk.  If you pass\r\n// an error, then that'll put the hurt on the whole operation.  If you\r\n// never call cb(), then you'll never get another chunk.\r\nTransform.prototype._transform = function (chunk, encoding, cb) {\r\n  throw new Error('Not implemented');\r\n};\r\n\r\nTransform.prototype._write = function (chunk, encoding, cb) {\r\n  var ts = this._transformState;\r\n  ts.writecb = cb;\r\n  ts.writechunk = chunk;\r\n  ts.writeencoding = encoding;\r\n  if (!ts.transforming) {\r\n    var rs = this._readableState;\r\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\r\n  }\r\n};\r\n\r\n// Doesn't matter what the args are here.\r\n// _transform does all the work.\r\n// That we got here means that the readable side wants more data.\r\nTransform.prototype._read = function (n) {\r\n  var ts = this._transformState;\r\n\r\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\r\n    ts.transforming = true;\r\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\r\n  } else {\r\n    // mark that we need a transform, so that any data that comes in\r\n    // will get processed, now that we've asked for it.\r\n    ts.needTransform = true;\r\n  }\r\n};\r\n\r\nfunction done(stream, er) {\r\n  if (er) return stream.emit('error', er);\r\n\r\n  // if there's nothing in the write buffer, then that means\r\n  // that nothing more will ever be provided\r\n  var ws = stream._writableState;\r\n  var ts = stream._transformState;\r\n\r\n  if (ws.length) throw new Error('Calling transform done when ws.length != 0');\r\n\r\n  if (ts.transforming) throw new Error('Calling transform done when still transforming');\r\n\r\n  return stream.push(null);\r\n}\r\n\r\ninherits$1(PassThrough, Transform);\r\nfunction PassThrough(options) {\r\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\r\n\r\n  Transform.call(this, options);\r\n}\r\n\r\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\r\n  cb(null, chunk);\r\n};\r\n\r\ninherits$1(Stream, EventEmitter);\r\nStream.Readable = Readable;\r\nStream.Writable = Writable;\r\nStream.Duplex = Duplex;\r\nStream.Transform = Transform;\r\nStream.PassThrough = PassThrough;\r\n\r\n// Backwards-compat with node 0.4.x\r\nStream.Stream = Stream;\r\n\r\n// old-style streams.  Note that the pipe method (the only relevant\r\n// part of this class) is overridden in the Readable class.\r\n\r\nfunction Stream() {\r\n  EventEmitter.call(this);\r\n}\r\n\r\nStream.prototype.pipe = function(dest, options) {\r\n  var source = this;\r\n\r\n  function ondata(chunk) {\r\n    if (dest.writable) {\r\n      if (false === dest.write(chunk) && source.pause) {\r\n        source.pause();\r\n      }\r\n    }\r\n  }\r\n\r\n  source.on('data', ondata);\r\n\r\n  function ondrain() {\r\n    if (source.readable && source.resume) {\r\n      source.resume();\r\n    }\r\n  }\r\n\r\n  dest.on('drain', ondrain);\r\n\r\n  // If the 'end' option is not supplied, dest.end() will be called when\r\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\r\n  if (!dest._isStdio && (!options || options.end !== false)) {\r\n    source.on('end', onend);\r\n    source.on('close', onclose);\r\n  }\r\n\r\n  var didOnEnd = false;\r\n  function onend() {\r\n    if (didOnEnd) return;\r\n    didOnEnd = true;\r\n\r\n    dest.end();\r\n  }\r\n\r\n\r\n  function onclose() {\r\n    if (didOnEnd) return;\r\n    didOnEnd = true;\r\n\r\n    if (typeof dest.destroy === 'function') dest.destroy();\r\n  }\r\n\r\n  // don't leave dangling pipes when there are errors.\r\n  function onerror(er) {\r\n    cleanup();\r\n    if (EventEmitter.listenerCount(this, 'error') === 0) {\r\n      throw er; // Unhandled stream error in pipe.\r\n    }\r\n  }\r\n\r\n  source.on('error', onerror);\r\n  dest.on('error', onerror);\r\n\r\n  // remove all the event listeners that were added.\r\n  function cleanup() {\r\n    source.removeListener('data', ondata);\r\n    dest.removeListener('drain', ondrain);\r\n\r\n    source.removeListener('end', onend);\r\n    source.removeListener('close', onclose);\r\n\r\n    source.removeListener('error', onerror);\r\n    dest.removeListener('error', onerror);\r\n\r\n    source.removeListener('end', cleanup);\r\n    source.removeListener('close', cleanup);\r\n\r\n    dest.removeListener('close', cleanup);\r\n  }\r\n\r\n  source.on('end', cleanup);\r\n  source.on('close', cleanup);\r\n\r\n  dest.on('close', cleanup);\r\n\r\n  dest.emit('pipe', source);\r\n\r\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\r\n  return dest;\r\n};\r\n\r\nvar rStates = {\r\n  UNSENT: 0,\r\n  OPENED: 1,\r\n  HEADERS_RECEIVED: 2,\r\n  LOADING: 3,\r\n  DONE: 4\r\n};\r\nfunction IncomingMessage(xhr, response, mode) {\r\n  var self = this;\r\n  Readable.call(self);\r\n\r\n  self._mode = mode;\r\n  self.headers = {};\r\n  self.rawHeaders = [];\r\n  self.trailers = {};\r\n  self.rawTrailers = [];\r\n\r\n  // Fake the 'close' event, but only once 'end' fires\r\n  self.on('end', function() {\r\n    // The nextTick is necessary to prevent the 'request' module from causing an infinite loop\r\n    process.nextTick(function() {\r\n      self.emit('close');\r\n    });\r\n  });\r\n  var read;\r\n  if (mode === 'fetch') {\r\n    self._fetchResponse = response;\r\n\r\n    self.url = response.url;\r\n    self.statusCode = response.status;\r\n    self.statusMessage = response.statusText;\r\n      // backwards compatible version of for (<item> of <iterable>):\r\n      // for (var <item>,_i,_it = <iterable>[Symbol.iterator](); <item> = (_i = _it.next()).value,!_i.done;)\r\n    for (var header, _i, _it = response.headers[Symbol.iterator](); header = (_i = _it.next()).value, !_i.done;) {\r\n      self.headers[header[0].toLowerCase()] = header[1];\r\n      self.rawHeaders.push(header[0], header[1]);\r\n    }\r\n\r\n    // TODO: this doesn't respect backpressure. Once WritableStream is available, this can be fixed\r\n    var reader = response.body.getReader();\r\n\r\n    read = function () {\r\n      reader.read().then(function(result) {\r\n        if (self._destroyed)\r\n          return\r\n        if (result.done) {\r\n          self.push(null);\r\n          return\r\n        }\r\n        self.push(new Buffer(result.value));\r\n        read();\r\n      });\r\n    };\r\n    read();\r\n\r\n  } else {\r\n    self._xhr = xhr;\r\n    self._pos = 0;\r\n\r\n    self.url = xhr.responseURL;\r\n    self.statusCode = xhr.status;\r\n    self.statusMessage = xhr.statusText;\r\n    var headers = xhr.getAllResponseHeaders().split(/\\r?\\n/);\r\n    headers.forEach(function(header) {\r\n      var matches = header.match(/^([^:]+):\\s*(.*)/);\r\n      if (matches) {\r\n        var key = matches[1].toLowerCase();\r\n        if (key === 'set-cookie') {\r\n          if (self.headers[key] === undefined) {\r\n            self.headers[key] = [];\r\n          }\r\n          self.headers[key].push(matches[2]);\r\n        } else if (self.headers[key] !== undefined) {\r\n          self.headers[key] += ', ' + matches[2];\r\n        } else {\r\n          self.headers[key] = matches[2];\r\n        }\r\n        self.rawHeaders.push(matches[1], matches[2]);\r\n      }\r\n    });\r\n\r\n    self._charset = 'x-user-defined';\r\n    if (!overrideMimeType) {\r\n      var mimeType = self.rawHeaders['mime-type'];\r\n      if (mimeType) {\r\n        var charsetMatch = mimeType.match(/;\\s*charset=([^;])(;|$)/);\r\n        if (charsetMatch) {\r\n          self._charset = charsetMatch[1].toLowerCase();\r\n        }\r\n      }\r\n      if (!self._charset)\r\n        self._charset = 'utf-8'; // best guess\r\n    }\r\n  }\r\n}\r\n\r\ninherits$1(IncomingMessage, Readable);\r\n\r\nIncomingMessage.prototype._read = function() {};\r\n\r\nIncomingMessage.prototype._onXHRProgress = function() {\r\n  var self = this;\r\n\r\n  var xhr = self._xhr;\r\n\r\n  var response = null;\r\n  switch (self._mode) {\r\n  case 'text:vbarray': // For IE9\r\n    if (xhr.readyState !== rStates.DONE)\r\n      break\r\n    try {\r\n      // This fails in IE8\r\n      response = new global.VBArray(xhr.responseBody).toArray();\r\n    } catch (e) {\r\n      // pass\r\n    }\r\n    if (response !== null) {\r\n      self.push(new Buffer(response));\r\n      break\r\n    }\r\n    // Falls through in IE8\r\n  case 'text':\r\n    try { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4\r\n      response = xhr.responseText;\r\n    } catch (e) {\r\n      self._mode = 'text:vbarray';\r\n      break\r\n    }\r\n    if (response.length > self._pos) {\r\n      var newData = response.substr(self._pos);\r\n      if (self._charset === 'x-user-defined') {\r\n        var buffer = new Buffer(newData.length);\r\n        for (var i = 0; i < newData.length; i++)\r\n          buffer[i] = newData.charCodeAt(i) & 0xff;\r\n\r\n        self.push(buffer);\r\n      } else {\r\n        self.push(newData, self._charset);\r\n      }\r\n      self._pos = response.length;\r\n    }\r\n    break\r\n  case 'arraybuffer':\r\n    if (xhr.readyState !== rStates.DONE || !xhr.response)\r\n      break\r\n    response = xhr.response;\r\n    self.push(new Buffer(new Uint8Array(response)));\r\n    break\r\n  case 'moz-chunked-arraybuffer': // take whole\r\n    response = xhr.response;\r\n    if (xhr.readyState !== rStates.LOADING || !response)\r\n      break\r\n    self.push(new Buffer(new Uint8Array(response)));\r\n    break\r\n  case 'ms-stream':\r\n    response = xhr.response;\r\n    if (xhr.readyState !== rStates.LOADING)\r\n      break\r\n    var reader = new global.MSStreamReader();\r\n    reader.onprogress = function() {\r\n      if (reader.result.byteLength > self._pos) {\r\n        self.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))));\r\n        self._pos = reader.result.byteLength;\r\n      }\r\n    };\r\n    reader.onload = function() {\r\n      self.push(null);\r\n    };\r\n      // reader.onerror = ??? // TODO: this\r\n    reader.readAsArrayBuffer(response);\r\n    break\r\n  }\r\n\r\n  // The ms-stream case handles end separately in reader.onload()\r\n  if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {\r\n    self.push(null);\r\n  }\r\n};\r\n\r\n// from https://github.com/jhiesey/to-arraybuffer/blob/6502d9850e70ba7935a7df4ad86b358fc216f9f0/index.js\r\nfunction toArrayBuffer (buf) {\r\n  // If the buffer is backed by a Uint8Array, a faster version will work\r\n  if (buf instanceof Uint8Array) {\r\n    // If the buffer isn't a subarray, return the underlying ArrayBuffer\r\n    if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {\r\n      return buf.buffer\r\n    } else if (typeof buf.buffer.slice === 'function') {\r\n      // Otherwise we need to get a proper copy\r\n      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)\r\n    }\r\n  }\r\n\r\n  if (isBuffer(buf)) {\r\n    // This is the slow version that will work with any Buffer\r\n    // implementation (even in old browsers)\r\n    var arrayCopy = new Uint8Array(buf.length);\r\n    var len = buf.length;\r\n    for (var i = 0; i < len; i++) {\r\n      arrayCopy[i] = buf[i];\r\n    }\r\n    return arrayCopy.buffer\r\n  } else {\r\n    throw new Error('Argument must be a Buffer')\r\n  }\r\n}\r\n\r\nfunction decideMode(preferBinary, useFetch) {\r\n  if (hasFetch && useFetch) {\r\n    return 'fetch'\r\n  } else if (mozchunkedarraybuffer) {\r\n    return 'moz-chunked-arraybuffer'\r\n  } else if (msstream) {\r\n    return 'ms-stream'\r\n  } else if (arraybuffer && preferBinary) {\r\n    return 'arraybuffer'\r\n  } else if (vbArray && preferBinary) {\r\n    return 'text:vbarray'\r\n  } else {\r\n    return 'text'\r\n  }\r\n}\r\n\r\nfunction ClientRequest(opts) {\r\n  var self = this;\r\n  Writable.call(self);\r\n\r\n  self._opts = opts;\r\n  self._body = [];\r\n  self._headers = {};\r\n  if (opts.auth)\r\n    self.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'));\r\n  Object.keys(opts.headers).forEach(function(name) {\r\n    self.setHeader(name, opts.headers[name]);\r\n  });\r\n\r\n  var preferBinary;\r\n  var useFetch = true;\r\n  if (opts.mode === 'disable-fetch') {\r\n    // If the use of XHR should be preferred and includes preserving the 'content-type' header\r\n    useFetch = false;\r\n    preferBinary = true;\r\n  } else if (opts.mode === 'prefer-streaming') {\r\n    // If streaming is a high priority but binary compatibility and\r\n    // the accuracy of the 'content-type' header aren't\r\n    preferBinary = false;\r\n  } else if (opts.mode === 'allow-wrong-content-type') {\r\n    // If streaming is more important than preserving the 'content-type' header\r\n    preferBinary = !overrideMimeType;\r\n  } else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {\r\n    // Use binary if text streaming may corrupt data or the content-type header, or for speed\r\n    preferBinary = true;\r\n  } else {\r\n    throw new Error('Invalid value for opts.mode')\r\n  }\r\n  self._mode = decideMode(preferBinary, useFetch);\r\n\r\n  self.on('finish', function() {\r\n    self._onFinish();\r\n  });\r\n}\r\n\r\ninherits$1(ClientRequest, Writable);\r\n// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method\r\nvar unsafeHeaders = [\r\n  'accept-charset',\r\n  'accept-encoding',\r\n  'access-control-request-headers',\r\n  'access-control-request-method',\r\n  'connection',\r\n  'content-length',\r\n  'cookie',\r\n  'cookie2',\r\n  'date',\r\n  'dnt',\r\n  'expect',\r\n  'host',\r\n  'keep-alive',\r\n  'origin',\r\n  'referer',\r\n  'te',\r\n  'trailer',\r\n  'transfer-encoding',\r\n  'upgrade',\r\n  'user-agent',\r\n  'via'\r\n];\r\nClientRequest.prototype.setHeader = function(name, value) {\r\n  var self = this;\r\n  var lowerName = name.toLowerCase();\r\n    // This check is not necessary, but it prevents warnings from browsers about setting unsafe\r\n    // headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but\r\n    // http-browserify did it, so I will too.\r\n  if (unsafeHeaders.indexOf(lowerName) !== -1)\r\n    return\r\n\r\n  self._headers[lowerName] = {\r\n    name: name,\r\n    value: value\r\n  };\r\n};\r\n\r\nClientRequest.prototype.getHeader = function(name) {\r\n  var self = this;\r\n  return self._headers[name.toLowerCase()].value\r\n};\r\n\r\nClientRequest.prototype.removeHeader = function(name) {\r\n  var self = this;\r\n  delete self._headers[name.toLowerCase()];\r\n};\r\n\r\nClientRequest.prototype._onFinish = function() {\r\n  var self = this;\r\n\r\n  if (self._destroyed)\r\n    return\r\n  var opts = self._opts;\r\n\r\n  var headersObj = self._headers;\r\n  var body;\r\n  if (opts.method === 'POST' || opts.method === 'PUT' || opts.method === 'PATCH') {\r\n    if (blobConstructor()) {\r\n      body = new global.Blob(self._body.map(function(buffer) {\r\n        return toArrayBuffer(buffer)\r\n      }), {\r\n        type: (headersObj['content-type'] || {}).value || ''\r\n      });\r\n    } else {\r\n      // get utf8 string\r\n      body = Buffer.concat(self._body).toString();\r\n    }\r\n  }\r\n\r\n  if (self._mode === 'fetch') {\r\n    var headers = Object.keys(headersObj).map(function(name) {\r\n      return [headersObj[name].name, headersObj[name].value]\r\n    });\r\n\r\n    global.fetch(self._opts.url, {\r\n      method: self._opts.method,\r\n      headers: headers,\r\n      body: body,\r\n      mode: 'cors',\r\n      credentials: opts.withCredentials ? 'include' : 'same-origin'\r\n    }).then(function(response) {\r\n      self._fetchResponse = response;\r\n      self._connect();\r\n    }, function(reason) {\r\n      self.emit('error', reason);\r\n    });\r\n  } else {\r\n    var xhr = self._xhr = new global.XMLHttpRequest();\r\n    try {\r\n      xhr.open(self._opts.method, self._opts.url, true);\r\n    } catch (err) {\r\n      process.nextTick(function() {\r\n        self.emit('error', err);\r\n      });\r\n      return\r\n    }\r\n\r\n    // Can't set responseType on really old browsers\r\n    if ('responseType' in xhr)\r\n      xhr.responseType = self._mode.split(':')[0];\r\n\r\n    if ('withCredentials' in xhr)\r\n      xhr.withCredentials = !!opts.withCredentials;\r\n\r\n    if (self._mode === 'text' && 'overrideMimeType' in xhr)\r\n      xhr.overrideMimeType('text/plain; charset=x-user-defined');\r\n\r\n    Object.keys(headersObj).forEach(function(name) {\r\n      xhr.setRequestHeader(headersObj[name].name, headersObj[name].value);\r\n    });\r\n\r\n    self._response = null;\r\n    xhr.onreadystatechange = function() {\r\n      switch (xhr.readyState) {\r\n      case rStates.LOADING:\r\n      case rStates.DONE:\r\n        self._onXHRProgress();\r\n        break\r\n      }\r\n    };\r\n      // Necessary for streaming in Firefox, since xhr.response is ONLY defined\r\n      // in onprogress, not in onreadystatechange with xhr.readyState = 3\r\n    if (self._mode === 'moz-chunked-arraybuffer') {\r\n      xhr.onprogress = function() {\r\n        self._onXHRProgress();\r\n      };\r\n    }\r\n\r\n    xhr.onerror = function() {\r\n      if (self._destroyed)\r\n        return\r\n      self.emit('error', new Error('XHR error'));\r\n    };\r\n\r\n    try {\r\n      xhr.send(body);\r\n    } catch (err) {\r\n      process.nextTick(function() {\r\n        self.emit('error', err);\r\n      });\r\n      return\r\n    }\r\n  }\r\n};\r\n\r\n/**\r\n * Checks if xhr.status is readable and non-zero, indicating no error.\r\n * Even though the spec says it should be available in readyState 3,\r\n * accessing it throws an exception in IE8\r\n */\r\nfunction statusValid(xhr) {\r\n  try {\r\n    var status = xhr.status;\r\n    return (status !== null && status !== 0)\r\n  } catch (e) {\r\n    return false\r\n  }\r\n}\r\n\r\nClientRequest.prototype._onXHRProgress = function() {\r\n  var self = this;\r\n\r\n  if (!statusValid(self._xhr) || self._destroyed)\r\n    return\r\n\r\n  if (!self._response)\r\n    self._connect();\r\n\r\n  self._response._onXHRProgress();\r\n};\r\n\r\nClientRequest.prototype._connect = function() {\r\n  var self = this;\r\n\r\n  if (self._destroyed)\r\n    return\r\n\r\n  self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode);\r\n  self.emit('response', self._response);\r\n};\r\n\r\nClientRequest.prototype._write = function(chunk, encoding, cb) {\r\n  var self = this;\r\n\r\n  self._body.push(chunk);\r\n  cb();\r\n};\r\n\r\nClientRequest.prototype.abort = ClientRequest.prototype.destroy = function() {\r\n  var self = this;\r\n  self._destroyed = true;\r\n  if (self._response)\r\n    self._response._destroyed = true;\r\n  if (self._xhr)\r\n    self._xhr.abort();\r\n    // Currently, there isn't a way to truly abort a fetch.\r\n    // If you like bikeshedding, see https://github.com/whatwg/fetch/issues/27\r\n};\r\n\r\nClientRequest.prototype.end = function(data, encoding, cb) {\r\n  var self = this;\r\n  if (typeof data === 'function') {\r\n    cb = data;\r\n    data = undefined;\r\n  }\r\n\r\n  Writable.prototype.end.call(self, data, encoding, cb);\r\n};\r\n\r\nClientRequest.prototype.flushHeaders = function() {};\r\nClientRequest.prototype.setTimeout = function() {};\r\nClientRequest.prototype.setNoDelay = function() {};\r\nClientRequest.prototype.setSocketKeepAlive = function() {};\r\n\r\n/*! https://mths.be/punycode v1.4.1 by @mathias */\r\n\r\n\r\n/** Highest positive signed 32-bit float value */\r\nvar maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\r\n\r\n/** Bootstring parameters */\r\nvar base = 36;\r\nvar tMin = 1;\r\nvar tMax = 26;\r\nvar skew = 38;\r\nvar damp = 700;\r\nvar initialBias = 72;\r\nvar initialN = 128; // 0x80\r\nvar delimiter = '-'; // '\\x2D'\r\nvar regexNonASCII = /[^\\x20-\\x7E]/; // unprintable ASCII chars + non-ASCII chars\r\nvar regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\r\n\r\n/** Error messages */\r\nvar errors = {\r\n  'overflow': 'Overflow: input needs wider integers to process',\r\n  'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\r\n  'invalid-input': 'Invalid input'\r\n};\r\n\r\n/** Convenience shortcuts */\r\nvar baseMinusTMin = base - tMin;\r\nvar floor = Math.floor;\r\nvar stringFromCharCode = String.fromCharCode;\r\n\r\n/*--------------------------------------------------------------------------*/\r\n\r\n/**\r\n * A generic error utility function.\r\n * @private\r\n * @param {String} type The error type.\r\n * @returns {Error} Throws a `RangeError` with the applicable error message.\r\n */\r\nfunction error(type) {\r\n  throw new RangeError(errors[type]);\r\n}\r\n\r\n/**\r\n * A generic `Array#map` utility function.\r\n * @private\r\n * @param {Array} array The array to iterate over.\r\n * @param {Function} callback The function that gets called for every array\r\n * item.\r\n * @returns {Array} A new array of values returned by the callback function.\r\n */\r\nfunction map$1(array, fn) {\r\n  var length = array.length;\r\n  var result = [];\r\n  while (length--) {\r\n    result[length] = fn(array[length]);\r\n  }\r\n  return result;\r\n}\r\n\r\n/**\r\n * A simple `Array#map`-like wrapper to work with domain name strings or email\r\n * addresses.\r\n * @private\r\n * @param {String} domain The domain name or email address.\r\n * @param {Function} callback The function that gets called for every\r\n * character.\r\n * @returns {Array} A new string of characters returned by the callback\r\n * function.\r\n */\r\nfunction mapDomain(string, fn) {\r\n  var parts = string.split('@');\r\n  var result = '';\r\n  if (parts.length > 1) {\r\n    // In email addresses, only the domain name should be punycoded. Leave\r\n    // the local part (i.e. everything up to `@`) intact.\r\n    result = parts[0] + '@';\r\n    string = parts[1];\r\n  }\r\n  // Avoid `split(regex)` for IE8 compatibility. See #17.\r\n  string = string.replace(regexSeparators, '\\x2E');\r\n  var labels = string.split('.');\r\n  var encoded = map$1(labels, fn).join('.');\r\n  return result + encoded;\r\n}\r\n\r\n/**\r\n * Creates an array containing the numeric code points of each Unicode\r\n * character in the string. While JavaScript uses UCS-2 internally,\r\n * this function will convert a pair of surrogate halves (each of which\r\n * UCS-2 exposes as separate characters) into a single code point,\r\n * matching UTF-16.\r\n * @see `punycode.ucs2.encode`\r\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\r\n * @memberOf punycode.ucs2\r\n * @name decode\r\n * @param {String} string The Unicode input string (UCS-2).\r\n * @returns {Array} The new array of code points.\r\n */\r\nfunction ucs2decode(string) {\r\n  var output = [],\r\n    counter = 0,\r\n    length = string.length,\r\n    value,\r\n    extra;\r\n  while (counter < length) {\r\n    value = string.charCodeAt(counter++);\r\n    if (value >= 0xD800 && value <= 0xDBFF && counter < length) {\r\n      // high surrogate, and there is a next character\r\n      extra = string.charCodeAt(counter++);\r\n      if ((extra & 0xFC00) == 0xDC00) { // low surrogate\r\n        output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\r\n      } else {\r\n        // unmatched surrogate; only append this code unit, in case the next\r\n        // code unit is the high surrogate of a surrogate pair\r\n        output.push(value);\r\n        counter--;\r\n      }\r\n    } else {\r\n      output.push(value);\r\n    }\r\n  }\r\n  return output;\r\n}\r\n\r\n/**\r\n * Converts a digit/integer into a basic code point.\r\n * @see `basicToDigit()`\r\n * @private\r\n * @param {Number} digit The numeric value of a basic code point.\r\n * @returns {Number} The basic code point whose value (when used for\r\n * representing integers) is `digit`, which needs to be in the range\r\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\r\n * used; else, the lowercase form is used. The behavior is undefined\r\n * if `flag` is non-zero and `digit` has no uppercase form.\r\n */\r\nfunction digitToBasic(digit, flag) {\r\n  //  0..25 map to ASCII a..z or A..Z\r\n  // 26..35 map to ASCII 0..9\r\n  return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\r\n}\r\n\r\n/**\r\n * Bias adaptation function as per section 3.4 of RFC 3492.\r\n * https://tools.ietf.org/html/rfc3492#section-3.4\r\n * @private\r\n */\r\nfunction adapt(delta, numPoints, firstTime) {\r\n  var k = 0;\r\n  delta = firstTime ? floor(delta / damp) : delta >> 1;\r\n  delta += floor(delta / numPoints);\r\n  for ( /* no initialization */ ; delta > baseMinusTMin * tMax >> 1; k += base) {\r\n    delta = floor(delta / baseMinusTMin);\r\n  }\r\n  return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\r\n}\r\n\r\n/**\r\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\r\n * Punycode string of ASCII-only symbols.\r\n * @memberOf punycode\r\n * @param {String} input The string of Unicode symbols.\r\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\r\n */\r\nfunction encode(input) {\r\n  var n,\r\n    delta,\r\n    handledCPCount,\r\n    basicLength,\r\n    bias,\r\n    j,\r\n    m,\r\n    q,\r\n    k,\r\n    t,\r\n    currentValue,\r\n    output = [],\r\n    /** `inputLength` will hold the number of code points in `input`. */\r\n    inputLength,\r\n    /** Cached calculation results */\r\n    handledCPCountPlusOne,\r\n    baseMinusT,\r\n    qMinusT;\r\n\r\n  // Convert the input in UCS-2 to Unicode\r\n  input = ucs2decode(input);\r\n\r\n  // Cache the length\r\n  inputLength = input.length;\r\n\r\n  // Initialize the state\r\n  n = initialN;\r\n  delta = 0;\r\n  bias = initialBias;\r\n\r\n  // Handle the basic code points\r\n  for (j = 0; j < inputLength; ++j) {\r\n    currentValue = input[j];\r\n    if (currentValue < 0x80) {\r\n      output.push(stringFromCharCode(currentValue));\r\n    }\r\n  }\r\n\r\n  handledCPCount = basicLength = output.length;\r\n\r\n  // `handledCPCount` is the number of code points that have been handled;\r\n  // `basicLength` is the number of basic code points.\r\n\r\n  // Finish the basic string - if it is not empty - with a delimiter\r\n  if (basicLength) {\r\n    output.push(delimiter);\r\n  }\r\n\r\n  // Main encoding loop:\r\n  while (handledCPCount < inputLength) {\r\n\r\n    // All non-basic code points < n have been handled already. Find the next\r\n    // larger one:\r\n    for (m = maxInt, j = 0; j < inputLength; ++j) {\r\n      currentValue = input[j];\r\n      if (currentValue >= n && currentValue < m) {\r\n        m = currentValue;\r\n      }\r\n    }\r\n\r\n    // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\r\n    // but guard against overflow\r\n    handledCPCountPlusOne = handledCPCount + 1;\r\n    if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\r\n      error('overflow');\r\n    }\r\n\r\n    delta += (m - n) * handledCPCountPlusOne;\r\n    n = m;\r\n\r\n    for (j = 0; j < inputLength; ++j) {\r\n      currentValue = input[j];\r\n\r\n      if (currentValue < n && ++delta > maxInt) {\r\n        error('overflow');\r\n      }\r\n\r\n      if (currentValue == n) {\r\n        // Represent delta as a generalized variable-length integer\r\n        for (q = delta, k = base; /* no condition */ ; k += base) {\r\n          t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\r\n          if (q < t) {\r\n            break;\r\n          }\r\n          qMinusT = q - t;\r\n          baseMinusT = base - t;\r\n          output.push(\r\n            stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\r\n          );\r\n          q = floor(qMinusT / baseMinusT);\r\n        }\r\n\r\n        output.push(stringFromCharCode(digitToBasic(q, 0)));\r\n        bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\r\n        delta = 0;\r\n        ++handledCPCount;\r\n      }\r\n    }\r\n\r\n    ++delta;\r\n    ++n;\r\n\r\n  }\r\n  return output.join('');\r\n}\r\n\r\n/**\r\n * Converts a Unicode string representing a domain name or an email address to\r\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\r\n * i.e. it doesn't matter if you call it with a domain that's already in\r\n * ASCII.\r\n * @memberOf punycode\r\n * @param {String} input The domain name or email address to convert, as a\r\n * Unicode string.\r\n * @returns {String} The Punycode representation of the given domain name or\r\n * email address.\r\n */\r\nfunction toASCII(input) {\r\n  return mapDomain(input, function(string) {\r\n    return regexNonASCII.test(string) ?\r\n      'xn--' + encode(string) :\r\n      string;\r\n  });\r\n}\r\n\r\n// Copyright Joyent, Inc. and other Node contributors.\r\n//\r\n// Permission is hereby granted, free of charge, to any person obtaining a\r\n// copy of this software and associated documentation files (the\r\n// \"Software\"), to deal in the Software without restriction, including\r\n// without limitation the rights to use, copy, modify, merge, publish,\r\n// distribute, sublicense, and/or sell copies of the Software, and to permit\r\n// persons to whom the Software is furnished to do so, subject to the\r\n// following conditions:\r\n//\r\n// The above copyright notice and this permission notice shall be included\r\n// in all copies or substantial portions of the Software.\r\n//\r\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\r\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\r\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\r\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\r\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\r\n\r\n\r\n// If obj.hasOwnProperty has been overridden, then calling\r\n// obj.hasOwnProperty(prop) will break.\r\n// See: https://github.com/joyent/node/issues/1707\r\nfunction hasOwnProperty(obj, prop) {\r\n  return Object.prototype.hasOwnProperty.call(obj, prop);\r\n}\r\nvar isArray = Array.isArray || function (xs) {\r\n  return Object.prototype.toString.call(xs) === '[object Array]';\r\n};\r\nfunction stringifyPrimitive(v) {\r\n  switch (typeof v) {\r\n    case 'string':\r\n      return v;\r\n\r\n    case 'boolean':\r\n      return v ? 'true' : 'false';\r\n\r\n    case 'number':\r\n      return isFinite(v) ? v : '';\r\n\r\n    default:\r\n      return '';\r\n  }\r\n}\r\n\r\nfunction stringify (obj, sep, eq, name) {\r\n  sep = sep || '&';\r\n  eq = eq || '=';\r\n  if (obj === null) {\r\n    obj = undefined;\r\n  }\r\n\r\n  if (typeof obj === 'object') {\r\n    return map(objectKeys(obj), function(k) {\r\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\r\n      if (isArray(obj[k])) {\r\n        return map(obj[k], function(v) {\r\n          return ks + encodeURIComponent(stringifyPrimitive(v));\r\n        }).join(sep);\r\n      } else {\r\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\r\n      }\r\n    }).join(sep);\r\n\r\n  }\r\n\r\n  if (!name) return '';\r\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\r\n         encodeURIComponent(stringifyPrimitive(obj));\r\n}\r\nfunction map (xs, f) {\r\n  if (xs.map) return xs.map(f);\r\n  var res = [];\r\n  for (var i = 0; i < xs.length; i++) {\r\n    res.push(f(xs[i], i));\r\n  }\r\n  return res;\r\n}\r\n\r\nvar objectKeys = Object.keys || function (obj) {\r\n  var res = [];\r\n  for (var key in obj) {\r\n    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\r\n  }\r\n  return res;\r\n};\r\n\r\nfunction parse$1(qs, sep, eq, options) {\r\n  sep = sep || '&';\r\n  eq = eq || '=';\r\n  var obj = {};\r\n\r\n  if (typeof qs !== 'string' || qs.length === 0) {\r\n    return obj;\r\n  }\r\n\r\n  var regexp = /\\+/g;\r\n  qs = qs.split(sep);\r\n\r\n  var maxKeys = 1000;\r\n  if (options && typeof options.maxKeys === 'number') {\r\n    maxKeys = options.maxKeys;\r\n  }\r\n\r\n  var len = qs.length;\r\n  // maxKeys <= 0 means that we should not limit keys count\r\n  if (maxKeys > 0 && len > maxKeys) {\r\n    len = maxKeys;\r\n  }\r\n\r\n  for (var i = 0; i < len; ++i) {\r\n    var x = qs[i].replace(regexp, '%20'),\r\n        idx = x.indexOf(eq),\r\n        kstr, vstr, k, v;\r\n\r\n    if (idx >= 0) {\r\n      kstr = x.substr(0, idx);\r\n      vstr = x.substr(idx + 1);\r\n    } else {\r\n      kstr = x;\r\n      vstr = '';\r\n    }\r\n\r\n    k = decodeURIComponent(kstr);\r\n    v = decodeURIComponent(vstr);\r\n\r\n    if (!hasOwnProperty(obj, k)) {\r\n      obj[k] = v;\r\n    } else if (isArray(obj[k])) {\r\n      obj[k].push(v);\r\n    } else {\r\n      obj[k] = [obj[k], v];\r\n    }\r\n  }\r\n\r\n  return obj;\r\n}\r\n\r\n// Copyright Joyent, Inc. and other Node contributors.\r\nfunction Url() {\r\n  this.protocol = null;\r\n  this.slashes = null;\r\n  this.auth = null;\r\n  this.host = null;\r\n  this.port = null;\r\n  this.hostname = null;\r\n  this.hash = null;\r\n  this.search = null;\r\n  this.query = null;\r\n  this.pathname = null;\r\n  this.path = null;\r\n  this.href = null;\r\n}\r\n\r\n// Reference: RFC 3986, RFC 1808, RFC 2396\r\n\r\n// define these here so at least they only have to be\r\n// compiled once on the first module load.\r\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\r\n  portPattern = /:[0-9]*$/,\r\n\r\n  // Special case for a simple path URL\r\n  simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\r\n\r\n  // RFC 2396: characters reserved for delimiting URLs.\r\n  // We actually just auto-escape these.\r\n  delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\r\n\r\n  // RFC 2396: characters not allowed for various reasons.\r\n  unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\r\n\r\n  // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\r\n  autoEscape = ['\\''].concat(unwise),\r\n  // Characters that are never ever allowed in a hostname.\r\n  // Note that any invalid chars are also handled, but these\r\n  // are the ones that are *expected* to be seen, so we fast-path\r\n  // them.\r\n  nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\r\n  hostEndingChars = ['/', '?', '#'],\r\n  hostnameMaxLen = 255,\r\n  hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\r\n  hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\r\n  // protocols that can allow \"unsafe\" and \"unwise\" chars.\r\n  unsafeProtocol = {\r\n    'javascript': true,\r\n    'javascript:': true\r\n  },\r\n  // protocols that never have a hostname.\r\n  hostlessProtocol = {\r\n    'javascript': true,\r\n    'javascript:': true\r\n  },\r\n  // protocols that always contain a // bit.\r\n  slashedProtocol = {\r\n    'http': true,\r\n    'https': true,\r\n    'ftp': true,\r\n    'gopher': true,\r\n    'file': true,\r\n    'http:': true,\r\n    'https:': true,\r\n    'ftp:': true,\r\n    'gopher:': true,\r\n    'file:': true\r\n  };\r\n\r\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\r\n  if (url && isObject(url) && url instanceof Url) return url;\r\n\r\n  var u = new Url;\r\n  u.parse(url, parseQueryString, slashesDenoteHost);\r\n  return u;\r\n}\r\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\r\n  return parse(this, url, parseQueryString, slashesDenoteHost);\r\n};\r\n\r\nfunction parse(self, url, parseQueryString, slashesDenoteHost) {\r\n  if (!isString(url)) {\r\n    throw new TypeError('Parameter \\'url\\' must be a string, not ' + typeof url);\r\n  }\r\n\r\n  // Copy chrome, IE, opera backslash-handling behavior.\r\n  // Back slashes before the query string get converted to forward slashes\r\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\r\n  var queryIndex = url.indexOf('?'),\r\n    splitter =\r\n    (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\r\n    uSplit = url.split(splitter),\r\n    slashRegex = /\\\\/g;\r\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\r\n  url = uSplit.join(splitter);\r\n\r\n  var rest = url;\r\n\r\n  // trim before proceeding.\r\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\r\n  rest = rest.trim();\r\n\r\n  if (!slashesDenoteHost && url.split('#').length === 1) {\r\n    // Try fast path regexp\r\n    var simplePath = simplePathPattern.exec(rest);\r\n    if (simplePath) {\r\n      self.path = rest;\r\n      self.href = rest;\r\n      self.pathname = simplePath[1];\r\n      if (simplePath[2]) {\r\n        self.search = simplePath[2];\r\n        if (parseQueryString) {\r\n          self.query = parse$1(self.search.substr(1));\r\n        } else {\r\n          self.query = self.search.substr(1);\r\n        }\r\n      } else if (parseQueryString) {\r\n        self.search = '';\r\n        self.query = {};\r\n      }\r\n      return self;\r\n    }\r\n  }\r\n\r\n  var proto = protocolPattern.exec(rest);\r\n  if (proto) {\r\n    proto = proto[0];\r\n    var lowerProto = proto.toLowerCase();\r\n    self.protocol = lowerProto;\r\n    rest = rest.substr(proto.length);\r\n  }\r\n\r\n  // figure out if it's got a host\r\n  // user@server is *always* interpreted as a hostname, and url\r\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\r\n  // how the browser resolves relative URLs.\r\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\r\n    var slashes = rest.substr(0, 2) === '//';\r\n    if (slashes && !(proto && hostlessProtocol[proto])) {\r\n      rest = rest.substr(2);\r\n      self.slashes = true;\r\n    }\r\n  }\r\n  var i, hec, l, p;\r\n  if (!hostlessProtocol[proto] &&\r\n    (slashes || (proto && !slashedProtocol[proto]))) {\r\n\r\n    // there's a hostname.\r\n    // the first instance of /, ?, ;, or # ends the host.\r\n    //\r\n    // If there is an @ in the hostname, then non-host chars *are* allowed\r\n    // to the left of the last @ sign, unless some host-ending character\r\n    // comes *before* the @-sign.\r\n    // URLs are obnoxious.\r\n    //\r\n    // ex:\r\n    // http://a@b@c/ => user:a@b host:c\r\n    // http://a@b?@c => user:a host:c path:/?@c\r\n\r\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\r\n    // Review our test case against browsers more comprehensively.\r\n\r\n    // find the first instance of any hostEndingChars\r\n    var hostEnd = -1;\r\n    for (i = 0; i < hostEndingChars.length; i++) {\r\n      hec = rest.indexOf(hostEndingChars[i]);\r\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\r\n        hostEnd = hec;\r\n    }\r\n\r\n    // at this point, either we have an explicit point where the\r\n    // auth portion cannot go past, or the last @ char is the decider.\r\n    var auth, atSign;\r\n    if (hostEnd === -1) {\r\n      // atSign can be anywhere.\r\n      atSign = rest.lastIndexOf('@');\r\n    } else {\r\n      // atSign must be in auth portion.\r\n      // http://a@b/c@d => host:b auth:a path:/c@d\r\n      atSign = rest.lastIndexOf('@', hostEnd);\r\n    }\r\n\r\n    // Now we have a portion which is definitely the auth.\r\n    // Pull that off.\r\n    if (atSign !== -1) {\r\n      auth = rest.slice(0, atSign);\r\n      rest = rest.slice(atSign + 1);\r\n      self.auth = decodeURIComponent(auth);\r\n    }\r\n\r\n    // the host is the remaining to the left of the first non-host char\r\n    hostEnd = -1;\r\n    for (i = 0; i < nonHostChars.length; i++) {\r\n      hec = rest.indexOf(nonHostChars[i]);\r\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\r\n        hostEnd = hec;\r\n    }\r\n    // if we still have not hit it, then the entire thing is a host.\r\n    if (hostEnd === -1)\r\n      hostEnd = rest.length;\r\n\r\n    self.host = rest.slice(0, hostEnd);\r\n    rest = rest.slice(hostEnd);\r\n\r\n    // pull out port.\r\n    parseHost(self);\r\n\r\n    // we've indicated that there is a hostname,\r\n    // so even if it's empty, it has to be present.\r\n    self.hostname = self.hostname || '';\r\n\r\n    // if hostname begins with [ and ends with ]\r\n    // assume that it's an IPv6 address.\r\n    var ipv6Hostname = self.hostname[0] === '[' &&\r\n      self.hostname[self.hostname.length - 1] === ']';\r\n\r\n    // validate a little.\r\n    if (!ipv6Hostname) {\r\n      var hostparts = self.hostname.split(/\\./);\r\n      for (i = 0, l = hostparts.length; i < l; i++) {\r\n        var part = hostparts[i];\r\n        if (!part) continue;\r\n        if (!part.match(hostnamePartPattern)) {\r\n          var newpart = '';\r\n          for (var j = 0, k = part.length; j < k; j++) {\r\n            if (part.charCodeAt(j) > 127) {\r\n              // we replace non-ASCII char with a temporary placeholder\r\n              // we need this to make sure size of hostname is not\r\n              // broken by replacing non-ASCII by nothing\r\n              newpart += 'x';\r\n            } else {\r\n              newpart += part[j];\r\n            }\r\n          }\r\n          // we test again with ASCII char only\r\n          if (!newpart.match(hostnamePartPattern)) {\r\n            var validParts = hostparts.slice(0, i);\r\n            var notHost = hostparts.slice(i + 1);\r\n            var bit = part.match(hostnamePartStart);\r\n            if (bit) {\r\n              validParts.push(bit[1]);\r\n              notHost.unshift(bit[2]);\r\n            }\r\n            if (notHost.length) {\r\n              rest = '/' + notHost.join('.') + rest;\r\n            }\r\n            self.hostname = validParts.join('.');\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    if (self.hostname.length > hostnameMaxLen) {\r\n      self.hostname = '';\r\n    } else {\r\n      // hostnames are always lower case.\r\n      self.hostname = self.hostname.toLowerCase();\r\n    }\r\n\r\n    if (!ipv6Hostname) {\r\n      // IDNA Support: Returns a punycoded representation of \"domain\".\r\n      // It only converts parts of the domain name that\r\n      // have non-ASCII characters, i.e. it doesn't matter if\r\n      // you call it with a domain that already is ASCII-only.\r\n      self.hostname = toASCII(self.hostname);\r\n    }\r\n\r\n    p = self.port ? ':' + self.port : '';\r\n    var h = self.hostname || '';\r\n    self.host = h + p;\r\n    self.href += self.host;\r\n\r\n    // strip [ and ] from the hostname\r\n    // the host field still retains them, though\r\n    if (ipv6Hostname) {\r\n      self.hostname = self.hostname.substr(1, self.hostname.length - 2);\r\n      if (rest[0] !== '/') {\r\n        rest = '/' + rest;\r\n      }\r\n    }\r\n  }\r\n\r\n  // now rest is set to the post-host stuff.\r\n  // chop off any delim chars.\r\n  if (!unsafeProtocol[lowerProto]) {\r\n\r\n    // First, make 100% sure that any \"autoEscape\" chars get\r\n    // escaped, even if encodeURIComponent doesn't think they\r\n    // need to be.\r\n    for (i = 0, l = autoEscape.length; i < l; i++) {\r\n      var ae = autoEscape[i];\r\n      if (rest.indexOf(ae) === -1)\r\n        continue;\r\n      var esc = encodeURIComponent(ae);\r\n      if (esc === ae) {\r\n        esc = escape(ae);\r\n      }\r\n      rest = rest.split(ae).join(esc);\r\n    }\r\n  }\r\n\r\n\r\n  // chop off from the tail first.\r\n  var hash = rest.indexOf('#');\r\n  if (hash !== -1) {\r\n    // got a fragment string.\r\n    self.hash = rest.substr(hash);\r\n    rest = rest.slice(0, hash);\r\n  }\r\n  var qm = rest.indexOf('?');\r\n  if (qm !== -1) {\r\n    self.search = rest.substr(qm);\r\n    self.query = rest.substr(qm + 1);\r\n    if (parseQueryString) {\r\n      self.query = parse$1(self.query);\r\n    }\r\n    rest = rest.slice(0, qm);\r\n  } else if (parseQueryString) {\r\n    // no query string, but parseQueryString still requested\r\n    self.search = '';\r\n    self.query = {};\r\n  }\r\n  if (rest) self.pathname = rest;\r\n  if (slashedProtocol[lowerProto] &&\r\n    self.hostname && !self.pathname) {\r\n    self.pathname = '/';\r\n  }\r\n\r\n  //to support http.request\r\n  if (self.pathname || self.search) {\r\n    p = self.pathname || '';\r\n    var s = self.search || '';\r\n    self.path = p + s;\r\n  }\r\n\r\n  // finally, reconstruct the href based on what has been validated.\r\n  self.href = format(self);\r\n  return self;\r\n}\r\n\r\nfunction format(self) {\r\n  var auth = self.auth || '';\r\n  if (auth) {\r\n    auth = encodeURIComponent(auth);\r\n    auth = auth.replace(/%3A/i, ':');\r\n    auth += '@';\r\n  }\r\n\r\n  var protocol = self.protocol || '',\r\n    pathname = self.pathname || '',\r\n    hash = self.hash || '',\r\n    host = false,\r\n    query = '';\r\n\r\n  if (self.host) {\r\n    host = auth + self.host;\r\n  } else if (self.hostname) {\r\n    host = auth + (self.hostname.indexOf(':') === -1 ?\r\n      self.hostname :\r\n      '[' + this.hostname + ']');\r\n    if (self.port) {\r\n      host += ':' + self.port;\r\n    }\r\n  }\r\n\r\n  if (self.query &&\r\n    isObject(self.query) &&\r\n    Object.keys(self.query).length) {\r\n    query = stringify(self.query);\r\n  }\r\n\r\n  var search = self.search || (query && ('?' + query)) || '';\r\n\r\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\r\n\r\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\r\n  // unless they had them to begin with.\r\n  if (self.slashes ||\r\n    (!protocol || slashedProtocol[protocol]) && host !== false) {\r\n    host = '//' + (host || '');\r\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\r\n  } else if (!host) {\r\n    host = '';\r\n  }\r\n\r\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\r\n  if (search && search.charAt(0) !== '?') search = '?' + search;\r\n\r\n  pathname = pathname.replace(/[?#]/g, function(match) {\r\n    return encodeURIComponent(match);\r\n  });\r\n  search = search.replace('#', '%23');\r\n\r\n  return protocol + host + pathname + search + hash;\r\n}\r\n\r\nUrl.prototype.format = function() {\r\n  return format(this);\r\n};\r\n\r\nUrl.prototype.resolve = function(relative) {\r\n  return this.resolveObject(urlParse(relative, false, true)).format();\r\n};\r\n\r\nUrl.prototype.resolveObject = function(relative) {\r\n  if (isString(relative)) {\r\n    var rel = new Url();\r\n    rel.parse(relative, false, true);\r\n    relative = rel;\r\n  }\r\n\r\n  var result = new Url();\r\n  var tkeys = Object.keys(this);\r\n  for (var tk = 0; tk < tkeys.length; tk++) {\r\n    var tkey = tkeys[tk];\r\n    result[tkey] = this[tkey];\r\n  }\r\n\r\n  // hash is always overridden, no matter what.\r\n  // even href=\"\" will remove it.\r\n  result.hash = relative.hash;\r\n\r\n  // if the relative url is empty, then there's nothing left to do here.\r\n  if (relative.href === '') {\r\n    result.href = result.format();\r\n    return result;\r\n  }\r\n\r\n  // hrefs like //foo/bar always cut to the protocol.\r\n  if (relative.slashes && !relative.protocol) {\r\n    // take everything except the protocol from relative\r\n    var rkeys = Object.keys(relative);\r\n    for (var rk = 0; rk < rkeys.length; rk++) {\r\n      var rkey = rkeys[rk];\r\n      if (rkey !== 'protocol')\r\n        result[rkey] = relative[rkey];\r\n    }\r\n\r\n    //urlParse appends trailing / to urls like http://www.example.com\r\n    if (slashedProtocol[result.protocol] &&\r\n      result.hostname && !result.pathname) {\r\n      result.path = result.pathname = '/';\r\n    }\r\n\r\n    result.href = result.format();\r\n    return result;\r\n  }\r\n  var relPath;\r\n  if (relative.protocol && relative.protocol !== result.protocol) {\r\n    // if it's a known url protocol, then changing\r\n    // the protocol does weird things\r\n    // first, if it's not file:, then we MUST have a host,\r\n    // and if there was a path\r\n    // to begin with, then we MUST have a path.\r\n    // if it is file:, then the host is dropped,\r\n    // because that's known to be hostless.\r\n    // anything else is assumed to be absolute.\r\n    if (!slashedProtocol[relative.protocol]) {\r\n      var keys = Object.keys(relative);\r\n      for (var v = 0; v < keys.length; v++) {\r\n        var k = keys[v];\r\n        result[k] = relative[k];\r\n      }\r\n      result.href = result.format();\r\n      return result;\r\n    }\r\n\r\n    result.protocol = relative.protocol;\r\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\r\n      relPath = (relative.pathname || '').split('/');\r\n      while (relPath.length && !(relative.host = relPath.shift()));\r\n      if (!relative.host) relative.host = '';\r\n      if (!relative.hostname) relative.hostname = '';\r\n      if (relPath[0] !== '') relPath.unshift('');\r\n      if (relPath.length < 2) relPath.unshift('');\r\n      result.pathname = relPath.join('/');\r\n    } else {\r\n      result.pathname = relative.pathname;\r\n    }\r\n    result.search = relative.search;\r\n    result.query = relative.query;\r\n    result.host = relative.host || '';\r\n    result.auth = relative.auth;\r\n    result.hostname = relative.hostname || relative.host;\r\n    result.port = relative.port;\r\n    // to support http.request\r\n    if (result.pathname || result.search) {\r\n      var p = result.pathname || '';\r\n      var s = result.search || '';\r\n      result.path = p + s;\r\n    }\r\n    result.slashes = result.slashes || relative.slashes;\r\n    result.href = result.format();\r\n    return result;\r\n  }\r\n\r\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\r\n    isRelAbs = (\r\n      relative.host ||\r\n      relative.pathname && relative.pathname.charAt(0) === '/'\r\n    ),\r\n    mustEndAbs = (isRelAbs || isSourceAbs ||\r\n      (result.host && relative.pathname)),\r\n    removeAllDots = mustEndAbs,\r\n    srcPath = result.pathname && result.pathname.split('/') || [],\r\n    psychotic = result.protocol && !slashedProtocol[result.protocol];\r\n  relPath = relative.pathname && relative.pathname.split('/') || [];\r\n  // if the url is a non-slashed url, then relative\r\n  // links like ../.. should be able\r\n  // to crawl up to the hostname, as well.  This is strange.\r\n  // result.protocol has already been set by now.\r\n  // Later on, put the first path part into the host field.\r\n  if (psychotic) {\r\n    result.hostname = '';\r\n    result.port = null;\r\n    if (result.host) {\r\n      if (srcPath[0] === '') srcPath[0] = result.host;\r\n      else srcPath.unshift(result.host);\r\n    }\r\n    result.host = '';\r\n    if (relative.protocol) {\r\n      relative.hostname = null;\r\n      relative.port = null;\r\n      if (relative.host) {\r\n        if (relPath[0] === '') relPath[0] = relative.host;\r\n        else relPath.unshift(relative.host);\r\n      }\r\n      relative.host = null;\r\n    }\r\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\r\n  }\r\n  var authInHost;\r\n  if (isRelAbs) {\r\n    // it's absolute.\r\n    result.host = (relative.host || relative.host === '') ?\r\n      relative.host : result.host;\r\n    result.hostname = (relative.hostname || relative.hostname === '') ?\r\n      relative.hostname : result.hostname;\r\n    result.search = relative.search;\r\n    result.query = relative.query;\r\n    srcPath = relPath;\r\n    // fall through to the dot-handling below.\r\n  } else if (relPath.length) {\r\n    // it's relative\r\n    // throw away the existing file, and take the new path instead.\r\n    if (!srcPath) srcPath = [];\r\n    srcPath.pop();\r\n    srcPath = srcPath.concat(relPath);\r\n    result.search = relative.search;\r\n    result.query = relative.query;\r\n  } else if (!isNullOrUndefined(relative.search)) {\r\n    // just pull out the search.\r\n    // like href='?foo'.\r\n    // Put this after the other two cases because it simplifies the booleans\r\n    if (psychotic) {\r\n      result.hostname = result.host = srcPath.shift();\r\n      //occationaly the auth can get stuck only in host\r\n      //this especially happens in cases like\r\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\r\n      authInHost = result.host && result.host.indexOf('@') > 0 ?\r\n        result.host.split('@') : false;\r\n      if (authInHost) {\r\n        result.auth = authInHost.shift();\r\n        result.host = result.hostname = authInHost.shift();\r\n      }\r\n    }\r\n    result.search = relative.search;\r\n    result.query = relative.query;\r\n    //to support http.request\r\n    if (!isNull(result.pathname) || !isNull(result.search)) {\r\n      result.path = (result.pathname ? result.pathname : '') +\r\n        (result.search ? result.search : '');\r\n    }\r\n    result.href = result.format();\r\n    return result;\r\n  }\r\n\r\n  if (!srcPath.length) {\r\n    // no path at all.  easy.\r\n    // we've already handled the other stuff above.\r\n    result.pathname = null;\r\n    //to support http.request\r\n    if (result.search) {\r\n      result.path = '/' + result.search;\r\n    } else {\r\n      result.path = null;\r\n    }\r\n    result.href = result.format();\r\n    return result;\r\n  }\r\n\r\n  // if a url ENDs in . or .., then it must get a trailing slash.\r\n  // however, if it ends in anything else non-slashy,\r\n  // then it must NOT get a trailing slash.\r\n  var last = srcPath.slice(-1)[0];\r\n  var hasTrailingSlash = (\r\n    (result.host || relative.host || srcPath.length > 1) &&\r\n    (last === '.' || last === '..') || last === '');\r\n\r\n  // strip single dots, resolve double dots to parent dir\r\n  // if the path tries to go above the root, `up` ends up > 0\r\n  var up = 0;\r\n  for (var i = srcPath.length; i >= 0; i--) {\r\n    last = srcPath[i];\r\n    if (last === '.') {\r\n      srcPath.splice(i, 1);\r\n    } else if (last === '..') {\r\n      srcPath.splice(i, 1);\r\n      up++;\r\n    } else if (up) {\r\n      srcPath.splice(i, 1);\r\n      up--;\r\n    }\r\n  }\r\n\r\n  // if the path is allowed to go above the root, restore leading ..s\r\n  if (!mustEndAbs && !removeAllDots) {\r\n    for (; up--; up) {\r\n      srcPath.unshift('..');\r\n    }\r\n  }\r\n\r\n  if (mustEndAbs && srcPath[0] !== '' &&\r\n    (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\r\n    srcPath.unshift('');\r\n  }\r\n\r\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\r\n    srcPath.push('');\r\n  }\r\n\r\n  var isAbsolute = srcPath[0] === '' ||\r\n    (srcPath[0] && srcPath[0].charAt(0) === '/');\r\n\r\n  // put the host back\r\n  if (psychotic) {\r\n    result.hostname = result.host = isAbsolute ? '' :\r\n      srcPath.length ? srcPath.shift() : '';\r\n    //occationaly the auth can get stuck only in host\r\n    //this especially happens in cases like\r\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\r\n    authInHost = result.host && result.host.indexOf('@') > 0 ?\r\n      result.host.split('@') : false;\r\n    if (authInHost) {\r\n      result.auth = authInHost.shift();\r\n      result.host = result.hostname = authInHost.shift();\r\n    }\r\n  }\r\n\r\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\r\n\r\n  if (mustEndAbs && !isAbsolute) {\r\n    srcPath.unshift('');\r\n  }\r\n\r\n  if (!srcPath.length) {\r\n    result.pathname = null;\r\n    result.path = null;\r\n  } else {\r\n    result.pathname = srcPath.join('/');\r\n  }\r\n\r\n  //to support request.http\r\n  if (!isNull(result.pathname) || !isNull(result.search)) {\r\n    result.path = (result.pathname ? result.pathname : '') +\r\n      (result.search ? result.search : '');\r\n  }\r\n  result.auth = relative.auth || result.auth;\r\n  result.slashes = result.slashes || relative.slashes;\r\n  result.href = result.format();\r\n  return result;\r\n};\r\n\r\nUrl.prototype.parseHost = function() {\r\n  return parseHost(this);\r\n};\r\n\r\nfunction parseHost(self) {\r\n  var host = self.host;\r\n  var port = portPattern.exec(host);\r\n  if (port) {\r\n    port = port[0];\r\n    if (port !== ':') {\r\n      self.port = port.substr(1);\r\n    }\r\n    host = host.substr(0, host.length - port.length);\r\n  }\r\n  if (host) self.hostname = host;\r\n}\r\n\r\n/*\r\nthis and http-lib folder\r\n\r\nThe MIT License\r\n\r\nCopyright (c) 2015 John Hiesey\r\n\r\nPermission is hereby granted, free of charge,\r\nto any person obtaining a copy of this software and\r\nassociated documentation files (the \"Software\"), to\r\ndeal in the Software without restriction, including\r\nwithout limitation the rights to use, copy, modify,\r\nmerge, publish, distribute, sublicense, and/or sell\r\ncopies of the Software, and to permit persons to whom\r\nthe Software is furnished to do so,\r\nsubject to the following conditions:\r\n\r\nThe above copyright notice and this permission notice\r\nshall be included in all copies or substantial portions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\r\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\r\nOF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\r\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR\r\nANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\r\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\r\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r\n\r\n*/\r\n\r\nfunction request(opts, cb) {\r\n  if (typeof opts === 'string')\r\n    opts = urlParse(opts);\r\n\r\n\r\n  // Normally, the page is loaded from http or https, so not specifying a protocol\r\n  // will result in a (valid) protocol-relative url. However, this won't work if\r\n  // the protocol is something else, like 'file:'\r\n  var defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : '';\r\n\r\n  var protocol = opts.protocol || defaultProtocol;\r\n  var host = opts.hostname || opts.host;\r\n  var port = opts.port;\r\n  var path = opts.path || '/';\r\n\r\n  // Necessary for IPv6 addresses\r\n  if (host && host.indexOf(':') !== -1)\r\n    host = '[' + host + ']';\r\n\r\n  // This may be a relative url. The browser should always be able to interpret it correctly.\r\n  opts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path;\r\n  opts.method = (opts.method || 'GET').toUpperCase();\r\n  opts.headers = opts.headers || {};\r\n\r\n  // Also valid opts.auth, opts.mode\r\n\r\n  var req = new ClientRequest(opts);\r\n  if (cb)\r\n    req.on('response', cb);\r\n  return req\r\n}\r\n\r\nfunction get(opts, cb) {\r\n  var req = request(opts, cb);\r\n  req.end();\r\n  return req\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nclass WebExtensionService {\r\n    constructor() {\r\n        this.queue = [];\r\n        window.addEventListener(\"message\", (event) => this.receive(event));\r\n    }\r\n    receive(event) {\r\n        var _a, _b, _c, _d, _e;\r\n        if (!/^web-eid:/.test((_a = event.data) === null || _a === void 0 ? void 0 : _a.action))\r\n            return;\r\n        const message = event.data;\r\n        const suffix = (_c = (_b = message.action) === null || _b === void 0 ? void 0 : _b.match(/success$|failure$|ack$/)) === null || _c === void 0 ? void 0 : _c[0];\r\n        const initialAction = this.getInitialAction(message.action);\r\n        const pending = this.getPendingMessage(initialAction);\r\n        if (suffix === \"ack\") {\r\n            console.log(\"ack message\", message);\r\n            console.log(\"ack pending\", pending === null || pending === void 0 ? void 0 : pending.message.action);\r\n            console.log(\"ack queue\", JSON.stringify(this.queue));\r\n        }\r\n        if (pending) {\r\n            switch (suffix) {\r\n                case \"ack\": {\r\n                    clearTimeout(pending.ackTimer);\r\n                    break;\r\n                }\r\n                case \"success\": {\r\n                    (_d = pending.resolve) === null || _d === void 0 ? void 0 : _d.call(pending, message);\r\n                    this.removeFromQueue(initialAction);\r\n                    break;\r\n                }\r\n                case \"failure\": {\r\n                    (_e = pending.reject) === null || _e === void 0 ? void 0 : _e.call(pending, message.error ? deserializeError(message.error) : message);\r\n                    this.removeFromQueue(initialAction);\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    send(message, timeout) {\r\n        if (this.getPendingMessage(message.action)) {\r\n            return Promise.reject(new ActionPendingError());\r\n        }\r\n        else if (!window.isSecureContext) {\r\n            return Promise.reject(new ContextInsecureError());\r\n        }\r\n        else {\r\n            const pending = { message };\r\n            this.queue.push(pending);\r\n            pending.promise = new Promise((resolve, reject) => {\r\n                pending.resolve = resolve;\r\n                pending.reject = reject;\r\n            });\r\n            pending.ackTimer = window.setTimeout(() => this.onAckTimeout(pending), config$1.EXTENSION_HANDSHAKE_TIMEOUT);\r\n            pending.replyTimer = window.setTimeout(() => this.onReplyTimeout(pending), timeout);\r\n            this.publishMessage(message, timeout);\r\n            return pending.promise;\r\n        }\r\n    }\r\n    publishMessage(message, timeout) {\r\n        if (message.useAuthApp && message.useAuthApp == true) {\r\n            if (this.isAndroidDevice()) {\r\n                // Launch auth app.\r\n                this.launchAuthApp(message);\r\n            }\r\n            else {\r\n                // Display QR code.\r\n                this.displayQRCode(message);\r\n            }\r\n            this.pollForLoginSuccess(message, timeout).then((res) => {\r\n                console.log(res);\r\n            });\r\n        }\r\n        else {\r\n            // Use ID-card reader.\r\n            window.postMessage(message, \"*\");\r\n        }\r\n    }\r\n    launchAuthApp(message) {\r\n        const intentUrl = new IntentUrl(message);\r\n        // Since deeplink gives no feedback about app launch, check if browser window lost focus.\r\n        document.addEventListener(\"visibilitychange\", function sendAckMessage() {\r\n            if (document.hidden) {\r\n                // Send acknowledge message to itself.\r\n                window.postMessage({ action: this.getRelevantAckAction(message) }, location.origin);\r\n                setTimeout(() => document.removeEventListener(\"visibilitychange\", sendAckMessage), config$1.EXTENSION_HANDSHAKE_TIMEOUT);\r\n            }\r\n        }.bind(this));\r\n        window.location.href = intentUrl.toString();\r\n    }\r\n    displayQRCode(message) {\r\n        const intentUrl = new IntentUrl(message);\r\n        const qrCode = QrCode;\r\n        const qr0 = qrCode.encodeText(intentUrl.toString(), Ecc.MEDIUM);\r\n        const svg = toSvgString(qr0, 24, \"#FFF\", \"#000\");\r\n        const canvas = document.getElementById(\"canvas\");\r\n        if (canvas) {\r\n            canvas.innerHTML = svg;\r\n        }\r\n        window.postMessage({ action: this.getRelevantAckAction(message) }, location.origin);\r\n    }\r\n    async pollForLoginSuccess(message, timeout) {\r\n        if (message.getAuthSuccessUrl) {\r\n            if (!message.getAuthSuccessUrl.startsWith(\"https://\")) {\r\n                throw new ProtocolInsecureError(`HTTPS required for getAuthSuccessUrl ${message.getAuthSuccessUrl}`);\r\n            }\r\n            const headers = message.headers;\r\n            const options = {\r\n                method: \"GET\",\r\n                headers: headers,\r\n                timeout: timeout,\r\n            };\r\n            return get(message.getAuthSuccessUrl, options).on(\"error\", (e) => {\r\n                console.error(e);\r\n            }).on(\"timeout\", () => {\r\n                console.error(\"Timeout\");\r\n            });\r\n            // return await Promise.race([\r\n            //   https.get(message.getAuthSuccessUrl, options, (res) => {\r\n            //     if (res.statusCode < 200 || res.statusCode > 299) {\r\n            //       return reject(new Error(`HTTP status code ${res.statusCode}`))\r\n            //     }\r\n            //\r\n            //     const body = []\r\n            //     res.on('data', (chunk) => body.push(chunk))\r\n            //     res.on('end', () => {\r\n            //       const resString = Buffer.concat(body).toString()\r\n            //       resolve(resString)\r\n            //     })\r\n            //\r\n            //   this.throwAfterTimeout(\r\n            //     timeout,\r\n            //     new ServerTimeoutError(`server failed to respond in time - GET ${message.getAuthSuccessUrl}`),\r\n            //   ),\r\n            // ]) as HttpResponse;\r\n        }\r\n        else {\r\n            throw new MissingParameterError(\"getAuthSuccessUrl missing for Android auth app authentication option.\");\r\n        }\r\n    }\r\n    async throwAfterTimeout(milliseconds, error) {\r\n        await this.sleep(milliseconds);\r\n        throw error;\r\n    }\r\n    async sleep(milliseconds) {\r\n        return new Promise((resolve) => {\r\n            setTimeout(() => resolve(), milliseconds);\r\n        });\r\n    }\r\n    isAndroidDevice() {\r\n        return navigator.userAgent.toLowerCase().indexOf(\"android\") > -1;\r\n    }\r\n    getRelevantAckAction(message) {\r\n        let ackAction;\r\n        switch (message.action) {\r\n            case Action$1.AUTHENTICATE:\r\n                ackAction = Action$1.AUTHENTICATE_ACK;\r\n                break;\r\n            case Action$1.SIGN:\r\n                ackAction = Action$1.SIGN_ACK;\r\n                break;\r\n            case Action$1.STATUS:\r\n                ackAction = Action$1.STATUS_ACK;\r\n                break;\r\n            default:\r\n                ackAction = Action$1.STATUS_ACK;\r\n                break;\r\n        }\r\n        return ackAction;\r\n    }\r\n    onReplyTimeout(pending) {\r\n        var _a;\r\n        console.log(\"onReplyTimeout\", pending.message.action);\r\n        (_a = pending.reject) === null || _a === void 0 ? void 0 : _a.call(pending, new ActionTimeoutError());\r\n        this.removeFromQueue(pending.message.action);\r\n    }\r\n    onAckTimeout(pending) {\r\n        var _a, _b;\r\n        console.log(\"onAckTimeout\", pending.message.action);\r\n        console.log(\"Pending message\");\r\n        console.log(pending.message.authApp);\r\n        if (pending.message.useAuthApp && pending.message.useAuthApp == true) {\r\n            (_a = pending.reject) === null || _a === void 0 ? void 0 : _a.call(pending, new AuthAppNotInstalledError());\r\n        }\r\n        else {\r\n            (_b = pending.reject) === null || _b === void 0 ? void 0 : _b.call(pending, new ExtensionUnavailableError());\r\n        }\r\n        clearTimeout(pending.replyTimer);\r\n    }\r\n    getPendingMessage(action) {\r\n        return this.queue.find((pm) => {\r\n            return pm.message.action === action;\r\n        });\r\n    }\r\n    getInitialAction(action) {\r\n        return action.replace(/-success$|-failure$|-ack$/, \"\");\r\n    }\r\n    removeFromQueue(action) {\r\n        const pending = this.getPendingMessage(action);\r\n        clearTimeout(pending === null || pending === void 0 ? void 0 : pending.replyTimer);\r\n        this.queue = this.queue.filter((pending) => (pending.message.action !== action));\r\n    }\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nconst semverPattern = new RegExp(\"^(0|[1-9]\\\\d*)\\\\.(0|[1-9]\\\\d*)\\\\.(0|[1-9]\\\\d*)(?:-((?:0|[1-9]\\\\d*|\\\\d*[a-zA-Z-][0-9a-zA-Z-]*)\" +\r\n    \"(?:\\\\.(?:0|[1-9]\\\\d*|\\\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\\\+([0-9a-zA-Z-]+(?:\\\\.[0-9a-zA-Z-]+)*))?$\");\r\nvar IdentifierDiff;\r\n(function (IdentifierDiff) {\r\n    IdentifierDiff[IdentifierDiff[\"NEWER\"] = 1] = \"NEWER\";\r\n    IdentifierDiff[IdentifierDiff[\"SAME\"] = 0] = \"SAME\";\r\n    IdentifierDiff[IdentifierDiff[\"OLDER\"] = -1] = \"OLDER\";\r\n})(IdentifierDiff || (IdentifierDiff = {}));\r\nfunction parseSemver(string = \"\") {\r\n    const result = string.match(semverPattern);\r\n    const [, majorStr, minorStr, patchStr, rc, build] = result ? result : [];\r\n    const major = parseInt(majorStr, 10);\r\n    const minor = parseInt(minorStr, 10);\r\n    const patch = parseInt(patchStr, 10);\r\n    for (const indentifier of [major, minor, patch]) {\r\n        if (Number.isNaN(indentifier)) {\r\n            throw new VersionInvalidError(`Invalid SemVer string '${string}'`);\r\n        }\r\n    }\r\n    return { major, minor, patch, rc, build, string };\r\n}\r\n/**\r\n * Compares two Semver objects.\r\n *\r\n * @param {Semver} a First SemVer object\r\n * @param {Semver} b Second Semver object\r\n *\r\n * @returns {SemverDiff} Diff for major, minor and patch.\r\n */\r\nfunction compareSemver(a, b) {\r\n    return {\r\n        major: Math.sign(a.major - b.major),\r\n        minor: Math.sign(a.minor - b.minor),\r\n        patch: Math.sign(a.patch - b.patch),\r\n    };\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\n/**\r\n * Checks if update is required.\r\n *\r\n * @param version Object containing SemVer version strings for library, extension and native app.\r\n *\r\n * @returns Object which specifies if the extension or native app should be updated.\r\n */\r\nfunction checkCompatibility(version) {\r\n    const library = parseSemver(version.library);\r\n    const extension = parseSemver(version.extension);\r\n    const nativeApp = parseSemver(version.nativeApp);\r\n    const extensionDiff = compareSemver(extension, library);\r\n    const nativeAppDiff = compareSemver(nativeApp, library);\r\n    return {\r\n        extension: extensionDiff.major === IdentifierDiff.OLDER,\r\n        nativeApp: nativeAppDiff.major === IdentifierDiff.OLDER,\r\n    };\r\n}\r\n/**\r\n * Checks an object if 'library', 'extension' or 'nativeApp' properties are present.\r\n * Values are not checked for SemVer validity.\r\n *\r\n * @param object Object which will be checked for version properties.\r\n *\r\n * @returns Were any of the version properties found in the provided object.\r\n */\r\nfunction hasVersionProperties(object) {\r\n    if (typeof object === \"object\") {\r\n        for (const prop of [\"library\", \"extension\", \"nativeApp\"]) {\r\n            if (Object.hasOwnProperty.call(object, prop))\r\n                return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nfunction defer() {\r\n    return new Promise((resolve) => setTimeout(resolve));\r\n}\r\n\r\n/*\r\n * Copyright (c) Estonian Information System Authority\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\nconst webExtensionService = new WebExtensionService();\r\nasync function status() {\r\n    await defer(); // Give chrome a moment to load the extension content script\r\n    let statusResponse;\r\n    const library = config$1.VERSION;\r\n    const timeout = config$1.EXTENSION_HANDSHAKE_TIMEOUT + config$1.NATIVE_APP_HANDSHAKE_TIMEOUT;\r\n    const message = { action: Action$1.STATUS };\r\n    try {\r\n        statusResponse = await webExtensionService.send(message, timeout);\r\n    }\r\n    catch (error) {\r\n        error.library = library;\r\n        throw error;\r\n    }\r\n    const versions = { library, ...statusResponse };\r\n    const requiresUpdate = checkCompatibility(versions);\r\n    if (requiresUpdate.extension || requiresUpdate.nativeApp) {\r\n        throw new VersionMismatchError(undefined, versions, requiresUpdate);\r\n    }\r\n    return versions;\r\n}\r\nasync function authenticate(options) {\r\n    await defer(); // Give chrome a moment to load the extension content script\r\n    if (typeof options != \"object\") {\r\n        throw new MissingParameterError(\"authenticate function requires an options object as parameter\");\r\n    }\r\n    if (!options.getAuthChallengeUrl) {\r\n        throw new MissingParameterError(\"getAuthChallengeUrl missing from authenticate options\");\r\n    }\r\n    if (!options.postAuthTokenUrl) {\r\n        throw new MissingParameterError(\"postAuthTokenUrl missing from authenticate options\");\r\n    }\r\n    const timeout = (config$1.EXTENSION_HANDSHAKE_TIMEOUT +\r\n        config$1.NATIVE_APP_HANDSHAKE_TIMEOUT +\r\n        (options.serverRequestTimeout || config$1.DEFAULT_SERVER_REQUEST_TIMEOUT) * 2 +\r\n        (options.userInteractionTimeout || config$1.DEFAULT_USER_INTERACTION_TIMEOUT));\r\n    const message = { ...options, action: Action$1.AUTHENTICATE };\r\n    const result = await webExtensionService.send(message, timeout);\r\n    return result.response;\r\n}\r\nasync function sign(options) {\r\n    await defer(); // Give chrome a moment to load the extension content script\r\n    if (typeof options != \"object\") {\r\n        throw new MissingParameterError(\"sign function requires an options object as parameter\");\r\n    }\r\n    if (!options.postPrepareSigningUrl) {\r\n        throw new MissingParameterError(\"postPrepareSigningUrl missing from sign options\");\r\n    }\r\n    if (!options.postFinalizeSigningUrl) {\r\n        throw new MissingParameterError(\"postFinalizeSigningUrl missing from sign options\");\r\n    }\r\n    const timeout = (config$1.EXTENSION_HANDSHAKE_TIMEOUT +\r\n        config$1.NATIVE_APP_HANDSHAKE_TIMEOUT +\r\n        (options.serverRequestTimeout || config$1.DEFAULT_SERVER_REQUEST_TIMEOUT) * 2 +\r\n        (options.userInteractionTimeout || config$1.DEFAULT_USER_INTERACTION_TIMEOUT) * 2);\r\n    const message = { ...options, action: Action$1.SIGN };\r\n    const result = await webExtensionService.send(message, timeout);\r\n    return result.response;\r\n}\r\n\r\nexport { Action$1 as Action, ErrorCode$1 as ErrorCode, authenticate, config$1 as config, hasVersionProperties, sign, status };\r\n","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../node_modules/vue-loader-v16/dist/index.js??ref--1-0!./Navbar.vue?vue&type=style&index=0&id=21165a6a&scoped=true&lang=css\"","export * from \"-!../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../node_modules/vue-loader-v16/dist/stylePostLoader.js!../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../node_modules/vue-loader-v16/dist/index.js??ref--1-0!./App.vue?vue&type=style&index=0&id=4d88d202&lang=css\""],"sourceRoot":""}