{"version":3,"sources":["webpack:///./node_modules/tunnel-agent/index.js","webpack:///./node_modules/url/url.js","webpack:///./node_modules/url/util.js","webpack:///./node_modules/uri-js/dist/es5/uri.all.js","webpack:///./node_modules/tweetnacl/nacl-fast.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/stream-http/lib/request.js","webpack:///./node_modules/stream-http/index.js","webpack:///./node_modules/stream-http/lib/capability.js","webpack:///./node_modules/stream-http/lib/response.js","webpack:///./node_modules/stream-browserify/index.js","webpack:///./node_modules/to-arraybuffer/index.js"],"names":["debug","tls","http","https","events","assert","util","Buffer","httpOverHttp","options","agent","TunnelingAgent","request","httpsOverHttp","createSocket","createSecureSocket","defaultPort","httpOverHttps","httpsOverHttps","self","this","proxyOptions","proxy","maxSockets","Agent","defaultMaxSockets","requests","sockets","on","socket","host","port","i","len","length","pending","splice","onSocket","destroy","removeSocket","cb","prototype","call","secureSocket","connect","mergeOptions","servername","indexOf","target","arguments","overrides","keys","Object","j","keyLen","k","undefined","exports","inherits","EventEmitter","addRequest","req","path","push","createConnection","onFree","emit","onCloseOrRemove","err","removeListener","placeholder","connectOptions","method","proxyAuth","headers","from","toString","connectReq","onResponse","res","upgrade","onUpgrade","head","process","nextTick","onConnect","removeAllListeners","statusCode","equal","error","Error","code","onError","cause","message","stack","useChunkedEncodingByDefault","once","end","pos","shift","NODE_DEBUG","test","args","Array","slice","unshift","console","apply","punycode","Url","protocol","slashes","auth","hostname","hash","search","query","pathname","href","parse","urlParse","resolve","urlResolve","resolveObject","urlResolveObject","format","urlFormat","protocolPattern","portPattern","simplePathPattern","delims","unwise","concat","autoEscape","nonHostChars","hostEndingChars","hostnameMaxLen","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","url","parseQueryString","slashesDenoteHost","isObject","u","obj","isString","source","relative","TypeError","queryIndex","splitter","uSplit","split","slashRegex","replace","join","rest","trim","simplePath","exec","substr","proto","lowerProto","toLowerCase","match","atSign","hostEnd","hec","lastIndexOf","decodeURIComponent","parseHost","ipv6Hostname","hostparts","l","part","newpart","charCodeAt","validParts","notHost","bit","toASCII","p","h","ae","esc","encodeURIComponent","escape","qm","s","stringify","charAt","rel","result","tkeys","tk","tkey","rkeys","rk","rkey","v","relPath","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","pop","isNullOrUndefined","authInHost","isNull","last","hasTrailingSlash","up","isAbsolute","module","arg","global","factory","merge","_len","sets","_key","xl","x","subexp","str","typeOf","o","toUpperCase","toArray","setInterval","assign","key","buildExps","isIRI","ALPHA$$","DIGIT$$","HEXDIG$$","PCT_ENCODED$","GEN_DELIMS$$","SUB_DELIMS$$","RESERVED$$","UCSCHAR$$","IPRIVATE$$","UNRESERVED$$","SCHEME$","USERINFO$","DEC_OCTET_RELAXED$","IPV4ADDRESS$","H16$","LS32$","IPV6ADDRESS1$","IPV6ADDRESS2$","IPV6ADDRESS3$","IPV6ADDRESS4$","IPV6ADDRESS5$","IPV6ADDRESS6$","IPV6ADDRESS7$","IPV6ADDRESS8$","IPV6ADDRESS9$","IPV6ADDRESS$","ZONEID$","IPV6ADDRZ_RELAXED$","IPVFUTURE$","IP_LITERAL$","REG_NAME$","HOST$","PORT$","AUTHORITY$","PCHAR$","SEGMENT$","SEGMENT_NZ$","SEGMENT_NZ_NC$","PATH_ABEMPTY$","PATH_ABSOLUTE$","PATH_NOSCHEME$","PATH_ROOTLESS$","PATH_EMPTY$","QUERY$","FRAGMENT$","HIER_PART$","URI$","RELATIVE_PART$","RELATIVE$","NOT_SCHEME","RegExp","NOT_USERINFO","NOT_HOST","NOT_PATH","NOT_PATH_NOSCHEME","NOT_QUERY","NOT_FRAGMENT","ESCAPE","UNRESERVED","OTHER_CHARS","PCT_ENCODED","IPV4ADDRESS","IPV6ADDRESS","URI_PROTOCOL","IRI_PROTOCOL","slicedToArray","sliceIterator","arr","_arr","_n","_d","_e","_s","_i","Symbol","iterator","next","done","value","isArray","toConsumableArray","arr2","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","errors","baseMinusTMin","floor","Math","stringFromCharCode","String","fromCharCode","error$1","type","RangeError","map","array","fn","mapDomain","string","parts","labels","encoded","ucs2decode","output","counter","extra","ucs2encode","fromCodePoint","basicToDigit","codePoint","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","decode","input","inputLength","n","bias","basic","index","oldi","w","t","baseMinusT","out","encode","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","_currentValue2","return","basicLength","handledCPCount","m","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","_step2","_iterator2","currentValue","handledCPCountPlusOne","_iteratorNormalCompletion3","_didIteratorError3","_iteratorError3","_step3","_iterator3","_currentValue","q","qMinusT","toUnicode","SCHEMES","pctEncChar","chr","c","e","pctDecChars","newStr","il","parseInt","c2","_c","c3","_normalizeComponentEncoding","components","decodeUnreserved","decStr","scheme","userinfo","fragment","_stripLeadingZeros","_normalizeIPv4","matches","_matches","address","_normalizeIPv6","_matches2","zone","_address$toLowerCase$","reverse","_address$toLowerCase$2","first","firstFields","lastFields","isLastFieldIPv4Address","fieldCount","lastFieldsStart","fields","allZeroFields","reduce","acc","field","lastLongest","longestZeroFields","sort","a","b","newHost","newFirst","newLast","URI_PARSE","NO_MATCH_IS_UNDEFINED","uriString","iri","reference","isNaN","schemeHandler","unicodeSupport","domainHost","_recomposeAuthority","uriTokens","_","$1","$2","RDS1","RDS2","RDS3","RDS5","removeDotSegments","im","serialize","authority","absolutePath","resolveComponents","skipNormalization","tolerant","baseURI","relativeURI","schemelessOptions","normalize","uri","uriA","uriB","escapeComponent","unescapeComponent","handler","secure","handler$1","isSecure","wsComponents","handler$2","resourceName","_wsComponents$resourc","_wsComponents$resourc2","handler$3","O","ATEXT$$","QTEXT$$","VCHAR$$","SOME_DELIMS$$","NOT_LOCAL_PART","NOT_HFNAME","NOT_HFVALUE","handler$4","mailtoComponents","to","unknownHeaders","hfields","hfield","toAddrs","_x","_xl","subject","body","_x2","_xl2","addr","toAddr","atIdx","localPart","domain","name","URN_PARSE","handler$5","urnComponents","nid","nss","urnScheme","uriComponents","UUID","handler$6","uuidComponents","uuid","defineProperty","nacl","gf","init","r","Float64Array","randombytes","_0","Uint8Array","_9","gf0","gf1","_121665","D","D2","X","Y","I","ts64","vn","xi","y","yi","d","crypto_verify_16","crypto_verify_32","core_salsa20","j0","j1","j2","j3","j4","j5","j6","j7","j8","j9","j10","j11","j12","j13","j14","j15","x0","x1","x2","x3","x4","x5","x6","x7","x8","x9","x10","x11","x12","x13","x14","x15","core_hsalsa20","crypto_core_salsa20","inp","crypto_core_hsalsa20","sigma","crypto_stream_salsa20_xor","cpos","mpos","z","crypto_stream_salsa20","crypto_stream","sn","crypto_stream_xor","poly1305","t0","t1","t2","t3","t4","t5","t6","t7","buffer","Uint16Array","pad","leftover","fin","crypto_onetimeauth","outpos","update","finish","crypto_onetimeauth_verify","hpos","crypto_secretbox","crypto_secretbox_open","set25519","car25519","sel25519","pack25519","neq25519","par25519","unpack25519","A","Z","M","t8","t9","t10","t11","t12","t13","t14","t15","t16","t17","t18","t19","t20","t21","t22","t23","t24","t25","t26","t27","t28","t29","t30","b0","b1","b2","b3","b4","b5","b6","b7","b8","b9","b10","b11","b12","b13","b14","b15","S","inv25519","pow2523","crypto_scalarmult","f","x32","subarray","x16","crypto_scalarmult_base","crypto_box_keypair","crypto_box_beforenm","blocks","bytes","d0","d1","d2","d3","d4","d5","d6","d7","d8","d9","hibit","h0","h1","h2","h3","h4","h5","h6","h7","h8","h9","r0","r1","r2","r3","r4","r5","r6","r7","r8","r9","mac","macpos","mask","g","want","crypto_box_afternm","crypto_box_open_afternm","crypto_box","crypto_box_open","K","crypto_hashblocks_hl","hh","hl","bh0","bh1","bh2","bh3","bh4","bh5","bh6","bh7","bl0","bl1","bl2","bl3","bl4","bl5","bl6","bl7","th","tl","wh","Int32Array","wl","ah0","ah1","ah2","ah3","ah4","ah5","ah6","ah7","al0","al1","al2","al3","al4","al5","al6","al7","crypto_hash","add","cswap","pack","tx","ty","zi","scalarmult","scalarbase","crypto_sign_keypair","pk","sk","seeded","L","modL","carry","crypto_sign","sm","smlen","unpackneg","chk","num","den","den2","den4","den6","crypto_sign_open","mlen","crypto_secretbox_KEYBYTES","crypto_secretbox_NONCEBYTES","crypto_secretbox_ZEROBYTES","crypto_secretbox_BOXZEROBYTES","crypto_scalarmult_BYTES","crypto_scalarmult_SCALARBYTES","crypto_box_PUBLICKEYBYTES","crypto_box_SECRETKEYBYTES","crypto_box_BEFORENMBYTES","crypto_box_NONCEBYTES","crypto_box_ZEROBYTES","crypto_box_BOXZEROBYTES","crypto_sign_BYTES","crypto_sign_PUBLICKEYBYTES","crypto_sign_SECRETKEYBYTES","crypto_sign_SEEDBYTES","crypto_hash_BYTES","checkLengths","checkBoxLengths","checkArrayTypes","cleanup","lowlevel","decodeUTF8","encodeUTF8","encodeBase64","decodeBase64","randomBytes","secretbox","msg","nonce","open","box","keyLength","nonceLength","overheadLength","scalarMult","scalarLength","groupElementLength","publicKey","secretKey","before","after","keyPair","fromSecretKey","publicKeyLength","secretKeyLength","sharedKeyLength","sign","signedMsg","tmp","detached","sig","verify","fromSeed","seed","seedLength","signatureLength","hashLength","setPRNG","crypto","msCrypto","getRandomValues","QUOTA","min","isEncoding","encoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","StringDecoder","nb","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","write","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","allocUnsafe","utf8CheckByte","byte","utf8CheckIncomplete","buf","utf8CheckExtraBytes","copy","utf8Text","total","utf8End","response","stream","toArrayBuffer","IncomingMessage","rStates","readyStates","decideMode","preferBinary","useFetch","capability","fetch","mozchunkedarraybuffer","msstream","arraybuffer","vbArray","ClientRequest","opts","Writable","_opts","_body","_headers","setHeader","forEach","mode","abortController","overrideMimeType","_mode","_fetchTimer","_onFinish","statusValid","xhr","status","lowerName","unsafeHeaders","getHeader","header","removeHeader","_destroyed","headersObj","blobConstructor","Blob","headersList","keyName","signal","controller","AbortController","_fetchAbortController","requestTimeout","setTimeout","abort","credentials","withCredentials","then","_fetchResponse","_connect","reason","clearTimeout","_xhr","XMLHttpRequest","responseType","timeout","ontimeout","setRequestHeader","_response","onreadystatechange","readyState","LOADING","DONE","_onXHRProgress","onprogress","onerror","send","_write","chunk","data","flushHeaders","setNoDelay","setSocketKeepAlive","extend","statusCodes","defaultProtocol","location","get","globalAgent","STATUS_CODES","METHODS","writableStream","isFunction","WritableStream","ArrayBuffer","getXHR","XDomainRequest","checkTypeSupport","haveArrayBuffer","haveSlice","VBArray","UNSENT","OPENED","HEADERS_RECEIVED","fetchTimer","Readable","rawHeaders","trailers","rawTrailers","statusMessage","statusText","writable","Promise","reject","_resumeFetch","close","pipeTo","catch","reader","getReader","read","_pos","responseURL","getAllResponseHeaders","_charset","mimeType","charsetMatch","_read","responseBody","responseText","newData","MSStreamReader","byteLength","onload","readAsArrayBuffer","Stream","EE","Duplex","Transform","PassThrough","pipe","dest","ondata","pause","ondrain","readable","resume","_isStdio","onend","onclose","didOnEnd","er","listenerCount","byteOffset","isBuffer","arrayCopy"],"mappings":"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","file":"js/account~ec8c427e.5cb6714f.js","sourcesContent":["'use strict'\n\nvar net = require('net')\n  , tls = require('tls')\n  , http = require('http')\n  , https = require('https')\n  , events = require('events')\n  , assert = require('assert')\n  , util = require('util')\n  , Buffer = require('safe-buffer').Buffer\n  ;\n\nexports.httpOverHttp = httpOverHttp\nexports.httpsOverHttp = httpsOverHttp\nexports.httpOverHttps = httpOverHttps\nexports.httpsOverHttps = httpsOverHttps\n\n\nfunction httpOverHttp(options) {\n  var agent = new TunnelingAgent(options)\n  agent.request = http.request\n  return agent\n}\n\nfunction httpsOverHttp(options) {\n  var agent = new TunnelingAgent(options)\n  agent.request = http.request\n  agent.createSocket = createSecureSocket\n  agent.defaultPort = 443\n  return agent\n}\n\nfunction httpOverHttps(options) {\n  var agent = new TunnelingAgent(options)\n  agent.request = https.request\n  return agent\n}\n\nfunction httpsOverHttps(options) {\n  var agent = new TunnelingAgent(options)\n  agent.request = https.request\n  agent.createSocket = createSecureSocket\n  agent.defaultPort = 443\n  return agent\n}\n\n\nfunction TunnelingAgent(options) {\n  var self = this\n  self.options = options || {}\n  self.proxyOptions = self.options.proxy || {}\n  self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets\n  self.requests = []\n  self.sockets = []\n\n  self.on('free', function onFree(socket, host, port) {\n    for (var i = 0, len = self.requests.length; i < len; ++i) {\n      var pending = self.requests[i]\n      if (pending.host === host && pending.port === port) {\n        // Detect the request to connect same origin server,\n        // reuse the connection.\n        self.requests.splice(i, 1)\n        pending.request.onSocket(socket)\n        return\n      }\n    }\n    socket.destroy()\n    self.removeSocket(socket)\n  })\n}\nutil.inherits(TunnelingAgent, events.EventEmitter)\n\nTunnelingAgent.prototype.addRequest = function addRequest(req, options) {\n  var self = this\n\n   // Legacy API: addRequest(req, host, port, path)\n  if (typeof options === 'string') {\n    options = {\n      host: options,\n      port: arguments[2],\n      path: arguments[3]\n    };\n  }\n\n  if (self.sockets.length >= this.maxSockets) {\n    // We are over limit so we'll add it to the queue.\n    self.requests.push({host: options.host, port: options.port, request: req})\n    return\n  }\n\n  // If we are under maxSockets create a new one.\n  self.createConnection({host: options.host, port: options.port, request: req})\n}\n\nTunnelingAgent.prototype.createConnection = function createConnection(pending) {\n  var self = this\n\n  self.createSocket(pending, function(socket) {\n    socket.on('free', onFree)\n    socket.on('close', onCloseOrRemove)\n    socket.on('agentRemove', onCloseOrRemove)\n    pending.request.onSocket(socket)\n\n    function onFree() {\n      self.emit('free', socket, pending.host, pending.port)\n    }\n\n    function onCloseOrRemove(err) {\n      self.removeSocket(socket)\n      socket.removeListener('free', onFree)\n      socket.removeListener('close', onCloseOrRemove)\n      socket.removeListener('agentRemove', onCloseOrRemove)\n    }\n  })\n}\n\nTunnelingAgent.prototype.createSocket = function createSocket(options, cb) {\n  var self = this\n  var placeholder = {}\n  self.sockets.push(placeholder)\n\n  var connectOptions = mergeOptions({}, self.proxyOptions,\n    { method: 'CONNECT'\n    , path: options.host + ':' + options.port\n    , agent: false\n    }\n  )\n  if (connectOptions.proxyAuth) {\n    connectOptions.headers = connectOptions.headers || {}\n    connectOptions.headers['Proxy-Authorization'] = 'Basic ' +\n        Buffer.from(connectOptions.proxyAuth).toString('base64')\n  }\n\n  debug('making CONNECT request')\n  var connectReq = self.request(connectOptions)\n  connectReq.useChunkedEncodingByDefault = false // for v0.6\n  connectReq.once('response', onResponse) // for v0.6\n  connectReq.once('upgrade', onUpgrade)   // for v0.6\n  connectReq.once('connect', onConnect)   // for v0.7 or later\n  connectReq.once('error', onError)\n  connectReq.end()\n\n  function onResponse(res) {\n    // Very hacky. This is necessary to avoid http-parser leaks.\n    res.upgrade = true\n  }\n\n  function onUpgrade(res, socket, head) {\n    // Hacky.\n    process.nextTick(function() {\n      onConnect(res, socket, head)\n    })\n  }\n\n  function onConnect(res, socket, head) {\n    connectReq.removeAllListeners()\n    socket.removeAllListeners()\n\n    if (res.statusCode === 200) {\n      assert.equal(head.length, 0)\n      debug('tunneling connection has established')\n      self.sockets[self.sockets.indexOf(placeholder)] = socket\n      cb(socket)\n    } else {\n      debug('tunneling socket could not be established, statusCode=%d', res.statusCode)\n      var error = new Error('tunneling socket could not be established, ' + 'statusCode=' + res.statusCode)\n      error.code = 'ECONNRESET'\n      options.request.emit('error', error)\n      self.removeSocket(placeholder)\n    }\n  }\n\n  function onError(cause) {\n    connectReq.removeAllListeners()\n\n    debug('tunneling socket could not be established, cause=%s\\n', cause.message, cause.stack)\n    var error = new Error('tunneling socket could not be established, ' + 'cause=' + cause.message)\n    error.code = 'ECONNRESET'\n    options.request.emit('error', error)\n    self.removeSocket(placeholder)\n  }\n}\n\nTunnelingAgent.prototype.removeSocket = function removeSocket(socket) {\n  var pos = this.sockets.indexOf(socket)\n  if (pos === -1) return\n\n  this.sockets.splice(pos, 1)\n\n  var pending = this.requests.shift()\n  if (pending) {\n    // If we have pending requests and a socket gets closed a new one\n    // needs to be created to take over in the pool for the one that closed.\n    this.createConnection(pending)\n  }\n}\n\nfunction createSecureSocket(options, cb) {\n  var self = this\n  TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {\n    // 0 is dummy port for v0.6\n    var secureSocket = tls.connect(0, mergeOptions({}, self.options,\n      { servername: options.host\n      , socket: socket\n      }\n    ))\n    self.sockets[self.sockets.indexOf(socket)] = secureSocket\n    cb(secureSocket)\n  })\n}\n\n\nfunction mergeOptions(target) {\n  for (var i = 1, len = arguments.length; i < len; ++i) {\n    var overrides = arguments[i]\n    if (typeof overrides === 'object') {\n      var keys = Object.keys(overrides)\n      for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {\n        var k = keys[j]\n        if (overrides[k] !== undefined) {\n          target[k] = overrides[k]\n        }\n      }\n    }\n  }\n  return target\n}\n\n\nvar debug\nif (process.env.NODE_DEBUG && /\\btunnel\\b/.test(process.env.NODE_DEBUG)) {\n  debug = function() {\n    var args = Array.prototype.slice.call(arguments)\n    if (typeof args[0] === 'string') {\n      args[0] = 'TUNNEL: ' + args[0]\n    } else {\n      args.unshift('TUNNEL:')\n    }\n    console.error.apply(console, args)\n  }\n} else {\n  debug = function() {}\n}\nexports.debug = debug // for test\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = ['\\''].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n    hostEndingChars = ['/', '?', '#'],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    unsafeProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    },\n    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n\n  var u = new Url;\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n  if (!util.isString(url)) {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  }\n\n  // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n  var queryIndex = url.indexOf('?'),\n      splitter =\n          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n      uSplit = url.split(splitter),\n      slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n\n  var rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1)\n      hostEnd = rest.length;\n\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) continue;\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host;\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1)\n        continue;\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\n  }\n\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n  if (rest) this.pathname = rest;\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  //to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (util.isString(obj)) obj = urlParse(obj);\n  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n  return obj.format();\n}\n\nUrl.prototype.format = function() {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n      pathname = this.pathname || '',\n      hash = this.hash || '',\n      host = false,\n      query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ?\n        this.hostname :\n        '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query &&\n      util.isObject(this.query) &&\n      Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n  if (search && search.charAt(0) !== '?') search = '?' + search;\n\n  pathname = pathname.replace(/[?#]/g, function(match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n  if (util.isString(relative)) {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n      isRelAbs = (\n          relative.host ||\n          relative.pathname && relative.pathname.charAt(0) === '/'\n      ),\n      mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (result.host && relative.pathname)),\n      removeAllDots = mustEndAbs,\n      srcPath = result.pathname && result.pathname.split('/') || [],\n      relPath = relative.pathname && relative.pathname.split('/') || [],\n      psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n                  relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n                      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (!util.isNullOrUndefined(relative.search)) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift();\n      //occationaly the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n      var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                       result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n      (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n                                    srcPath.length ? srcPath.shift() : '';\n    //occationaly the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n    var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                     result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  }\n\n  //to support request.http\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function() {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) this.hostname = host;\n};\n","'use strict';\n\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\n};\n","/** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */\n(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\n\t(factory((global.URI = global.URI || {})));\n}(this, (function (exports) { 'use strict';\n\nfunction merge() {\n    for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {\n        sets[_key] = arguments[_key];\n    }\n\n    if (sets.length > 1) {\n        sets[0] = sets[0].slice(0, -1);\n        var xl = sets.length - 1;\n        for (var x = 1; x < xl; ++x) {\n            sets[x] = sets[x].slice(1, -1);\n        }\n        sets[xl] = sets[xl].slice(1);\n        return sets.join('');\n    } else {\n        return sets[0];\n    }\n}\nfunction subexp(str) {\n    return \"(?:\" + str + \")\";\n}\nfunction typeOf(o) {\n    return o === undefined ? \"undefined\" : o === null ? \"null\" : Object.prototype.toString.call(o).split(\" \").pop().split(\"]\").shift().toLowerCase();\n}\nfunction toUpperCase(str) {\n    return str.toUpperCase();\n}\nfunction toArray(obj) {\n    return obj !== undefined && obj !== null ? obj instanceof Array ? obj : typeof obj.length !== \"number\" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj) : [];\n}\nfunction assign(target, source) {\n    var obj = target;\n    if (source) {\n        for (var key in source) {\n            obj[key] = source[key];\n        }\n    }\n    return obj;\n}\n\nfunction buildExps(isIRI) {\n    var ALPHA$$ = \"[A-Za-z]\",\n        CR$ = \"[\\\\x0D]\",\n        DIGIT$$ = \"[0-9]\",\n        DQUOTE$$ = \"[\\\\x22]\",\n        HEXDIG$$ = merge(DIGIT$$, \"[A-Fa-f]\"),\n        //case-insensitive\n    LF$$ = \"[\\\\x0A]\",\n        SP$$ = \"[\\\\x20]\",\n        PCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$)),\n        //expanded\n    GEN_DELIMS$$ = \"[\\\\:\\\\/\\\\?\\\\#\\\\[\\\\]\\\\@]\",\n        SUB_DELIMS$$ = \"[\\\\!\\\\$\\\\&\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\=]\",\n        RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$),\n        UCSCHAR$$ = isIRI ? \"[\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF]\" : \"[]\",\n        //subset, excludes bidi control characters\n    IPRIVATE$$ = isIRI ? \"[\\\\uE000-\\\\uF8FF]\" : \"[]\",\n        //subset\n    UNRESERVED$$ = merge(ALPHA$$, DIGIT$$, \"[\\\\-\\\\.\\\\_\\\\~]\", UCSCHAR$$),\n        SCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\") + \"*\"),\n        USERINFO$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\")) + \"*\"),\n        DEC_OCTET$ = subexp(subexp(\"25[0-5]\") + \"|\" + subexp(\"2[0-4]\" + DIGIT$$) + \"|\" + subexp(\"1\" + DIGIT$$ + DIGIT$$) + \"|\" + subexp(\"[1-9]\" + DIGIT$$) + \"|\" + DIGIT$$),\n        DEC_OCTET_RELAXED$ = subexp(subexp(\"25[0-5]\") + \"|\" + subexp(\"2[0-4]\" + DIGIT$$) + \"|\" + subexp(\"1\" + DIGIT$$ + DIGIT$$) + \"|\" + subexp(\"0?[1-9]\" + DIGIT$$) + \"|0?0?\" + DIGIT$$),\n        //relaxed parsing rules\n    IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$ + \"\\\\.\" + DEC_OCTET_RELAXED$),\n        H16$ = subexp(HEXDIG$$ + \"{1,4}\"),\n        LS32$ = subexp(subexp(H16$ + \"\\\\:\" + H16$) + \"|\" + IPV4ADDRESS$),\n        IPV6ADDRESS1$ = subexp(subexp(H16$ + \"\\\\:\") + \"{6}\" + LS32$),\n        //                           6( h16 \":\" ) ls32\n    IPV6ADDRESS2$ = subexp(\"\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{5}\" + LS32$),\n        //                      \"::\" 5( h16 \":\" ) ls32\n    IPV6ADDRESS3$ = subexp(subexp(H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{4}\" + LS32$),\n        //[               h16 ] \"::\" 4( h16 \":\" ) ls32\n    IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,1}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{3}\" + LS32$),\n        //[ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n    IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,2}\" + H16$) + \"?\\\\:\\\\:\" + subexp(H16$ + \"\\\\:\") + \"{2}\" + LS32$),\n        //[ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n    IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,3}\" + H16$) + \"?\\\\:\\\\:\" + H16$ + \"\\\\:\" + LS32$),\n        //[ *3( h16 \":\" ) h16 ] \"::\"    h16 \":\"   ls32\n    IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,4}\" + H16$) + \"?\\\\:\\\\:\" + LS32$),\n        //[ *4( h16 \":\" ) h16 ] \"::\"              ls32\n    IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,5}\" + H16$) + \"?\\\\:\\\\:\" + H16$),\n        //[ *5( h16 \":\" ) h16 ] \"::\"              h16\n    IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + \"\\\\:\") + \"{0,6}\" + H16$) + \"?\\\\:\\\\:\"),\n        //[ *6( h16 \":\" ) h16 ] \"::\"\n    IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join(\"|\")),\n        ZONEID$ = subexp(subexp(UNRESERVED$$ + \"|\" + PCT_ENCODED$) + \"+\"),\n        //RFC 6874\n    IPV6ADDRZ$ = subexp(IPV6ADDRESS$ + \"\\\\%25\" + ZONEID$),\n        //RFC 6874\n    IPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + ZONEID$),\n        //RFC 6874, with relaxed parsing rules\n    IPVFUTURE$ = subexp(\"[vV]\" + HEXDIG$$ + \"+\\\\.\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:]\") + \"+\"),\n        IP_LITERAL$ = subexp(\"\\\\[\" + subexp(IPV6ADDRZ_RELAXED$ + \"|\" + IPV6ADDRESS$ + \"|\" + IPVFUTURE$) + \"\\\\]\"),\n        //RFC 6874\n    REG_NAME$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$)) + \"*\"),\n        HOST$ = subexp(IP_LITERAL$ + \"|\" + IPV4ADDRESS$ + \"(?!\" + REG_NAME$ + \")\" + \"|\" + REG_NAME$),\n        PORT$ = subexp(DIGIT$$ + \"*\"),\n        AUTHORITY$ = subexp(subexp(USERINFO$ + \"@\") + \"?\" + HOST$ + subexp(\"\\\\:\" + PORT$) + \"?\"),\n        PCHAR$ = subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@]\")),\n        SEGMENT$ = subexp(PCHAR$ + \"*\"),\n        SEGMENT_NZ$ = subexp(PCHAR$ + \"+\"),\n        SEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + \"|\" + merge(UNRESERVED$$, SUB_DELIMS$$, \"[\\\\@]\")) + \"+\"),\n        PATH_ABEMPTY$ = subexp(subexp(\"\\\\/\" + SEGMENT$) + \"*\"),\n        PATH_ABSOLUTE$ = subexp(\"\\\\/\" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + \"?\"),\n        //simplified\n    PATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$),\n        //simplified\n    PATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$),\n        //simplified\n    PATH_EMPTY$ = \"(?!\" + PCHAR$ + \")\",\n        PATH$ = subexp(PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$),\n        QUERY$ = subexp(subexp(PCHAR$ + \"|\" + merge(\"[\\\\/\\\\?]\", IPRIVATE$$)) + \"*\"),\n        FRAGMENT$ = subexp(subexp(PCHAR$ + \"|[\\\\/\\\\?]\") + \"*\"),\n        HIER_PART$ = subexp(subexp(\"\\\\/\\\\/\" + AUTHORITY$ + PATH_ABEMPTY$) + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$),\n        URI$ = subexp(SCHEME$ + \"\\\\:\" + HIER_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\" + subexp(\"\\\\#\" + FRAGMENT$) + \"?\"),\n        RELATIVE_PART$ = subexp(subexp(\"\\\\/\\\\/\" + AUTHORITY$ + PATH_ABEMPTY$) + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_EMPTY$),\n        RELATIVE$ = subexp(RELATIVE_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\" + subexp(\"\\\\#\" + FRAGMENT$) + \"?\"),\n        URI_REFERENCE$ = subexp(URI$ + \"|\" + RELATIVE$),\n        ABSOLUTE_URI$ = subexp(SCHEME$ + \"\\\\:\" + HIER_PART$ + subexp(\"\\\\?\" + QUERY$) + \"?\"),\n        GENERIC_REF$ = \"^(\" + SCHEME$ + \")\\\\:\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n        RELATIVE_REF$ = \"^(){0}\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_NOSCHEME$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n        ABSOLUTE_REF$ = \"^(\" + SCHEME$ + \")\\\\:\" + subexp(subexp(\"\\\\/\\\\/(\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?)\") + \"?(\" + PATH_ABEMPTY$ + \"|\" + PATH_ABSOLUTE$ + \"|\" + PATH_ROOTLESS$ + \"|\" + PATH_EMPTY$ + \")\") + subexp(\"\\\\?(\" + QUERY$ + \")\") + \"?$\",\n        SAMEDOC_REF$ = \"^\" + subexp(\"\\\\#(\" + FRAGMENT$ + \")\") + \"?$\",\n        AUTHORITY_REF$ = \"^\" + subexp(\"(\" + USERINFO$ + \")@\") + \"?(\" + HOST$ + \")\" + subexp(\"\\\\:(\" + PORT$ + \")\") + \"?$\";\n    return {\n        NOT_SCHEME: new RegExp(merge(\"[^]\", ALPHA$$, DIGIT$$, \"[\\\\+\\\\-\\\\.]\"), \"g\"),\n        NOT_USERINFO: new RegExp(merge(\"[^\\\\%\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_HOST: new RegExp(merge(\"[^\\\\%\\\\[\\\\]\\\\:]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_PATH: new RegExp(merge(\"[^\\\\%\\\\/\\\\:\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_PATH_NOSCHEME: new RegExp(merge(\"[^\\\\%\\\\/\\\\@]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        NOT_QUERY: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\", IPRIVATE$$), \"g\"),\n        NOT_FRAGMENT: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, SUB_DELIMS$$, \"[\\\\:\\\\@\\\\/\\\\?]\"), \"g\"),\n        ESCAPE: new RegExp(merge(\"[^]\", UNRESERVED$$, SUB_DELIMS$$), \"g\"),\n        UNRESERVED: new RegExp(UNRESERVED$$, \"g\"),\n        OTHER_CHARS: new RegExp(merge(\"[^\\\\%]\", UNRESERVED$$, RESERVED$$), \"g\"),\n        PCT_ENCODED: new RegExp(PCT_ENCODED$, \"g\"),\n        IPV4ADDRESS: new RegExp(\"^(\" + IPV4ADDRESS$ + \")$\"),\n        IPV6ADDRESS: new RegExp(\"^\\\\[?(\" + IPV6ADDRESS$ + \")\" + subexp(subexp(\"\\\\%25|\\\\%(?!\" + HEXDIG$$ + \"{2})\") + \"(\" + ZONEID$ + \")\") + \"?\\\\]?$\") //RFC 6874, with relaxed parsing rules\n    };\n}\nvar URI_PROTOCOL = buildExps(false);\n\nvar IRI_PROTOCOL = buildExps(true);\n\nvar slicedToArray = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if (Symbol.iterator in Object(arr)) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar toConsumableArray = function (arr) {\n  if (Array.isArray(arr)) {\n    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n    return arr2;\n  } else {\n    return Array.from(arr);\n  }\n};\n\n/** Highest positive signed 32-bit float value */\n\nvar maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nvar base = 36;\nvar tMin = 1;\nvar tMax = 26;\nvar skew = 38;\nvar damp = 700;\nvar initialBias = 72;\nvar initialN = 128; // 0x80\nvar delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nvar regexPunycode = /^xn--/;\nvar regexNonASCII = /[^\\0-\\x7E]/; // non-ASCII chars\nvar regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nvar errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nvar baseMinusTMin = base - tMin;\nvar floor = Math.floor;\nvar stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error$1(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, fn) {\n\tvar result = [];\n\tvar length = array.length;\n\twhile (length--) {\n\t\tresult[length] = fn(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {Array} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(string, fn) {\n\tvar parts = string.split('@');\n\tvar result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tstring = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tstring = string.replace(regexSeparators, '\\x2E');\n\tvar labels = string.split('.');\n\tvar encoded = map(labels, fn).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tvar output = [];\n\tvar counter = 0;\n\tvar length = string.length;\n\twhile (counter < length) {\n\t\tvar value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tvar extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) {\n\t\t\t\t// Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nvar ucs2encode = function ucs2encode(array) {\n\treturn String.fromCodePoint.apply(String, toConsumableArray(array));\n};\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nvar basicToDigit = function basicToDigit(codePoint) {\n\tif (codePoint - 0x30 < 0x0A) {\n\t\treturn codePoint - 0x16;\n\t}\n\tif (codePoint - 0x41 < 0x1A) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint - 0x61 < 0x1A) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nvar digitToBasic = function digitToBasic(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nvar adapt = function adapt(delta, numPoints, firstTime) {\n\tvar k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (; /* no initialization */delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nvar decode = function decode(input) {\n\t// Don't use UCS-2.\n\tvar output = [];\n\tvar inputLength = input.length;\n\tvar i = 0;\n\tvar n = initialN;\n\tvar bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tvar basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (var j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror$1('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (var index = basic > 0 ? basic + 1 : 0; index < inputLength;) /* no final expression */{\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tvar oldi = i;\n\t\tfor (var w = 1, k = base;; /* no condition */k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror$1('invalid-input');\n\t\t\t}\n\n\t\t\tvar digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\terror$1('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tvar t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tvar baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror$1('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\t\t}\n\n\t\tvar out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror$1('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\t}\n\n\treturn String.fromCodePoint.apply(String, output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nvar encode = function encode(input) {\n\tvar output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tvar inputLength = input.length;\n\n\t// Initialize the state.\n\tvar n = initialN;\n\tvar delta = 0;\n\tvar bias = initialBias;\n\n\t// Handle the basic code points.\n\tvar _iteratorNormalCompletion = true;\n\tvar _didIteratorError = false;\n\tvar _iteratorError = undefined;\n\n\ttry {\n\t\tfor (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n\t\t\tvar _currentValue2 = _step.value;\n\n\t\t\tif (_currentValue2 < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(_currentValue2));\n\t\t\t}\n\t\t}\n\t} catch (err) {\n\t\t_didIteratorError = true;\n\t\t_iteratorError = err;\n\t} finally {\n\t\ttry {\n\t\t\tif (!_iteratorNormalCompletion && _iterator.return) {\n\t\t\t\t_iterator.return();\n\t\t\t}\n\t\t} finally {\n\t\t\tif (_didIteratorError) {\n\t\t\t\tthrow _iteratorError;\n\t\t\t}\n\t\t}\n\t}\n\n\tvar basicLength = output.length;\n\tvar handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tvar m = maxInt;\n\t\tvar _iteratorNormalCompletion2 = true;\n\t\tvar _didIteratorError2 = false;\n\t\tvar _iteratorError2 = undefined;\n\n\t\ttry {\n\t\t\tfor (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n\t\t\t\tvar currentValue = _step2.value;\n\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow.\n\t\t} catch (err) {\n\t\t\t_didIteratorError2 = true;\n\t\t\t_iteratorError2 = err;\n\t\t} finally {\n\t\t\ttry {\n\t\t\t\tif (!_iteratorNormalCompletion2 && _iterator2.return) {\n\t\t\t\t\t_iterator2.return();\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tif (_didIteratorError2) {\n\t\t\t\t\tthrow _iteratorError2;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tvar handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror$1('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tvar _iteratorNormalCompletion3 = true;\n\t\tvar _didIteratorError3 = false;\n\t\tvar _iteratorError3 = undefined;\n\n\t\ttry {\n\t\t\tfor (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n\t\t\t\tvar _currentValue = _step3.value;\n\n\t\t\t\tif (_currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror$1('overflow');\n\t\t\t\t}\n\t\t\t\tif (_currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\t\tvar q = delta;\n\t\t\t\t\tfor (var k = base;; /* no condition */k += base) {\n\t\t\t\t\t\tvar t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tvar qMinusT = q - t;\n\t\t\t\t\t\tvar baseMinusT = base - t;\n\t\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (err) {\n\t\t\t_didIteratorError3 = true;\n\t\t\t_iteratorError3 = err;\n\t\t} finally {\n\t\t\ttry {\n\t\t\t\tif (!_iteratorNormalCompletion3 && _iterator3.return) {\n\t\t\t\t\t_iterator3.return();\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tif (_didIteratorError3) {\n\t\t\t\t\tthrow _iteratorError3;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n * it doesn't matter if you call it on a string that has already been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nvar toUnicode = function toUnicode(input) {\n\treturn mapDomain(input, function (string) {\n\t\treturn regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\n * i.e. it doesn't matter if you call it with a domain that's already in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nvar toASCII = function toASCII(input) {\n\treturn mapDomain(input, function (string) {\n\t\treturn regexNonASCII.test(string) ? 'xn--' + encode(string) : string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nvar punycode = {\n\t/**\n  * A string representing the current Punycode.js version number.\n  * @memberOf punycode\n  * @type String\n  */\n\t'version': '2.1.0',\n\t/**\n  * An object of methods to convert from JavaScript's internal character\n  * representation (UCS-2) to Unicode code points, and back.\n  * @see <https://mathiasbynens.be/notes/javascript-encoding>\n  * @memberOf punycode\n  * @type Object\n  */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\n/**\n * URI.js\n *\n * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript.\n * @author <a href=\"mailto:gary.court@gmail.com\">Gary Court</a>\n * @see http://github.com/garycourt/uri-js\n */\n/**\n * Copyright 2011 Gary Court. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without modification, are\n * permitted provided that the following conditions are met:\n *\n *    1. Redistributions of source code must retain the above copyright notice, this list of\n *       conditions and the following disclaimer.\n *\n *    2. Redistributions in binary form must reproduce the above copyright notice, this list\n *       of conditions and the following disclaimer in the documentation and/or other materials\n *       provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED\n * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND\n * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR\n * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\n * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * The views and conclusions contained in the software and documentation are those of the\n * authors and should not be interpreted as representing official policies, either expressed\n * or implied, of Gary Court.\n */\nvar SCHEMES = {};\nfunction pctEncChar(chr) {\n    var c = chr.charCodeAt(0);\n    var e = void 0;\n    if (c < 16) e = \"%0\" + c.toString(16).toUpperCase();else if (c < 128) e = \"%\" + c.toString(16).toUpperCase();else if (c < 2048) e = \"%\" + (c >> 6 | 192).toString(16).toUpperCase() + \"%\" + (c & 63 | 128).toString(16).toUpperCase();else e = \"%\" + (c >> 12 | 224).toString(16).toUpperCase() + \"%\" + (c >> 6 & 63 | 128).toString(16).toUpperCase() + \"%\" + (c & 63 | 128).toString(16).toUpperCase();\n    return e;\n}\nfunction pctDecChars(str) {\n    var newStr = \"\";\n    var i = 0;\n    var il = str.length;\n    while (i < il) {\n        var c = parseInt(str.substr(i + 1, 2), 16);\n        if (c < 128) {\n            newStr += String.fromCharCode(c);\n            i += 3;\n        } else if (c >= 194 && c < 224) {\n            if (il - i >= 6) {\n                var c2 = parseInt(str.substr(i + 4, 2), 16);\n                newStr += String.fromCharCode((c & 31) << 6 | c2 & 63);\n            } else {\n                newStr += str.substr(i, 6);\n            }\n            i += 6;\n        } else if (c >= 224) {\n            if (il - i >= 9) {\n                var _c = parseInt(str.substr(i + 4, 2), 16);\n                var c3 = parseInt(str.substr(i + 7, 2), 16);\n                newStr += String.fromCharCode((c & 15) << 12 | (_c & 63) << 6 | c3 & 63);\n            } else {\n                newStr += str.substr(i, 9);\n            }\n            i += 9;\n        } else {\n            newStr += str.substr(i, 3);\n            i += 3;\n        }\n    }\n    return newStr;\n}\nfunction _normalizeComponentEncoding(components, protocol) {\n    function decodeUnreserved(str) {\n        var decStr = pctDecChars(str);\n        return !decStr.match(protocol.UNRESERVED) ? str : decStr;\n    }\n    if (components.scheme) components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_SCHEME, \"\");\n    if (components.userinfo !== undefined) components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.host !== undefined) components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.path !== undefined) components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.query !== undefined) components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    if (components.fragment !== undefined) components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);\n    return components;\n}\n\nfunction _stripLeadingZeros(str) {\n    return str.replace(/^0*(.*)/, \"$1\") || \"0\";\n}\nfunction _normalizeIPv4(host, protocol) {\n    var matches = host.match(protocol.IPV4ADDRESS) || [];\n\n    var _matches = slicedToArray(matches, 2),\n        address = _matches[1];\n\n    if (address) {\n        return address.split(\".\").map(_stripLeadingZeros).join(\".\");\n    } else {\n        return host;\n    }\n}\nfunction _normalizeIPv6(host, protocol) {\n    var matches = host.match(protocol.IPV6ADDRESS) || [];\n\n    var _matches2 = slicedToArray(matches, 3),\n        address = _matches2[1],\n        zone = _matches2[2];\n\n    if (address) {\n        var _address$toLowerCase$ = address.toLowerCase().split('::').reverse(),\n            _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2),\n            last = _address$toLowerCase$2[0],\n            first = _address$toLowerCase$2[1];\n\n        var firstFields = first ? first.split(\":\").map(_stripLeadingZeros) : [];\n        var lastFields = last.split(\":\").map(_stripLeadingZeros);\n        var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);\n        var fieldCount = isLastFieldIPv4Address ? 7 : 8;\n        var lastFieldsStart = lastFields.length - fieldCount;\n        var fields = Array(fieldCount);\n        for (var x = 0; x < fieldCount; ++x) {\n            fields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || '';\n        }\n        if (isLastFieldIPv4Address) {\n            fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);\n        }\n        var allZeroFields = fields.reduce(function (acc, field, index) {\n            if (!field || field === \"0\") {\n                var lastLongest = acc[acc.length - 1];\n                if (lastLongest && lastLongest.index + lastLongest.length === index) {\n                    lastLongest.length++;\n                } else {\n                    acc.push({ index: index, length: 1 });\n                }\n            }\n            return acc;\n        }, []);\n        var longestZeroFields = allZeroFields.sort(function (a, b) {\n            return b.length - a.length;\n        })[0];\n        var newHost = void 0;\n        if (longestZeroFields && longestZeroFields.length > 1) {\n            var newFirst = fields.slice(0, longestZeroFields.index);\n            var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);\n            newHost = newFirst.join(\":\") + \"::\" + newLast.join(\":\");\n        } else {\n            newHost = fields.join(\":\");\n        }\n        if (zone) {\n            newHost += \"%\" + zone;\n        }\n        return newHost;\n    } else {\n        return host;\n    }\n}\nvar URI_PARSE = /^(?:([^:\\/?#]+):)?(?:\\/\\/((?:([^\\/?#@]*)@)?(\\[[^\\/?#\\]]+\\]|[^\\/?#:]*)(?:\\:(\\d*))?))?([^?#]*)(?:\\?([^#]*))?(?:#((?:.|\\n|\\r)*))?/i;\nvar NO_MATCH_IS_UNDEFINED = \"\".match(/(){0}/)[1] === undefined;\nfunction parse(uriString) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    var components = {};\n    var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;\n    if (options.reference === \"suffix\") uriString = (options.scheme ? options.scheme + \":\" : \"\") + \"//\" + uriString;\n    var matches = uriString.match(URI_PARSE);\n    if (matches) {\n        if (NO_MATCH_IS_UNDEFINED) {\n            //store each component\n            components.scheme = matches[1];\n            components.userinfo = matches[3];\n            components.host = matches[4];\n            components.port = parseInt(matches[5], 10);\n            components.path = matches[6] || \"\";\n            components.query = matches[7];\n            components.fragment = matches[8];\n            //fix port number\n            if (isNaN(components.port)) {\n                components.port = matches[5];\n            }\n        } else {\n            //IE FIX for improper RegExp matching\n            //store each component\n            components.scheme = matches[1] || undefined;\n            components.userinfo = uriString.indexOf(\"@\") !== -1 ? matches[3] : undefined;\n            components.host = uriString.indexOf(\"//\") !== -1 ? matches[4] : undefined;\n            components.port = parseInt(matches[5], 10);\n            components.path = matches[6] || \"\";\n            components.query = uriString.indexOf(\"?\") !== -1 ? matches[7] : undefined;\n            components.fragment = uriString.indexOf(\"#\") !== -1 ? matches[8] : undefined;\n            //fix port number\n            if (isNaN(components.port)) {\n                components.port = uriString.match(/\\/\\/(?:.|\\n)*\\:(?:\\/|\\?|\\#|$)/) ? matches[4] : undefined;\n            }\n        }\n        if (components.host) {\n            //normalize IP hosts\n            components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);\n        }\n        //determine reference type\n        if (components.scheme === undefined && components.userinfo === undefined && components.host === undefined && components.port === undefined && !components.path && components.query === undefined) {\n            components.reference = \"same-document\";\n        } else if (components.scheme === undefined) {\n            components.reference = \"relative\";\n        } else if (components.fragment === undefined) {\n            components.reference = \"absolute\";\n        } else {\n            components.reference = \"uri\";\n        }\n        //check for reference errors\n        if (options.reference && options.reference !== \"suffix\" && options.reference !== components.reference) {\n            components.error = components.error || \"URI is not a \" + options.reference + \" reference.\";\n        }\n        //find scheme handler\n        var schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n        //check if scheme can't handle IRIs\n        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {\n            //if host component is a domain name\n            if (components.host && (options.domainHost || schemeHandler && schemeHandler.domainHost)) {\n                //convert Unicode IDN -> ASCII IDN\n                try {\n                    components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());\n                } catch (e) {\n                    components.error = components.error || \"Host's domain name can not be converted to ASCII via punycode: \" + e;\n                }\n            }\n            //convert IRI -> URI\n            _normalizeComponentEncoding(components, URI_PROTOCOL);\n        } else {\n            //normalize encodings\n            _normalizeComponentEncoding(components, protocol);\n        }\n        //perform scheme specific parsing\n        if (schemeHandler && schemeHandler.parse) {\n            schemeHandler.parse(components, options);\n        }\n    } else {\n        components.error = components.error || \"URI can not be parsed.\";\n    }\n    return components;\n}\n\nfunction _recomposeAuthority(components, options) {\n    var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;\n    var uriTokens = [];\n    if (components.userinfo !== undefined) {\n        uriTokens.push(components.userinfo);\n        uriTokens.push(\"@\");\n    }\n    if (components.host !== undefined) {\n        //normalize IP hosts, add brackets and escape zone separator for IPv6\n        uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function (_, $1, $2) {\n            return \"[\" + $1 + ($2 ? \"%25\" + $2 : \"\") + \"]\";\n        }));\n    }\n    if (typeof components.port === \"number\" || typeof components.port === \"string\") {\n        uriTokens.push(\":\");\n        uriTokens.push(String(components.port));\n    }\n    return uriTokens.length ? uriTokens.join(\"\") : undefined;\n}\n\nvar RDS1 = /^\\.\\.?\\//;\nvar RDS2 = /^\\/\\.(\\/|$)/;\nvar RDS3 = /^\\/\\.\\.(\\/|$)/;\nvar RDS5 = /^\\/?(?:.|\\n)*?(?=\\/|$)/;\nfunction removeDotSegments(input) {\n    var output = [];\n    while (input.length) {\n        if (input.match(RDS1)) {\n            input = input.replace(RDS1, \"\");\n        } else if (input.match(RDS2)) {\n            input = input.replace(RDS2, \"/\");\n        } else if (input.match(RDS3)) {\n            input = input.replace(RDS3, \"/\");\n            output.pop();\n        } else if (input === \".\" || input === \"..\") {\n            input = \"\";\n        } else {\n            var im = input.match(RDS5);\n            if (im) {\n                var s = im[0];\n                input = input.slice(s.length);\n                output.push(s);\n            } else {\n                throw new Error(\"Unexpected dot segment condition\");\n            }\n        }\n    }\n    return output.join(\"\");\n}\n\nfunction serialize(components) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    var protocol = options.iri ? IRI_PROTOCOL : URI_PROTOCOL;\n    var uriTokens = [];\n    //find scheme handler\n    var schemeHandler = SCHEMES[(options.scheme || components.scheme || \"\").toLowerCase()];\n    //perform scheme specific serialization\n    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);\n    if (components.host) {\n        //if host component is an IPv6 address\n        if (protocol.IPV6ADDRESS.test(components.host)) {}\n        //TODO: normalize IPv6 address as per RFC 5952\n\n        //if host component is a domain name\n        else if (options.domainHost || schemeHandler && schemeHandler.domainHost) {\n                //convert IDN via punycode\n                try {\n                    components.host = !options.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host);\n                } catch (e) {\n                    components.error = components.error || \"Host's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n                }\n            }\n    }\n    //normalize encoding\n    _normalizeComponentEncoding(components, protocol);\n    if (options.reference !== \"suffix\" && components.scheme) {\n        uriTokens.push(components.scheme);\n        uriTokens.push(\":\");\n    }\n    var authority = _recomposeAuthority(components, options);\n    if (authority !== undefined) {\n        if (options.reference !== \"suffix\") {\n            uriTokens.push(\"//\");\n        }\n        uriTokens.push(authority);\n        if (components.path && components.path.charAt(0) !== \"/\") {\n            uriTokens.push(\"/\");\n        }\n    }\n    if (components.path !== undefined) {\n        var s = components.path;\n        if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {\n            s = removeDotSegments(s);\n        }\n        if (authority === undefined) {\n            s = s.replace(/^\\/\\//, \"/%2F\"); //don't allow the path to start with \"//\"\n        }\n        uriTokens.push(s);\n    }\n    if (components.query !== undefined) {\n        uriTokens.push(\"?\");\n        uriTokens.push(components.query);\n    }\n    if (components.fragment !== undefined) {\n        uriTokens.push(\"#\");\n        uriTokens.push(components.fragment);\n    }\n    return uriTokens.join(\"\"); //merge tokens into a string\n}\n\nfunction resolveComponents(base, relative) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var skipNormalization = arguments[3];\n\n    var target = {};\n    if (!skipNormalization) {\n        base = parse(serialize(base, options), options); //normalize base components\n        relative = parse(serialize(relative, options), options); //normalize relative components\n    }\n    options = options || {};\n    if (!options.tolerant && relative.scheme) {\n        target.scheme = relative.scheme;\n        //target.authority = relative.authority;\n        target.userinfo = relative.userinfo;\n        target.host = relative.host;\n        target.port = relative.port;\n        target.path = removeDotSegments(relative.path || \"\");\n        target.query = relative.query;\n    } else {\n        if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {\n            //target.authority = relative.authority;\n            target.userinfo = relative.userinfo;\n            target.host = relative.host;\n            target.port = relative.port;\n            target.path = removeDotSegments(relative.path || \"\");\n            target.query = relative.query;\n        } else {\n            if (!relative.path) {\n                target.path = base.path;\n                if (relative.query !== undefined) {\n                    target.query = relative.query;\n                } else {\n                    target.query = base.query;\n                }\n            } else {\n                if (relative.path.charAt(0) === \"/\") {\n                    target.path = removeDotSegments(relative.path);\n                } else {\n                    if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {\n                        target.path = \"/\" + relative.path;\n                    } else if (!base.path) {\n                        target.path = relative.path;\n                    } else {\n                        target.path = base.path.slice(0, base.path.lastIndexOf(\"/\") + 1) + relative.path;\n                    }\n                    target.path = removeDotSegments(target.path);\n                }\n                target.query = relative.query;\n            }\n            //target.authority = base.authority;\n            target.userinfo = base.userinfo;\n            target.host = base.host;\n            target.port = base.port;\n        }\n        target.scheme = base.scheme;\n    }\n    target.fragment = relative.fragment;\n    return target;\n}\n\nfunction resolve(baseURI, relativeURI, options) {\n    var schemelessOptions = assign({ scheme: 'null' }, options);\n    return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);\n}\n\nfunction normalize(uri, options) {\n    if (typeof uri === \"string\") {\n        uri = serialize(parse(uri, options), options);\n    } else if (typeOf(uri) === \"object\") {\n        uri = parse(serialize(uri, options), options);\n    }\n    return uri;\n}\n\nfunction equal(uriA, uriB, options) {\n    if (typeof uriA === \"string\") {\n        uriA = serialize(parse(uriA, options), options);\n    } else if (typeOf(uriA) === \"object\") {\n        uriA = serialize(uriA, options);\n    }\n    if (typeof uriB === \"string\") {\n        uriB = serialize(parse(uriB, options), options);\n    } else if (typeOf(uriB) === \"object\") {\n        uriB = serialize(uriB, options);\n    }\n    return uriA === uriB;\n}\n\nfunction escapeComponent(str, options) {\n    return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar);\n}\n\nfunction unescapeComponent(str, options) {\n    return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars);\n}\n\nvar handler = {\n    scheme: \"http\",\n    domainHost: true,\n    parse: function parse(components, options) {\n        //report missing host\n        if (!components.host) {\n            components.error = components.error || \"HTTP URIs must have a host.\";\n        }\n        return components;\n    },\n    serialize: function serialize(components, options) {\n        var secure = String(components.scheme).toLowerCase() === \"https\";\n        //normalize the default port\n        if (components.port === (secure ? 443 : 80) || components.port === \"\") {\n            components.port = undefined;\n        }\n        //normalize the empty path\n        if (!components.path) {\n            components.path = \"/\";\n        }\n        //NOTE: We do not parse query strings for HTTP URIs\n        //as WWW Form Url Encoded query strings are part of the HTML4+ spec,\n        //and not the HTTP spec.\n        return components;\n    }\n};\n\nvar handler$1 = {\n    scheme: \"https\",\n    domainHost: handler.domainHost,\n    parse: handler.parse,\n    serialize: handler.serialize\n};\n\nfunction isSecure(wsComponents) {\n    return typeof wsComponents.secure === 'boolean' ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === \"wss\";\n}\n//RFC 6455\nvar handler$2 = {\n    scheme: \"ws\",\n    domainHost: true,\n    parse: function parse(components, options) {\n        var wsComponents = components;\n        //indicate if the secure flag is set\n        wsComponents.secure = isSecure(wsComponents);\n        //construct resouce name\n        wsComponents.resourceName = (wsComponents.path || '/') + (wsComponents.query ? '?' + wsComponents.query : '');\n        wsComponents.path = undefined;\n        wsComponents.query = undefined;\n        return wsComponents;\n    },\n    serialize: function serialize(wsComponents, options) {\n        //normalize the default port\n        if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === \"\") {\n            wsComponents.port = undefined;\n        }\n        //ensure scheme matches secure flag\n        if (typeof wsComponents.secure === 'boolean') {\n            wsComponents.scheme = wsComponents.secure ? 'wss' : 'ws';\n            wsComponents.secure = undefined;\n        }\n        //reconstruct path from resource name\n        if (wsComponents.resourceName) {\n            var _wsComponents$resourc = wsComponents.resourceName.split('?'),\n                _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2),\n                path = _wsComponents$resourc2[0],\n                query = _wsComponents$resourc2[1];\n\n            wsComponents.path = path && path !== '/' ? path : undefined;\n            wsComponents.query = query;\n            wsComponents.resourceName = undefined;\n        }\n        //forbid fragment component\n        wsComponents.fragment = undefined;\n        return wsComponents;\n    }\n};\n\nvar handler$3 = {\n    scheme: \"wss\",\n    domainHost: handler$2.domainHost,\n    parse: handler$2.parse,\n    serialize: handler$2.serialize\n};\n\nvar O = {};\nvar isIRI = true;\n//RFC 3986\nvar UNRESERVED$$ = \"[A-Za-z0-9\\\\-\\\\.\\\\_\\\\~\" + (isIRI ? \"\\\\xA0-\\\\u200D\\\\u2010-\\\\u2029\\\\u202F-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF\" : \"\") + \"]\";\nvar HEXDIG$$ = \"[0-9A-Fa-f]\"; //case-insensitive\nvar PCT_ENCODED$ = subexp(subexp(\"%[EFef]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%[89A-Fa-f]\" + HEXDIG$$ + \"%\" + HEXDIG$$ + HEXDIG$$) + \"|\" + subexp(\"%\" + HEXDIG$$ + HEXDIG$$)); //expanded\n//RFC 5322, except these symbols as per RFC 6068: @ : / ? # [ ] & ; =\n//const ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\#\\\\$\\\\%\\\\&\\\\'\\\\*\\\\+\\\\-\\\\/\\\\=\\\\?\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QTEXT$$ = \"[\\\\x01-\\\\x08\\\\x0B\\\\x0C\\\\x0E-\\\\x1F\\\\x7F]\";  //(%d1-8 / %d11-12 / %d14-31 / %d127)\n//const QTEXT$$ = merge(\"[\\\\x21\\\\x23-\\\\x5B\\\\x5D-\\\\x7E]\", OBS_QTEXT$$);  //%d33 / %d35-91 / %d93-126 / obs-qtext\n//const VCHAR$$ = \"[\\\\x21-\\\\x7E]\";\n//const WSP$$ = \"[\\\\x20\\\\x09]\";\n//const OBS_QP$ = subexp(\"\\\\\\\\\" + merge(\"[\\\\x00\\\\x0D\\\\x0A]\", OBS_QTEXT$$));  //%d0 / CR / LF / obs-qtext\n//const FWS$ = subexp(subexp(WSP$$ + \"*\" + \"\\\\x0D\\\\x0A\") + \"?\" + WSP$$ + \"+\");\n//const QUOTED_PAIR$ = subexp(subexp(\"\\\\\\\\\" + subexp(VCHAR$$ + \"|\" + WSP$$)) + \"|\" + OBS_QP$);\n//const QUOTED_STRING$ = subexp('\\\\\"' + subexp(FWS$ + \"?\" + QCONTENT$) + \"*\" + FWS$ + \"?\" + '\\\\\"');\nvar ATEXT$$ = \"[A-Za-z0-9\\\\!\\\\$\\\\%\\\\'\\\\*\\\\+\\\\-\\\\^\\\\_\\\\`\\\\{\\\\|\\\\}\\\\~]\";\nvar QTEXT$$ = \"[\\\\!\\\\$\\\\%\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\-\\\\.0-9\\\\<\\\\>A-Z\\\\x5E-\\\\x7E]\";\nvar VCHAR$$ = merge(QTEXT$$, \"[\\\\\\\"\\\\\\\\]\");\nvar SOME_DELIMS$$ = \"[\\\\!\\\\$\\\\'\\\\(\\\\)\\\\*\\\\+\\\\,\\\\;\\\\:\\\\@]\";\nvar UNRESERVED = new RegExp(UNRESERVED$$, \"g\");\nvar PCT_ENCODED = new RegExp(PCT_ENCODED$, \"g\");\nvar NOT_LOCAL_PART = new RegExp(merge(\"[^]\", ATEXT$$, \"[\\\\.]\", '[\\\\\"]', VCHAR$$), \"g\");\nvar NOT_HFNAME = new RegExp(merge(\"[^]\", UNRESERVED$$, SOME_DELIMS$$), \"g\");\nvar NOT_HFVALUE = NOT_HFNAME;\nfunction decodeUnreserved(str) {\n    var decStr = pctDecChars(str);\n    return !decStr.match(UNRESERVED) ? str : decStr;\n}\nvar handler$4 = {\n    scheme: \"mailto\",\n    parse: function parse$$1(components, options) {\n        var mailtoComponents = components;\n        var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(\",\") : [];\n        mailtoComponents.path = undefined;\n        if (mailtoComponents.query) {\n            var unknownHeaders = false;\n            var headers = {};\n            var hfields = mailtoComponents.query.split(\"&\");\n            for (var x = 0, xl = hfields.length; x < xl; ++x) {\n                var hfield = hfields[x].split(\"=\");\n                switch (hfield[0]) {\n                    case \"to\":\n                        var toAddrs = hfield[1].split(\",\");\n                        for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) {\n                            to.push(toAddrs[_x]);\n                        }\n                        break;\n                    case \"subject\":\n                        mailtoComponents.subject = unescapeComponent(hfield[1], options);\n                        break;\n                    case \"body\":\n                        mailtoComponents.body = unescapeComponent(hfield[1], options);\n                        break;\n                    default:\n                        unknownHeaders = true;\n                        headers[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options);\n                        break;\n                }\n            }\n            if (unknownHeaders) mailtoComponents.headers = headers;\n        }\n        mailtoComponents.query = undefined;\n        for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) {\n            var addr = to[_x2].split(\"@\");\n            addr[0] = unescapeComponent(addr[0]);\n            if (!options.unicodeSupport) {\n                //convert Unicode IDN -> ASCII IDN\n                try {\n                    addr[1] = punycode.toASCII(unescapeComponent(addr[1], options).toLowerCase());\n                } catch (e) {\n                    mailtoComponents.error = mailtoComponents.error || \"Email address's domain name can not be converted to ASCII via punycode: \" + e;\n                }\n            } else {\n                addr[1] = unescapeComponent(addr[1], options).toLowerCase();\n            }\n            to[_x2] = addr.join(\"@\");\n        }\n        return mailtoComponents;\n    },\n    serialize: function serialize$$1(mailtoComponents, options) {\n        var components = mailtoComponents;\n        var to = toArray(mailtoComponents.to);\n        if (to) {\n            for (var x = 0, xl = to.length; x < xl; ++x) {\n                var toAddr = String(to[x]);\n                var atIdx = toAddr.lastIndexOf(\"@\");\n                var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);\n                var domain = toAddr.slice(atIdx + 1);\n                //convert IDN via punycode\n                try {\n                    domain = !options.iri ? punycode.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode.toUnicode(domain);\n                } catch (e) {\n                    components.error = components.error || \"Email address's domain name can not be converted to \" + (!options.iri ? \"ASCII\" : \"Unicode\") + \" via punycode: \" + e;\n                }\n                to[x] = localPart + \"@\" + domain;\n            }\n            components.path = to.join(\",\");\n        }\n        var headers = mailtoComponents.headers = mailtoComponents.headers || {};\n        if (mailtoComponents.subject) headers[\"subject\"] = mailtoComponents.subject;\n        if (mailtoComponents.body) headers[\"body\"] = mailtoComponents.body;\n        var fields = [];\n        for (var name in headers) {\n            if (headers[name] !== O[name]) {\n                fields.push(name.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) + \"=\" + headers[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar));\n            }\n        }\n        if (fields.length) {\n            components.query = fields.join(\"&\");\n        }\n        return components;\n    }\n};\n\nvar URN_PARSE = /^([^\\:]+)\\:(.*)/;\n//RFC 2141\nvar handler$5 = {\n    scheme: \"urn\",\n    parse: function parse$$1(components, options) {\n        var matches = components.path && components.path.match(URN_PARSE);\n        var urnComponents = components;\n        if (matches) {\n            var scheme = options.scheme || urnComponents.scheme || \"urn\";\n            var nid = matches[1].toLowerCase();\n            var nss = matches[2];\n            var urnScheme = scheme + \":\" + (options.nid || nid);\n            var schemeHandler = SCHEMES[urnScheme];\n            urnComponents.nid = nid;\n            urnComponents.nss = nss;\n            urnComponents.path = undefined;\n            if (schemeHandler) {\n                urnComponents = schemeHandler.parse(urnComponents, options);\n            }\n        } else {\n            urnComponents.error = urnComponents.error || \"URN can not be parsed.\";\n        }\n        return urnComponents;\n    },\n    serialize: function serialize$$1(urnComponents, options) {\n        var scheme = options.scheme || urnComponents.scheme || \"urn\";\n        var nid = urnComponents.nid;\n        var urnScheme = scheme + \":\" + (options.nid || nid);\n        var schemeHandler = SCHEMES[urnScheme];\n        if (schemeHandler) {\n            urnComponents = schemeHandler.serialize(urnComponents, options);\n        }\n        var uriComponents = urnComponents;\n        var nss = urnComponents.nss;\n        uriComponents.path = (nid || options.nid) + \":\" + nss;\n        return uriComponents;\n    }\n};\n\nvar UUID = /^[0-9A-Fa-f]{8}(?:\\-[0-9A-Fa-f]{4}){3}\\-[0-9A-Fa-f]{12}$/;\n//RFC 4122\nvar handler$6 = {\n    scheme: \"urn:uuid\",\n    parse: function parse(urnComponents, options) {\n        var uuidComponents = urnComponents;\n        uuidComponents.uuid = uuidComponents.nss;\n        uuidComponents.nss = undefined;\n        if (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {\n            uuidComponents.error = uuidComponents.error || \"UUID is not valid.\";\n        }\n        return uuidComponents;\n    },\n    serialize: function serialize(uuidComponents, options) {\n        var urnComponents = uuidComponents;\n        //normalize UUID\n        urnComponents.nss = (uuidComponents.uuid || \"\").toLowerCase();\n        return urnComponents;\n    }\n};\n\nSCHEMES[handler.scheme] = handler;\nSCHEMES[handler$1.scheme] = handler$1;\nSCHEMES[handler$2.scheme] = handler$2;\nSCHEMES[handler$3.scheme] = handler$3;\nSCHEMES[handler$4.scheme] = handler$4;\nSCHEMES[handler$5.scheme] = handler$5;\nSCHEMES[handler$6.scheme] = handler$6;\n\nexports.SCHEMES = SCHEMES;\nexports.pctEncChar = pctEncChar;\nexports.pctDecChars = pctDecChars;\nexports.parse = parse;\nexports.removeDotSegments = removeDotSegments;\nexports.serialize = serialize;\nexports.resolveComponents = resolveComponents;\nexports.resolve = resolve;\nexports.normalize = normalize;\nexports.equal = equal;\nexports.escapeComponent = escapeComponent;\nexports.unescapeComponent = unescapeComponent;\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=uri.all.js.map\n","(function(nacl) {\n'use strict';\n\n// Ported in 2014 by Dmitry Chestnykh and Devi Mandiri.\n// Public domain.\n//\n// Implementation derived from TweetNaCl version 20140427.\n// See for details: http://tweetnacl.cr.yp.to/\n\nvar gf = function(init) {\n  var i, r = new Float64Array(16);\n  if (init) for (i = 0; i < init.length; i++) r[i] = init[i];\n  return r;\n};\n\n//  Pluggable, initialized in high-level API below.\nvar randombytes = function(/* x, n */) { throw new Error('no PRNG'); };\n\nvar _0 = new Uint8Array(16);\nvar _9 = new Uint8Array(32); _9[0] = 9;\n\nvar gf0 = gf(),\n    gf1 = gf([1]),\n    _121665 = gf([0xdb41, 1]),\n    D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]),\n    D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]),\n    X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]),\n    Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]),\n    I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);\n\nfunction ts64(x, i, h, l) {\n  x[i]   = (h >> 24) & 0xff;\n  x[i+1] = (h >> 16) & 0xff;\n  x[i+2] = (h >>  8) & 0xff;\n  x[i+3] = h & 0xff;\n  x[i+4] = (l >> 24)  & 0xff;\n  x[i+5] = (l >> 16)  & 0xff;\n  x[i+6] = (l >>  8)  & 0xff;\n  x[i+7] = l & 0xff;\n}\n\nfunction vn(x, xi, y, yi, n) {\n  var i,d = 0;\n  for (i = 0; i < n; i++) d |= x[xi+i]^y[yi+i];\n  return (1 & ((d - 1) >>> 8)) - 1;\n}\n\nfunction crypto_verify_16(x, xi, y, yi) {\n  return vn(x,xi,y,yi,16);\n}\n\nfunction crypto_verify_32(x, xi, y, yi) {\n  return vn(x,xi,y,yi,32);\n}\n\nfunction core_salsa20(o, p, k, c) {\n  var j0  = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,\n      j1  = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,\n      j2  = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,\n      j3  = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,\n      j4  = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,\n      j5  = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,\n      j6  = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,\n      j7  = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,\n      j8  = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,\n      j9  = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,\n      j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,\n      j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,\n      j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,\n      j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,\n      j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,\n      j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;\n\n  var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,\n      x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,\n      x15 = j15, u;\n\n  for (var i = 0; i < 20; i += 2) {\n    u = x0 + x12 | 0;\n    x4 ^= u<<7 | u>>>(32-7);\n    u = x4 + x0 | 0;\n    x8 ^= u<<9 | u>>>(32-9);\n    u = x8 + x4 | 0;\n    x12 ^= u<<13 | u>>>(32-13);\n    u = x12 + x8 | 0;\n    x0 ^= u<<18 | u>>>(32-18);\n\n    u = x5 + x1 | 0;\n    x9 ^= u<<7 | u>>>(32-7);\n    u = x9 + x5 | 0;\n    x13 ^= u<<9 | u>>>(32-9);\n    u = x13 + x9 | 0;\n    x1 ^= u<<13 | u>>>(32-13);\n    u = x1 + x13 | 0;\n    x5 ^= u<<18 | u>>>(32-18);\n\n    u = x10 + x6 | 0;\n    x14 ^= u<<7 | u>>>(32-7);\n    u = x14 + x10 | 0;\n    x2 ^= u<<9 | u>>>(32-9);\n    u = x2 + x14 | 0;\n    x6 ^= u<<13 | u>>>(32-13);\n    u = x6 + x2 | 0;\n    x10 ^= u<<18 | u>>>(32-18);\n\n    u = x15 + x11 | 0;\n    x3 ^= u<<7 | u>>>(32-7);\n    u = x3 + x15 | 0;\n    x7 ^= u<<9 | u>>>(32-9);\n    u = x7 + x3 | 0;\n    x11 ^= u<<13 | u>>>(32-13);\n    u = x11 + x7 | 0;\n    x15 ^= u<<18 | u>>>(32-18);\n\n    u = x0 + x3 | 0;\n    x1 ^= u<<7 | u>>>(32-7);\n    u = x1 + x0 | 0;\n    x2 ^= u<<9 | u>>>(32-9);\n    u = x2 + x1 | 0;\n    x3 ^= u<<13 | u>>>(32-13);\n    u = x3 + x2 | 0;\n    x0 ^= u<<18 | u>>>(32-18);\n\n    u = x5 + x4 | 0;\n    x6 ^= u<<7 | u>>>(32-7);\n    u = x6 + x5 | 0;\n    x7 ^= u<<9 | u>>>(32-9);\n    u = x7 + x6 | 0;\n    x4 ^= u<<13 | u>>>(32-13);\n    u = x4 + x7 | 0;\n    x5 ^= u<<18 | u>>>(32-18);\n\n    u = x10 + x9 | 0;\n    x11 ^= u<<7 | u>>>(32-7);\n    u = x11 + x10 | 0;\n    x8 ^= u<<9 | u>>>(32-9);\n    u = x8 + x11 | 0;\n    x9 ^= u<<13 | u>>>(32-13);\n    u = x9 + x8 | 0;\n    x10 ^= u<<18 | u>>>(32-18);\n\n    u = x15 + x14 | 0;\n    x12 ^= u<<7 | u>>>(32-7);\n    u = x12 + x15 | 0;\n    x13 ^= u<<9 | u>>>(32-9);\n    u = x13 + x12 | 0;\n    x14 ^= u<<13 | u>>>(32-13);\n    u = x14 + x13 | 0;\n    x15 ^= u<<18 | u>>>(32-18);\n  }\n   x0 =  x0 +  j0 | 0;\n   x1 =  x1 +  j1 | 0;\n   x2 =  x2 +  j2 | 0;\n   x3 =  x3 +  j3 | 0;\n   x4 =  x4 +  j4 | 0;\n   x5 =  x5 +  j5 | 0;\n   x6 =  x6 +  j6 | 0;\n   x7 =  x7 +  j7 | 0;\n   x8 =  x8 +  j8 | 0;\n   x9 =  x9 +  j9 | 0;\n  x10 = x10 + j10 | 0;\n  x11 = x11 + j11 | 0;\n  x12 = x12 + j12 | 0;\n  x13 = x13 + j13 | 0;\n  x14 = x14 + j14 | 0;\n  x15 = x15 + j15 | 0;\n\n  o[ 0] = x0 >>>  0 & 0xff;\n  o[ 1] = x0 >>>  8 & 0xff;\n  o[ 2] = x0 >>> 16 & 0xff;\n  o[ 3] = x0 >>> 24 & 0xff;\n\n  o[ 4] = x1 >>>  0 & 0xff;\n  o[ 5] = x1 >>>  8 & 0xff;\n  o[ 6] = x1 >>> 16 & 0xff;\n  o[ 7] = x1 >>> 24 & 0xff;\n\n  o[ 8] = x2 >>>  0 & 0xff;\n  o[ 9] = x2 >>>  8 & 0xff;\n  o[10] = x2 >>> 16 & 0xff;\n  o[11] = x2 >>> 24 & 0xff;\n\n  o[12] = x3 >>>  0 & 0xff;\n  o[13] = x3 >>>  8 & 0xff;\n  o[14] = x3 >>> 16 & 0xff;\n  o[15] = x3 >>> 24 & 0xff;\n\n  o[16] = x4 >>>  0 & 0xff;\n  o[17] = x4 >>>  8 & 0xff;\n  o[18] = x4 >>> 16 & 0xff;\n  o[19] = x4 >>> 24 & 0xff;\n\n  o[20] = x5 >>>  0 & 0xff;\n  o[21] = x5 >>>  8 & 0xff;\n  o[22] = x5 >>> 16 & 0xff;\n  o[23] = x5 >>> 24 & 0xff;\n\n  o[24] = x6 >>>  0 & 0xff;\n  o[25] = x6 >>>  8 & 0xff;\n  o[26] = x6 >>> 16 & 0xff;\n  o[27] = x6 >>> 24 & 0xff;\n\n  o[28] = x7 >>>  0 & 0xff;\n  o[29] = x7 >>>  8 & 0xff;\n  o[30] = x7 >>> 16 & 0xff;\n  o[31] = x7 >>> 24 & 0xff;\n\n  o[32] = x8 >>>  0 & 0xff;\n  o[33] = x8 >>>  8 & 0xff;\n  o[34] = x8 >>> 16 & 0xff;\n  o[35] = x8 >>> 24 & 0xff;\n\n  o[36] = x9 >>>  0 & 0xff;\n  o[37] = x9 >>>  8 & 0xff;\n  o[38] = x9 >>> 16 & 0xff;\n  o[39] = x9 >>> 24 & 0xff;\n\n  o[40] = x10 >>>  0 & 0xff;\n  o[41] = x10 >>>  8 & 0xff;\n  o[42] = x10 >>> 16 & 0xff;\n  o[43] = x10 >>> 24 & 0xff;\n\n  o[44] = x11 >>>  0 & 0xff;\n  o[45] = x11 >>>  8 & 0xff;\n  o[46] = x11 >>> 16 & 0xff;\n  o[47] = x11 >>> 24 & 0xff;\n\n  o[48] = x12 >>>  0 & 0xff;\n  o[49] = x12 >>>  8 & 0xff;\n  o[50] = x12 >>> 16 & 0xff;\n  o[51] = x12 >>> 24 & 0xff;\n\n  o[52] = x13 >>>  0 & 0xff;\n  o[53] = x13 >>>  8 & 0xff;\n  o[54] = x13 >>> 16 & 0xff;\n  o[55] = x13 >>> 24 & 0xff;\n\n  o[56] = x14 >>>  0 & 0xff;\n  o[57] = x14 >>>  8 & 0xff;\n  o[58] = x14 >>> 16 & 0xff;\n  o[59] = x14 >>> 24 & 0xff;\n\n  o[60] = x15 >>>  0 & 0xff;\n  o[61] = x15 >>>  8 & 0xff;\n  o[62] = x15 >>> 16 & 0xff;\n  o[63] = x15 >>> 24 & 0xff;\n}\n\nfunction core_hsalsa20(o,p,k,c) {\n  var j0  = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,\n      j1  = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,\n      j2  = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,\n      j3  = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,\n      j4  = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,\n      j5  = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,\n      j6  = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,\n      j7  = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,\n      j8  = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,\n      j9  = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,\n      j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,\n      j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,\n      j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,\n      j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,\n      j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,\n      j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;\n\n  var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,\n      x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,\n      x15 = j15, u;\n\n  for (var i = 0; i < 20; i += 2) {\n    u = x0 + x12 | 0;\n    x4 ^= u<<7 | u>>>(32-7);\n    u = x4 + x0 | 0;\n    x8 ^= u<<9 | u>>>(32-9);\n    u = x8 + x4 | 0;\n    x12 ^= u<<13 | u>>>(32-13);\n    u = x12 + x8 | 0;\n    x0 ^= u<<18 | u>>>(32-18);\n\n    u = x5 + x1 | 0;\n    x9 ^= u<<7 | u>>>(32-7);\n    u = x9 + x5 | 0;\n    x13 ^= u<<9 | u>>>(32-9);\n    u = x13 + x9 | 0;\n    x1 ^= u<<13 | u>>>(32-13);\n    u = x1 + x13 | 0;\n    x5 ^= u<<18 | u>>>(32-18);\n\n    u = x10 + x6 | 0;\n    x14 ^= u<<7 | u>>>(32-7);\n    u = x14 + x10 | 0;\n    x2 ^= u<<9 | u>>>(32-9);\n    u = x2 + x14 | 0;\n    x6 ^= u<<13 | u>>>(32-13);\n    u = x6 + x2 | 0;\n    x10 ^= u<<18 | u>>>(32-18);\n\n    u = x15 + x11 | 0;\n    x3 ^= u<<7 | u>>>(32-7);\n    u = x3 + x15 | 0;\n    x7 ^= u<<9 | u>>>(32-9);\n    u = x7 + x3 | 0;\n    x11 ^= u<<13 | u>>>(32-13);\n    u = x11 + x7 | 0;\n    x15 ^= u<<18 | u>>>(32-18);\n\n    u = x0 + x3 | 0;\n    x1 ^= u<<7 | u>>>(32-7);\n    u = x1 + x0 | 0;\n    x2 ^= u<<9 | u>>>(32-9);\n    u = x2 + x1 | 0;\n    x3 ^= u<<13 | u>>>(32-13);\n    u = x3 + x2 | 0;\n    x0 ^= u<<18 | u>>>(32-18);\n\n    u = x5 + x4 | 0;\n    x6 ^= u<<7 | u>>>(32-7);\n    u = x6 + x5 | 0;\n    x7 ^= u<<9 | u>>>(32-9);\n    u = x7 + x6 | 0;\n    x4 ^= u<<13 | u>>>(32-13);\n    u = x4 + x7 | 0;\n    x5 ^= u<<18 | u>>>(32-18);\n\n    u = x10 + x9 | 0;\n    x11 ^= u<<7 | u>>>(32-7);\n    u = x11 + x10 | 0;\n    x8 ^= u<<9 | u>>>(32-9);\n    u = x8 + x11 | 0;\n    x9 ^= u<<13 | u>>>(32-13);\n    u = x9 + x8 | 0;\n    x10 ^= u<<18 | u>>>(32-18);\n\n    u = x15 + x14 | 0;\n    x12 ^= u<<7 | u>>>(32-7);\n    u = x12 + x15 | 0;\n    x13 ^= u<<9 | u>>>(32-9);\n    u = x13 + x12 | 0;\n    x14 ^= u<<13 | u>>>(32-13);\n    u = x14 + x13 | 0;\n    x15 ^= u<<18 | u>>>(32-18);\n  }\n\n  o[ 0] = x0 >>>  0 & 0xff;\n  o[ 1] = x0 >>>  8 & 0xff;\n  o[ 2] = x0 >>> 16 & 0xff;\n  o[ 3] = x0 >>> 24 & 0xff;\n\n  o[ 4] = x5 >>>  0 & 0xff;\n  o[ 5] = x5 >>>  8 & 0xff;\n  o[ 6] = x5 >>> 16 & 0xff;\n  o[ 7] = x5 >>> 24 & 0xff;\n\n  o[ 8] = x10 >>>  0 & 0xff;\n  o[ 9] = x10 >>>  8 & 0xff;\n  o[10] = x10 >>> 16 & 0xff;\n  o[11] = x10 >>> 24 & 0xff;\n\n  o[12] = x15 >>>  0 & 0xff;\n  o[13] = x15 >>>  8 & 0xff;\n  o[14] = x15 >>> 16 & 0xff;\n  o[15] = x15 >>> 24 & 0xff;\n\n  o[16] = x6 >>>  0 & 0xff;\n  o[17] = x6 >>>  8 & 0xff;\n  o[18] = x6 >>> 16 & 0xff;\n  o[19] = x6 >>> 24 & 0xff;\n\n  o[20] = x7 >>>  0 & 0xff;\n  o[21] = x7 >>>  8 & 0xff;\n  o[22] = x7 >>> 16 & 0xff;\n  o[23] = x7 >>> 24 & 0xff;\n\n  o[24] = x8 >>>  0 & 0xff;\n  o[25] = x8 >>>  8 & 0xff;\n  o[26] = x8 >>> 16 & 0xff;\n  o[27] = x8 >>> 24 & 0xff;\n\n  o[28] = x9 >>>  0 & 0xff;\n  o[29] = x9 >>>  8 & 0xff;\n  o[30] = x9 >>> 16 & 0xff;\n  o[31] = x9 >>> 24 & 0xff;\n}\n\nfunction crypto_core_salsa20(out,inp,k,c) {\n  core_salsa20(out,inp,k,c);\n}\n\nfunction crypto_core_hsalsa20(out,inp,k,c) {\n  core_hsalsa20(out,inp,k,c);\n}\n\nvar sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);\n            // \"expand 32-byte k\"\n\nfunction crypto_stream_salsa20_xor(c,cpos,m,mpos,b,n,k) {\n  var z = new Uint8Array(16), x = new Uint8Array(64);\n  var u, i;\n  for (i = 0; i < 16; i++) z[i] = 0;\n  for (i = 0; i < 8; i++) z[i] = n[i];\n  while (b >= 64) {\n    crypto_core_salsa20(x,z,k,sigma);\n    for (i = 0; i < 64; i++) c[cpos+i] = m[mpos+i] ^ x[i];\n    u = 1;\n    for (i = 8; i < 16; i++) {\n      u = u + (z[i] & 0xff) | 0;\n      z[i] = u & 0xff;\n      u >>>= 8;\n    }\n    b -= 64;\n    cpos += 64;\n    mpos += 64;\n  }\n  if (b > 0) {\n    crypto_core_salsa20(x,z,k,sigma);\n    for (i = 0; i < b; i++) c[cpos+i] = m[mpos+i] ^ x[i];\n  }\n  return 0;\n}\n\nfunction crypto_stream_salsa20(c,cpos,b,n,k) {\n  var z = new Uint8Array(16), x = new Uint8Array(64);\n  var u, i;\n  for (i = 0; i < 16; i++) z[i] = 0;\n  for (i = 0; i < 8; i++) z[i] = n[i];\n  while (b >= 64) {\n    crypto_core_salsa20(x,z,k,sigma);\n    for (i = 0; i < 64; i++) c[cpos+i] = x[i];\n    u = 1;\n    for (i = 8; i < 16; i++) {\n      u = u + (z[i] & 0xff) | 0;\n      z[i] = u & 0xff;\n      u >>>= 8;\n    }\n    b -= 64;\n    cpos += 64;\n  }\n  if (b > 0) {\n    crypto_core_salsa20(x,z,k,sigma);\n    for (i = 0; i < b; i++) c[cpos+i] = x[i];\n  }\n  return 0;\n}\n\nfunction crypto_stream(c,cpos,d,n,k) {\n  var s = new Uint8Array(32);\n  crypto_core_hsalsa20(s,n,k,sigma);\n  var sn = new Uint8Array(8);\n  for (var i = 0; i < 8; i++) sn[i] = n[i+16];\n  return crypto_stream_salsa20(c,cpos,d,sn,s);\n}\n\nfunction crypto_stream_xor(c,cpos,m,mpos,d,n,k) {\n  var s = new Uint8Array(32);\n  crypto_core_hsalsa20(s,n,k,sigma);\n  var sn = new Uint8Array(8);\n  for (var i = 0; i < 8; i++) sn[i] = n[i+16];\n  return crypto_stream_salsa20_xor(c,cpos,m,mpos,d,sn,s);\n}\n\n/*\n* Port of Andrew Moon's Poly1305-donna-16. Public domain.\n* https://github.com/floodyberry/poly1305-donna\n*/\n\nvar poly1305 = function(key) {\n  this.buffer = new Uint8Array(16);\n  this.r = new Uint16Array(10);\n  this.h = new Uint16Array(10);\n  this.pad = new Uint16Array(8);\n  this.leftover = 0;\n  this.fin = 0;\n\n  var t0, t1, t2, t3, t4, t5, t6, t7;\n\n  t0 = key[ 0] & 0xff | (key[ 1] & 0xff) << 8; this.r[0] = ( t0                     ) & 0x1fff;\n  t1 = key[ 2] & 0xff | (key[ 3] & 0xff) << 8; this.r[1] = ((t0 >>> 13) | (t1 <<  3)) & 0x1fff;\n  t2 = key[ 4] & 0xff | (key[ 5] & 0xff) << 8; this.r[2] = ((t1 >>> 10) | (t2 <<  6)) & 0x1f03;\n  t3 = key[ 6] & 0xff | (key[ 7] & 0xff) << 8; this.r[3] = ((t2 >>>  7) | (t3 <<  9)) & 0x1fff;\n  t4 = key[ 8] & 0xff | (key[ 9] & 0xff) << 8; this.r[4] = ((t3 >>>  4) | (t4 << 12)) & 0x00ff;\n  this.r[5] = ((t4 >>>  1)) & 0x1ffe;\n  t5 = key[10] & 0xff | (key[11] & 0xff) << 8; this.r[6] = ((t4 >>> 14) | (t5 <<  2)) & 0x1fff;\n  t6 = key[12] & 0xff | (key[13] & 0xff) << 8; this.r[7] = ((t5 >>> 11) | (t6 <<  5)) & 0x1f81;\n  t7 = key[14] & 0xff | (key[15] & 0xff) << 8; this.r[8] = ((t6 >>>  8) | (t7 <<  8)) & 0x1fff;\n  this.r[9] = ((t7 >>>  5)) & 0x007f;\n\n  this.pad[0] = key[16] & 0xff | (key[17] & 0xff) << 8;\n  this.pad[1] = key[18] & 0xff | (key[19] & 0xff) << 8;\n  this.pad[2] = key[20] & 0xff | (key[21] & 0xff) << 8;\n  this.pad[3] = key[22] & 0xff | (key[23] & 0xff) << 8;\n  this.pad[4] = key[24] & 0xff | (key[25] & 0xff) << 8;\n  this.pad[5] = key[26] & 0xff | (key[27] & 0xff) << 8;\n  this.pad[6] = key[28] & 0xff | (key[29] & 0xff) << 8;\n  this.pad[7] = key[30] & 0xff | (key[31] & 0xff) << 8;\n};\n\npoly1305.prototype.blocks = function(m, mpos, bytes) {\n  var hibit = this.fin ? 0 : (1 << 11);\n  var t0, t1, t2, t3, t4, t5, t6, t7, c;\n  var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9;\n\n  var h0 = this.h[0],\n      h1 = this.h[1],\n      h2 = this.h[2],\n      h3 = this.h[3],\n      h4 = this.h[4],\n      h5 = this.h[5],\n      h6 = this.h[6],\n      h7 = this.h[7],\n      h8 = this.h[8],\n      h9 = this.h[9];\n\n  var r0 = this.r[0],\n      r1 = this.r[1],\n      r2 = this.r[2],\n      r3 = this.r[3],\n      r4 = this.r[4],\n      r5 = this.r[5],\n      r6 = this.r[6],\n      r7 = this.r[7],\n      r8 = this.r[8],\n      r9 = this.r[9];\n\n  while (bytes >= 16) {\n    t0 = m[mpos+ 0] & 0xff | (m[mpos+ 1] & 0xff) << 8; h0 += ( t0                     ) & 0x1fff;\n    t1 = m[mpos+ 2] & 0xff | (m[mpos+ 3] & 0xff) << 8; h1 += ((t0 >>> 13) | (t1 <<  3)) & 0x1fff;\n    t2 = m[mpos+ 4] & 0xff | (m[mpos+ 5] & 0xff) << 8; h2 += ((t1 >>> 10) | (t2 <<  6)) & 0x1fff;\n    t3 = m[mpos+ 6] & 0xff | (m[mpos+ 7] & 0xff) << 8; h3 += ((t2 >>>  7) | (t3 <<  9)) & 0x1fff;\n    t4 = m[mpos+ 8] & 0xff | (m[mpos+ 9] & 0xff) << 8; h4 += ((t3 >>>  4) | (t4 << 12)) & 0x1fff;\n    h5 += ((t4 >>>  1)) & 0x1fff;\n    t5 = m[mpos+10] & 0xff | (m[mpos+11] & 0xff) << 8; h6 += ((t4 >>> 14) | (t5 <<  2)) & 0x1fff;\n    t6 = m[mpos+12] & 0xff | (m[mpos+13] & 0xff) << 8; h7 += ((t5 >>> 11) | (t6 <<  5)) & 0x1fff;\n    t7 = m[mpos+14] & 0xff | (m[mpos+15] & 0xff) << 8; h8 += ((t6 >>>  8) | (t7 <<  8)) & 0x1fff;\n    h9 += ((t7 >>> 5)) | hibit;\n\n    c = 0;\n\n    d0 = c;\n    d0 += h0 * r0;\n    d0 += h1 * (5 * r9);\n    d0 += h2 * (5 * r8);\n    d0 += h3 * (5 * r7);\n    d0 += h4 * (5 * r6);\n    c = (d0 >>> 13); d0 &= 0x1fff;\n    d0 += h5 * (5 * r5);\n    d0 += h6 * (5 * r4);\n    d0 += h7 * (5 * r3);\n    d0 += h8 * (5 * r2);\n    d0 += h9 * (5 * r1);\n    c += (d0 >>> 13); d0 &= 0x1fff;\n\n    d1 = c;\n    d1 += h0 * r1;\n    d1 += h1 * r0;\n    d1 += h2 * (5 * r9);\n    d1 += h3 * (5 * r8);\n    d1 += h4 * (5 * r7);\n    c = (d1 >>> 13); d1 &= 0x1fff;\n    d1 += h5 * (5 * r6);\n    d1 += h6 * (5 * r5);\n    d1 += h7 * (5 * r4);\n    d1 += h8 * (5 * r3);\n    d1 += h9 * (5 * r2);\n    c += (d1 >>> 13); d1 &= 0x1fff;\n\n    d2 = c;\n    d2 += h0 * r2;\n    d2 += h1 * r1;\n    d2 += h2 * r0;\n    d2 += h3 * (5 * r9);\n    d2 += h4 * (5 * r8);\n    c = (d2 >>> 13); d2 &= 0x1fff;\n    d2 += h5 * (5 * r7);\n    d2 += h6 * (5 * r6);\n    d2 += h7 * (5 * r5);\n    d2 += h8 * (5 * r4);\n    d2 += h9 * (5 * r3);\n    c += (d2 >>> 13); d2 &= 0x1fff;\n\n    d3 = c;\n    d3 += h0 * r3;\n    d3 += h1 * r2;\n    d3 += h2 * r1;\n    d3 += h3 * r0;\n    d3 += h4 * (5 * r9);\n    c = (d3 >>> 13); d3 &= 0x1fff;\n    d3 += h5 * (5 * r8);\n    d3 += h6 * (5 * r7);\n    d3 += h7 * (5 * r6);\n    d3 += h8 * (5 * r5);\n    d3 += h9 * (5 * r4);\n    c += (d3 >>> 13); d3 &= 0x1fff;\n\n    d4 = c;\n    d4 += h0 * r4;\n    d4 += h1 * r3;\n    d4 += h2 * r2;\n    d4 += h3 * r1;\n    d4 += h4 * r0;\n    c = (d4 >>> 13); d4 &= 0x1fff;\n    d4 += h5 * (5 * r9);\n    d4 += h6 * (5 * r8);\n    d4 += h7 * (5 * r7);\n    d4 += h8 * (5 * r6);\n    d4 += h9 * (5 * r5);\n    c += (d4 >>> 13); d4 &= 0x1fff;\n\n    d5 = c;\n    d5 += h0 * r5;\n    d5 += h1 * r4;\n    d5 += h2 * r3;\n    d5 += h3 * r2;\n    d5 += h4 * r1;\n    c = (d5 >>> 13); d5 &= 0x1fff;\n    d5 += h5 * r0;\n    d5 += h6 * (5 * r9);\n    d5 += h7 * (5 * r8);\n    d5 += h8 * (5 * r7);\n    d5 += h9 * (5 * r6);\n    c += (d5 >>> 13); d5 &= 0x1fff;\n\n    d6 = c;\n    d6 += h0 * r6;\n    d6 += h1 * r5;\n    d6 += h2 * r4;\n    d6 += h3 * r3;\n    d6 += h4 * r2;\n    c = (d6 >>> 13); d6 &= 0x1fff;\n    d6 += h5 * r1;\n    d6 += h6 * r0;\n    d6 += h7 * (5 * r9);\n    d6 += h8 * (5 * r8);\n    d6 += h9 * (5 * r7);\n    c += (d6 >>> 13); d6 &= 0x1fff;\n\n    d7 = c;\n    d7 += h0 * r7;\n    d7 += h1 * r6;\n    d7 += h2 * r5;\n    d7 += h3 * r4;\n    d7 += h4 * r3;\n    c = (d7 >>> 13); d7 &= 0x1fff;\n    d7 += h5 * r2;\n    d7 += h6 * r1;\n    d7 += h7 * r0;\n    d7 += h8 * (5 * r9);\n    d7 += h9 * (5 * r8);\n    c += (d7 >>> 13); d7 &= 0x1fff;\n\n    d8 = c;\n    d8 += h0 * r8;\n    d8 += h1 * r7;\n    d8 += h2 * r6;\n    d8 += h3 * r5;\n    d8 += h4 * r4;\n    c = (d8 >>> 13); d8 &= 0x1fff;\n    d8 += h5 * r3;\n    d8 += h6 * r2;\n    d8 += h7 * r1;\n    d8 += h8 * r0;\n    d8 += h9 * (5 * r9);\n    c += (d8 >>> 13); d8 &= 0x1fff;\n\n    d9 = c;\n    d9 += h0 * r9;\n    d9 += h1 * r8;\n    d9 += h2 * r7;\n    d9 += h3 * r6;\n    d9 += h4 * r5;\n    c = (d9 >>> 13); d9 &= 0x1fff;\n    d9 += h5 * r4;\n    d9 += h6 * r3;\n    d9 += h7 * r2;\n    d9 += h8 * r1;\n    d9 += h9 * r0;\n    c += (d9 >>> 13); d9 &= 0x1fff;\n\n    c = (((c << 2) + c)) | 0;\n    c = (c + d0) | 0;\n    d0 = c & 0x1fff;\n    c = (c >>> 13);\n    d1 += c;\n\n    h0 = d0;\n    h1 = d1;\n    h2 = d2;\n    h3 = d3;\n    h4 = d4;\n    h5 = d5;\n    h6 = d6;\n    h7 = d7;\n    h8 = d8;\n    h9 = d9;\n\n    mpos += 16;\n    bytes -= 16;\n  }\n  this.h[0] = h0;\n  this.h[1] = h1;\n  this.h[2] = h2;\n  this.h[3] = h3;\n  this.h[4] = h4;\n  this.h[5] = h5;\n  this.h[6] = h6;\n  this.h[7] = h7;\n  this.h[8] = h8;\n  this.h[9] = h9;\n};\n\npoly1305.prototype.finish = function(mac, macpos) {\n  var g = new Uint16Array(10);\n  var c, mask, f, i;\n\n  if (this.leftover) {\n    i = this.leftover;\n    this.buffer[i++] = 1;\n    for (; i < 16; i++) this.buffer[i] = 0;\n    this.fin = 1;\n    this.blocks(this.buffer, 0, 16);\n  }\n\n  c = this.h[1] >>> 13;\n  this.h[1] &= 0x1fff;\n  for (i = 2; i < 10; i++) {\n    this.h[i] += c;\n    c = this.h[i] >>> 13;\n    this.h[i] &= 0x1fff;\n  }\n  this.h[0] += (c * 5);\n  c = this.h[0] >>> 13;\n  this.h[0] &= 0x1fff;\n  this.h[1] += c;\n  c = this.h[1] >>> 13;\n  this.h[1] &= 0x1fff;\n  this.h[2] += c;\n\n  g[0] = this.h[0] + 5;\n  c = g[0] >>> 13;\n  g[0] &= 0x1fff;\n  for (i = 1; i < 10; i++) {\n    g[i] = this.h[i] + c;\n    c = g[i] >>> 13;\n    g[i] &= 0x1fff;\n  }\n  g[9] -= (1 << 13);\n\n  mask = (c ^ 1) - 1;\n  for (i = 0; i < 10; i++) g[i] &= mask;\n  mask = ~mask;\n  for (i = 0; i < 10; i++) this.h[i] = (this.h[i] & mask) | g[i];\n\n  this.h[0] = ((this.h[0]       ) | (this.h[1] << 13)                    ) & 0xffff;\n  this.h[1] = ((this.h[1] >>>  3) | (this.h[2] << 10)                    ) & 0xffff;\n  this.h[2] = ((this.h[2] >>>  6) | (this.h[3] <<  7)                    ) & 0xffff;\n  this.h[3] = ((this.h[3] >>>  9) | (this.h[4] <<  4)                    ) & 0xffff;\n  this.h[4] = ((this.h[4] >>> 12) | (this.h[5] <<  1) | (this.h[6] << 14)) & 0xffff;\n  this.h[5] = ((this.h[6] >>>  2) | (this.h[7] << 11)                    ) & 0xffff;\n  this.h[6] = ((this.h[7] >>>  5) | (this.h[8] <<  8)                    ) & 0xffff;\n  this.h[7] = ((this.h[8] >>>  8) | (this.h[9] <<  5)                    ) & 0xffff;\n\n  f = this.h[0] + this.pad[0];\n  this.h[0] = f & 0xffff;\n  for (i = 1; i < 8; i++) {\n    f = (((this.h[i] + this.pad[i]) | 0) + (f >>> 16)) | 0;\n    this.h[i] = f & 0xffff;\n  }\n\n  mac[macpos+ 0] = (this.h[0] >>> 0) & 0xff;\n  mac[macpos+ 1] = (this.h[0] >>> 8) & 0xff;\n  mac[macpos+ 2] = (this.h[1] >>> 0) & 0xff;\n  mac[macpos+ 3] = (this.h[1] >>> 8) & 0xff;\n  mac[macpos+ 4] = (this.h[2] >>> 0) & 0xff;\n  mac[macpos+ 5] = (this.h[2] >>> 8) & 0xff;\n  mac[macpos+ 6] = (this.h[3] >>> 0) & 0xff;\n  mac[macpos+ 7] = (this.h[3] >>> 8) & 0xff;\n  mac[macpos+ 8] = (this.h[4] >>> 0) & 0xff;\n  mac[macpos+ 9] = (this.h[4] >>> 8) & 0xff;\n  mac[macpos+10] = (this.h[5] >>> 0) & 0xff;\n  mac[macpos+11] = (this.h[5] >>> 8) & 0xff;\n  mac[macpos+12] = (this.h[6] >>> 0) & 0xff;\n  mac[macpos+13] = (this.h[6] >>> 8) & 0xff;\n  mac[macpos+14] = (this.h[7] >>> 0) & 0xff;\n  mac[macpos+15] = (this.h[7] >>> 8) & 0xff;\n};\n\npoly1305.prototype.update = function(m, mpos, bytes) {\n  var i, want;\n\n  if (this.leftover) {\n    want = (16 - this.leftover);\n    if (want > bytes)\n      want = bytes;\n    for (i = 0; i < want; i++)\n      this.buffer[this.leftover + i] = m[mpos+i];\n    bytes -= want;\n    mpos += want;\n    this.leftover += want;\n    if (this.leftover < 16)\n      return;\n    this.blocks(this.buffer, 0, 16);\n    this.leftover = 0;\n  }\n\n  if (bytes >= 16) {\n    want = bytes - (bytes % 16);\n    this.blocks(m, mpos, want);\n    mpos += want;\n    bytes -= want;\n  }\n\n  if (bytes) {\n    for (i = 0; i < bytes; i++)\n      this.buffer[this.leftover + i] = m[mpos+i];\n    this.leftover += bytes;\n  }\n};\n\nfunction crypto_onetimeauth(out, outpos, m, mpos, n, k) {\n  var s = new poly1305(k);\n  s.update(m, mpos, n);\n  s.finish(out, outpos);\n  return 0;\n}\n\nfunction crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {\n  var x = new Uint8Array(16);\n  crypto_onetimeauth(x,0,m,mpos,n,k);\n  return crypto_verify_16(h,hpos,x,0);\n}\n\nfunction crypto_secretbox(c,m,d,n,k) {\n  var i;\n  if (d < 32) return -1;\n  crypto_stream_xor(c,0,m,0,d,n,k);\n  crypto_onetimeauth(c, 16, c, 32, d - 32, c);\n  for (i = 0; i < 16; i++) c[i] = 0;\n  return 0;\n}\n\nfunction crypto_secretbox_open(m,c,d,n,k) {\n  var i;\n  var x = new Uint8Array(32);\n  if (d < 32) return -1;\n  crypto_stream(x,0,32,n,k);\n  if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1;\n  crypto_stream_xor(m,0,c,0,d,n,k);\n  for (i = 0; i < 32; i++) m[i] = 0;\n  return 0;\n}\n\nfunction set25519(r, a) {\n  var i;\n  for (i = 0; i < 16; i++) r[i] = a[i]|0;\n}\n\nfunction car25519(o) {\n  var i, v, c = 1;\n  for (i = 0; i < 16; i++) {\n    v = o[i] + c + 65535;\n    c = Math.floor(v / 65536);\n    o[i] = v - c * 65536;\n  }\n  o[0] += c-1 + 37 * (c-1);\n}\n\nfunction sel25519(p, q, b) {\n  var t, c = ~(b-1);\n  for (var i = 0; i < 16; i++) {\n    t = c & (p[i] ^ q[i]);\n    p[i] ^= t;\n    q[i] ^= t;\n  }\n}\n\nfunction pack25519(o, n) {\n  var i, j, b;\n  var m = gf(), t = gf();\n  for (i = 0; i < 16; i++) t[i] = n[i];\n  car25519(t);\n  car25519(t);\n  car25519(t);\n  for (j = 0; j < 2; j++) {\n    m[0] = t[0] - 0xffed;\n    for (i = 1; i < 15; i++) {\n      m[i] = t[i] - 0xffff - ((m[i-1]>>16) & 1);\n      m[i-1] &= 0xffff;\n    }\n    m[15] = t[15] - 0x7fff - ((m[14]>>16) & 1);\n    b = (m[15]>>16) & 1;\n    m[14] &= 0xffff;\n    sel25519(t, m, 1-b);\n  }\n  for (i = 0; i < 16; i++) {\n    o[2*i] = t[i] & 0xff;\n    o[2*i+1] = t[i]>>8;\n  }\n}\n\nfunction neq25519(a, b) {\n  var c = new Uint8Array(32), d = new Uint8Array(32);\n  pack25519(c, a);\n  pack25519(d, b);\n  return crypto_verify_32(c, 0, d, 0);\n}\n\nfunction par25519(a) {\n  var d = new Uint8Array(32);\n  pack25519(d, a);\n  return d[0] & 1;\n}\n\nfunction unpack25519(o, n) {\n  var i;\n  for (i = 0; i < 16; i++) o[i] = n[2*i] + (n[2*i+1] << 8);\n  o[15] &= 0x7fff;\n}\n\nfunction A(o, a, b) {\n  for (var i = 0; i < 16; i++) o[i] = a[i] + b[i];\n}\n\nfunction Z(o, a, b) {\n  for (var i = 0; i < 16; i++) o[i] = a[i] - b[i];\n}\n\nfunction M(o, a, b) {\n  var v, c,\n     t0 = 0,  t1 = 0,  t2 = 0,  t3 = 0,  t4 = 0,  t5 = 0,  t6 = 0,  t7 = 0,\n     t8 = 0,  t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0,\n    t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0,\n    t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0,\n    b0 = b[0],\n    b1 = b[1],\n    b2 = b[2],\n    b3 = b[3],\n    b4 = b[4],\n    b5 = b[5],\n    b6 = b[6],\n    b7 = b[7],\n    b8 = b[8],\n    b9 = b[9],\n    b10 = b[10],\n    b11 = b[11],\n    b12 = b[12],\n    b13 = b[13],\n    b14 = b[14],\n    b15 = b[15];\n\n  v = a[0];\n  t0 += v * b0;\n  t1 += v * b1;\n  t2 += v * b2;\n  t3 += v * b3;\n  t4 += v * b4;\n  t5 += v * b5;\n  t6 += v * b6;\n  t7 += v * b7;\n  t8 += v * b8;\n  t9 += v * b9;\n  t10 += v * b10;\n  t11 += v * b11;\n  t12 += v * b12;\n  t13 += v * b13;\n  t14 += v * b14;\n  t15 += v * b15;\n  v = a[1];\n  t1 += v * b0;\n  t2 += v * b1;\n  t3 += v * b2;\n  t4 += v * b3;\n  t5 += v * b4;\n  t6 += v * b5;\n  t7 += v * b6;\n  t8 += v * b7;\n  t9 += v * b8;\n  t10 += v * b9;\n  t11 += v * b10;\n  t12 += v * b11;\n  t13 += v * b12;\n  t14 += v * b13;\n  t15 += v * b14;\n  t16 += v * b15;\n  v = a[2];\n  t2 += v * b0;\n  t3 += v * b1;\n  t4 += v * b2;\n  t5 += v * b3;\n  t6 += v * b4;\n  t7 += v * b5;\n  t8 += v * b6;\n  t9 += v * b7;\n  t10 += v * b8;\n  t11 += v * b9;\n  t12 += v * b10;\n  t13 += v * b11;\n  t14 += v * b12;\n  t15 += v * b13;\n  t16 += v * b14;\n  t17 += v * b15;\n  v = a[3];\n  t3 += v * b0;\n  t4 += v * b1;\n  t5 += v * b2;\n  t6 += v * b3;\n  t7 += v * b4;\n  t8 += v * b5;\n  t9 += v * b6;\n  t10 += v * b7;\n  t11 += v * b8;\n  t12 += v * b9;\n  t13 += v * b10;\n  t14 += v * b11;\n  t15 += v * b12;\n  t16 += v * b13;\n  t17 += v * b14;\n  t18 += v * b15;\n  v = a[4];\n  t4 += v * b0;\n  t5 += v * b1;\n  t6 += v * b2;\n  t7 += v * b3;\n  t8 += v * b4;\n  t9 += v * b5;\n  t10 += v * b6;\n  t11 += v * b7;\n  t12 += v * b8;\n  t13 += v * b9;\n  t14 += v * b10;\n  t15 += v * b11;\n  t16 += v * b12;\n  t17 += v * b13;\n  t18 += v * b14;\n  t19 += v * b15;\n  v = a[5];\n  t5 += v * b0;\n  t6 += v * b1;\n  t7 += v * b2;\n  t8 += v * b3;\n  t9 += v * b4;\n  t10 += v * b5;\n  t11 += v * b6;\n  t12 += v * b7;\n  t13 += v * b8;\n  t14 += v * b9;\n  t15 += v * b10;\n  t16 += v * b11;\n  t17 += v * b12;\n  t18 += v * b13;\n  t19 += v * b14;\n  t20 += v * b15;\n  v = a[6];\n  t6 += v * b0;\n  t7 += v * b1;\n  t8 += v * b2;\n  t9 += v * b3;\n  t10 += v * b4;\n  t11 += v * b5;\n  t12 += v * b6;\n  t13 += v * b7;\n  t14 += v * b8;\n  t15 += v * b9;\n  t16 += v * b10;\n  t17 += v * b11;\n  t18 += v * b12;\n  t19 += v * b13;\n  t20 += v * b14;\n  t21 += v * b15;\n  v = a[7];\n  t7 += v * b0;\n  t8 += v * b1;\n  t9 += v * b2;\n  t10 += v * b3;\n  t11 += v * b4;\n  t12 += v * b5;\n  t13 += v * b6;\n  t14 += v * b7;\n  t15 += v * b8;\n  t16 += v * b9;\n  t17 += v * b10;\n  t18 += v * b11;\n  t19 += v * b12;\n  t20 += v * b13;\n  t21 += v * b14;\n  t22 += v * b15;\n  v = a[8];\n  t8 += v * b0;\n  t9 += v * b1;\n  t10 += v * b2;\n  t11 += v * b3;\n  t12 += v * b4;\n  t13 += v * b5;\n  t14 += v * b6;\n  t15 += v * b7;\n  t16 += v * b8;\n  t17 += v * b9;\n  t18 += v * b10;\n  t19 += v * b11;\n  t20 += v * b12;\n  t21 += v * b13;\n  t22 += v * b14;\n  t23 += v * b15;\n  v = a[9];\n  t9 += v * b0;\n  t10 += v * b1;\n  t11 += v * b2;\n  t12 += v * b3;\n  t13 += v * b4;\n  t14 += v * b5;\n  t15 += v * b6;\n  t16 += v * b7;\n  t17 += v * b8;\n  t18 += v * b9;\n  t19 += v * b10;\n  t20 += v * b11;\n  t21 += v * b12;\n  t22 += v * b13;\n  t23 += v * b14;\n  t24 += v * b15;\n  v = a[10];\n  t10 += v * b0;\n  t11 += v * b1;\n  t12 += v * b2;\n  t13 += v * b3;\n  t14 += v * b4;\n  t15 += v * b5;\n  t16 += v * b6;\n  t17 += v * b7;\n  t18 += v * b8;\n  t19 += v * b9;\n  t20 += v * b10;\n  t21 += v * b11;\n  t22 += v * b12;\n  t23 += v * b13;\n  t24 += v * b14;\n  t25 += v * b15;\n  v = a[11];\n  t11 += v * b0;\n  t12 += v * b1;\n  t13 += v * b2;\n  t14 += v * b3;\n  t15 += v * b4;\n  t16 += v * b5;\n  t17 += v * b6;\n  t18 += v * b7;\n  t19 += v * b8;\n  t20 += v * b9;\n  t21 += v * b10;\n  t22 += v * b11;\n  t23 += v * b12;\n  t24 += v * b13;\n  t25 += v * b14;\n  t26 += v * b15;\n  v = a[12];\n  t12 += v * b0;\n  t13 += v * b1;\n  t14 += v * b2;\n  t15 += v * b3;\n  t16 += v * b4;\n  t17 += v * b5;\n  t18 += v * b6;\n  t19 += v * b7;\n  t20 += v * b8;\n  t21 += v * b9;\n  t22 += v * b10;\n  t23 += v * b11;\n  t24 += v * b12;\n  t25 += v * b13;\n  t26 += v * b14;\n  t27 += v * b15;\n  v = a[13];\n  t13 += v * b0;\n  t14 += v * b1;\n  t15 += v * b2;\n  t16 += v * b3;\n  t17 += v * b4;\n  t18 += v * b5;\n  t19 += v * b6;\n  t20 += v * b7;\n  t21 += v * b8;\n  t22 += v * b9;\n  t23 += v * b10;\n  t24 += v * b11;\n  t25 += v * b12;\n  t26 += v * b13;\n  t27 += v * b14;\n  t28 += v * b15;\n  v = a[14];\n  t14 += v * b0;\n  t15 += v * b1;\n  t16 += v * b2;\n  t17 += v * b3;\n  t18 += v * b4;\n  t19 += v * b5;\n  t20 += v * b6;\n  t21 += v * b7;\n  t22 += v * b8;\n  t23 += v * b9;\n  t24 += v * b10;\n  t25 += v * b11;\n  t26 += v * b12;\n  t27 += v * b13;\n  t28 += v * b14;\n  t29 += v * b15;\n  v = a[15];\n  t15 += v * b0;\n  t16 += v * b1;\n  t17 += v * b2;\n  t18 += v * b3;\n  t19 += v * b4;\n  t20 += v * b5;\n  t21 += v * b6;\n  t22 += v * b7;\n  t23 += v * b8;\n  t24 += v * b9;\n  t25 += v * b10;\n  t26 += v * b11;\n  t27 += v * b12;\n  t28 += v * b13;\n  t29 += v * b14;\n  t30 += v * b15;\n\n  t0  += 38 * t16;\n  t1  += 38 * t17;\n  t2  += 38 * t18;\n  t3  += 38 * t19;\n  t4  += 38 * t20;\n  t5  += 38 * t21;\n  t6  += 38 * t22;\n  t7  += 38 * t23;\n  t8  += 38 * t24;\n  t9  += 38 * t25;\n  t10 += 38 * t26;\n  t11 += 38 * t27;\n  t12 += 38 * t28;\n  t13 += 38 * t29;\n  t14 += 38 * t30;\n  // t15 left as is\n\n  // first car\n  c = 1;\n  v =  t0 + c + 65535; c = Math.floor(v / 65536);  t0 = v - c * 65536;\n  v =  t1 + c + 65535; c = Math.floor(v / 65536);  t1 = v - c * 65536;\n  v =  t2 + c + 65535; c = Math.floor(v / 65536);  t2 = v - c * 65536;\n  v =  t3 + c + 65535; c = Math.floor(v / 65536);  t3 = v - c * 65536;\n  v =  t4 + c + 65535; c = Math.floor(v / 65536);  t4 = v - c * 65536;\n  v =  t5 + c + 65535; c = Math.floor(v / 65536);  t5 = v - c * 65536;\n  v =  t6 + c + 65535; c = Math.floor(v / 65536);  t6 = v - c * 65536;\n  v =  t7 + c + 65535; c = Math.floor(v / 65536);  t7 = v - c * 65536;\n  v =  t8 + c + 65535; c = Math.floor(v / 65536);  t8 = v - c * 65536;\n  v =  t9 + c + 65535; c = Math.floor(v / 65536);  t9 = v - c * 65536;\n  v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;\n  v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;\n  v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;\n  v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;\n  v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;\n  v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;\n  t0 += c-1 + 37 * (c-1);\n\n  // second car\n  c = 1;\n  v =  t0 + c + 65535; c = Math.floor(v / 65536);  t0 = v - c * 65536;\n  v =  t1 + c + 65535; c = Math.floor(v / 65536);  t1 = v - c * 65536;\n  v =  t2 + c + 65535; c = Math.floor(v / 65536);  t2 = v - c * 65536;\n  v =  t3 + c + 65535; c = Math.floor(v / 65536);  t3 = v - c * 65536;\n  v =  t4 + c + 65535; c = Math.floor(v / 65536);  t4 = v - c * 65536;\n  v =  t5 + c + 65535; c = Math.floor(v / 65536);  t5 = v - c * 65536;\n  v =  t6 + c + 65535; c = Math.floor(v / 65536);  t6 = v - c * 65536;\n  v =  t7 + c + 65535; c = Math.floor(v / 65536);  t7 = v - c * 65536;\n  v =  t8 + c + 65535; c = Math.floor(v / 65536);  t8 = v - c * 65536;\n  v =  t9 + c + 65535; c = Math.floor(v / 65536);  t9 = v - c * 65536;\n  v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;\n  v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;\n  v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;\n  v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;\n  v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;\n  v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;\n  t0 += c-1 + 37 * (c-1);\n\n  o[ 0] = t0;\n  o[ 1] = t1;\n  o[ 2] = t2;\n  o[ 3] = t3;\n  o[ 4] = t4;\n  o[ 5] = t5;\n  o[ 6] = t6;\n  o[ 7] = t7;\n  o[ 8] = t8;\n  o[ 9] = t9;\n  o[10] = t10;\n  o[11] = t11;\n  o[12] = t12;\n  o[13] = t13;\n  o[14] = t14;\n  o[15] = t15;\n}\n\nfunction S(o, a) {\n  M(o, a, a);\n}\n\nfunction inv25519(o, i) {\n  var c = gf();\n  var a;\n  for (a = 0; a < 16; a++) c[a] = i[a];\n  for (a = 253; a >= 0; a--) {\n    S(c, c);\n    if(a !== 2 && a !== 4) M(c, c, i);\n  }\n  for (a = 0; a < 16; a++) o[a] = c[a];\n}\n\nfunction pow2523(o, i) {\n  var c = gf();\n  var a;\n  for (a = 0; a < 16; a++) c[a] = i[a];\n  for (a = 250; a >= 0; a--) {\n      S(c, c);\n      if(a !== 1) M(c, c, i);\n  }\n  for (a = 0; a < 16; a++) o[a] = c[a];\n}\n\nfunction crypto_scalarmult(q, n, p) {\n  var z = new Uint8Array(32);\n  var x = new Float64Array(80), r, i;\n  var a = gf(), b = gf(), c = gf(),\n      d = gf(), e = gf(), f = gf();\n  for (i = 0; i < 31; i++) z[i] = n[i];\n  z[31]=(n[31]&127)|64;\n  z[0]&=248;\n  unpack25519(x,p);\n  for (i = 0; i < 16; i++) {\n    b[i]=x[i];\n    d[i]=a[i]=c[i]=0;\n  }\n  a[0]=d[0]=1;\n  for (i=254; i>=0; --i) {\n    r=(z[i>>>3]>>>(i&7))&1;\n    sel25519(a,b,r);\n    sel25519(c,d,r);\n    A(e,a,c);\n    Z(a,a,c);\n    A(c,b,d);\n    Z(b,b,d);\n    S(d,e);\n    S(f,a);\n    M(a,c,a);\n    M(c,b,e);\n    A(e,a,c);\n    Z(a,a,c);\n    S(b,a);\n    Z(c,d,f);\n    M(a,c,_121665);\n    A(a,a,d);\n    M(c,c,a);\n    M(a,d,f);\n    M(d,b,x);\n    S(b,e);\n    sel25519(a,b,r);\n    sel25519(c,d,r);\n  }\n  for (i = 0; i < 16; i++) {\n    x[i+16]=a[i];\n    x[i+32]=c[i];\n    x[i+48]=b[i];\n    x[i+64]=d[i];\n  }\n  var x32 = x.subarray(32);\n  var x16 = x.subarray(16);\n  inv25519(x32,x32);\n  M(x16,x16,x32);\n  pack25519(q,x16);\n  return 0;\n}\n\nfunction crypto_scalarmult_base(q, n) {\n  return crypto_scalarmult(q, n, _9);\n}\n\nfunction crypto_box_keypair(y, x) {\n  randombytes(x, 32);\n  return crypto_scalarmult_base(y, x);\n}\n\nfunction crypto_box_beforenm(k, y, x) {\n  var s = new Uint8Array(32);\n  crypto_scalarmult(s, x, y);\n  return crypto_core_hsalsa20(k, _0, s, sigma);\n}\n\nvar crypto_box_afternm = crypto_secretbox;\nvar crypto_box_open_afternm = crypto_secretbox_open;\n\nfunction crypto_box(c, m, d, n, y, x) {\n  var k = new Uint8Array(32);\n  crypto_box_beforenm(k, y, x);\n  return crypto_box_afternm(c, m, d, n, k);\n}\n\nfunction crypto_box_open(m, c, d, n, y, x) {\n  var k = new Uint8Array(32);\n  crypto_box_beforenm(k, y, x);\n  return crypto_box_open_afternm(m, c, d, n, k);\n}\n\nvar K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n];\n\nfunction crypto_hashblocks_hl(hh, hl, m, n) {\n  var wh = new Int32Array(16), wl = new Int32Array(16),\n      bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7,\n      bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7,\n      th, tl, i, j, h, l, a, b, c, d;\n\n  var ah0 = hh[0],\n      ah1 = hh[1],\n      ah2 = hh[2],\n      ah3 = hh[3],\n      ah4 = hh[4],\n      ah5 = hh[5],\n      ah6 = hh[6],\n      ah7 = hh[7],\n\n      al0 = hl[0],\n      al1 = hl[1],\n      al2 = hl[2],\n      al3 = hl[3],\n      al4 = hl[4],\n      al5 = hl[5],\n      al6 = hl[6],\n      al7 = hl[7];\n\n  var pos = 0;\n  while (n >= 128) {\n    for (i = 0; i < 16; i++) {\n      j = 8 * i + pos;\n      wh[i] = (m[j+0] << 24) | (m[j+1] << 16) | (m[j+2] << 8) | m[j+3];\n      wl[i] = (m[j+4] << 24) | (m[j+5] << 16) | (m[j+6] << 8) | m[j+7];\n    }\n    for (i = 0; i < 80; i++) {\n      bh0 = ah0;\n      bh1 = ah1;\n      bh2 = ah2;\n      bh3 = ah3;\n      bh4 = ah4;\n      bh5 = ah5;\n      bh6 = ah6;\n      bh7 = ah7;\n\n      bl0 = al0;\n      bl1 = al1;\n      bl2 = al2;\n      bl3 = al3;\n      bl4 = al4;\n      bl5 = al5;\n      bl6 = al6;\n      bl7 = al7;\n\n      // add\n      h = ah7;\n      l = al7;\n\n      a = l & 0xffff; b = l >>> 16;\n      c = h & 0xffff; d = h >>> 16;\n\n      // Sigma1\n      h = ((ah4 >>> 14) | (al4 << (32-14))) ^ ((ah4 >>> 18) | (al4 << (32-18))) ^ ((al4 >>> (41-32)) | (ah4 << (32-(41-32))));\n      l = ((al4 >>> 14) | (ah4 << (32-14))) ^ ((al4 >>> 18) | (ah4 << (32-18))) ^ ((ah4 >>> (41-32)) | (al4 << (32-(41-32))));\n\n      a += l & 0xffff; b += l >>> 16;\n      c += h & 0xffff; d += h >>> 16;\n\n      // Ch\n      h = (ah4 & ah5) ^ (~ah4 & ah6);\n      l = (al4 & al5) ^ (~al4 & al6);\n\n      a += l & 0xffff; b += l >>> 16;\n      c += h & 0xffff; d += h >>> 16;\n\n      // K\n      h = K[i*2];\n      l = K[i*2+1];\n\n      a += l & 0xffff; b += l >>> 16;\n      c += h & 0xffff; d += h >>> 16;\n\n      // w\n      h = wh[i%16];\n      l = wl[i%16];\n\n      a += l & 0xffff; b += l >>> 16;\n      c += h & 0xffff; d += h >>> 16;\n\n      b += a >>> 16;\n      c += b >>> 16;\n      d += c >>> 16;\n\n      th = c & 0xffff | d << 16;\n      tl = a & 0xffff | b << 16;\n\n      // add\n      h = th;\n      l = tl;\n\n      a = l & 0xffff; b = l >>> 16;\n      c = h & 0xffff; d = h >>> 16;\n\n      // Sigma0\n      h = ((ah0 >>> 28) | (al0 << (32-28))) ^ ((al0 >>> (34-32)) | (ah0 << (32-(34-32)))) ^ ((al0 >>> (39-32)) | (ah0 << (32-(39-32))));\n      l = ((al0 >>> 28) | (ah0 << (32-28))) ^ ((ah0 >>> (34-32)) | (al0 << (32-(34-32)))) ^ ((ah0 >>> (39-32)) | (al0 << (32-(39-32))));\n\n      a += l & 0xffff; b += l >>> 16;\n      c += h & 0xffff; d += h >>> 16;\n\n      // Maj\n      h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2);\n      l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2);\n\n      a += l & 0xffff; b += l >>> 16;\n      c += h & 0xffff; d += h >>> 16;\n\n      b += a >>> 16;\n      c += b >>> 16;\n      d += c >>> 16;\n\n      bh7 = (c & 0xffff) | (d << 16);\n      bl7 = (a & 0xffff) | (b << 16);\n\n      // add\n      h = bh3;\n      l = bl3;\n\n      a = l & 0xffff; b = l >>> 16;\n      c = h & 0xffff; d = h >>> 16;\n\n      h = th;\n      l = tl;\n\n      a += l & 0xffff; b += l >>> 16;\n      c += h & 0xffff; d += h >>> 16;\n\n      b += a >>> 16;\n      c += b >>> 16;\n      d += c >>> 16;\n\n      bh3 = (c & 0xffff) | (d << 16);\n      bl3 = (a & 0xffff) | (b << 16);\n\n      ah1 = bh0;\n      ah2 = bh1;\n      ah3 = bh2;\n      ah4 = bh3;\n      ah5 = bh4;\n      ah6 = bh5;\n      ah7 = bh6;\n      ah0 = bh7;\n\n      al1 = bl0;\n      al2 = bl1;\n      al3 = bl2;\n      al4 = bl3;\n      al5 = bl4;\n      al6 = bl5;\n      al7 = bl6;\n      al0 = bl7;\n\n      if (i%16 === 15) {\n        for (j = 0; j < 16; j++) {\n          // add\n          h = wh[j];\n          l = wl[j];\n\n          a = l & 0xffff; b = l >>> 16;\n          c = h & 0xffff; d = h >>> 16;\n\n          h = wh[(j+9)%16];\n          l = wl[(j+9)%16];\n\n          a += l & 0xffff; b += l >>> 16;\n          c += h & 0xffff; d += h >>> 16;\n\n          // sigma0\n          th = wh[(j+1)%16];\n          tl = wl[(j+1)%16];\n          h = ((th >>> 1) | (tl << (32-1))) ^ ((th >>> 8) | (tl << (32-8))) ^ (th >>> 7);\n          l = ((tl >>> 1) | (th << (32-1))) ^ ((tl >>> 8) | (th << (32-8))) ^ ((tl >>> 7) | (th << (32-7)));\n\n          a += l & 0xffff; b += l >>> 16;\n          c += h & 0xffff; d += h >>> 16;\n\n          // sigma1\n          th = wh[(j+14)%16];\n          tl = wl[(j+14)%16];\n          h = ((th >>> 19) | (tl << (32-19))) ^ ((tl >>> (61-32)) | (th << (32-(61-32)))) ^ (th >>> 6);\n          l = ((tl >>> 19) | (th << (32-19))) ^ ((th >>> (61-32)) | (tl << (32-(61-32)))) ^ ((tl >>> 6) | (th << (32-6)));\n\n          a += l & 0xffff; b += l >>> 16;\n          c += h & 0xffff; d += h >>> 16;\n\n          b += a >>> 16;\n          c += b >>> 16;\n          d += c >>> 16;\n\n          wh[j] = (c & 0xffff) | (d << 16);\n          wl[j] = (a & 0xffff) | (b << 16);\n        }\n      }\n    }\n\n    // add\n    h = ah0;\n    l = al0;\n\n    a = l & 0xffff; b = l >>> 16;\n    c = h & 0xffff; d = h >>> 16;\n\n    h = hh[0];\n    l = hl[0];\n\n    a += l & 0xffff; b += l >>> 16;\n    c += h & 0xffff; d += h >>> 16;\n\n    b += a >>> 16;\n    c += b >>> 16;\n    d += c >>> 16;\n\n    hh[0] = ah0 = (c & 0xffff) | (d << 16);\n    hl[0] = al0 = (a & 0xffff) | (b << 16);\n\n    h = ah1;\n    l = al1;\n\n    a = l & 0xffff; b = l >>> 16;\n    c = h & 0xffff; d = h >>> 16;\n\n    h = hh[1];\n    l = hl[1];\n\n    a += l & 0xffff; b += l >>> 16;\n    c += h & 0xffff; d += h >>> 16;\n\n    b += a >>> 16;\n    c += b >>> 16;\n    d += c >>> 16;\n\n    hh[1] = ah1 = (c & 0xffff) | (d << 16);\n    hl[1] = al1 = (a & 0xffff) | (b << 16);\n\n    h = ah2;\n    l = al2;\n\n    a = l & 0xffff; b = l >>> 16;\n    c = h & 0xffff; d = h >>> 16;\n\n    h = hh[2];\n    l = hl[2];\n\n    a += l & 0xffff; b += l >>> 16;\n    c += h & 0xffff; d += h >>> 16;\n\n    b += a >>> 16;\n    c += b >>> 16;\n    d += c >>> 16;\n\n    hh[2] = ah2 = (c & 0xffff) | (d << 16);\n    hl[2] = al2 = (a & 0xffff) | (b << 16);\n\n    h = ah3;\n    l = al3;\n\n    a = l & 0xffff; b = l >>> 16;\n    c = h & 0xffff; d = h >>> 16;\n\n    h = hh[3];\n    l = hl[3];\n\n    a += l & 0xffff; b += l >>> 16;\n    c += h & 0xffff; d += h >>> 16;\n\n    b += a >>> 16;\n    c += b >>> 16;\n    d += c >>> 16;\n\n    hh[3] = ah3 = (c & 0xffff) | (d << 16);\n    hl[3] = al3 = (a & 0xffff) | (b << 16);\n\n    h = ah4;\n    l = al4;\n\n    a = l & 0xffff; b = l >>> 16;\n    c = h & 0xffff; d = h >>> 16;\n\n    h = hh[4];\n    l = hl[4];\n\n    a += l & 0xffff; b += l >>> 16;\n    c += h & 0xffff; d += h >>> 16;\n\n    b += a >>> 16;\n    c += b >>> 16;\n    d += c >>> 16;\n\n    hh[4] = ah4 = (c & 0xffff) | (d << 16);\n    hl[4] = al4 = (a & 0xffff) | (b << 16);\n\n    h = ah5;\n    l = al5;\n\n    a = l & 0xffff; b = l >>> 16;\n    c = h & 0xffff; d = h >>> 16;\n\n    h = hh[5];\n    l = hl[5];\n\n    a += l & 0xffff; b += l >>> 16;\n    c += h & 0xffff; d += h >>> 16;\n\n    b += a >>> 16;\n    c += b >>> 16;\n    d += c >>> 16;\n\n    hh[5] = ah5 = (c & 0xffff) | (d << 16);\n    hl[5] = al5 = (a & 0xffff) | (b << 16);\n\n    h = ah6;\n    l = al6;\n\n    a = l & 0xffff; b = l >>> 16;\n    c = h & 0xffff; d = h >>> 16;\n\n    h = hh[6];\n    l = hl[6];\n\n    a += l & 0xffff; b += l >>> 16;\n    c += h & 0xffff; d += h >>> 16;\n\n    b += a >>> 16;\n    c += b >>> 16;\n    d += c >>> 16;\n\n    hh[6] = ah6 = (c & 0xffff) | (d << 16);\n    hl[6] = al6 = (a & 0xffff) | (b << 16);\n\n    h = ah7;\n    l = al7;\n\n    a = l & 0xffff; b = l >>> 16;\n    c = h & 0xffff; d = h >>> 16;\n\n    h = hh[7];\n    l = hl[7];\n\n    a += l & 0xffff; b += l >>> 16;\n    c += h & 0xffff; d += h >>> 16;\n\n    b += a >>> 16;\n    c += b >>> 16;\n    d += c >>> 16;\n\n    hh[7] = ah7 = (c & 0xffff) | (d << 16);\n    hl[7] = al7 = (a & 0xffff) | (b << 16);\n\n    pos += 128;\n    n -= 128;\n  }\n\n  return n;\n}\n\nfunction crypto_hash(out, m, n) {\n  var hh = new Int32Array(8),\n      hl = new Int32Array(8),\n      x = new Uint8Array(256),\n      i, b = n;\n\n  hh[0] = 0x6a09e667;\n  hh[1] = 0xbb67ae85;\n  hh[2] = 0x3c6ef372;\n  hh[3] = 0xa54ff53a;\n  hh[4] = 0x510e527f;\n  hh[5] = 0x9b05688c;\n  hh[6] = 0x1f83d9ab;\n  hh[7] = 0x5be0cd19;\n\n  hl[0] = 0xf3bcc908;\n  hl[1] = 0x84caa73b;\n  hl[2] = 0xfe94f82b;\n  hl[3] = 0x5f1d36f1;\n  hl[4] = 0xade682d1;\n  hl[5] = 0x2b3e6c1f;\n  hl[6] = 0xfb41bd6b;\n  hl[7] = 0x137e2179;\n\n  crypto_hashblocks_hl(hh, hl, m, n);\n  n %= 128;\n\n  for (i = 0; i < n; i++) x[i] = m[b-n+i];\n  x[n] = 128;\n\n  n = 256-128*(n<112?1:0);\n  x[n-9] = 0;\n  ts64(x, n-8,  (b / 0x20000000) | 0, b << 3);\n  crypto_hashblocks_hl(hh, hl, x, n);\n\n  for (i = 0; i < 8; i++) ts64(out, 8*i, hh[i], hl[i]);\n\n  return 0;\n}\n\nfunction add(p, q) {\n  var a = gf(), b = gf(), c = gf(),\n      d = gf(), e = gf(), f = gf(),\n      g = gf(), h = gf(), t = gf();\n\n  Z(a, p[1], p[0]);\n  Z(t, q[1], q[0]);\n  M(a, a, t);\n  A(b, p[0], p[1]);\n  A(t, q[0], q[1]);\n  M(b, b, t);\n  M(c, p[3], q[3]);\n  M(c, c, D2);\n  M(d, p[2], q[2]);\n  A(d, d, d);\n  Z(e, b, a);\n  Z(f, d, c);\n  A(g, d, c);\n  A(h, b, a);\n\n  M(p[0], e, f);\n  M(p[1], h, g);\n  M(p[2], g, f);\n  M(p[3], e, h);\n}\n\nfunction cswap(p, q, b) {\n  var i;\n  for (i = 0; i < 4; i++) {\n    sel25519(p[i], q[i], b);\n  }\n}\n\nfunction pack(r, p) {\n  var tx = gf(), ty = gf(), zi = gf();\n  inv25519(zi, p[2]);\n  M(tx, p[0], zi);\n  M(ty, p[1], zi);\n  pack25519(r, ty);\n  r[31] ^= par25519(tx) << 7;\n}\n\nfunction scalarmult(p, q, s) {\n  var b, i;\n  set25519(p[0], gf0);\n  set25519(p[1], gf1);\n  set25519(p[2], gf1);\n  set25519(p[3], gf0);\n  for (i = 255; i >= 0; --i) {\n    b = (s[(i/8)|0] >> (i&7)) & 1;\n    cswap(p, q, b);\n    add(q, p);\n    add(p, p);\n    cswap(p, q, b);\n  }\n}\n\nfunction scalarbase(p, s) {\n  var q = [gf(), gf(), gf(), gf()];\n  set25519(q[0], X);\n  set25519(q[1], Y);\n  set25519(q[2], gf1);\n  M(q[3], X, Y);\n  scalarmult(p, q, s);\n}\n\nfunction crypto_sign_keypair(pk, sk, seeded) {\n  var d = new Uint8Array(64);\n  var p = [gf(), gf(), gf(), gf()];\n  var i;\n\n  if (!seeded) randombytes(sk, 32);\n  crypto_hash(d, sk, 32);\n  d[0] &= 248;\n  d[31] &= 127;\n  d[31] |= 64;\n\n  scalarbase(p, d);\n  pack(pk, p);\n\n  for (i = 0; i < 32; i++) sk[i+32] = pk[i];\n  return 0;\n}\n\nvar L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10]);\n\nfunction modL(r, x) {\n  var carry, i, j, k;\n  for (i = 63; i >= 32; --i) {\n    carry = 0;\n    for (j = i - 32, k = i - 12; j < k; ++j) {\n      x[j] += carry - 16 * x[i] * L[j - (i - 32)];\n      carry = (x[j] + 128) >> 8;\n      x[j] -= carry * 256;\n    }\n    x[j] += carry;\n    x[i] = 0;\n  }\n  carry = 0;\n  for (j = 0; j < 32; j++) {\n    x[j] += carry - (x[31] >> 4) * L[j];\n    carry = x[j] >> 8;\n    x[j] &= 255;\n  }\n  for (j = 0; j < 32; j++) x[j] -= carry * L[j];\n  for (i = 0; i < 32; i++) {\n    x[i+1] += x[i] >> 8;\n    r[i] = x[i] & 255;\n  }\n}\n\nfunction reduce(r) {\n  var x = new Float64Array(64), i;\n  for (i = 0; i < 64; i++) x[i] = r[i];\n  for (i = 0; i < 64; i++) r[i] = 0;\n  modL(r, x);\n}\n\n// Note: difference from C - smlen returned, not passed as argument.\nfunction crypto_sign(sm, m, n, sk) {\n  var d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64);\n  var i, j, x = new Float64Array(64);\n  var p = [gf(), gf(), gf(), gf()];\n\n  crypto_hash(d, sk, 32);\n  d[0] &= 248;\n  d[31] &= 127;\n  d[31] |= 64;\n\n  var smlen = n + 64;\n  for (i = 0; i < n; i++) sm[64 + i] = m[i];\n  for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i];\n\n  crypto_hash(r, sm.subarray(32), n+32);\n  reduce(r);\n  scalarbase(p, r);\n  pack(sm, p);\n\n  for (i = 32; i < 64; i++) sm[i] = sk[i];\n  crypto_hash(h, sm, n + 64);\n  reduce(h);\n\n  for (i = 0; i < 64; i++) x[i] = 0;\n  for (i = 0; i < 32; i++) x[i] = r[i];\n  for (i = 0; i < 32; i++) {\n    for (j = 0; j < 32; j++) {\n      x[i+j] += h[i] * d[j];\n    }\n  }\n\n  modL(sm.subarray(32), x);\n  return smlen;\n}\n\nfunction unpackneg(r, p) {\n  var t = gf(), chk = gf(), num = gf(),\n      den = gf(), den2 = gf(), den4 = gf(),\n      den6 = gf();\n\n  set25519(r[2], gf1);\n  unpack25519(r[1], p);\n  S(num, r[1]);\n  M(den, num, D);\n  Z(num, num, r[2]);\n  A(den, r[2], den);\n\n  S(den2, den);\n  S(den4, den2);\n  M(den6, den4, den2);\n  M(t, den6, num);\n  M(t, t, den);\n\n  pow2523(t, t);\n  M(t, t, num);\n  M(t, t, den);\n  M(t, t, den);\n  M(r[0], t, den);\n\n  S(chk, r[0]);\n  M(chk, chk, den);\n  if (neq25519(chk, num)) M(r[0], r[0], I);\n\n  S(chk, r[0]);\n  M(chk, chk, den);\n  if (neq25519(chk, num)) return -1;\n\n  if (par25519(r[0]) === (p[31]>>7)) Z(r[0], gf0, r[0]);\n\n  M(r[3], r[0], r[1]);\n  return 0;\n}\n\nfunction crypto_sign_open(m, sm, n, pk) {\n  var i, mlen;\n  var t = new Uint8Array(32), h = new Uint8Array(64);\n  var p = [gf(), gf(), gf(), gf()],\n      q = [gf(), gf(), gf(), gf()];\n\n  mlen = -1;\n  if (n < 64) return -1;\n\n  if (unpackneg(q, pk)) return -1;\n\n  for (i = 0; i < n; i++) m[i] = sm[i];\n  for (i = 0; i < 32; i++) m[i+32] = pk[i];\n  crypto_hash(h, m, n);\n  reduce(h);\n  scalarmult(p, q, h);\n\n  scalarbase(q, sm.subarray(32));\n  add(p, q);\n  pack(t, p);\n\n  n -= 64;\n  if (crypto_verify_32(sm, 0, t, 0)) {\n    for (i = 0; i < n; i++) m[i] = 0;\n    return -1;\n  }\n\n  for (i = 0; i < n; i++) m[i] = sm[i + 64];\n  mlen = n;\n  return mlen;\n}\n\nvar crypto_secretbox_KEYBYTES = 32,\n    crypto_secretbox_NONCEBYTES = 24,\n    crypto_secretbox_ZEROBYTES = 32,\n    crypto_secretbox_BOXZEROBYTES = 16,\n    crypto_scalarmult_BYTES = 32,\n    crypto_scalarmult_SCALARBYTES = 32,\n    crypto_box_PUBLICKEYBYTES = 32,\n    crypto_box_SECRETKEYBYTES = 32,\n    crypto_box_BEFORENMBYTES = 32,\n    crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES,\n    crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES,\n    crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES,\n    crypto_sign_BYTES = 64,\n    crypto_sign_PUBLICKEYBYTES = 32,\n    crypto_sign_SECRETKEYBYTES = 64,\n    crypto_sign_SEEDBYTES = 32,\n    crypto_hash_BYTES = 64;\n\nnacl.lowlevel = {\n  crypto_core_hsalsa20: crypto_core_hsalsa20,\n  crypto_stream_xor: crypto_stream_xor,\n  crypto_stream: crypto_stream,\n  crypto_stream_salsa20_xor: crypto_stream_salsa20_xor,\n  crypto_stream_salsa20: crypto_stream_salsa20,\n  crypto_onetimeauth: crypto_onetimeauth,\n  crypto_onetimeauth_verify: crypto_onetimeauth_verify,\n  crypto_verify_16: crypto_verify_16,\n  crypto_verify_32: crypto_verify_32,\n  crypto_secretbox: crypto_secretbox,\n  crypto_secretbox_open: crypto_secretbox_open,\n  crypto_scalarmult: crypto_scalarmult,\n  crypto_scalarmult_base: crypto_scalarmult_base,\n  crypto_box_beforenm: crypto_box_beforenm,\n  crypto_box_afternm: crypto_box_afternm,\n  crypto_box: crypto_box,\n  crypto_box_open: crypto_box_open,\n  crypto_box_keypair: crypto_box_keypair,\n  crypto_hash: crypto_hash,\n  crypto_sign: crypto_sign,\n  crypto_sign_keypair: crypto_sign_keypair,\n  crypto_sign_open: crypto_sign_open,\n\n  crypto_secretbox_KEYBYTES: crypto_secretbox_KEYBYTES,\n  crypto_secretbox_NONCEBYTES: crypto_secretbox_NONCEBYTES,\n  crypto_secretbox_ZEROBYTES: crypto_secretbox_ZEROBYTES,\n  crypto_secretbox_BOXZEROBYTES: crypto_secretbox_BOXZEROBYTES,\n  crypto_scalarmult_BYTES: crypto_scalarmult_BYTES,\n  crypto_scalarmult_SCALARBYTES: crypto_scalarmult_SCALARBYTES,\n  crypto_box_PUBLICKEYBYTES: crypto_box_PUBLICKEYBYTES,\n  crypto_box_SECRETKEYBYTES: crypto_box_SECRETKEYBYTES,\n  crypto_box_BEFORENMBYTES: crypto_box_BEFORENMBYTES,\n  crypto_box_NONCEBYTES: crypto_box_NONCEBYTES,\n  crypto_box_ZEROBYTES: crypto_box_ZEROBYTES,\n  crypto_box_BOXZEROBYTES: crypto_box_BOXZEROBYTES,\n  crypto_sign_BYTES: crypto_sign_BYTES,\n  crypto_sign_PUBLICKEYBYTES: crypto_sign_PUBLICKEYBYTES,\n  crypto_sign_SECRETKEYBYTES: crypto_sign_SECRETKEYBYTES,\n  crypto_sign_SEEDBYTES: crypto_sign_SEEDBYTES,\n  crypto_hash_BYTES: crypto_hash_BYTES\n};\n\n/* High-level API */\n\nfunction checkLengths(k, n) {\n  if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size');\n  if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size');\n}\n\nfunction checkBoxLengths(pk, sk) {\n  if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error('bad public key size');\n  if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error('bad secret key size');\n}\n\nfunction checkArrayTypes() {\n  var t, i;\n  for (i = 0; i < arguments.length; i++) {\n     if ((t = Object.prototype.toString.call(arguments[i])) !== '[object Uint8Array]')\n       throw new TypeError('unexpected type ' + t + ', use Uint8Array');\n  }\n}\n\nfunction cleanup(arr) {\n  for (var i = 0; i < arr.length; i++) arr[i] = 0;\n}\n\n// TODO: Completely remove this in v0.15.\nif (!nacl.util) {\n  nacl.util = {};\n  nacl.util.decodeUTF8 = nacl.util.encodeUTF8 = nacl.util.encodeBase64 = nacl.util.decodeBase64 = function() {\n    throw new Error('nacl.util moved into separate package: https://github.com/dchest/tweetnacl-util-js');\n  };\n}\n\nnacl.randomBytes = function(n) {\n  var b = new Uint8Array(n);\n  randombytes(b, n);\n  return b;\n};\n\nnacl.secretbox = function(msg, nonce, key) {\n  checkArrayTypes(msg, nonce, key);\n  checkLengths(key, nonce);\n  var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);\n  var c = new Uint8Array(m.length);\n  for (var i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i];\n  crypto_secretbox(c, m, m.length, nonce, key);\n  return c.subarray(crypto_secretbox_BOXZEROBYTES);\n};\n\nnacl.secretbox.open = function(box, nonce, key) {\n  checkArrayTypes(box, nonce, key);\n  checkLengths(key, nonce);\n  var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);\n  var m = new Uint8Array(c.length);\n  for (var i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i];\n  if (c.length < 32) return false;\n  if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return false;\n  return m.subarray(crypto_secretbox_ZEROBYTES);\n};\n\nnacl.secretbox.keyLength = crypto_secretbox_KEYBYTES;\nnacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES;\nnacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES;\n\nnacl.scalarMult = function(n, p) {\n  checkArrayTypes(n, p);\n  if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');\n  if (p.length !== crypto_scalarmult_BYTES) throw new Error('bad p size');\n  var q = new Uint8Array(crypto_scalarmult_BYTES);\n  crypto_scalarmult(q, n, p);\n  return q;\n};\n\nnacl.scalarMult.base = function(n) {\n  checkArrayTypes(n);\n  if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');\n  var q = new Uint8Array(crypto_scalarmult_BYTES);\n  crypto_scalarmult_base(q, n);\n  return q;\n};\n\nnacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES;\nnacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES;\n\nnacl.box = function(msg, nonce, publicKey, secretKey) {\n  var k = nacl.box.before(publicKey, secretKey);\n  return nacl.secretbox(msg, nonce, k);\n};\n\nnacl.box.before = function(publicKey, secretKey) {\n  checkArrayTypes(publicKey, secretKey);\n  checkBoxLengths(publicKey, secretKey);\n  var k = new Uint8Array(crypto_box_BEFORENMBYTES);\n  crypto_box_beforenm(k, publicKey, secretKey);\n  return k;\n};\n\nnacl.box.after = nacl.secretbox;\n\nnacl.box.open = function(msg, nonce, publicKey, secretKey) {\n  var k = nacl.box.before(publicKey, secretKey);\n  return nacl.secretbox.open(msg, nonce, k);\n};\n\nnacl.box.open.after = nacl.secretbox.open;\n\nnacl.box.keyPair = function() {\n  var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);\n  var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);\n  crypto_box_keypair(pk, sk);\n  return {publicKey: pk, secretKey: sk};\n};\n\nnacl.box.keyPair.fromSecretKey = function(secretKey) {\n  checkArrayTypes(secretKey);\n  if (secretKey.length !== crypto_box_SECRETKEYBYTES)\n    throw new Error('bad secret key size');\n  var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);\n  crypto_scalarmult_base(pk, secretKey);\n  return {publicKey: pk, secretKey: new Uint8Array(secretKey)};\n};\n\nnacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES;\nnacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES;\nnacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES;\nnacl.box.nonceLength = crypto_box_NONCEBYTES;\nnacl.box.overheadLength = nacl.secretbox.overheadLength;\n\nnacl.sign = function(msg, secretKey) {\n  checkArrayTypes(msg, secretKey);\n  if (secretKey.length !== crypto_sign_SECRETKEYBYTES)\n    throw new Error('bad secret key size');\n  var signedMsg = new Uint8Array(crypto_sign_BYTES+msg.length);\n  crypto_sign(signedMsg, msg, msg.length, secretKey);\n  return signedMsg;\n};\n\nnacl.sign.open = function(signedMsg, publicKey) {\n  if (arguments.length !== 2)\n    throw new Error('nacl.sign.open accepts 2 arguments; did you mean to use nacl.sign.detached.verify?');\n  checkArrayTypes(signedMsg, publicKey);\n  if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)\n    throw new Error('bad public key size');\n  var tmp = new Uint8Array(signedMsg.length);\n  var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);\n  if (mlen < 0) return null;\n  var m = new Uint8Array(mlen);\n  for (var i = 0; i < m.length; i++) m[i] = tmp[i];\n  return m;\n};\n\nnacl.sign.detached = function(msg, secretKey) {\n  var signedMsg = nacl.sign(msg, secretKey);\n  var sig = new Uint8Array(crypto_sign_BYTES);\n  for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];\n  return sig;\n};\n\nnacl.sign.detached.verify = function(msg, sig, publicKey) {\n  checkArrayTypes(msg, sig, publicKey);\n  if (sig.length !== crypto_sign_BYTES)\n    throw new Error('bad signature size');\n  if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)\n    throw new Error('bad public key size');\n  var sm = new Uint8Array(crypto_sign_BYTES + msg.length);\n  var m = new Uint8Array(crypto_sign_BYTES + msg.length);\n  var i;\n  for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i];\n  for (i = 0; i < msg.length; i++) sm[i+crypto_sign_BYTES] = msg[i];\n  return (crypto_sign_open(m, sm, sm.length, publicKey) >= 0);\n};\n\nnacl.sign.keyPair = function() {\n  var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);\n  var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);\n  crypto_sign_keypair(pk, sk);\n  return {publicKey: pk, secretKey: sk};\n};\n\nnacl.sign.keyPair.fromSecretKey = function(secretKey) {\n  checkArrayTypes(secretKey);\n  if (secretKey.length !== crypto_sign_SECRETKEYBYTES)\n    throw new Error('bad secret key size');\n  var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);\n  for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32+i];\n  return {publicKey: pk, secretKey: new Uint8Array(secretKey)};\n};\n\nnacl.sign.keyPair.fromSeed = function(seed) {\n  checkArrayTypes(seed);\n  if (seed.length !== crypto_sign_SEEDBYTES)\n    throw new Error('bad seed size');\n  var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);\n  var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);\n  for (var i = 0; i < 32; i++) sk[i] = seed[i];\n  crypto_sign_keypair(pk, sk, true);\n  return {publicKey: pk, secretKey: sk};\n};\n\nnacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES;\nnacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES;\nnacl.sign.seedLength = crypto_sign_SEEDBYTES;\nnacl.sign.signatureLength = crypto_sign_BYTES;\n\nnacl.hash = function(msg) {\n  checkArrayTypes(msg);\n  var h = new Uint8Array(crypto_hash_BYTES);\n  crypto_hash(h, msg, msg.length);\n  return h;\n};\n\nnacl.hash.hashLength = crypto_hash_BYTES;\n\nnacl.verify = function(x, y) {\n  checkArrayTypes(x, y);\n  // Zero length arguments are considered not equal.\n  if (x.length === 0 || y.length === 0) return false;\n  if (x.length !== y.length) return false;\n  return (vn(x, 0, y, 0, x.length) === 0) ? true : false;\n};\n\nnacl.setPRNG = function(fn) {\n  randombytes = fn;\n};\n\n(function() {\n  // Initialize PRNG if environment provides CSPRNG.\n  // If not, methods calling randombytes will throw.\n  var crypto = typeof self !== 'undefined' ? (self.crypto || self.msCrypto) : null;\n  if (crypto && crypto.getRandomValues) {\n    // Browsers.\n    var QUOTA = 65536;\n    nacl.setPRNG(function(x, n) {\n      var i, v = new Uint8Array(n);\n      for (i = 0; i < n; i += QUOTA) {\n        crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));\n      }\n      for (i = 0; i < n; i++) x[i] = v[i];\n      cleanup(v);\n    });\n  } else if (typeof require !== 'undefined') {\n    // Node.js.\n    crypto = require('crypto');\n    if (crypto && crypto.randomBytes) {\n      nacl.setPRNG(function(x, n) {\n        var i, v = crypto.randomBytes(n);\n        for (i = 0; i < n; i++) x[i] = v[i];\n        cleanup(v);\n      });\n    }\n  }\n})();\n\n})(typeof module !== 'undefined' && module.exports ? module.exports : (self.nacl = self.nacl || {}));\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","var capability = require('./capability')\nvar inherits = require('inherits')\nvar response = require('./response')\nvar stream = require('readable-stream')\nvar toArrayBuffer = require('to-arraybuffer')\n\nvar IncomingMessage = response.IncomingMessage\nvar rStates = response.readyStates\n\nfunction decideMode (preferBinary, useFetch) {\n\tif (capability.fetch && useFetch) {\n\t\treturn 'fetch'\n\t} else if (capability.mozchunkedarraybuffer) {\n\t\treturn 'moz-chunked-arraybuffer'\n\t} else if (capability.msstream) {\n\t\treturn 'ms-stream'\n\t} else if (capability.arraybuffer && preferBinary) {\n\t\treturn 'arraybuffer'\n\t} else if (capability.vbArray && preferBinary) {\n\t\treturn 'text:vbarray'\n\t} else {\n\t\treturn 'text'\n\t}\n}\n\nvar ClientRequest = module.exports = function (opts) {\n\tvar self = this\n\tstream.Writable.call(self)\n\n\tself._opts = opts\n\tself._body = []\n\tself._headers = {}\n\tif (opts.auth)\n\t\tself.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'))\n\tObject.keys(opts.headers).forEach(function (name) {\n\t\tself.setHeader(name, opts.headers[name])\n\t})\n\n\tvar preferBinary\n\tvar useFetch = true\n\tif (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {\n\t\t// If the use of XHR should be preferred. Not typically needed.\n\t\tuseFetch = false\n\t\tpreferBinary = true\n\t} else if (opts.mode === 'prefer-streaming') {\n\t\t// If streaming is a high priority but binary compatibility and\n\t\t// the accuracy of the 'content-type' header aren't\n\t\tpreferBinary = false\n\t} else if (opts.mode === 'allow-wrong-content-type') {\n\t\t// If streaming is more important than preserving the 'content-type' header\n\t\tpreferBinary = !capability.overrideMimeType\n\t} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {\n\t\t// Use binary if text streaming may corrupt data or the content-type header, or for speed\n\t\tpreferBinary = true\n\t} else {\n\t\tthrow new Error('Invalid value for opts.mode')\n\t}\n\tself._mode = decideMode(preferBinary, useFetch)\n\tself._fetchTimer = null\n\n\tself.on('finish', function () {\n\t\tself._onFinish()\n\t})\n}\n\ninherits(ClientRequest, stream.Writable)\n\nClientRequest.prototype.setHeader = function (name, value) {\n\tvar self = this\n\tvar lowerName = name.toLowerCase()\n\t// This check is not necessary, but it prevents warnings from browsers about setting unsafe\n\t// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but\n\t// http-browserify did it, so I will too.\n\tif (unsafeHeaders.indexOf(lowerName) !== -1)\n\t\treturn\n\n\tself._headers[lowerName] = {\n\t\tname: name,\n\t\tvalue: value\n\t}\n}\n\nClientRequest.prototype.getHeader = function (name) {\n\tvar header = this._headers[name.toLowerCase()]\n\tif (header)\n\t\treturn header.value\n\treturn null\n}\n\nClientRequest.prototype.removeHeader = function (name) {\n\tvar self = this\n\tdelete self._headers[name.toLowerCase()]\n}\n\nClientRequest.prototype._onFinish = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\tvar opts = self._opts\n\n\tvar headersObj = self._headers\n\tvar body = null\n\tif (opts.method !== 'GET' && opts.method !== 'HEAD') {\n\t\tif (capability.arraybuffer) {\n\t\t\tbody = toArrayBuffer(Buffer.concat(self._body))\n\t\t} else if (capability.blobConstructor) {\n\t\t\tbody = new global.Blob(self._body.map(function (buffer) {\n\t\t\t\treturn toArrayBuffer(buffer)\n\t\t\t}), {\n\t\t\t\ttype: (headersObj['content-type'] || {}).value || ''\n\t\t\t})\n\t\t} else {\n\t\t\t// get utf8 string\n\t\t\tbody = Buffer.concat(self._body).toString()\n\t\t}\n\t}\n\n\t// create flattened list of headers\n\tvar headersList = []\n\tObject.keys(headersObj).forEach(function (keyName) {\n\t\tvar name = headersObj[keyName].name\n\t\tvar value = headersObj[keyName].value\n\t\tif (Array.isArray(value)) {\n\t\t\tvalue.forEach(function (v) {\n\t\t\t\theadersList.push([name, v])\n\t\t\t})\n\t\t} else {\n\t\t\theadersList.push([name, value])\n\t\t}\n\t})\n\n\tif (self._mode === 'fetch') {\n\t\tvar signal = null\n\t\tvar fetchTimer = null\n\t\tif (capability.abortController) {\n\t\t\tvar controller = new AbortController()\n\t\t\tsignal = controller.signal\n\t\t\tself._fetchAbortController = controller\n\n\t\t\tif ('requestTimeout' in opts && opts.requestTimeout !== 0) {\n\t\t\t\tself._fetchTimer = global.setTimeout(function () {\n\t\t\t\t\tself.emit('requestTimeout')\n\t\t\t\t\tif (self._fetchAbortController)\n\t\t\t\t\t\tself._fetchAbortController.abort()\n\t\t\t\t}, opts.requestTimeout)\n\t\t\t}\n\t\t}\n\n\t\tglobal.fetch(self._opts.url, {\n\t\t\tmethod: self._opts.method,\n\t\t\theaders: headersList,\n\t\t\tbody: body || undefined,\n\t\t\tmode: 'cors',\n\t\t\tcredentials: opts.withCredentials ? 'include' : 'same-origin',\n\t\t\tsignal: signal\n\t\t}).then(function (response) {\n\t\t\tself._fetchResponse = response\n\t\t\tself._connect()\n\t\t}, function (reason) {\n\t\t\tglobal.clearTimeout(self._fetchTimer)\n\t\t\tif (!self._destroyed)\n\t\t\t\tself.emit('error', reason)\n\t\t})\n\t} else {\n\t\tvar xhr = self._xhr = new global.XMLHttpRequest()\n\t\ttry {\n\t\t\txhr.open(self._opts.method, self._opts.url, true)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\n\t\t// Can't set responseType on really old browsers\n\t\tif ('responseType' in xhr)\n\t\t\txhr.responseType = self._mode.split(':')[0]\n\n\t\tif ('withCredentials' in xhr)\n\t\t\txhr.withCredentials = !!opts.withCredentials\n\n\t\tif (self._mode === 'text' && 'overrideMimeType' in xhr)\n\t\t\txhr.overrideMimeType('text/plain; charset=x-user-defined')\n\n\t\tif ('requestTimeout' in opts) {\n\t\t\txhr.timeout = opts.requestTimeout\n\t\t\txhr.ontimeout = function () {\n\t\t\t\tself.emit('requestTimeout')\n\t\t\t}\n\t\t}\n\n\t\theadersList.forEach(function (header) {\n\t\t\txhr.setRequestHeader(header[0], header[1])\n\t\t})\n\n\t\tself._response = null\n\t\txhr.onreadystatechange = function () {\n\t\t\tswitch (xhr.readyState) {\n\t\t\t\tcase rStates.LOADING:\n\t\t\t\tcase rStates.DONE:\n\t\t\t\t\tself._onXHRProgress()\n\t\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// Necessary for streaming in Firefox, since xhr.response is ONLY defined\n\t\t// in onprogress, not in onreadystatechange with xhr.readyState = 3\n\t\tif (self._mode === 'moz-chunked-arraybuffer') {\n\t\t\txhr.onprogress = function () {\n\t\t\t\tself._onXHRProgress()\n\t\t\t}\n\t\t}\n\n\t\txhr.onerror = function () {\n\t\t\tif (self._destroyed)\n\t\t\t\treturn\n\t\t\tself.emit('error', new Error('XHR error'))\n\t\t}\n\n\t\ttry {\n\t\t\txhr.send(body)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\t}\n}\n\n/**\n * Checks if xhr.status is readable and non-zero, indicating no error.\n * Even though the spec says it should be available in readyState 3,\n * accessing it throws an exception in IE8\n */\nfunction statusValid (xhr) {\n\ttry {\n\t\tvar status = xhr.status\n\t\treturn (status !== null && status !== 0)\n\t} catch (e) {\n\t\treturn false\n\t}\n}\n\nClientRequest.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tif (!statusValid(self._xhr) || self._destroyed)\n\t\treturn\n\n\tif (!self._response)\n\t\tself._connect()\n\n\tself._response._onXHRProgress()\n}\n\nClientRequest.prototype._connect = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\n\tself._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer)\n\tself._response.on('error', function(err) {\n\t\tself.emit('error', err)\n\t})\n\n\tself.emit('response', self._response)\n}\n\nClientRequest.prototype._write = function (chunk, encoding, cb) {\n\tvar self = this\n\n\tself._body.push(chunk)\n\tcb()\n}\n\nClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {\n\tvar self = this\n\tself._destroyed = true\n\tglobal.clearTimeout(self._fetchTimer)\n\tif (self._response)\n\t\tself._response._destroyed = true\n\tif (self._xhr)\n\t\tself._xhr.abort()\n\telse if (self._fetchAbortController)\n\t\tself._fetchAbortController.abort()\n}\n\nClientRequest.prototype.end = function (data, encoding, cb) {\n\tvar self = this\n\tif (typeof data === 'function') {\n\t\tcb = data\n\t\tdata = undefined\n\t}\n\n\tstream.Writable.prototype.end.call(self, data, encoding, cb)\n}\n\nClientRequest.prototype.flushHeaders = function () {}\nClientRequest.prototype.setTimeout = function () {}\nClientRequest.prototype.setNoDelay = function () {}\nClientRequest.prototype.setSocketKeepAlive = function () {}\n\n// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method\nvar unsafeHeaders = [\n\t'accept-charset',\n\t'accept-encoding',\n\t'access-control-request-headers',\n\t'access-control-request-method',\n\t'connection',\n\t'content-length',\n\t'cookie',\n\t'cookie2',\n\t'date',\n\t'dnt',\n\t'expect',\n\t'host',\n\t'keep-alive',\n\t'origin',\n\t'referer',\n\t'te',\n\t'trailer',\n\t'transfer-encoding',\n\t'upgrade',\n\t'via'\n]\n","var ClientRequest = require('./lib/request')\nvar response = require('./lib/response')\nvar extend = require('xtend')\nvar statusCodes = require('builtin-status-codes')\nvar url = require('url')\n\nvar http = exports\n\nhttp.request = function (opts, cb) {\n\tif (typeof opts === 'string')\n\t\topts = url.parse(opts)\n\telse\n\t\topts = extend(opts)\n\n\t// Normally, the page is loaded from http or https, so not specifying a protocol\n\t// will result in a (valid) protocol-relative url. However, this won't work if\n\t// the protocol is something else, like 'file:'\n\tvar defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''\n\n\tvar protocol = opts.protocol || defaultProtocol\n\tvar host = opts.hostname || opts.host\n\tvar port = opts.port\n\tvar path = opts.path || '/'\n\n\t// Necessary for IPv6 addresses\n\tif (host && host.indexOf(':') !== -1)\n\t\thost = '[' + host + ']'\n\n\t// This may be a relative url. The browser should always be able to interpret it correctly.\n\topts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path\n\topts.method = (opts.method || 'GET').toUpperCase()\n\topts.headers = opts.headers || {}\n\n\t// Also valid opts.auth, opts.mode\n\n\tvar req = new ClientRequest(opts)\n\tif (cb)\n\t\treq.on('response', cb)\n\treturn req\n}\n\nhttp.get = function get (opts, cb) {\n\tvar req = http.request(opts, cb)\n\treq.end()\n\treturn req\n}\n\nhttp.ClientRequest = ClientRequest\nhttp.IncomingMessage = response.IncomingMessage\n\nhttp.Agent = function () {}\nhttp.Agent.defaultMaxSockets = 4\n\nhttp.globalAgent = new http.Agent()\n\nhttp.STATUS_CODES = statusCodes\n\nhttp.METHODS = [\n\t'CHECKOUT',\n\t'CONNECT',\n\t'COPY',\n\t'DELETE',\n\t'GET',\n\t'HEAD',\n\t'LOCK',\n\t'M-SEARCH',\n\t'MERGE',\n\t'MKACTIVITY',\n\t'MKCOL',\n\t'MOVE',\n\t'NOTIFY',\n\t'OPTIONS',\n\t'PATCH',\n\t'POST',\n\t'PROPFIND',\n\t'PROPPATCH',\n\t'PURGE',\n\t'PUT',\n\t'REPORT',\n\t'SEARCH',\n\t'SUBSCRIBE',\n\t'TRACE',\n\t'UNLOCK',\n\t'UNSUBSCRIBE'\n]","exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)\n\nexports.writableStream = isFunction(global.WritableStream)\n\nexports.abortController = isFunction(global.AbortController)\n\nexports.blobConstructor = false\ntry {\n\tnew Blob([new ArrayBuffer(1)])\n\texports.blobConstructor = true\n} catch (e) {}\n\n// The xhr request to example.com may violate some restrictive CSP configurations,\n// so if we're running in a browser that supports `fetch`, avoid calling getXHR()\n// and assume support for certain features below.\nvar xhr\nfunction getXHR () {\n\t// Cache the xhr value\n\tif (xhr !== undefined) return xhr\n\n\tif (global.XMLHttpRequest) {\n\t\txhr = new global.XMLHttpRequest()\n\t\t// If XDomainRequest is available (ie only, where xhr might not work\n\t\t// cross domain), use the page location. Otherwise use example.com\n\t\t// Note: this doesn't actually make an http request.\n\t\ttry {\n\t\t\txhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')\n\t\t} catch(e) {\n\t\t\txhr = null\n\t\t}\n\t} else {\n\t\t// Service workers don't have XHR\n\t\txhr = null\n\t}\n\treturn xhr\n}\n\nfunction checkTypeSupport (type) {\n\tvar xhr = getXHR()\n\tif (!xhr) return false\n\ttry {\n\t\txhr.responseType = type\n\t\treturn xhr.responseType === type\n\t} catch (e) {}\n\treturn false\n}\n\n// For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.\n// Safari 7.1 appears to have fixed this bug.\nvar haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined'\nvar haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice)\n\n// If fetch is supported, then arraybuffer will be supported too. Skip calling\n// checkTypeSupport(), since that calls getXHR().\nexports.arraybuffer = exports.fetch || (haveArrayBuffer && checkTypeSupport('arraybuffer'))\n\n// These next two tests unavoidably show warnings in Chrome. Since fetch will always\n// be used if it's available, just return false for these to avoid the warnings.\nexports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream')\nexports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer &&\n\tcheckTypeSupport('moz-chunked-arraybuffer')\n\n// If fetch is supported, then overrideMimeType will be supported too. Skip calling\n// getXHR().\nexports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)\n\nexports.vbArray = isFunction(global.VBArray)\n\nfunction isFunction (value) {\n\treturn typeof value === 'function'\n}\n\nxhr = null // Help gc\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar stream = require('readable-stream')\n\nvar rStates = exports.readyStates = {\n\tUNSENT: 0,\n\tOPENED: 1,\n\tHEADERS_RECEIVED: 2,\n\tLOADING: 3,\n\tDONE: 4\n}\n\nvar IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {\n\tvar self = this\n\tstream.Readable.call(self)\n\n\tself._mode = mode\n\tself.headers = {}\n\tself.rawHeaders = []\n\tself.trailers = {}\n\tself.rawTrailers = []\n\n\t// Fake the 'close' event, but only once 'end' fires\n\tself.on('end', function () {\n\t\t// The nextTick is necessary to prevent the 'request' module from causing an infinite loop\n\t\tprocess.nextTick(function () {\n\t\t\tself.emit('close')\n\t\t})\n\t})\n\n\tif (mode === 'fetch') {\n\t\tself._fetchResponse = response\n\n\t\tself.url = response.url\n\t\tself.statusCode = response.status\n\t\tself.statusMessage = response.statusText\n\t\t\n\t\tresponse.headers.forEach(function (header, key){\n\t\t\tself.headers[key.toLowerCase()] = header\n\t\t\tself.rawHeaders.push(key, header)\n\t\t})\n\n\t\tif (capability.writableStream) {\n\t\t\tvar writable = new WritableStream({\n\t\t\t\twrite: function (chunk) {\n\t\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\t\tif (self._destroyed) {\n\t\t\t\t\t\t\treject()\n\t\t\t\t\t\t} else if(self.push(new Buffer(chunk))) {\n\t\t\t\t\t\t\tresolve()\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tself._resumeFetch = resolve\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t},\n\t\t\t\tclose: function () {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.push(null)\n\t\t\t\t},\n\t\t\t\tabort: function (err) {\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t}\n\t\t\t})\n\n\t\t\ttry {\n\t\t\t\tresponse.body.pipeTo(writable).catch(function (err) {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t})\n\t\t\t\treturn\n\t\t\t} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this\n\t\t}\n\t\t// fallback for when writableStream or pipeTo aren't available\n\t\tvar reader = response.body.getReader()\n\t\tfunction read () {\n\t\t\treader.read().then(function (result) {\n\t\t\t\tif (self._destroyed)\n\t\t\t\t\treturn\n\t\t\t\tif (result.done) {\n\t\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\t\tself.push(null)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tself.push(new Buffer(result.value))\n\t\t\t\tread()\n\t\t\t}).catch(function (err) {\n\t\t\t\tglobal.clearTimeout(fetchTimer)\n\t\t\t\tif (!self._destroyed)\n\t\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t}\n\t\tread()\n\t} else {\n\t\tself._xhr = xhr\n\t\tself._pos = 0\n\n\t\tself.url = xhr.responseURL\n\t\tself.statusCode = xhr.status\n\t\tself.statusMessage = xhr.statusText\n\t\tvar headers = xhr.getAllResponseHeaders().split(/\\r?\\n/)\n\t\theaders.forEach(function (header) {\n\t\t\tvar matches = header.match(/^([^:]+):\\s*(.*)/)\n\t\t\tif (matches) {\n\t\t\t\tvar key = matches[1].toLowerCase()\n\t\t\t\tif (key === 'set-cookie') {\n\t\t\t\t\tif (self.headers[key] === undefined) {\n\t\t\t\t\t\tself.headers[key] = []\n\t\t\t\t\t}\n\t\t\t\t\tself.headers[key].push(matches[2])\n\t\t\t\t} else if (self.headers[key] !== undefined) {\n\t\t\t\t\tself.headers[key] += ', ' + matches[2]\n\t\t\t\t} else {\n\t\t\t\t\tself.headers[key] = matches[2]\n\t\t\t\t}\n\t\t\t\tself.rawHeaders.push(matches[1], matches[2])\n\t\t\t}\n\t\t})\n\n\t\tself._charset = 'x-user-defined'\n\t\tif (!capability.overrideMimeType) {\n\t\t\tvar mimeType = self.rawHeaders['mime-type']\n\t\t\tif (mimeType) {\n\t\t\t\tvar charsetMatch = mimeType.match(/;\\s*charset=([^;])(;|$)/)\n\t\t\t\tif (charsetMatch) {\n\t\t\t\t\tself._charset = charsetMatch[1].toLowerCase()\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!self._charset)\n\t\t\t\tself._charset = 'utf-8' // best guess\n\t\t}\n\t}\n}\n\ninherits(IncomingMessage, stream.Readable)\n\nIncomingMessage.prototype._read = function () {\n\tvar self = this\n\n\tvar resolve = self._resumeFetch\n\tif (resolve) {\n\t\tself._resumeFetch = null\n\t\tresolve()\n\t}\n}\n\nIncomingMessage.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tvar xhr = self._xhr\n\n\tvar response = null\n\tswitch (self._mode) {\n\t\tcase 'text:vbarray': // For IE9\n\t\t\tif (xhr.readyState !== rStates.DONE)\n\t\t\t\tbreak\n\t\t\ttry {\n\t\t\t\t// This fails in IE8\n\t\t\t\tresponse = new global.VBArray(xhr.responseBody).toArray()\n\t\t\t} catch (e) {}\n\t\t\tif (response !== null) {\n\t\t\t\tself.push(new Buffer(response))\n\t\t\t\tbreak\n\t\t\t}\n\t\t\t// Falls through in IE8\t\n\t\tcase 'text':\n\t\t\ttry { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4\n\t\t\t\tresponse = xhr.responseText\n\t\t\t} catch (e) {\n\t\t\t\tself._mode = 'text:vbarray'\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tif (response.length > self._pos) {\n\t\t\t\tvar newData = response.substr(self._pos)\n\t\t\t\tif (self._charset === 'x-user-defined') {\n\t\t\t\t\tvar buffer = new Buffer(newData.length)\n\t\t\t\t\tfor (var i = 0; i < newData.length; i++)\n\t\t\t\t\t\tbuffer[i] = newData.charCodeAt(i) & 0xff\n\n\t\t\t\t\tself.push(buffer)\n\t\t\t\t} else {\n\t\t\t\t\tself.push(newData, self._charset)\n\t\t\t\t}\n\t\t\t\tself._pos = response.length\n\t\t\t}\n\t\t\tbreak\n\t\tcase 'arraybuffer':\n\t\t\tif (xhr.readyState !== rStates.DONE || !xhr.response)\n\t\t\t\tbreak\n\t\t\tresponse = xhr.response\n\t\t\tself.push(new Buffer(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'moz-chunked-arraybuffer': // take whole\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING || !response)\n\t\t\t\tbreak\n\t\t\tself.push(new Buffer(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'ms-stream':\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING)\n\t\t\t\tbreak\n\t\t\tvar reader = new global.MSStreamReader()\n\t\t\treader.onprogress = function () {\n\t\t\t\tif (reader.result.byteLength > self._pos) {\n\t\t\t\t\tself.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))))\n\t\t\t\t\tself._pos = reader.result.byteLength\n\t\t\t\t}\n\t\t\t}\n\t\t\treader.onload = function () {\n\t\t\t\tself.push(null)\n\t\t\t}\n\t\t\t// reader.onerror = ??? // TODO: this\n\t\t\treader.readAsArrayBuffer(response)\n\t\t\tbreak\n\t}\n\n\t// The ms-stream case handles end separately in reader.onload()\n\tif (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {\n\t\tself.push(null)\n\t}\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","var Buffer = require('buffer').Buffer\n\nmodule.exports = function (buf) {\n\t// If the buffer is backed by a Uint8Array, a faster version will work\n\tif (buf instanceof Uint8Array) {\n\t\t// If the buffer isn't a subarray, return the underlying ArrayBuffer\n\t\tif (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {\n\t\t\treturn buf.buffer\n\t\t} else if (typeof buf.buffer.slice === 'function') {\n\t\t\t// Otherwise we need to get a proper copy\n\t\t\treturn buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)\n\t\t}\n\t}\n\n\tif (Buffer.isBuffer(buf)) {\n\t\t// This is the slow version that will work with any Buffer\n\t\t// implementation (even in old browsers)\n\t\tvar arrayCopy = new Uint8Array(buf.length)\n\t\tvar len = buf.length\n\t\tfor (var i = 0; i < len; i++) {\n\t\t\tarrayCopy[i] = buf[i]\n\t\t}\n\t\treturn arrayCopy.buffer\n\t} else {\n\t\tthrow new Error('Argument must be a Buffer')\n\t}\n}\n"],"sourceRoot":""}