text: !function (f) {if ('object' == typeof exports && 'undefined' != typeof module) module.exports = f() else if ('function' == typeof define && define.amd) define([], f) else {('undefined' != typeof window ? window : 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : this).httpStream = f()}}((function () {
    return function e (t, n, r) {
      function s (o, u) {
        if (!n[o]) {
          if (!t[o]) {
            var a = 'function' == typeof require && require
            if (!u && a) return a(o, !0)
            if (i) return i(o, !0)
            var f = new Error('Cannot find module \'' + o + '\'')
            throw f.code = 'MODULE_NOT_FOUND', f
          }
          var l = n[o] = { exports: {} }
          t[o][0].call(l.exports, (function (e) {
            var n = t[o][1][e]
            return s(n || e)
          }), l, l.exports, e, t, n, r)
        }
        return n[o].exports
      }
  
      for (var i = 'function' == typeof require && require, o = 0; o < r.length; o++) s(r[o])
      return s
    }({
      1: [function (require, module, exports) {
        module.exports = {
          100: 'Continue',
          101: 'Switching Protocols',
          102: 'Processing',
          200: 'OK',
          201: 'Created',
          202: 'Accepted',
          203: 'Non-Authoritative Information',
          204: 'No Content',
          205: 'Reset Content',
          206: 'Partial Content',
          207: 'Multi-Status',
          208: 'Already Reported',
          226: 'IM Used',
          300: 'Multiple Choices',
          301: 'Moved Permanently',
          302: 'Found',
          303: 'See Other',
          304: 'Not Modified',
          305: 'Use Proxy',
          307: 'Temporary Redirect',
          308: 'Permanent Redirect',
          400: 'Bad Request',
          401: 'Unauthorized',
          402: 'Payment Required',
          403: 'Forbidden',
          404: 'Not Found',
          405: 'Method Not Allowed',
          406: 'Not Acceptable',
          407: 'Proxy Authentication Required',
          408: 'Request Timeout',
          409: 'Conflict',
          410: 'Gone',
          411: 'Length Required',
          412: 'Precondition Failed',
          413: 'Payload Too Large',
          414: 'URI Too Long',
          415: 'Unsupported Media Type',
          416: 'Range Not Satisfiable',
          417: 'Expectation Failed',
          418: 'I\'m a teapot',
          421: 'Misdirected Request',
          422: 'Unprocessable Entity',
          423: 'Locked',
          424: 'Failed Dependency',
          425: 'Unordered Collection',
          426: 'Upgrade Required',
          428: 'Precondition Required',
          429: 'Too Many Requests',
          431: 'Request Header Fields Too Large',
          451: 'Unavailable For Legal Reasons',
          500: 'Internal Server Error',
          501: 'Not Implemented',
          502: 'Bad Gateway',
          503: 'Service Unavailable',
          504: 'Gateway Timeout',
          505: 'HTTP Version Not Supported',
          506: 'Variant Also Negotiates',
          507: 'Insufficient Storage',
          508: 'Loop Detected',
          509: 'Bandwidth Limit Exceeded',
          510: 'Not Extended',
          511: 'Network Authentication Required'
        }
      }, {}],
      2: [function (require, module, exports) {
        'function' == typeof Object.create ? module.exports = function (ctor, superCtor) {
          superCtor && (ctor.super_ = superCtor, ctor.prototype = Object.create(superCtor.prototype, {
            constructor: {
              value: ctor,
              enumerable: !1,
              writable: !0,
              configurable: !0
            }
          }))
        } : module.exports = function (ctor, superCtor) {
          if (superCtor) {
            ctor.super_ = superCtor
            var TempCtor = function () {}
            TempCtor.prototype = superCtor.prototype, ctor.prototype = new TempCtor, ctor.prototype.constructor = ctor
          }
        }
      }, {}],
      3: [function (require, module, exports) {
        'use strict'
        var codes = {}
  
        function createErrorType (code, message, Base) {
          Base || (Base = Error)
          var NodeError = function (_Base) {
            var subClass, superClass
  
            function NodeError (arg1, arg2, arg3) {return _Base.call(this, function (arg1, arg2, arg3) {return 'string' == typeof message ? message : message(arg1, arg2, arg3)}(arg1, arg2, arg3)) || this}
  
            return superClass = _Base, (subClass = NodeError).prototype = Object.create(superClass.prototype), subClass.prototype.constructor = subClass, subClass.__proto__ = superClass, NodeError
          }(Base)
          NodeError.prototype.name = Base.name, NodeError.prototype.code = code, codes[code] = NodeError
        }
  
        function oneOf (expected, thing) {
          if (Array.isArray(expected)) {
            var len = expected.length
            return expected = expected.map((function (i) {return String(i)})), len > 2 ? 'one of '.concat(thing, ' ').concat(expected.slice(0, len - 1).join(', '), ', or ') + expected[len - 1] : 2 === len ? 'one of '.concat(thing, ' ').concat(expected[0], ' or ').concat(expected[1]) : 'of '.concat(thing, ' ').concat(expected[0])
          }
          return 'of '.concat(thing, ' ').concat(String(expected))
        }
  
        createErrorType('ERR_INVALID_OPT_VALUE', (function (name, value) {return 'The value "' + value + '" is invalid for option "' + name + '"'}), TypeError), createErrorType('ERR_INVALID_ARG_TYPE', (function (name, expected, actual) {
          var determiner, search, pos, msg
          if ('string' == typeof expected && (search = 'not ', expected.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search) ? (determiner = 'must not be', expected = expected.replace(/^not /, '')) : determiner = 'must be', function (str, search, this_len) {return (void 0 === this_len || this_len > str.length) && (this_len = str.length), str.substring(this_len - search.length, this_len) === search}(name, ' argument')) msg = 'The '.concat(name, ' ').concat(determiner, ' ').concat(oneOf(expected, 'type')) else {
            var type = function (str, search, start) {return 'number' != typeof start && (start = 0), !(start + search.length > str.length) && -1 !== str.indexOf(search, start)}(name, '.') ? 'property' : 'argument'
            msg = 'The "'.concat(name, '" ').concat(type, ' ').concat(determiner, ' ').concat(oneOf(expected, 'type'))
          }
          return msg += '. Received type '.concat(typeof actual)
        }), TypeError), createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF'), createErrorType('ERR_METHOD_NOT_IMPLEMENTED', (function (name) {return 'The ' + name + ' method is not implemented'})), createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close'), createErrorType('ERR_STREAM_DESTROYED', (function (name) {return 'Cannot call ' + name + ' after a stream was destroyed'})), createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times'), createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable'), createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end'), createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError), createErrorType('ERR_UNKNOWN_ENCODING', (function (arg) {return 'Unknown encoding: ' + arg}), TypeError), createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event'), module.exports.codes = codes
      }, {}],
      4: [function (require, module, exports) {
        (function (process) {
          'use strict'
          var objectKeys = Object.keys || function (obj) {
            var keys = []
            for (var key in obj) keys.push(key)
            return keys
          }
          module.exports = Duplex
          var Readable = require('./_stream_readable'), Writable = require('./_stream_writable')
          require('inherits')(Duplex, Readable)
          for (var keys = objectKeys(Writable.prototype), v = 0; v < keys.length; v++) {
            var method = keys[v]
            Duplex.prototype[method] || (Duplex.prototype[method] = Writable.prototype[method])
          }
  
          function Duplex (options) {
            if (!(this instanceof Duplex)) return new Duplex(options)
            Readable.call(this, options), Writable.call(this, options), this.allowHalfOpen = !0, options && (!1 === options.readable && (this.readable = !1), !1 === options.writable && (this.writable = !1), !1 === options.allowHalfOpen && (this.allowHalfOpen = !1, this.once('end', onend)))
          }
  
          function onend () {this._writableState.ended || process.nextTick(onEndNT, this)}
  
          function onEndNT (self) {self.end()}
  
          Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
            enumerable: !1,
            get: function () {return this._writableState.highWaterMark}
          }), Object.defineProperty(Duplex.prototype, 'writableBuffer', {
            enumerable: !1,
            get: function () {return this._writableState && this._writableState.getBuffer()}
          }), Object.defineProperty(Duplex.prototype, 'writableLength', {
            enumerable: !1,
            get: function () {return this._writableState.length}
          }), Object.defineProperty(Duplex.prototype, 'destroyed', {
            enumerable: !1,
            get: function () {return void 0 !== this._readableState && void 0 !== this._writableState && (this._readableState.destroyed && this._writableState.destroyed)},
            set: function (value) {void 0 !== this._readableState && void 0 !== this._writableState && (this._readableState.destroyed = value, this._writableState.destroyed = value)}
          })
        }).call(this, require('_process'))
      }, { './_stream_readable': 6, './_stream_writable': 8, _process: 32, inherits: 2 }],
      5: [function (require, module, exports) {
        'use strict'
        module.exports = PassThrough
        var Transform = require('./_stream_transform')
  
        function PassThrough (options) {
          if (!(this instanceof PassThrough)) return new PassThrough(options)
          Transform.call(this, options)
        }
  
        require('inherits')(PassThrough, Transform), PassThrough.prototype._transform = function (chunk, encoding, cb) {cb(null, chunk)}
      }, { './_stream_transform': 7, inherits: 2 }],
      6: [function (require, module, exports) {
        (function (process, global) {
          'use strict'
          var Duplex
          module.exports = Readable, Readable.ReadableState = ReadableState
          require('events').EventEmitter
          var EElistenerCount = function (emitter, type) {return emitter.listeners(type).length},
            Stream = require('./internal/streams/stream'), Buffer = require('buffer').Buffer,
            OurUint8Array = global.Uint8Array || function () {}
          var debug, debugUtil = require('util')
          debug = debugUtil && debugUtil.debuglog ? debugUtil.debuglog('stream') : function () {}
          var StringDecoder, createReadableStreamAsyncIterator, from,
            BufferList = require('./internal/streams/buffer_list'), destroyImpl = require('./internal/streams/destroy'),
            getHighWaterMark = require('./internal/streams/state').getHighWaterMark,
            _require$codes = require('../errors').codes, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
            ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
            ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
            ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT
          require('inherits')(Readable, Stream)
          var errorOrDestroy = destroyImpl.errorOrDestroy,
            kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']
  
          function ReadableState (options, stream, isDuplex) {Duplex = Duplex || require('./_stream_duplex'), options = options || {}, 'boolean' != typeof isDuplex && (isDuplex = stream instanceof Duplex), this.objectMode = !!options.objectMode, isDuplex && (this.objectMode = this.objectMode || !!options.readableObjectMode), this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex), this.buffer = new BufferList, this.length = 0, this.pipes = null, this.pipesCount = 0, this.flowing = null, this.ended = !1, this.endEmitted = !1, this.reading = !1, this.sync = !0, this.needReadable = !1, this.emittedReadable = !1, this.readableListening = !1, this.resumeScheduled = !1, this.paused = !0, this.emitClose = !1 !== options.emitClose, this.autoDestroy = !!options.autoDestroy, this.destroyed = !1, this.defaultEncoding = options.defaultEncoding || 'utf8', this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, options.encoding && (StringDecoder || (StringDecoder = require('string_decoder/').StringDecoder), this.decoder = new StringDecoder(options.encoding), this.encoding = options.encoding)}
  
          function Readable (options) {
            if (Duplex = Duplex || require('./_stream_duplex'), !(this instanceof Readable)) return new Readable(options)
            var isDuplex = this instanceof Duplex
            this._readableState = new ReadableState(options, this, isDuplex), this.readable = !0, options && ('function' == typeof options.read && (this._read = options.read), 'function' == typeof options.destroy && (this._destroy = options.destroy)), Stream.call(this)
          }
  
          function readableAddChunk (stream, chunk, encoding, addToFront, skipChunkCheck) {
            debug('readableAddChunk', chunk)
            var er, state = stream._readableState
            if (null === chunk) state.reading = !1, function (stream, state) {
              if (debug('onEofChunk'), state.ended) return
              if (state.decoder) {
                var chunk = state.decoder.end()
                chunk && chunk.length && (state.buffer.push(chunk), state.length += state.objectMode ? 1 : chunk.length)
              }
              state.ended = !0, state.sync ? emitReadable(stream) : (state.needReadable = !1, state.emittedReadable || (state.emittedReadable = !0, emitReadable_(stream)))
            }(stream, state) else if (skipChunkCheck || (er = function (state, chunk) {
              var er
              obj = chunk, Buffer.isBuffer(obj) || obj instanceof OurUint8Array || 'string' == typeof chunk || void 0 === chunk || state.objectMode || (er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk))
              var obj
              return er
            }(state, chunk)), er) errorOrDestroy(stream, er) else if (state.objectMode || chunk && chunk.length > 0) if ('string' == typeof chunk || state.objectMode || Object.getPrototypeOf(chunk) === Buffer.prototype || (chunk = function (chunk) {return Buffer.from(chunk)}(chunk)), addToFront) state.endEmitted ? errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT) : addChunk(stream, state, chunk, !0) else if (state.ended) errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF) else {
              if (state.destroyed) return !1
              state.reading = !1, state.decoder && !encoding ? (chunk = state.decoder.write(chunk), state.objectMode || 0 !== chunk.length ? addChunk(stream, state, chunk, !1) : maybeReadMore(stream, state)) : addChunk(stream, state, chunk, !1)
            } else addToFront || (state.reading = !1, maybeReadMore(stream, state))
            return !state.ended && (state.length < state.highWaterMark || 0 === state.length)
          }
  
          function addChunk (stream, state, chunk, addToFront) {state.flowing && 0 === state.length && !state.sync ? (state.awaitDrain = 0, stream.emit('data', chunk)) : (state.length += state.objectMode ? 1 : chunk.length, addToFront ? state.buffer.unshift(chunk) : state.buffer.push(chunk), state.needReadable && emitReadable(stream)), maybeReadMore(stream, state)}
  
          Object.defineProperty(Readable.prototype, 'destroyed', {
            enumerable: !1,
            get: function () {return void 0 !== this._readableState && this._readableState.destroyed},
            set: function (value) {this._readableState && (this._readableState.destroyed = value)}
          }), Readable.prototype.destroy = destroyImpl.destroy, Readable.prototype._undestroy = destroyImpl.undestroy, Readable.prototype._destroy = function (err, cb) {cb(err)}, Readable.prototype.push = function (chunk, encoding) {
            var skipChunkCheck, state = this._readableState
            return state.objectMode ? skipChunkCheck = !0 : 'string' == typeof chunk && ((encoding = encoding || state.defaultEncoding) !== state.encoding && (chunk = Buffer.from(chunk, encoding), encoding = ''), skipChunkCheck = !0), readableAddChunk(this, chunk, encoding, !1, skipChunkCheck)
          }, Readable.prototype.unshift = function (chunk) {return readableAddChunk(this, chunk, null, !0, !1)}, Readable.prototype.isPaused = function () {return !1 === this._readableState.flowing}, Readable.prototype.setEncoding = function (enc) {
            StringDecoder || (StringDecoder = require('string_decoder/').StringDecoder)
            var decoder = new StringDecoder(enc)
            this._readableState.decoder = decoder, this._readableState.encoding = this._readableState.decoder.encoding
            for (var p = this._readableState.buffer.head, content = ''; null !== p;) content += decoder.write(p.data), p = p.next
            return this._readableState.buffer.clear(), '' !== content && this._readableState.buffer.push(content), this._readableState.length = content.length, this
          }
  
          function howMuchToRead (n, state) {return n <= 0 || 0 === state.length && state.ended ? 0 : state.objectMode ? 1 : n != n ? state.flowing && state.length ? state.buffer.head.data.length : state.length : (n > state.highWaterMark && (state.highWaterMark = function (n) {return n >= 1073741824 ? n = 1073741824 : (n--, n |= n >>> 1, n |= n >>> 2, n |= n >>> 4, n |= n >>> 8, n |= n >>> 16, n++), n}(n)), n <= state.length ? n : state.ended ? state.length : (state.needReadable = !0, 0))}
  
          function emitReadable (stream) {
            var state = stream._readableState
            debug('emitReadable', state.needReadable, state.emittedReadable), state.needReadable = !1, state.emittedReadable || (debug('emitReadable', state.flowing), state.emittedReadable = !0, process.nextTick(emitReadable_, stream))
          }
  
          function emitReadable_ (stream) {
            var state = stream._readableState
            debug('emitReadable_', state.destroyed, state.length, state.ended), state.destroyed || !state.length && !state.ended || (stream.emit('readable'), state.emittedReadable = !1), state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark, flow(stream)
          }
  
          function maybeReadMore (stream, state) {state.readingMore || (state.readingMore = !0, process.nextTick(maybeReadMore_, stream, state))}
  
          function maybeReadMore_ (stream, state) {
            for (; !state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && 0 === state.length);) {
              var len = state.length
              if (debug('maybeReadMore read 0'), stream.read(0), len === state.length) break
            }
            state.readingMore = !1
          }
  
          function updateReadableListening (self) {
            var state = self._readableState
            state.readableListening = self.listenerCount('readable') > 0, state.resumeScheduled && !state.paused ? state.flowing = !0 : self.listenerCount('data') > 0 && self.resume()
          }
  
          function nReadingNextTick (self) {debug('readable nexttick read 0'), self.read(0)}
  
          function resume_ (stream, state) {debug('resume', state.reading), state.reading || stream.read(0), state.resumeScheduled = !1, stream.emit('resume'), flow(stream), state.flowing && !state.reading && stream.read(0)}
  
          function flow (stream) {
            var state = stream._readableState
            for (debug('flow', state.flowing); state.flowing && null !== stream.read();)
          }
  
          function fromList (n, state) {
            return 0 === state.length ? null : (state.objectMode ? ret = state.buffer.shift() : !n || n >= state.length ? (ret = state.decoder ? state.buffer.join('') : 1 === state.buffer.length ? state.buffer.first() : state.buffer.concat(state.length), state.buffer.clear()) : ret = state.buffer.consume(n, state.decoder), ret)
            var ret
          }
  
          function endReadable (stream) {
            var state = stream._readableState
            debug('endReadable', state.endEmitted), state.endEmitted || (state.ended = !0, process.nextTick(endReadableNT, state, stream))
          }
  
          function endReadableNT (state, stream) {
            if (debug('endReadableNT', state.endEmitted, state.length), !state.endEmitted && 0 === state.length && (state.endEmitted = !0, stream.readable = !1, stream.emit('end'), state.autoDestroy)) {
              var wState = stream._writableState;
              (!wState || wState.autoDestroy && wState.finished) && stream.destroy()
            }
          }
  
          function indexOf (xs, x) {
            for (var i = 0, l = xs.length; i < l; i++) if (xs[i] === x) return i
            return -1
          }
  
          Readable.prototype.read = function (n) {
            debug('read', n), n = parseInt(n, 10)
            var state = this._readableState, nOrig = n
            if (0 !== n && (state.emittedReadable = !1), 0 === n && state.needReadable && ((0 !== state.highWaterMark ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) return debug('read: emitReadable', state.length, state.ended), 0 === state.length && state.ended ? endReadable(this) : emitReadable(this), null
            if (0 === (n = howMuchToRead(n, state)) && state.ended) return 0 === state.length && endReadable(this), null
            var ret, doRead = state.needReadable
            return debug('need readable', doRead), (0 === state.length || state.length - n < state.highWaterMark) && debug('length less than watermark', doRead = !0), state.ended || state.reading ? debug('reading or ended', doRead = !1) : doRead && (debug('do read'), state.reading = !0, state.sync = !0, 0 === state.length && (state.needReadable = !0), this._read(state.highWaterMark), state.sync = !1, state.reading || (n = howMuchToRead(nOrig, state))), null === (ret = n > 0 ? fromList(n, state) : null) ? (state.needReadable = state.length <= state.highWaterMark, n = 0) : (state.length -= n, state.awaitDrain = 0), 0 === state.length && (state.ended || (state.needReadable = !0), nOrig !== n && state.ended && endReadable(this)), null !== ret && this.emit('data', ret), ret
          }, Readable.prototype._read = function (n) {errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'))}, Readable.prototype.pipe = function (dest, pipeOpts) {
            var src = this, state = this._readableState
            switch (state.pipesCount) {
              case 0:
                state.pipes = dest
                break
              case 1:
                state.pipes = [state.pipes, dest]
                break
              default:
                state.pipes.push(dest)
            }
            state.pipesCount += 1, debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts)
            var endFn = (!pipeOpts || !1 !== pipeOpts.end) && dest !== process.stdout && dest !== process.stderr ? onend : unpipe
  
            function onunpipe (readable, unpipeInfo) {debug('onunpipe'), readable === src && unpipeInfo && !1 === unpipeInfo.hasUnpiped && (unpipeInfo.hasUnpiped = !0, debug('cleanup'), dest.removeListener('close', onclose), dest.removeListener('finish', onfinish), dest.removeListener('drain', ondrain), dest.removeListener('error', onerror), dest.removeListener('unpipe', onunpipe), src.removeListener('end', onend), src.removeListener('end', unpipe), src.removeListener('data', ondata), cleanedUp = !0, !state.awaitDrain || dest._writableState && !dest._writableState.needDrain || ondrain())}
  
            function onend () {debug('onend'), dest.end()}
  
            state.endEmitted ? process.nextTick(endFn) : src.once('end', endFn), dest.on('unpipe', onunpipe)
            var ondrain = function (src) {
              return function () {
                var state = src._readableState
                debug('pipeOnDrain', state.awaitDrain), state.awaitDrain && state.awaitDrain--, 0 === state.awaitDrain && EElistenerCount(src, 'data') && (state.flowing = !0, flow(src))
              }
            }(src)
            dest.on('drain', ondrain)
            var cleanedUp = !1
  
            function ondata (chunk) {
              debug('ondata')
              var ret = dest.write(chunk)
              debug('dest.write', ret), !1 === ret && ((1 === state.pipesCount && state.pipes === dest || state.pipesCount > 1 && -1 !== indexOf(state.pipes, dest)) && !cleanedUp && (debug('false write response, pause', state.awaitDrain), state.awaitDrain++), src.pause())
            }
  
            function onerror (er) {debug('onerror', er), unpipe(), dest.removeListener('error', onerror), 0 === EElistenerCount(dest, 'error') && errorOrDestroy(dest, er)}
  
            function onclose () {dest.removeListener('finish', onfinish), unpipe()}
  
            function onfinish () {debug('onfinish'), dest.removeListener('close', onclose), unpipe()}
  
            function unpipe () {debug('unpipe'), src.unpipe(dest)}
  
            return src.on('data', ondata), function (emitter, event, fn) {
              if ('function' == typeof emitter.prependListener) return emitter.prependListener(event, fn)
              emitter._events && emitter._events[event] ? Array.isArray(emitter._events[event]) ? emitter._events[event].unshift(fn) : emitter._events[event] = [fn, emitter._events[event]] : emitter.on(event, fn)
            }(dest, 'error', onerror), dest.once('close', onclose), dest.once('finish', onfinish), dest.emit('pipe', src), state.flowing || (debug('pipe resume'), src.resume()), dest
          }, Readable.prototype.unpipe = function (dest) {
            var state = this._readableState, unpipeInfo = { hasUnpiped: !1 }
            if (0 === state.pipesCount) return this
            if (1 === state.pipesCount) return dest && dest !== state.pipes || (dest || (dest = state.pipes), state.pipes = null, state.pipesCount = 0, state.flowing = !1, dest && dest.emit('unpipe', this, unpipeInfo)), this
            if (!dest) {
              var dests = state.pipes, len = state.pipesCount
              state.pipes = null, state.pipesCount = 0, state.flowing = !1
              for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, { hasUnpiped: !1 })
              return this
            }
            var index = indexOf(state.pipes, dest)
            return -1 === index || (state.pipes.splice(index, 1), state.pipesCount -= 1, 1 === state.pipesCount && (state.pipes = state.pipes[0]), dest.emit('unpipe', this, unpipeInfo)), this
          }, Readable.prototype.on = function (ev, fn) {
            var res = Stream.prototype.on.call(this, ev, fn), state = this._readableState
            return 'data' === ev ? (state.readableListening = this.listenerCount('readable') > 0, !1 !== state.flowing && this.resume()) : 'readable' === ev && (state.endEmitted || state.readableListening || (state.readableListening = state.needReadable = !0, state.flowing = !1, state.emittedReadable = !1, debug('on readable', state.length, state.reading), state.length ? emitReadable(this) : state.reading || process.nextTick(nReadingNextTick, this))), res
          }, Readable.prototype.addListener = Readable.prototype.on, Readable.prototype.removeListener = function (ev, fn) {
            var res = Stream.prototype.removeListener.call(this, ev, fn)
            return 'readable' === ev && process.nextTick(updateReadableListening, this), res
          }, Readable.prototype.removeAllListeners = function (ev) {
            var res = Stream.prototype.removeAllListeners.apply(this, arguments)
            return 'readable' !== ev && void 0 !== ev || process.nextTick(updateReadableListening, this), res
          }, Readable.prototype.resume = function () {
            var state = this._readableState
            return state.flowing || (debug('resume'), state.flowing = !state.readableListening, function (stream, state) {state.resumeScheduled || (state.resumeScheduled = !0, process.nextTick(resume_, stream, state))}(this, state)), state.paused = !1, this
          }, Readable.prototype.pause = function () {return debug('call pause flowing=%j', this._readableState.flowing), !1 !== this._readableState.flowing && (debug('pause'), this._readableState.flowing = !1, this.emit('pause')), this._readableState.paused = !0, this}, Readable.prototype.wrap = function (stream) {
            var _this = this, state = this._readableState, paused = !1
            for (var i in stream.on('end', (function () {
              if (debug('wrapped end'), state.decoder && !state.ended) {
                var chunk = state.decoder.end()
                chunk && chunk.length && _this.push(chunk)
              }
              _this.push(null)
            })), stream.on('data', (function (chunk) {(debug('wrapped data'), state.decoder && (chunk = state.decoder.write(chunk)), state.objectMode && null == chunk) || (state.objectMode || chunk && chunk.length) && (_this.push(chunk) || (paused = !0, stream.pause()))})), stream) void 0 === this[i] && 'function' == typeof stream[i] && (this[i] = function (method) {return function () {return stream[method].apply(stream, arguments)}}(i))
            for (var n = 0; n < kProxyEvents.length; n++) stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]))
            return this._read = function (n) {debug('wrapped _read', n), paused && (paused = !1, stream.resume())}, this
          }, 'function' == typeof Symbol && (Readable.prototype[Symbol.asyncIterator] = function () {return void 0 === createReadableStreamAsyncIterator && (createReadableStreamAsyncIterator = require('./internal/streams/async_iterator')), createReadableStreamAsyncIterator(this)}), Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
            enumerable: !1,
            get: function () {return this._readableState.highWaterMark}
          }), Object.defineProperty(Readable.prototype, 'readableBuffer', {
            enumerable: !1,
            get: function () {return this._readableState && this._readableState.buffer}
          }), Object.defineProperty(Readable.prototype, 'readableFlowing', {
            enumerable: !1,
            get: function () {return this._readableState.flowing},
            set: function (state) {this._readableState && (this._readableState.flowing = state)}
          }), Readable._fromList = fromList, Object.defineProperty(Readable.prototype, 'readableLength', {
            enumerable: !1,
            get: function () {return this._readableState.length}
          }), 'function' == typeof Symbol && (Readable.from = function (iterable, opts) {return void 0 === from && (from = require('./internal/streams/from')), from(Readable, iterable, opts)})
        }).call(this, require('_process'), 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {})
      }, {
        '../errors': 3,
        './_stream_duplex': 4,
        './internal/streams/async_iterator': 9,
        './internal/streams/buffer_list': 10,
        './internal/streams/destroy': 11,
        './internal/streams/from': 13,
        './internal/streams/state': 15,
        './internal/streams/stream': 16,
        _process: 32,
        buffer: 28,
        events: 29,
        inherits: 2,
        'string_decoder/': 23,
        util: 27
      }],
      7: [function (require, module, exports) {
        'use strict'
        module.exports = Transform
        var _require$codes = require('../errors').codes,
          ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
          ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
          ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
          ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0, Duplex = require('./_stream_duplex')
  
        function afterTransform (er, data) {
          var ts = this._transformState
          ts.transforming = !1
          var cb = ts.writecb
          if (null === cb) return this.emit('error', new ERR_MULTIPLE_CALLBACK)
          ts.writechunk = null, ts.writecb = null, null != data && this.push(data), cb(er)
          var rs = this._readableState
          rs.reading = !1, (rs.needReadable || rs.length < rs.highWaterMark) && this._read(rs.highWaterMark)
        }
  
        function Transform (options) {
          if (!(this instanceof Transform)) return new Transform(options)
          Duplex.call(this, options), this._transformState = {
            afterTransform: afterTransform.bind(this),
            needTransform: !1,
            transforming: !1,
            writecb: null,
            writechunk: null,
            writeencoding: null
          }, this._readableState.needReadable = !0, this._readableState.sync = !1, options && ('function' == typeof options.transform && (this._transform = options.transform), 'function' == typeof options.flush && (this._flush = options.flush)), this.on('prefinish', prefinish)
        }
  
        function prefinish () {
          var _this = this
          'function' != typeof this._flush || this._readableState.destroyed ? done(this, null, null) : this._flush((function (er, data) {done(_this, er, data)}))
        }
  
        function done (stream, er, data) {
          if (er) return stream.emit('error', er)
          if (null != data && stream.push(data), stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0
          if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING
          return stream.push(null)
        }
  
        require('inherits')(Transform, Duplex), Transform.prototype.push = function (chunk, encoding) {return this._transformState.needTransform = !1, Duplex.prototype.push.call(this, chunk, encoding)}, Transform.prototype._transform = function (chunk, encoding, cb) {cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'))}, Transform.prototype._write = function (chunk, encoding, cb) {
          var ts = this._transformState
          if (ts.writecb = cb, ts.writechunk = chunk, ts.writeencoding = encoding, !ts.transforming) {
            var rs = this._readableState;
            (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) && this._read(rs.highWaterMark)
          }
        }, Transform.prototype._read = function (n) {
          var ts = this._transformState
          null === ts.writechunk || ts.transforming ? ts.needTransform = !0 : (ts.transforming = !0, this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform))
        }, Transform.prototype._destroy = function (err, cb) {Duplex.prototype._destroy.call(this, err, (function (err2) {cb(err2)}))}
      }, { '../errors': 3, './_stream_duplex': 4, inherits: 2 }],
      8: [function (require, module, exports) {
        (function (process, global) {
          'use strict'
  
          function CorkedRequest (state) {
            var _this = this
            this.next = null, this.entry = null, this.finish = function () {
              !function (corkReq, state, err) {
                var entry = corkReq.entry
                corkReq.entry = null
                for (; entry;) {
                  var cb = entry.callback
                  state.pendingcb--, cb(err), entry = entry.next
                }
                state.corkedRequestsFree.next = corkReq
              }(_this, state)
            }
          }
  
          var Duplex
          module.exports = Writable, Writable.WritableState = WritableState
          var internalUtil = { deprecate: require('util-deprecate') }, Stream = require('./internal/streams/stream'),
            Buffer = require('buffer').Buffer, OurUint8Array = global.Uint8Array || function () {}
          var realHasInstance, destroyImpl = require('./internal/streams/destroy'),
            getHighWaterMark = require('./internal/streams/state').getHighWaterMark,
            _require$codes = require('../errors').codes, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
            ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
            ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
            ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
            ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
            ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
            ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
            ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING, errorOrDestroy = destroyImpl.errorOrDestroy
  
          function nop () {}
  
          function WritableState (options, stream, isDuplex) {
            Duplex = Duplex || require('./_stream_duplex'), options = options || {}, 'boolean' != typeof isDuplex && (isDuplex = stream instanceof Duplex), this.objectMode = !!options.objectMode, isDuplex && (this.objectMode = this.objectMode || !!options.writableObjectMode), this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1
            var noDecode = !1 === options.decodeStrings
            this.decodeStrings = !noDecode, this.defaultEncoding = options.defaultEncoding || 'utf8', this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function (er) {
              !function (stream, er) {
                var state = stream._writableState, sync = state.sync, cb = state.writecb
                if ('function' != typeof cb) throw new ERR_MULTIPLE_CALLBACK
                if (function (state) {state.writing = !1, state.writecb = null, state.length -= state.writelen, state.writelen = 0}(state), er) !function (stream, state, sync, er, cb) {--state.pendingcb, sync ? (process.nextTick(cb, er), process.nextTick(finishMaybe, stream, state), stream._writableState.errorEmitted = !0, errorOrDestroy(stream, er)) : (cb(er), stream._writableState.errorEmitted = !0, errorOrDestroy(stream, er), finishMaybe(stream, state))}(stream, state, sync, er, cb) else {
                  var finished = needFinish(state) || stream.destroyed
                  finished || state.corked || state.bufferProcessing || !state.bufferedRequest || clearBuffer(stream, state), sync ? process.nextTick(afterWrite, stream, state, finished, cb) : afterWrite(stream, state, finished, cb)
                }
              }(stream, er)
            }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.emitClose = !1 !== options.emitClose, this.autoDestroy = !!options.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new CorkedRequest(this)
          }
  
          function Writable (options) {
            var isDuplex = this instanceof (Duplex = Duplex || require('./_stream_duplex'))
            if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options)
            this._writableState = new WritableState(options, this, isDuplex), this.writable = !0, options && ('function' == typeof options.write && (this._write = options.write), 'function' == typeof options.writev && (this._writev = options.writev), 'function' == typeof options.destroy && (this._destroy = options.destroy), 'function' == typeof options.final && (this._final = options.final)), Stream.call(this)
          }
  
          function doWrite (stream, state, writev, len, chunk, encoding, cb) {state.writelen = len, state.writecb = cb, state.writing = !0, state.sync = !0, state.destroyed ? state.onwrite(new ERR_STREAM_DESTROYED('write')) : writev ? stream._writev(chunk, state.onwrite) : stream._write(chunk, encoding, state.onwrite), state.sync = !1}
  
          function afterWrite (stream, state, finished, cb) {finished || function (stream, state) {0 === state.length && state.needDrain && (state.needDrain = !1, stream.emit('drain'))}(stream, state), state.pendingcb--, cb(), finishMaybe(stream, state)}
  
          function clearBuffer (stream, state) {
            state.bufferProcessing = !0
            var entry = state.bufferedRequest
            if (stream._writev && entry && entry.next) {
              var l = state.bufferedRequestCount, buffer = new Array(l), holder = state.corkedRequestsFree
              holder.entry = entry
              for (var count = 0, allBuffers = !0; entry;) buffer[count] = entry, entry.isBuf || (allBuffers = !1), entry = entry.next, count += 1
              buffer.allBuffers = allBuffers, doWrite(stream, state, !0, state.length, buffer, '', holder.finish), state.pendingcb++, state.lastBufferedRequest = null, holder.next ? (state.corkedRequestsFree = holder.next, holder.next = null) : state.corkedRequestsFree = new CorkedRequest(state), state.bufferedRequestCount = 0
            } else {
              for (; entry;) {
                var chunk = entry.chunk, encoding = entry.encoding, cb = entry.callback
                if (doWrite(stream, state, !1, state.objectMode ? 1 : chunk.length, chunk, encoding, cb), entry = entry.next, state.bufferedRequestCount--, state.writing) break
              }
              null === entry && (state.lastBufferedRequest = null)
            }
            state.bufferedRequest = entry, state.bufferProcessing = !1
          }
  
          function needFinish (state) {return state.ending && 0 === state.length && null === state.bufferedRequest && !state.finished && !state.writing}
  
          function callFinal (stream, state) {stream._final((function (err) {state.pendingcb--, err && errorOrDestroy(stream, err), state.prefinished = !0, stream.emit('prefinish'), finishMaybe(stream, state)}))}
  
          function finishMaybe (stream, state) {
            var need = needFinish(state)
            if (need && (function (stream, state) {state.prefinished || state.finalCalled || ('function' != typeof stream._final || state.destroyed ? (state.prefinished = !0, stream.emit('prefinish')) : (state.pendingcb++, state.finalCalled = !0, process.nextTick(callFinal, stream, state)))}(stream, state), 0 === state.pendingcb && (state.finished = !0, stream.emit('finish'), state.autoDestroy))) {
              var rState = stream._readableState;
              (!rState || rState.autoDestroy && rState.endEmitted) && stream.destroy()
            }
            return need
          }
  
          require('inherits')(Writable, Stream), WritableState.prototype.getBuffer = function () {
            for (var current = this.bufferedRequest, out = []; current;) out.push(current), current = current.next
            return out
          }, function () {try {Object.defineProperty(WritableState.prototype, 'buffer', { get: internalUtil.deprecate((function () {return this.getBuffer()}), '_writableState.buffer is deprecated. Use _writableState.getBuffer instead.', 'DEP0003') })} catch (_) {}}(), 'function' == typeof Symbol && Symbol.hasInstance && 'function' == typeof Function.prototype[Symbol.hasInstance] ? (realHasInstance = Function.prototype[Symbol.hasInstance], Object.defineProperty(Writable, Symbol.hasInstance, { value: function (object) {return !!realHasInstance.call(this, object) || this === Writable && (object && object._writableState instanceof WritableState)} })) : realHasInstance = function (object) {return object instanceof this}, Writable.prototype.pipe = function () {errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE)}, Writable.prototype.write = function (chunk, encoding, cb) {
            var obj, state = this._writableState, ret = !1,
              isBuf = !state.objectMode && (obj = chunk, Buffer.isBuffer(obj) || obj instanceof OurUint8Array)
            return isBuf && !Buffer.isBuffer(chunk) && (chunk = function (chunk) {return Buffer.from(chunk)}(chunk)), 'function' == typeof encoding && (cb = encoding, encoding = null), isBuf ? encoding = 'buffer' : encoding || (encoding = state.defaultEncoding), 'function' != typeof cb && (cb = nop), state.ending ? function (stream, cb) {
              var er = new ERR_STREAM_WRITE_AFTER_END
              errorOrDestroy(stream, er), process.nextTick(cb, er)
            }(this, cb) : (isBuf || function (stream, state, chunk, cb) {
              var er
              return null === chunk ? er = new ERR_STREAM_NULL_VALUES : 'string' == typeof chunk || state.objectMode || (er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk)), !er || (errorOrDestroy(stream, er), process.nextTick(cb, er), !1)
            }(this, state, chunk, cb)) && (state.pendingcb++, ret = function (stream, state, isBuf, chunk, encoding, cb) {
              if (!isBuf) {
                var newChunk = function (state, chunk, encoding) {
                  state.objectMode || !1 === state.decodeStrings || 'string' != typeof chunk || (chunk = Buffer.from(chunk, encoding))
                  return chunk
                }(state, chunk, encoding)
                chunk !== newChunk && (isBuf = !0, encoding = 'buffer', chunk = newChunk)
              }
              var len = state.objectMode ? 1 : chunk.length
              state.length += len
              var ret = state.length < state.highWaterMark
              ret || (state.needDrain = !0)
              if (state.writing || state.corked) {
                var last = state.lastBufferedRequest
                state.lastBufferedRequest = {
                  chunk: chunk,
                  encoding: encoding,
                  isBuf: isBuf,
                  callback: cb,
                  next: null
                }, last ? last.next = state.lastBufferedRequest : state.bufferedRequest = state.lastBufferedRequest, state.bufferedRequestCount += 1
              } else doWrite(stream, state, !1, len, chunk, encoding, cb)
              return ret
            }(this, state, isBuf, chunk, encoding, cb)), ret
          }, Writable.prototype.cork = function () {this._writableState.corked++}, Writable.prototype.uncork = function () {
            var state = this._writableState
            state.corked && (state.corked--, state.writing || state.corked || state.bufferProcessing || !state.bufferedRequest || clearBuffer(this, state))
          }, Writable.prototype.setDefaultEncoding = function (encoding) {
            if ('string' == typeof encoding && (encoding = encoding.toLowerCase()), !(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding)
            return this._writableState.defaultEncoding = encoding, this
          }, Object.defineProperty(Writable.prototype, 'writableBuffer', {
            enumerable: !1,
            get: function () {return this._writableState && this._writableState.getBuffer()}
          }), Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
            enumerable: !1,
            get: function () {return this._writableState.highWaterMark}
          }), Writable.prototype._write = function (chunk, encoding, cb) {cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'))}, Writable.prototype._writev = null, Writable.prototype.end = function (chunk, encoding, cb) {
            var state = this._writableState
            return 'function' == typeof chunk ? (cb = chunk, chunk = null, encoding = null) : 'function' == typeof encoding && (cb = encoding, encoding = null), null != chunk && this.write(chunk, encoding), state.corked && (state.corked = 1, this.uncork()), state.ending || function (stream, state, cb) {
              state.ending = !0, finishMaybe(stream, state), cb && (state.finished ? process.nextTick(cb) : stream.once('finish', cb))
              state.ended = !0, stream.writable = !1
            }(this, state, cb), this
          }, Object.defineProperty(Writable.prototype, 'writableLength', {
            enumerable: !1,
            get: function () {return this._writableState.length}
          }), Object.defineProperty(Writable.prototype, 'destroyed', {
            enumerable: !1,
            get: function () {return void 0 !== this._writableState && this._writableState.destroyed},
            set: function (value) {this._writableState && (this._writableState.destroyed = value)}
          }), Writable.prototype.destroy = destroyImpl.destroy, Writable.prototype._undestroy = destroyImpl.undestroy, Writable.prototype._destroy = function (err, cb) {cb(err)}
        }).call(this, require('_process'), 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {})
      }, {
        '../errors': 3,
        './_stream_duplex': 4,
        './internal/streams/destroy': 11,
        './internal/streams/state': 15,
        './internal/streams/stream': 16,
        _process: 32,
        buffer: 28,
        inherits: 2,
        'util-deprecate': 24
      }],
      9: [function (require, module, exports) {
        (function (process) {
          'use strict'
          var _Object$setPrototypeO
  
          function _defineProperty (obj, key, value) {
            return key in obj ? Object.defineProperty(obj, key, {
              value: value,
              enumerable: !0,
              configurable: !0,
              writable: !0
            }) : obj[key] = value, obj
          }
  
          var finished = require('./end-of-stream'), kLastResolve = Symbol('lastResolve'),
            kLastReject = Symbol('lastReject'), kError = Symbol('error'), kEnded = Symbol('ended'),
            kLastPromise = Symbol('lastPromise'), kHandlePromise = Symbol('handlePromise'), kStream = Symbol('stream')
  
          function createIterResult (value, done) {return { value: value, done: done }}
  
          function readAndResolve (iter) {
            var resolve = iter[kLastResolve]
            if (null !== resolve) {
              var data = iter[kStream].read()
              null !== data && (iter[kLastPromise] = null, iter[kLastResolve] = null, iter[kLastReject] = null, resolve(createIterResult(data, !1)))
            }
          }
  
          function onReadable (iter) {process.nextTick(readAndResolve, iter)}
  
          var AsyncIteratorPrototype = Object.getPrototypeOf((function () {})),
            ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_defineProperty(_Object$setPrototypeO = {
              get stream () {return this[kStream]},
              next: function () {
                var _this = this, error = this[kError]
                if (null !== error) return Promise.reject(error)
                if (this[kEnded]) return Promise.resolve(createIterResult(void 0, !0))
                if (this[kStream].destroyed) return new Promise((function (resolve, reject) {process.nextTick((function () {_this[kError] ? reject(_this[kError]) : resolve(createIterResult(void 0, !0))}))}))
                var promise, lastPromise = this[kLastPromise]
                if (lastPromise) promise = new Promise(function (lastPromise, iter) {return function (resolve, reject) {lastPromise.then((function () {iter[kEnded] ? resolve(createIterResult(void 0, !0)) : iter[kHandlePromise](resolve, reject)}), reject)}}(lastPromise, this)) else {
                  var data = this[kStream].read()
                  if (null !== data) return Promise.resolve(createIterResult(data, !1))
                  promise = new Promise(this[kHandlePromise])
                }
                return this[kLastPromise] = promise, promise
              }
            }, Symbol.asyncIterator, (function () {return this})), _defineProperty(_Object$setPrototypeO, 'return', (function () {
              var _this2 = this
              return new Promise((function (resolve, reject) {_this2[kStream].destroy(null, (function (err) {err ? reject(err) : resolve(createIterResult(void 0, !0))}))}))
            })), _Object$setPrototypeO), AsyncIteratorPrototype)
          module.exports = function (stream) {
            var _Object$create,
              iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_defineProperty(_Object$create = {}, kStream, {
                value: stream,
                writable: !0
              }), _defineProperty(_Object$create, kLastResolve, {
                value: null,
                writable: !0
              }), _defineProperty(_Object$create, kLastReject, {
                value: null,
                writable: !0
              }), _defineProperty(_Object$create, kError, {
                value: null,
                writable: !0
              }), _defineProperty(_Object$create, kEnded, {
                value: stream._readableState.endEmitted,
                writable: !0
              }), _defineProperty(_Object$create, kHandlePromise, {
                value: function (resolve, reject) {
                  var data = iterator[kStream].read()
                  data ? (iterator[kLastPromise] = null, iterator[kLastResolve] = null, iterator[kLastReject] = null, resolve(createIterResult(data, !1))) : (iterator[kLastResolve] = resolve, iterator[kLastReject] = reject)
                }, writable: !0
              }), _Object$create))
            return iterator[kLastPromise] = null, finished(stream, (function (err) {
              if (err && 'ERR_STREAM_PREMATURE_CLOSE' !== err.code) {
                var reject = iterator[kLastReject]
                return null !== reject && (iterator[kLastPromise] = null, iterator[kLastResolve] = null, iterator[kLastReject] = null, reject(err)), void (iterator[kError] = err)
              }
              var resolve = iterator[kLastResolve]
              null !== resolve && (iterator[kLastPromise] = null, iterator[kLastResolve] = null, iterator[kLastReject] = null, resolve(createIterResult(void 0, !0))), iterator[kEnded] = !0
            })), stream.on('readable', onReadable.bind(null, iterator)), iterator
          }
        }).call(this, require('_process'))
      }, { './end-of-stream': 12, _process: 32 }],
      10: [function (require, module, exports) {
        'use strict'
  
        function ownKeys (object, enumerableOnly) {
          var keys = Object.keys(object)
          if (Object.getOwnPropertySymbols) {
            var symbols = Object.getOwnPropertySymbols(object)
            enumerableOnly && (symbols = symbols.filter((function (sym) {return Object.getOwnPropertyDescriptor(object, sym).enumerable}))), keys.push.apply(keys, symbols)
          }
          return keys
        }
  
        function _defineProperty (obj, key, value) {
          return key in obj ? Object.defineProperty(obj, key, {
            value: value,
            enumerable: !0,
            configurable: !0,
            writable: !0
          }) : obj[key] = value, obj
        }
  
        function _defineProperties (target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i]
            descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 'value' in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor)
          }
        }
  
        var Buffer = require('buffer').Buffer, inspect = require('util').inspect,
          custom = inspect && inspect.custom || 'inspect'
        module.exports = function () {
          function BufferList () {!function (instance, Constructor) {if (!(instance instanceof Constructor)) throw new TypeError('Cannot call a class as a function')}(this, BufferList), this.head = null, this.tail = null, this.length = 0}
  
          var Constructor, protoProps, staticProps
          return Constructor = BufferList, (protoProps = [{
            key: 'push',
            value: function (v) {
              var entry = { data: v, next: null }
              this.length > 0 ? this.tail.next = entry : this.head = entry, this.tail = entry, ++this.length
            }
          }, {
            key: 'unshift', value: function (v) {
              var entry = { data: v, next: this.head }
              0 === this.length && (this.tail = entry), this.head = entry, ++this.length
            }
          }, {
            key: 'shift', value: function () {
              if (0 !== this.length) {
                var ret = this.head.data
                return 1 === this.length ? this.head = this.tail = null : this.head = this.head.next, --this.length, ret
              }
            }
          }, { key: 'clear', value: function () {this.head = this.tail = null, this.length = 0} }, {
            key: 'join',
            value: function (s) {
              if (0 === this.length) return ''
              for (var p = this.head, ret = '' + p.data; p = p.next;) ret += s + p.data
              return ret
            }
          }, {
            key: 'concat', value: function (n) {
              if (0 === this.length) return Buffer.alloc(0)
              for (var src, target, offset, ret = Buffer.allocUnsafe(n >>> 0), p = this.head, i = 0; p;) src = p.data, target = ret, offset = i, Buffer.prototype.copy.call(src, target, offset), i += p.data.length, p = p.next
              return ret
            }
          }, {
            key: 'consume', value: function (n, hasStrings) {
              var ret
              return n < this.head.data.length ? (ret = this.head.data.slice(0, n), this.head.data = this.head.data.slice(n)) : ret = n === this.head.data.length ? this.shift() : hasStrings ? this._getString(n) : this._getBuffer(n), ret
            }
          }, { key: 'first', value: function () {return this.head.data} }, {
            key: '_getString',
            value: function (n) {
              var p = this.head, c = 1, ret = p.data
              for (n -= ret.length; p = p.next;) {
                var str = p.data, nb = n > str.length ? str.length : n
                if (nb === str.length ? ret += str : ret += str.slice(0, n), 0 == (n -= nb)) {
                  nb === str.length ? (++c, p.next ? this.head = p.next : this.head = this.tail = null) : (this.head = p, p.data = str.slice(nb))
                  break
                }
                ++c
              }
              return this.length -= c, ret
            }
          }, {
            key: '_getBuffer', value: function (n) {
              var ret = Buffer.allocUnsafe(n), p = this.head, c = 1
              for (p.data.copy(ret), n -= p.data.length; p = p.next;) {
                var buf = p.data, nb = n > buf.length ? buf.length : n
                if (buf.copy(ret, ret.length - n, 0, nb), 0 == (n -= nb)) {
                  nb === buf.length ? (++c, p.next ? this.head = p.next : this.head = this.tail = null) : (this.head = p, p.data = buf.slice(nb))
                  break
                }
                ++c
              }
              return this.length -= c, ret
            }
          }, {
            key: custom,
            value: function (_, options) {
              return inspect(this, function (target) {
                for (var i = 1; i < arguments.length; i++) {
                  var source = null != arguments[i] ? arguments[i] : {}
                  i % 2 ? ownKeys(Object(source), !0).forEach((function (key) {_defineProperty(target, key, source[key])})) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach((function (key) {Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key))}))
                }
                return target
              }({}, options, { depth: 0, customInspect: !1 }))
            }
          }]) && _defineProperties(Constructor.prototype, protoProps), staticProps && _defineProperties(Constructor, staticProps), BufferList
        }()
      }, { buffer: 28, util: 27 }],
      11: [function (require, module, exports) {
        (function (process) {
          'use strict'
  
          function emitErrorAndCloseNT (self, err) {emitErrorNT(self, err), emitCloseNT(self)}
  
          function emitCloseNT (self) {self._writableState && !self._writableState.emitClose || self._readableState && !self._readableState.emitClose || self.emit('close')}
  
          function emitErrorNT (self, err) {self.emit('error', err)}
  
          module.exports = {
            destroy: function (err, cb) {
              var _this = this, readableDestroyed = this._readableState && this._readableState.destroyed,
                writableDestroyed = this._writableState && this._writableState.destroyed
              return readableDestroyed || writableDestroyed ? (cb ? cb(err) : err && (this._writableState ? this._writableState.errorEmitted || (this._writableState.errorEmitted = !0, process.nextTick(emitErrorNT, this, err)) : process.nextTick(emitErrorNT, this, err)), this) : (this._readableState && (this._readableState.destroyed = !0), this._writableState && (this._writableState.destroyed = !0), this._destroy(err || null, (function (err) {!cb && err ? _this._writableState ? _this._writableState.errorEmitted ? process.nextTick(emitCloseNT, _this) : (_this._writableState.errorEmitted = !0, process.nextTick(emitErrorAndCloseNT, _this, err)) : process.nextTick(emitErrorAndCloseNT, _this, err) : cb ? (process.nextTick(emitCloseNT, _this), cb(err)) : process.nextTick(emitCloseNT, _this)})), this)
            },
            undestroy: function () {this._readableState && (this._readableState.destroyed = !1, this._readableState.reading = !1, this._readableState.ended = !1, this._readableState.endEmitted = !1), this._writableState && (this._writableState.destroyed = !1, this._writableState.ended = !1, this._writableState.ending = !1, this._writableState.finalCalled = !1, this._writableState.prefinished = !1, this._writableState.finished = !1, this._writableState.errorEmitted = !1)},
            errorOrDestroy: function (stream, err) {
              var rState = stream._readableState, wState = stream._writableState
              rState && rState.autoDestroy || wState && wState.autoDestroy ? stream.destroy(err) : stream.emit('error', err)
            }
          }
        }).call(this, require('_process'))
      }, { _process: 32 }],
      12: [function (require, module, exports) {
        'use strict'
        var ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE
  
        function noop () {}
  
        module.exports = function eos (stream, opts, callback) {
          if ('function' == typeof opts) return eos(stream, null, opts)
          opts || (opts = {}), callback = function (callback) {
            var called = !1
            return function () {
              if (!called) {
                called = !0
                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key]
                callback.apply(this, args)
              }
            }
          }(callback || noop)
          var readable = opts.readable || !1 !== opts.readable && stream.readable,
            writable = opts.writable || !1 !== opts.writable && stream.writable,
            onlegacyfinish = function () {stream.writable || onfinish()},
            writableEnded = stream._writableState && stream._writableState.finished,
            onfinish = function () {writable = !1, writableEnded = !0, readable || callback.call(stream)},
            readableEnded = stream._readableState && stream._readableState.endEmitted,
            onend = function () {readable = !1, readableEnded = !0, writable || callback.call(stream)},
            onerror = function (err) {callback.call(stream, err)}, onclose = function () {
              var err
              return readable && !readableEnded ? (stream._readableState && stream._readableState.ended || (err = new ERR_STREAM_PREMATURE_CLOSE), callback.call(stream, err)) : writable && !writableEnded ? (stream._writableState && stream._writableState.ended || (err = new ERR_STREAM_PREMATURE_CLOSE), callback.call(stream, err)) : void 0
            }, onrequest = function () {stream.req.on('finish', onfinish)}
          return !function (stream) {return stream.setHeader && 'function' == typeof stream.abort}(stream) ? writable && !stream._writableState && (stream.on('end', onlegacyfinish), stream.on('close', onlegacyfinish)) : (stream.on('complete', onfinish), stream.on('abort', onclose), stream.req ? onrequest() : stream.on('request', onrequest)), stream.on('end', onend), stream.on('finish', onfinish), !1 !== opts.error && stream.on('error', onerror), stream.on('close', onclose), function () {stream.removeListener('complete', onfinish), stream.removeListener('abort', onclose), stream.removeListener('request', onrequest), stream.req && stream.req.removeListener('finish', onfinish), stream.removeListener('end', onlegacyfinish), stream.removeListener('close', onlegacyfinish), stream.removeListener('finish', onfinish), stream.removeListener('end', onend), stream.removeListener('error', onerror), stream.removeListener('close', onclose)}
        }
      }, { '../../../errors': 3 }],
      13: [function (require, module, exports) {module.exports = function () {throw new Error('Readable.from is not available in the browser')}}, {}],
      14: [function (require, module, exports) {
        'use strict'
        var eos
        var _require$codes = require('../../../errors').codes, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
          ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED
  
        function noop (err) {if (err) throw err}
  
        function destroyer (stream, reading, writing, callback) {
          callback = function (callback) {
            var called = !1
            return function () {called || (called = !0, callback.apply(void 0, arguments))}
          }(callback)
          var closed = !1
          stream.on('close', (function () {closed = !0})), void 0 === eos && (eos = require('./end-of-stream')), eos(stream, {
            readable: reading,
            writable: writing
          }, (function (err) {
            if (err) return callback(err)
            closed = !0, callback()
          }))
          var destroyed = !1
          return function (err) {if (!closed && !destroyed) return destroyed = !0, function (stream) {return stream.setHeader && 'function' == typeof stream.abort}(stream) ? stream.abort() : 'function' == typeof stream.destroy ? stream.destroy() : void callback(err || new ERR_STREAM_DESTROYED('pipe'))}
        }
  
        function call (fn) {fn()}
  
        function pipe (from, to) {return from.pipe(to)}
  
        function popCallback (streams) {return streams.length ? 'function' != typeof streams[streams.length - 1] ? noop : streams.pop() : noop}
  
        module.exports = function () {
          for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) streams[_key] = arguments[_key]
          var error, callback = popCallback(streams)
          if (Array.isArray(streams[0]) && (streams = streams[0]), streams.length < 2) throw new ERR_MISSING_ARGS('streams')
          var destroys = streams.map((function (stream, i) {
            var reading = i < streams.length - 1
            return destroyer(stream, reading, i > 0, (function (err) {error || (error = err), err && destroys.forEach(call), reading || (destroys.forEach(call), callback(error))}))
          }))
          return streams.reduce(pipe)
        }
      }, { '../../../errors': 3, './end-of-stream': 12 }],
      15: [function (require, module, exports) {
        'use strict'
        var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE
        module.exports = {
          getHighWaterMark: function (state, options, duplexKey, isDuplex) {
            var hwm = function (options, isDuplex, duplexKey) {return null != options.highWaterMark ? options.highWaterMark : isDuplex ? options[duplexKey] : null}(options, isDuplex, duplexKey)
            if (null != hwm) {
              if (!isFinite(hwm) || Math.floor(hwm) !== hwm || hwm < 0) throw new ERR_INVALID_OPT_VALUE(isDuplex ? duplexKey : 'highWaterMark', hwm)
              return Math.floor(hwm)
            }
            return state.objectMode ? 16 : 16384
          }
        }
      }, { '../../../errors': 3 }],
      16: [function (require, module, exports) {module.exports = require('events').EventEmitter}, { events: 29 }],
      17: [function (require, module, exports) {(exports = module.exports = require('./lib/_stream_readable.js')).Stream = exports, exports.Readable = exports, exports.Writable = require('./lib/_stream_writable.js'), exports.Duplex = require('./lib/_stream_duplex.js'), exports.Transform = require('./lib/_stream_transform.js'), exports.PassThrough = require('./lib/_stream_passthrough.js'), exports.finished = require('./lib/internal/streams/end-of-stream.js'), exports.pipeline = require('./lib/internal/streams/pipeline.js')}, {
        './lib/_stream_duplex.js': 4,
        './lib/_stream_passthrough.js': 5,
        './lib/_stream_readable.js': 6,
        './lib/_stream_transform.js': 7,
        './lib/_stream_writable.js': 8,
        './lib/internal/streams/end-of-stream.js': 12,
        './lib/internal/streams/pipeline.js': 14
      }],
      18: [function (require, module, exports) {
        /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
        var buffer = require('buffer'), Buffer = buffer.Buffer
  
        function copyProps (src, dst) {for (var key in src) dst[key] = src[key]}
  
        function SafeBuffer (arg, encodingOrOffset, length) {return Buffer(arg, encodingOrOffset, length)}
  
        Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow ? module.exports = buffer : (copyProps(buffer, exports), exports.Buffer = SafeBuffer), SafeBuffer.prototype = Object.create(Buffer.prototype), copyProps(Buffer, SafeBuffer), SafeBuffer.from = function (arg, encodingOrOffset, length) {
          if ('number' == typeof arg) throw new TypeError('Argument must not be a number')
          return Buffer(arg, encodingOrOffset, length)
        }, SafeBuffer.alloc = function (size, fill, encoding) {
          if ('number' != typeof size) throw new TypeError('Argument must be a number')
          var buf = Buffer(size)
          return void 0 !== fill ? 'string' == typeof encoding ? buf.fill(fill, encoding) : buf.fill(fill) : buf.fill(0), buf
        }, SafeBuffer.allocUnsafe = function (size) {
          if ('number' != typeof size) throw new TypeError('Argument must be a number')
          return Buffer(size)
        }, SafeBuffer.allocUnsafeSlow = function (size) {
          if ('number' != typeof size) throw new TypeError('Argument must be a number')
          return buffer.SlowBuffer(size)
        }
      }, { buffer: 28 }],
      19: [function (require, module, exports) {
        (function (global) {
          var xhr
  
          function getXHR () {
            if (void 0 !== xhr) return xhr
            if (global.XMLHttpRequest) {
              xhr = new global.XMLHttpRequest
              try {xhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')} catch (e) {xhr = null}
            } else xhr = null
            return xhr
          }
  
          function checkTypeSupport (type) {
            var xhr = getXHR()
            if (!xhr) return !1
            try {return xhr.responseType = type, xhr.responseType === type} catch (e) {}
            return !1
          }
  
          function isFunction (value) {return 'function' == typeof value}
  
          exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream), exports.writableStream = isFunction(global.WritableStream), exports.abortController = isFunction(global.AbortController), exports.arraybuffer = exports.fetch || checkTypeSupport('arraybuffer'), exports.msstream = !exports.fetch && checkTypeSupport('ms-stream'), exports.mozchunkedarraybuffer = !exports.fetch && checkTypeSupport('moz-chunked-arraybuffer'), exports.overrideMimeType = exports.fetch || !!getXHR() && isFunction(getXHR().overrideMimeType), xhr = null
        }).call(this, 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {})
      }, {}],
      20: [function (require, module, exports) {
        (function (process, global, Buffer) {
          var capability = require('./capability'), inherits = require('inherits'), response = require('./response'),
            stream = require('readable-stream'), IncomingMessage = response.IncomingMessage,
            rStates = response.readyStates
          var ClientRequest = module.exports = function (opts) {
            var preferBinary, self = this
            stream.Writable.call(self), self._opts = opts, self._body = [], self._headers = {}, opts.auth && self.setHeader('Authorization', 'Basic ' + Buffer.from(opts.auth).toString('base64')), Object.keys(opts.headers).forEach((function (name) {self.setHeader(name, opts.headers[name])}))
            var useFetch = !0
            if ('disable-fetch' === opts.mode || 'requestTimeout' in opts && !capability.abortController) useFetch = !1, preferBinary = !0 else if ('prefer-streaming' === opts.mode) preferBinary = !1 else if ('allow-wrong-content-type' === opts.mode) preferBinary = !capability.overrideMimeType else {
              if (opts.mode && 'default' !== opts.mode && 'prefer-fast' !== opts.mode) throw new Error('Invalid value for opts.mode')
              preferBinary = !0
            }
            self._mode = function (preferBinary, useFetch) {return capability.fetch && useFetch ? 'fetch' : capability.mozchunkedarraybuffer ? 'moz-chunked-arraybuffer' : capability.msstream ? 'ms-stream' : capability.arraybuffer && preferBinary ? 'arraybuffer' : 'text'}(preferBinary, useFetch), self._fetchTimer = null, self.on('finish', (function () {self._onFinish()}))
          }
          inherits(ClientRequest, stream.Writable), ClientRequest.prototype.setHeader = function (name, value) {
            var lowerName = name.toLowerCase();
            -1 === unsafeHeaders.indexOf(lowerName) && (this._headers[lowerName] = { name: name, value: value })
          }, ClientRequest.prototype.getHeader = function (name) {
            var header = this._headers[name.toLowerCase()]
            return header ? header.value : null
          }, ClientRequest.prototype.removeHeader = function (name) {delete this._headers[name.toLowerCase()]}, ClientRequest.prototype._onFinish = function () {
            var self = this
            if (!self._destroyed) {
              var opts = self._opts, headersObj = self._headers, body = null
              'GET' !== opts.method && 'HEAD' !== opts.method && (body = new Blob(self._body, { type: (headersObj['content-type'] || {}).value || '' }))
              var headersList = []
              if (Object.keys(headersObj).forEach((function (keyName) {
                var name = headersObj[keyName].name, value = headersObj[keyName].value
                Array.isArray(value) ? value.forEach((function (v) {headersList.push([name, v])})) : headersList.push([name, value])
              })), 'fetch' === self._mode) {
                var signal = null
                if (capability.abortController) {
                  var controller = new AbortController
                  signal = controller.signal, self._fetchAbortController = controller, 'requestTimeout' in opts && 0 !== opts.requestTimeout && (self._fetchTimer = global.setTimeout((function () {self.emit('requestTimeout'), self._fetchAbortController && self._fetchAbortController.abort()}), opts.requestTimeout))
                }
                global.fetch(self._opts.url, {
                  method: self._opts.method,
                  headers: headersList,
                  body: body || void 0,
                  mode: 'cors',
                  credentials: opts.withCredentials ? 'include' : 'same-origin',
                  signal: signal
                }).then((function (response) {self._fetchResponse = response, self._connect()}), (function (reason) {global.clearTimeout(self._fetchTimer), self._destroyed || self.emit('error', reason)}))
              } else {
                var xhr = self._xhr = new global.XMLHttpRequest
                try {xhr.open(self._opts.method, self._opts.url, !0)} catch (err) {return void process.nextTick((function () {self.emit('error', err)}))}
                'responseType' in xhr && (xhr.responseType = self._mode), 'withCredentials' in xhr && (xhr.withCredentials = !!opts.withCredentials), 'text' === self._mode && 'overrideMimeType' in xhr && xhr.overrideMimeType('text/plain; charset=x-user-defined'), 'requestTimeout' in opts && (xhr.timeout = opts.requestTimeout, xhr.ontimeout = function () {self.emit('requestTimeout')}), headersList.forEach((function (header) {xhr.setRequestHeader(header[0], header[1])})), self._response = null, xhr.onreadystatechange = function () {
                  switch (xhr.readyState) {
                    case rStates.LOADING:
                    case rStates.DONE:
                      self._onXHRProgress()
                  }
                }, 'moz-chunked-arraybuffer' === self._mode && (xhr.onprogress = function () {self._onXHRProgress()}), xhr.onerror = function () {self._destroyed || self.emit('error', new Error('XHR error'))}
                try {xhr.send(body)} catch (err) {return void process.nextTick((function () {self.emit('error', err)}))}
              }
            }
          }, ClientRequest.prototype._onXHRProgress = function () {
            (function (xhr) {
              try {
                var status = xhr.status
                return null !== status && 0 !== status
              } catch (e) {return !1}
            })(this._xhr) && !this._destroyed && (this._response || this._connect(), this._response._onXHRProgress())
          }, ClientRequest.prototype._connect = function () {
            var self = this
            self._destroyed || (self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer), self._response.on('error', (function (err) {self.emit('error', err)})), self.emit('response', self._response))
          }, ClientRequest.prototype._write = function (chunk, encoding, cb) {this._body.push(chunk), cb()}, ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {this._destroyed = !0, global.clearTimeout(this._fetchTimer), this._response && (this._response._destroyed = !0), this._xhr ? this._xhr.abort() : this._fetchAbortController && this._fetchAbortController.abort()}, ClientRequest.prototype.end = function (data, encoding, cb) {'function' == typeof data && (cb = data, data = void 0), stream.Writable.prototype.end.call(this, data, encoding, cb)}, ClientRequest.prototype.flushHeaders = function () {}, ClientRequest.prototype.setTimeout = function () {}, ClientRequest.prototype.setNoDelay = function () {}, ClientRequest.prototype.setSocketKeepAlive = function () {}
          var unsafeHeaders = ['accept-charset', 'accept-encoding', 'access-control-request-headers', 'access-control-request-method', 'connection', 'content-length', 'cookie', 'cookie2', 'date', 'dnt', 'expect', 'host', 'keep-alive', 'origin', 'referer', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'via']
        }).call(this, require('_process'), 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {}, require('buffer').Buffer)
      }, { './capability': 19, './response': 21, _process: 32, buffer: 28, inherits: 2, 'readable-stream': 17 }],
      21: [function (require, module, exports) {
        (function (process, global, Buffer) {
          var capability = require('./capability'), inherits = require('inherits'), stream = require('readable-stream'),
            rStates = exports.readyStates = { UNSENT: 0, OPENED: 1, HEADERS_RECEIVED: 2, LOADING: 3, DONE: 4 },
            IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {
              var self = this
              if (stream.Readable.call(self), self._mode = mode, self.headers = {}, self.rawHeaders = [], self.trailers = {}, self.rawTrailers = [], self.on('end', (function () {process.nextTick((function () {self.emit('close')}))})), 'fetch' === mode) {
                if (self._fetchResponse = response, self.url = response.url, self.statusCode = response.status, self.statusMessage = response.statusText, response.headers.forEach((function (header, key) {self.headers[key.toLowerCase()] = header, self.rawHeaders.push(key, header)})), capability.writableStream) {
                  var writable = new WritableStream({
                    write: function (chunk) {return new Promise((function (resolve, reject) {self._destroyed ? reject() : self.push(Buffer.from(chunk)) ? resolve() : self._resumeFetch = resolve}))},
                    close: function () {global.clearTimeout(fetchTimer), self._destroyed || self.push(null)},
                    abort: function (err) {self._destroyed || self.emit('error', err)}
                  })
                  try {return void response.body.pipeTo(writable).catch((function (err) {global.clearTimeout(fetchTimer), self._destroyed || self.emit('error', err)}))} catch (e) {}
                }
                var reader = response.body.getReader()
                !function read () {
                  reader.read().then((function (result) {
                    if (!self._destroyed) {
                      if (result.done) return global.clearTimeout(fetchTimer), void self.push(null)
                      self.push(Buffer.from(result.value)), read()
                    }
                  })).catch((function (err) {global.clearTimeout(fetchTimer), self._destroyed || self.emit('error', err)}))
                }()
              } else {
                if (self._xhr = xhr, self._pos = 0, self.url = xhr.responseURL, self.statusCode = xhr.status, self.statusMessage = xhr.statusText, xhr.getAllResponseHeaders().split(/\r?\n/).forEach((function (header) {
                  var matches = header.match(/^([^:]+):\s*(.*)/)
                  if (matches) {
                    var key = matches[1].toLowerCase()
                    'set-cookie' === key ? (void 0 === self.headers[key] && (self.headers[key] = []), self.headers[key].push(matches[2])) : void 0 !== self.headers[key] ? self.headers[key] += ', ' + matches[2] : self.headers[key] = matches[2], self.rawHeaders.push(matches[1], matches[2])
                  }
                })), self._charset = 'x-user-defined', !capability.overrideMimeType) {
                  var mimeType = self.rawHeaders['mime-type']
                  if (mimeType) {
                    var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/)
                    charsetMatch && (self._charset = charsetMatch[1].toLowerCase())
                  }
                  self._charset || (self._charset = 'utf-8')
                }
              }
            }
          inherits(IncomingMessage, stream.Readable), IncomingMessage.prototype._read = function () {
            var resolve = this._resumeFetch
            resolve && (this._resumeFetch = null, resolve())
          }, IncomingMessage.prototype._onXHRProgress = function () {
            var self = this, xhr = self._xhr, response = null
            switch (self._mode) {
              case'text':
                if ((response = xhr.responseText).length > self._pos) {
                  var newData = response.substr(self._pos)
                  if ('x-user-defined' === self._charset) {
                    for (var buffer = Buffer.alloc(newData.length), i = 0; i < newData.length; i++) buffer[i] = 255 & newData.charCodeAt(i)
                    self.push(buffer)
                  } else self.push(newData, self._charset)
                  self._pos = response.length
                }
                break
              case'arraybuffer':
                if (xhr.readyState !== rStates.DONE || !xhr.response) break
                response = xhr.response, self.push(Buffer.from(new Uint8Array(response)))
                break
              case'moz-chunked-arraybuffer':
                if (response = xhr.response, xhr.readyState !== rStates.LOADING || !response) break
                self.push(Buffer.from(new Uint8Array(response)))
                break
              case'ms-stream':
                if (response = xhr.response, xhr.readyState !== rStates.LOADING) break
                var reader = new global.MSStreamReader
                reader.onprogress = function () {reader.result.byteLength > self._pos && (self.push(Buffer.from(new Uint8Array(reader.result.slice(self._pos)))), self._pos = reader.result.byteLength)}, reader.onload = function () {self.push(null)}, reader.readAsArrayBuffer(response)
            }
            self._xhr.readyState === rStates.DONE && 'ms-stream' !== self._mode && self.push(null)
          }
        }).call(this, require('_process'), 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {}, require('buffer').Buffer)
      }, { './capability': 19, _process: 32, buffer: 28, inherits: 2, 'readable-stream': 17 }],
      22: [function (require, module, exports) {
        (function (global) {
          var ClientRequest = require('./lib/request'), response = require('./lib/response'), extend = require('xtend'),
            statusCodes = require('builtin-status-codes'), url = require('url'), http = exports
          http.request = function (opts, cb) {
            opts = 'string' == typeof opts ? url.parse(opts) : extend(opts)
            var defaultProtocol = -1 === global.location.protocol.search(/^https?:$/) ? 'http:' : '',
              protocol = opts.protocol || defaultProtocol, host = opts.hostname || opts.host, port = opts.port,
              path = opts.path || '/'
            host && -1 !== host.indexOf(':') && (host = '[' + host + ']'), opts.url = (host ? protocol + '//' + host : '') + (port ? ':' + port : '') + path, opts.method = (opts.method || 'GET').toUpperCase(), opts.headers = opts.headers || {}
            var req = new ClientRequest(opts)
            return cb && req.on('response', cb), req
          }, http.get = function (opts, cb) {
            var req = http.request(opts, cb)
            return req.end(), req
          }, http.ClientRequest = ClientRequest, http.IncomingMessage = response.IncomingMessage, http.Agent = function () {}, http.Agent.defaultMaxSockets = 4, http.globalAgent = new http.Agent, http.STATUS_CODES = statusCodes, http.METHODS = ['CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REPORT', 'SEARCH', 'SUBSCRIBE', 'TRACE', 'UNLOCK', 'UNSUBSCRIBE']
        }).call(this, 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {})
      }, { './lib/request': 20, './lib/response': 21, 'builtin-status-codes': 1, url: 37, xtend: 25 }],
      23: [function (require, module, exports) {
        'use strict'
        var Buffer = require('safe-buffer').Buffer, isEncoding = Buffer.isEncoding || function (encoding) {
          switch ((encoding = '' + encoding) && encoding.toLowerCase()) {
            case'hex':
            case'utf8':
            case'utf-8':
            case'ascii':
            case'binary':
            case'base64':
            case'ucs2':
            case'ucs-2':
            case'utf16le':
            case'utf-16le':
            case'raw':
              return !0
            default:
              return !1
          }
        }
  
        function StringDecoder (encoding) {
          var nb
          switch (this.encoding = function (enc) {
            var nenc = function (enc) {
              if (!enc) return 'utf8'
              for (var retried; ;) switch (enc) {
                case'utf8':
                case'utf-8':
                  return 'utf8'
                case'ucs2':
                case'ucs-2':
                case'utf16le':
                case'utf-16le':
                  return 'utf16le'
                case'latin1':
                case'binary':
                  return 'latin1'
                case'base64':
                case'ascii':
                case'hex':
                  return enc
                default:
                  if (retried) return
                  enc = ('' + enc).toLowerCase(), retried = !0
              }
            }(enc)
            if ('string' != typeof nenc && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc)
            return nenc || enc
          }(encoding), this.encoding) {
            case'utf16le':
              this.text = utf16Text, this.end = utf16End, nb = 4
              break
            case'utf8':
              this.fillLast = utf8FillLast, nb = 4
              break
            case'base64':
              this.text = base64Text, this.end = base64End, nb = 3
              break
            default:
              return this.write = simpleWrite, void (this.end = simpleEnd)
          }
          this.lastNeed = 0, this.lastTotal = 0, this.lastChar = Buffer.allocUnsafe(nb)
        }
  
        function utf8CheckByte (byte) {return byte <= 127 ? 0 : byte >> 5 == 6 ? 2 : byte >> 4 == 14 ? 3 : byte >> 3 == 30 ? 4 : byte >> 6 == 2 ? -1 : -2}
  
        function utf8FillLast (buf) {
          var p = this.lastTotal - this.lastNeed, r = function (self, buf, p) {
            if (128 != (192 & buf[0])) return self.lastNeed = 0, '�'
            if (self.lastNeed > 1 && buf.length > 1) {
              if (128 != (192 & buf[1])) return self.lastNeed = 1, '�'
              if (self.lastNeed > 2 && buf.length > 2 && 128 != (192 & buf[2])) return self.lastNeed = 2, '�'
            }
          }(this, buf)
          return void 0 !== r ? r : this.lastNeed <= buf.length ? (buf.copy(this.lastChar, p, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal)) : (buf.copy(this.lastChar, p, 0, buf.length), void (this.lastNeed -= buf.length))
        }
  
        function utf16Text (buf, i) {
          if ((buf.length - i) % 2 == 0) {
            var r = buf.toString('utf16le', i)
            if (r) {
              var c = r.charCodeAt(r.length - 1)
              if (c >= 55296 && c <= 56319) return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = buf[buf.length - 2], this.lastChar[1] = buf[buf.length - 1], r.slice(0, -1)
            }
            return r
          }
          return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = buf[buf.length - 1], buf.toString('utf16le', i, buf.length - 1)
        }
  
        function utf16End (buf) {
          var r = buf && buf.length ? this.write(buf) : ''
          if (this.lastNeed) {
            var end = this.lastTotal - this.lastNeed
            return r + this.lastChar.toString('utf16le', 0, end)
          }
          return r
        }
  
        function base64Text (buf, i) {
          var n = (buf.length - i) % 3
          return 0 === n ? buf.toString('base64', i) : (this.lastNeed = 3 - n, this.lastTotal = 3, 1 === n ? this.lastChar[0] = buf[buf.length - 1] : (this.lastChar[0] = buf[buf.length - 2], this.lastChar[1] = buf[buf.length - 1]), buf.toString('base64', i, buf.length - n))
        }
  
        function base64End (buf) {
          var r = buf && buf.length ? this.write(buf) : ''
          return this.lastNeed ? r + this.lastChar.toString('base64', 0, 3 - this.lastNeed) : r
        }
  
        function simpleWrite (buf) {return buf.toString(this.encoding)}
  
        function simpleEnd (buf) {return buf && buf.length ? this.write(buf) : ''}
  
        exports.StringDecoder = StringDecoder, StringDecoder.prototype.write = function (buf) {
          if (0 === buf.length) return ''
          var r, i
          if (this.lastNeed) {
            if (void 0 === (r = this.fillLast(buf))) return ''
            i = this.lastNeed, this.lastNeed = 0
          } else i = 0
          return i < buf.length ? r ? r + this.text(buf, i) : this.text(buf, i) : r || ''
        }, StringDecoder.prototype.end = function (buf) {
          var r = buf && buf.length ? this.write(buf) : ''
          return this.lastNeed ? r + '�' : r
        }, StringDecoder.prototype.text = function (buf, i) {
          var total = function (self, buf, i) {
            var j = buf.length - 1
            if (j < i) return 0
            var nb = utf8CheckByte(buf[j])
            if (nb >= 0) return nb > 0 && (self.lastNeed = nb - 1), nb
            if (--j < i || -2 === nb) return 0
            if ((nb = utf8CheckByte(buf[j])) >= 0) return nb > 0 && (self.lastNeed = nb - 2), nb
            if (--j < i || -2 === nb) return 0
            if ((nb = utf8CheckByte(buf[j])) >= 0) return nb > 0 && (2 === nb ? nb = 0 : self.lastNeed = nb - 3), nb
            return 0
          }(this, buf, i)
          if (!this.lastNeed) return buf.toString('utf8', i)
          this.lastTotal = total
          var end = buf.length - (total - this.lastNeed)
          return buf.copy(this.lastChar, 0, end), buf.toString('utf8', i, end)
        }, StringDecoder.prototype.fillLast = function (buf) {
          if (this.lastNeed <= buf.length) return buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal)
          buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length), this.lastNeed -= buf.length
        }
      }, { 'safe-buffer': 18 }],
      24: [function (require, module, exports) {
        (function (global) {
          function config (name) {
            try {if (!global.localStorage) return !1} catch (_) {return !1}
            var val = global.localStorage[name]
            return null != val && 'true' === String(val).toLowerCase()
          }
  
          module.exports = function (fn, msg) {
            if (config('noDeprecation')) return fn
            var warned = !1
            return function () {
              if (!warned) {
                if (config('throwDeprecation')) throw new Error(msg)
                config('traceDeprecation') ? console.trace(msg) : console.warn(msg), warned = !0
              }
              return fn.apply(this, arguments)
            }
          }
        }).call(this, 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {})
      }, {}],
      25: [function (require, module, exports) {
        module.exports = function () {
          for (var target = {}, i = 0; i < arguments.length; i++) {
            var source = arguments[i]
            for (var key in source) hasOwnProperty.call(source, key) && (target[key] = source[key])
          }
          return target
        }
        var hasOwnProperty = Object.prototype.hasOwnProperty
      }, {}],
      26: [function (require, module, exports) {
        'use strict'
        exports.byteLength = function (b64) {return 3 * b64.length / 4 - placeHoldersCount(b64)}, exports.toByteArray = function (b64) {
          var i, l, tmp, placeHolders, arr, len = b64.length
          placeHolders = placeHoldersCount(b64), arr = new Arr(3 * len / 4 - placeHolders), l = placeHolders > 0 ? len - 4 : len
          var L = 0
          for (i = 0; i < l; i += 4) tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)], arr[L++] = tmp >> 16 & 255, arr[L++] = tmp >> 8 & 255, arr[L++] = 255 & tmp
          2 === placeHolders ? (tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4, arr[L++] = 255 & tmp) : 1 === placeHolders && (tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2, arr[L++] = tmp >> 8 & 255, arr[L++] = 255 & tmp)
          return arr
        }, exports.fromByteArray = function (uint8) {
          for (var tmp, len = uint8.length, extraBytes = len % 3, output = '', parts = [], i = 0, len2 = len - extraBytes; i < len2; i += 16383) parts.push(encodeChunk(uint8, i, i + 16383 > len2 ? len2 : i + 16383))
          1 === extraBytes ? (tmp = uint8[len - 1], output += lookup[tmp >> 2], output += lookup[tmp << 4 & 63], output += '==') : 2 === extraBytes && (tmp = (uint8[len - 2] << 8) + uint8[len - 1], output += lookup[tmp >> 10], output += lookup[tmp >> 4 & 63], output += lookup[tmp << 2 & 63], output += '=')
          return parts.push(output), parts.join('')
        }
        for (var lookup = [], revLookup = [], Arr = 'undefined' != typeof Uint8Array ? Uint8Array : Array, code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', i = 0, len = code.length; i < len; ++i) lookup[i] = code[i], revLookup[code.charCodeAt(i)] = i
  
        function placeHoldersCount (b64) {
          var len = b64.length
          if (len % 4 > 0) throw new Error('Invalid string. Length must be a multiple of 4')
          return '=' === b64[len - 2] ? 2 : '=' === b64[len - 1] ? 1 : 0
        }
  
        function encodeChunk (uint8, start, end) {
          for (var tmp, num, output = [], i = start; i < end; i += 3) tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2], output.push(lookup[(num = tmp) >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[63 & num])
          return output.join('')
        }
  
        revLookup['-'.charCodeAt(0)] = 62, revLookup['_'.charCodeAt(0)] = 63
      }, {}],
      27: [function (require, module, exports) {}, {}],
      28: [function (require, module, exports) {
        (function (global) {
          /*!
   * The buffer module from node.js, for the browser.
   *
   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
   * @license  MIT
   */
          'use strict'
          var base64 = require('base64-js'), ieee754 = require('ieee754'), isArray = require('isarray')
  
          function kMaxLength () {return Buffer.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823}
  
          function createBuffer (that, length) {
            if (kMaxLength() < length) throw new RangeError('Invalid typed array length')
            return Buffer.TYPED_ARRAY_SUPPORT ? (that = new Uint8Array(length)).__proto__ = Buffer.prototype : (null === that && (that = new Buffer(length)), that.length = length), that
          }
  
          function Buffer (arg, encodingOrOffset, length) {
            if (!(Buffer.TYPED_ARRAY_SUPPORT || this instanceof Buffer)) return new Buffer(arg, encodingOrOffset, length)
            if ('number' == typeof arg) {
              if ('string' == typeof encodingOrOffset) throw new Error('If encoding is specified then the first argument must be a string')
              return allocUnsafe(this, arg)
            }
            return from(this, arg, encodingOrOffset, length)
          }
  
          function from (that, value, encodingOrOffset, length) {
            if ('number' == typeof value) throw new TypeError('"value" argument must not be a number')
            return 'undefined' != typeof ArrayBuffer && value instanceof ArrayBuffer ? function (that, array, byteOffset, length) {
              if (array.byteLength, byteOffset < 0 || array.byteLength < byteOffset) throw new RangeError('\'offset\' is out of bounds')
              if (array.byteLength < byteOffset + (length || 0)) throw new RangeError('\'length\' is out of bounds')
              array = void 0 === byteOffset && void 0 === length ? new Uint8Array(array) : void 0 === length ? new Uint8Array(array, byteOffset) : new Uint8Array(array, byteOffset, length)
              Buffer.TYPED_ARRAY_SUPPORT ? (that = array).__proto__ = Buffer.prototype : that = fromArrayLike(that, array)
              return that
            }(that, value, encodingOrOffset, length) : 'string' == typeof value ? function (that, string, encoding) {
              'string' == typeof encoding && '' !== encoding || (encoding = 'utf8')
              if (!Buffer.isEncoding(encoding)) throw new TypeError('"encoding" must be a valid string encoding')
              var length = 0 | byteLength(string, encoding),
                actual = (that = createBuffer(that, length)).write(string, encoding)
              actual !== length && (that = that.slice(0, actual))
              return that
            }(that, value, encodingOrOffset) : function (that, obj) {
              if (Buffer.isBuffer(obj)) {
                var len = 0 | checked(obj.length)
                return 0 === (that = createBuffer(that, len)).length || obj.copy(that, 0, 0, len), that
              }
              if (obj) {
                if ('undefined' != typeof ArrayBuffer && obj.buffer instanceof ArrayBuffer || 'length' in obj) return 'number' != typeof obj.length || (val = obj.length) != val ? createBuffer(that, 0) : fromArrayLike(that, obj)
                if ('Buffer' === obj.type && isArray(obj.data)) return fromArrayLike(that, obj.data)
              }
              var val
              throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
            }(that, value)
          }
  
          function assertSize (size) {
            if ('number' != typeof size) throw new TypeError('"size" argument must be a number')
            if (size < 0) throw new RangeError('"size" argument must not be negative')
          }
  
          function allocUnsafe (that, size) {
            if (assertSize(size), that = createBuffer(that, size < 0 ? 0 : 0 | checked(size)), !Buffer.TYPED_ARRAY_SUPPORT) for (var i = 0; i < size; ++i) that[i] = 0
            return that
          }
  
          function fromArrayLike (that, array) {
            var length = array.length < 0 ? 0 : 0 | checked(array.length)
            that = createBuffer(that, length)
            for (var i = 0; i < length; i += 1) that[i] = 255 & array[i]
            return that
          }
  
          function checked (length) {
            if (length >= kMaxLength()) throw new RangeError('Attempt to allocate Buffer larger than maximum size: 0x' + kMaxLength().toString(16) + ' bytes')
            return 0 | length
          }
  
          function byteLength (string, encoding) {
            if (Buffer.isBuffer(string)) return string.length
            if ('undefined' != typeof ArrayBuffer && 'function' == typeof ArrayBuffer.isView && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) return string.byteLength
            'string' != typeof string && (string = '' + string)
            var len = string.length
            if (0 === len) return 0
            for (var loweredCase = !1; ;) switch (encoding) {
              case'ascii':
              case'latin1':
              case'binary':
                return len
              case'utf8':
              case'utf-8':
              case void 0:
                return utf8ToBytes(string).length
              case'ucs2':
              case'ucs-2':
              case'utf16le':
              case'utf-16le':
                return 2 * len
              case'hex':
                return len >>> 1
              case'base64':
                return base64ToBytes(string).length
              default:
                if (loweredCase) return utf8ToBytes(string).length
                encoding = ('' + encoding).toLowerCase(), loweredCase = !0
            }
          }
  
          function slowToString (encoding, start, end) {
            var loweredCase = !1
            if ((void 0 === start || start < 0) && (start = 0), start > this.length) return ''
            if ((void 0 === end || end > this.length) && (end = this.length), end <= 0) return ''
            if ((end >>>= 0) <= (start >>>= 0)) return ''
            for (encoding || (encoding = 'utf8'); ;) switch (encoding) {
              case'hex':
                return hexSlice(this, start, end)
              case'utf8':
              case'utf-8':
                return utf8Slice(this, start, end)
              case'ascii':
                return asciiSlice(this, start, end)
              case'latin1':
              case'binary':
                return latin1Slice(this, start, end)
              case'base64':
                return base64Slice(this, start, end)
              case'ucs2':
              case'ucs-2':
              case'utf16le':
              case'utf-16le':
                return utf16leSlice(this, start, end)
              default:
                if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
                encoding = (encoding + '').toLowerCase(), loweredCase = !0
            }
          }
  
          function swap (b, n, m) {
            var i = b[n]
            b[n] = b[m], b[m] = i
          }
  
          function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
            if (0 === buffer.length) return -1
            if ('string' == typeof byteOffset ? (encoding = byteOffset, byteOffset = 0) : byteOffset > 2147483647 ? byteOffset = 2147483647 : byteOffset < -2147483648 && (byteOffset = -2147483648), byteOffset = +byteOffset, isNaN(byteOffset) && (byteOffset = dir ? 0 : buffer.length - 1), byteOffset < 0 && (byteOffset = buffer.length + byteOffset), byteOffset >= buffer.length) {
              if (dir) return -1
              byteOffset = buffer.length - 1
            } else if (byteOffset < 0) {
              if (!dir) return -1
              byteOffset = 0
            }
            if ('string' == typeof val && (val = Buffer.from(val, encoding)), Buffer.isBuffer(val)) return 0 === val.length ? -1 : arrayIndexOf(buffer, val, byteOffset, encoding, dir)
            if ('number' == typeof val) return val &= 255, Buffer.TYPED_ARRAY_SUPPORT && 'function' == typeof Uint8Array.prototype.indexOf ? dir ? Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) : Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) : arrayIndexOf(buffer, [val], byteOffset, encoding, dir)
            throw new TypeError('val must be string, number or Buffer')
          }
  
          function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
            var i, indexSize = 1, arrLength = arr.length, valLength = val.length
            if (void 0 !== encoding && ('ucs2' === (encoding = String(encoding).toLowerCase()) || 'ucs-2' === encoding || 'utf16le' === encoding || 'utf-16le' === encoding)) {
              if (arr.length < 2 || val.length < 2) return -1
              indexSize = 2, arrLength /= 2, valLength /= 2, byteOffset /= 2
            }
  
            function read (buf, i) {return 1 === indexSize ? buf[i] : buf.readUInt16BE(i * indexSize)}
  
            if (dir) {
              var foundIndex = -1
              for (i = byteOffset; i < arrLength; i++) if (read(arr, i) === read(val, -1 === foundIndex ? 0 : i - foundIndex)) {if (-1 === foundIndex && (foundIndex = i), i - foundIndex + 1 === valLength) return foundIndex * indexSize} else -1 !== foundIndex && (i -= i - foundIndex), foundIndex = -1
            } else for (byteOffset + valLength > arrLength && (byteOffset = arrLength - valLength), i = byteOffset; i >= 0; i--) {
              for (var found = !0, j = 0; j < valLength; j++) if (read(arr, i + j) !== read(val, j)) {
                found = !1
                break
              }
              if (found) return i
            }
            return -1
          }
  
          function hexWrite (buf, string, offset, length) {
            offset = Number(offset) || 0
            var remaining = buf.length - offset
            length ? (length = Number(length)) > remaining && (length = remaining) : length = remaining
            var strLen = string.length
            if (strLen % 2 != 0) throw new TypeError('Invalid hex string')
            length > strLen / 2 && (length = strLen / 2)
            for (var i = 0; i < length; ++i) {
              var parsed = parseInt(string.substr(2 * i, 2), 16)
              if (isNaN(parsed)) return i
              buf[offset + i] = parsed
            }
            return i
          }
  
          function utf8Write (buf, string, offset, length) {return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)}
  
          function asciiWrite (buf, string, offset, length) {
            return blitBuffer(function (str) {
              for (var byteArray = [], i = 0; i < str.length; ++i) byteArray.push(255 & str.charCodeAt(i))
              return byteArray
            }(string), buf, offset, length)
          }
  
          function latin1Write (buf, string, offset, length) {return asciiWrite(buf, string, offset, length)}
  
          function base64Write (buf, string, offset, length) {return blitBuffer(base64ToBytes(string), buf, offset, length)}
  
          function ucs2Write (buf, string, offset, length) {
            return blitBuffer(function (str, units) {
              for (var c, hi, lo, byteArray = [], i = 0; i < str.length && !((units -= 2) < 0); ++i) hi = (c = str.charCodeAt(i)) >> 8, lo = c % 256, byteArray.push(lo), byteArray.push(hi)
              return byteArray
            }(string, buf.length - offset), buf, offset, length)
          }
  
          function base64Slice (buf, start, end) {return 0 === start && end === buf.length ? base64.fromByteArray(buf) : base64.fromByteArray(buf.slice(start, end))}
  
          function utf8Slice (buf, start, end) {
            end = Math.min(buf.length, end)
            for (var res = [], i = start; i < end;) {
              var secondByte, thirdByte, fourthByte, tempCodePoint, firstByte = buf[i], codePoint = null,
                bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1
              if (i + bytesPerSequence <= end) switch (bytesPerSequence) {
                case 1:
                  firstByte < 128 && (codePoint = firstByte)
                  break
                case 2:
                  128 == (192 & (secondByte = buf[i + 1])) && (tempCodePoint = (31 & firstByte) << 6 | 63 & secondByte) > 127 && (codePoint = tempCodePoint)
                  break
                case 3:
                  secondByte = buf[i + 1], thirdByte = buf[i + 2], 128 == (192 & secondByte) && 128 == (192 & thirdByte) && (tempCodePoint = (15 & firstByte) << 12 | (63 & secondByte) << 6 | 63 & thirdByte) > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343) && (codePoint = tempCodePoint)
                  break
                case 4:
                  secondByte = buf[i + 1], thirdByte = buf[i + 2], fourthByte = buf[i + 3], 128 == (192 & secondByte) && 128 == (192 & thirdByte) && 128 == (192 & fourthByte) && (tempCodePoint = (15 & firstByte) << 18 | (63 & secondByte) << 12 | (63 & thirdByte) << 6 | 63 & fourthByte) > 65535 && tempCodePoint < 1114112 && (codePoint = tempCodePoint)
              }
              null === codePoint ? (codePoint = 65533, bytesPerSequence = 1) : codePoint > 65535 && (codePoint -= 65536, res.push(codePoint >>> 10 & 1023 | 55296), codePoint = 56320 | 1023 & codePoint), res.push(codePoint), i += bytesPerSequence
            }
            return function (codePoints) {
              var len = codePoints.length
              if (len <= 4096) return String.fromCharCode.apply(String, codePoints)
              var res = '', i = 0
              for (; i < len;) res += String.fromCharCode.apply(String, codePoints.slice(i, i += 4096))
              return res
            }(res)
          }
  
          exports.Buffer = Buffer, exports.SlowBuffer = function (length) {
            +length != length && (length = 0)
            return Buffer.alloc(+length)
          }, exports.INSPECT_MAX_BYTES = 50, Buffer.TYPED_ARRAY_SUPPORT = void 0 !== global.TYPED_ARRAY_SUPPORT ? global.TYPED_ARRAY_SUPPORT : function () {
            try {
              var arr = new Uint8Array(1)
              return arr.__proto__ = {
                __proto__: Uint8Array.prototype,
                foo: function () {return 42}
              }, 42 === arr.foo() && 'function' == typeof arr.subarray && 0 === arr.subarray(1, 1).byteLength
            } catch (e) {return !1}
          }(), exports.kMaxLength = kMaxLength(), Buffer.poolSize = 8192, Buffer._augment = function (arr) {return arr.__proto__ = Buffer.prototype, arr}, Buffer.from = function (value, encodingOrOffset, length) {return from(null, value, encodingOrOffset, length)}, Buffer.TYPED_ARRAY_SUPPORT && (Buffer.prototype.__proto__ = Uint8Array.prototype, Buffer.__proto__ = Uint8Array, 'undefined' != typeof Symbol && Symbol.species && Buffer[Symbol.species] === Buffer && Object.defineProperty(Buffer, Symbol.species, {
            value: null,
            configurable: !0
          })), Buffer.alloc = function (size, fill, encoding) {return function (that, size, fill, encoding) {return assertSize(size), size <= 0 ? createBuffer(that, size) : void 0 !== fill ? 'string' == typeof encoding ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill) : createBuffer(that, size)}(null, size, fill, encoding)}, Buffer.allocUnsafe = function (size) {return allocUnsafe(null, size)}, Buffer.allocUnsafeSlow = function (size) {return allocUnsafe(null, size)}, Buffer.isBuffer = function (b) {return !(null == b || !b._isBuffer)}, Buffer.compare = function (a, b) {
            if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) throw new TypeError('Arguments must be Buffers')
            if (a === b) return 0
            for (var x = a.length, y = b.length, i = 0, len = Math.min(x, y); i < len; ++i) if (a[i] !== b[i]) {
              x = a[i], y = b[i]
              break
            }
            return x < y ? -1 : y < x ? 1 : 0
          }, Buffer.isEncoding = function (encoding) {
            switch (String(encoding).toLowerCase()) {
              case'hex':
              case'utf8':
              case'utf-8':
              case'ascii':
              case'latin1':
              case'binary':
              case'base64':
              case'ucs2':
              case'ucs-2':
              case'utf16le':
              case'utf-16le':
                return !0
              default:
                return !1
            }
          }, Buffer.concat = function (list, length) {
            if (!isArray(list)) throw new TypeError('"list" argument must be an Array of Buffers')
            if (0 === list.length) return Buffer.alloc(0)
            var i
            if (void 0 === length) for (length = 0, i = 0; i < list.length; ++i) length += list[i].length
            var buffer = Buffer.allocUnsafe(length), pos = 0
            for (i = 0; i < list.length; ++i) {
              var buf = list[i]
              if (!Buffer.isBuffer(buf)) throw new TypeError('"list" argument must be an Array of Buffers')
              buf.copy(buffer, pos), pos += buf.length
            }
            return buffer
          }, Buffer.byteLength = byteLength, Buffer.prototype._isBuffer = !0, Buffer.prototype.swap16 = function () {
            var len = this.length
            if (len % 2 != 0) throw new RangeError('Buffer size must be a multiple of 16-bits')
            for (var i = 0; i < len; i += 2) swap(this, i, i + 1)
            return this
          }, Buffer.prototype.swap32 = function () {
            var len = this.length
            if (len % 4 != 0) throw new RangeError('Buffer size must be a multiple of 32-bits')
            for (var i = 0; i < len; i += 4) swap(this, i, i + 3), swap(this, i + 1, i + 2)
            return this
          }, Buffer.prototype.swap64 = function () {
            var len = this.length
            if (len % 8 != 0) throw new RangeError('Buffer size must be a multiple of 64-bits')
            for (var i = 0; i < len; i += 8) swap(this, i, i + 7), swap(this, i + 1, i + 6), swap(this, i + 2, i + 5), swap(this, i + 3, i + 4)
            return this
          }, Buffer.prototype.toString = function () {
            var length = 0 | this.length
            return 0 === length ? '' : 0 === arguments.length ? utf8Slice(this, 0, length) : slowToString.apply(this, arguments)
          }, Buffer.prototype.equals = function (b) {
            if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
            return this === b || 0 === Buffer.compare(this, b)
          }, Buffer.prototype.inspect = function () {
            var str = '', max = exports.INSPECT_MAX_BYTES
            return this.length > 0 && (str = this.toString('hex', 0, max).match(/.{2}/g).join(' '), this.length > max && (str += ' ... ')), '<Buffer ' + str + '>'
          }, Buffer.prototype.compare = function (target, start, end, thisStart, thisEnd) {
            if (!Buffer.isBuffer(target)) throw new TypeError('Argument must be a Buffer')
            if (void 0 === start && (start = 0), void 0 === end && (end = target ? target.length : 0), void 0 === thisStart && (thisStart = 0), void 0 === thisEnd && (thisEnd = this.length), start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) throw new RangeError('out of range index')
            if (thisStart >= thisEnd && start >= end) return 0
            if (thisStart >= thisEnd) return -1
            if (start >= end) return 1
            if (this === target) return 0
            for (var x = (thisEnd >>>= 0) - (thisStart >>>= 0), y = (end >>>= 0) - (start >>>= 0), len = Math.min(x, y), thisCopy = this.slice(thisStart, thisEnd), targetCopy = target.slice(start, end), i = 0; i < len; ++i) if (thisCopy[i] !== targetCopy[i]) {
              x = thisCopy[i], y = targetCopy[i]
              break
            }
            return x < y ? -1 : y < x ? 1 : 0
          }, Buffer.prototype.includes = function (val, byteOffset, encoding) {return -1 !== this.indexOf(val, byteOffset, encoding)}, Buffer.prototype.indexOf = function (val, byteOffset, encoding) {return bidirectionalIndexOf(this, val, byteOffset, encoding, !0)}, Buffer.prototype.lastIndexOf = function (val, byteOffset, encoding) {return bidirectionalIndexOf(this, val, byteOffset, encoding, !1)}, Buffer.prototype.write = function (string, offset, length, encoding) {
            if (void 0 === offset) encoding = 'utf8', length = this.length, offset = 0 else if (void 0 === length && 'string' == typeof offset) encoding = offset, length = this.length, offset = 0 else {
              if (!isFinite(offset)) throw new Error('Buffer.write(string, encoding, offset[, length]) is no longer supported')
              offset |= 0, isFinite(length) ? (length |= 0, void 0 === encoding && (encoding = 'utf8')) : (encoding = length, length = void 0)
            }
            var remaining = this.length - offset
            if ((void 0 === length || length > remaining) && (length = remaining), string.length > 0 && (length < 0 || offset < 0) || offset > this.length) throw new RangeError('Attempt to write outside buffer bounds')
            encoding || (encoding = 'utf8')
            for (var loweredCase = !1; ;) switch (encoding) {
              case'hex':
                return hexWrite(this, string, offset, length)
              case'utf8':
              case'utf-8':
                return utf8Write(this, string, offset, length)
              case'ascii':
                return asciiWrite(this, string, offset, length)
              case'latin1':
              case'binary':
                return latin1Write(this, string, offset, length)
              case'base64':
                return base64Write(this, string, offset, length)
              case'ucs2':
              case'ucs-2':
              case'utf16le':
              case'utf-16le':
                return ucs2Write(this, string, offset, length)
              default:
                if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
                encoding = ('' + encoding).toLowerCase(), loweredCase = !0
            }
          }, Buffer.prototype.toJSON = function () {
            return {
              type: 'Buffer',
              data: Array.prototype.slice.call(this._arr || this, 0)
            }
          }
  
          function asciiSlice (buf, start, end) {
            var ret = ''
            end = Math.min(buf.length, end)
            for (var i = start; i < end; ++i) ret += String.fromCharCode(127 & buf[i])
            return ret
          }
  
          function latin1Slice (buf, start, end) {
            var ret = ''
            end = Math.min(buf.length, end)
            for (var i = start; i < end; ++i) ret += String.fromCharCode(buf[i])
            return ret
          }
  
          function hexSlice (buf, start, end) {
            var len = buf.length;
            (!start || start < 0) && (start = 0), (!end || end < 0 || end > len) && (end = len)
            for (var out = '', i = start; i < end; ++i) out += toHex(buf[i])
            return out
          }
  
          function utf16leSlice (buf, start, end) {
            for (var bytes = buf.slice(start, end), res = '', i = 0; i < bytes.length; i += 2) res += String.fromCharCode(bytes[i] + 256 * bytes[i + 1])
            return res
          }
  
          function checkOffset (offset, ext, length) {
            if (offset % 1 != 0 || offset < 0) throw new RangeError('offset is not uint')
            if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
          }
  
          function checkInt (buf, value, offset, ext, max, min) {
            if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
            if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
            if (offset + ext > buf.length) throw new RangeError('Index out of range')
          }
  
          function objectWriteUInt16 (buf, value, offset, littleEndian) {
            value < 0 && (value = 65535 + value + 1)
            for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) buf[offset + i] = (value & 255 << 8 * (littleEndian ? i : 1 - i)) >>> 8 * (littleEndian ? i : 1 - i)
          }
  
          function objectWriteUInt32 (buf, value, offset, littleEndian) {
            value < 0 && (value = 4294967295 + value + 1)
            for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) buf[offset + i] = value >>> 8 * (littleEndian ? i : 3 - i) & 255
          }
  
          function checkIEEE754 (buf, value, offset, ext, max, min) {
            if (offset + ext > buf.length) throw new RangeError('Index out of range')
            if (offset < 0) throw new RangeError('Index out of range')
          }
  
          function writeFloat (buf, value, offset, littleEndian, noAssert) {return noAssert || checkIEEE754(buf, 0, offset, 4), ieee754.write(buf, value, offset, littleEndian, 23, 4), offset + 4}
  
          function writeDouble (buf, value, offset, littleEndian, noAssert) {return noAssert || checkIEEE754(buf, 0, offset, 8), ieee754.write(buf, value, offset, littleEndian, 52, 8), offset + 8}
  
          Buffer.prototype.slice = function (start, end) {
            var newBuf, len = this.length
            if ((start = ~~start) < 0 ? (start += len) < 0 && (start = 0) : start > len && (start = len), (end = void 0 === end ? len : ~~end) < 0 ? (end += len) < 0 && (end = 0) : end > len && (end = len), end < start && (end = start), Buffer.TYPED_ARRAY_SUPPORT) (newBuf = this.subarray(start, end)).__proto__ = Buffer.prototype else {
              var sliceLen = end - start
              newBuf = new Buffer(sliceLen, void 0)
              for (var i = 0; i < sliceLen; ++i) newBuf[i] = this[i + start]
            }
            return newBuf
          }, Buffer.prototype.readUIntLE = function (offset, byteLength, noAssert) {
            offset |= 0, byteLength |= 0, noAssert || checkOffset(offset, byteLength, this.length)
            for (var val = this[offset], mul = 1, i = 0; ++i < byteLength && (mul *= 256);) val += this[offset + i] * mul
            return val
          }, Buffer.prototype.readUIntBE = function (offset, byteLength, noAssert) {
            offset |= 0, byteLength |= 0, noAssert || checkOffset(offset, byteLength, this.length)
            for (var val = this[offset + --byteLength], mul = 1; byteLength > 0 && (mul *= 256);) val += this[offset + --byteLength] * mul
            return val
          }, Buffer.prototype.readUInt8 = function (offset, noAssert) {return noAssert || checkOffset(offset, 1, this.length), this[offset]}, Buffer.prototype.readUInt16LE = function (offset, noAssert) {return noAssert || checkOffset(offset, 2, this.length), this[offset] | this[offset + 1] << 8}, Buffer.prototype.readUInt16BE = function (offset, noAssert) {return noAssert || checkOffset(offset, 2, this.length), this[offset] << 8 | this[offset + 1]}, Buffer.prototype.readUInt32LE = function (offset, noAssert) {return noAssert || checkOffset(offset, 4, this.length), (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + 16777216 * this[offset + 3]}, Buffer.prototype.readUInt32BE = function (offset, noAssert) {return noAssert || checkOffset(offset, 4, this.length), 16777216 * this[offset] + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3])}, Buffer.prototype.readIntLE = function (offset, byteLength, noAssert) {
            offset |= 0, byteLength |= 0, noAssert || checkOffset(offset, byteLength, this.length)
            for (var val = this[offset], mul = 1, i = 0; ++i < byteLength && (mul *= 256);) val += this[offset + i] * mul
            return val >= (mul *= 128) && (val -= Math.pow(2, 8 * byteLength)), val
          }, Buffer.prototype.readIntBE = function (offset, byteLength, noAssert) {
            offset |= 0, byteLength |= 0, noAssert || checkOffset(offset, byteLength, this.length)
            for (var i = byteLength, mul = 1, val = this[offset + --i]; i > 0 && (mul *= 256);) val += this[offset + --i] * mul
            return val >= (mul *= 128) && (val -= Math.pow(2, 8 * byteLength)), val
          }, Buffer.prototype.readInt8 = function (offset, noAssert) {return noAssert || checkOffset(offset, 1, this.length), 128 & this[offset] ? -1 * (255 - this[offset] + 1) : this[offset]}, Buffer.prototype.readInt16LE = function (offset, noAssert) {
            noAssert || checkOffset(offset, 2, this.length)
            var val = this[offset] | this[offset + 1] << 8
            return 32768 & val ? 4294901760 | val : val
          }, Buffer.prototype.readInt16BE = function (offset, noAssert) {
            noAssert || checkOffset(offset, 2, this.length)
            var val = this[offset + 1] | this[offset] << 8
            return 32768 & val ? 4294901760 | val : val
          }, Buffer.prototype.readInt32LE = function (offset, noAssert) {return noAssert || checkOffset(offset, 4, this.length), this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24}, Buffer.prototype.readInt32BE = function (offset, noAssert) {return noAssert || checkOffset(offset, 4, this.length), this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]}, Buffer.prototype.readFloatLE = function (offset, noAssert) {return noAssert || checkOffset(offset, 4, this.length), ieee754.read(this, offset, !0, 23, 4)}, Buffer.prototype.readFloatBE = function (offset, noAssert) {return noAssert || checkOffset(offset, 4, this.length), ieee754.read(this, offset, !1, 23, 4)}, Buffer.prototype.readDoubleLE = function (offset, noAssert) {return noAssert || checkOffset(offset, 8, this.length), ieee754.read(this, offset, !0, 52, 8)}, Buffer.prototype.readDoubleBE = function (offset, noAssert) {return noAssert || checkOffset(offset, 8, this.length), ieee754.read(this, offset, !1, 52, 8)}, Buffer.prototype.writeUIntLE = function (value, offset, byteLength, noAssert) {
            (value = +value, offset |= 0, byteLength |= 0, noAssert) || checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength) - 1, 0)
            var mul = 1, i = 0
            for (this[offset] = 255 & value; ++i < byteLength && (mul *= 256);) this[offset + i] = value / mul & 255
            return offset + byteLength
          }, Buffer.prototype.writeUIntBE = function (value, offset, byteLength, noAssert) {
            (value = +value, offset |= 0, byteLength |= 0, noAssert) || checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength) - 1, 0)
            var i = byteLength - 1, mul = 1
            for (this[offset + i] = 255 & value; --i >= 0 && (mul *= 256);) this[offset + i] = value / mul & 255
            return offset + byteLength
          }, Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 1, 255, 0), Buffer.TYPED_ARRAY_SUPPORT || (value = Math.floor(value)), this[offset] = 255 & value, offset + 1}, Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 2, 65535, 0), Buffer.TYPED_ARRAY_SUPPORT ? (this[offset] = 255 & value, this[offset + 1] = value >>> 8) : objectWriteUInt16(this, value, offset, !0), offset + 2}, Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 2, 65535, 0), Buffer.TYPED_ARRAY_SUPPORT ? (this[offset] = value >>> 8, this[offset + 1] = 255 & value) : objectWriteUInt16(this, value, offset, !1), offset + 2}, Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 4, 4294967295, 0), Buffer.TYPED_ARRAY_SUPPORT ? (this[offset + 3] = value >>> 24, this[offset + 2] = value >>> 16, this[offset + 1] = value >>> 8, this[offset] = 255 & value) : objectWriteUInt32(this, value, offset, !0), offset + 4}, Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 4, 4294967295, 0), Buffer.TYPED_ARRAY_SUPPORT ? (this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = 255 & value) : objectWriteUInt32(this, value, offset, !1), offset + 4}, Buffer.prototype.writeIntLE = function (value, offset, byteLength, noAssert) {
            if (value = +value, offset |= 0, !noAssert) {
              var limit = Math.pow(2, 8 * byteLength - 1)
              checkInt(this, value, offset, byteLength, limit - 1, -limit)
            }
            var i = 0, mul = 1, sub = 0
            for (this[offset] = 255 & value; ++i < byteLength && (mul *= 256);) value < 0 && 0 === sub && 0 !== this[offset + i - 1] && (sub = 1), this[offset + i] = (value / mul >> 0) - sub & 255
            return offset + byteLength
          }, Buffer.prototype.writeIntBE = function (value, offset, byteLength, noAssert) {
            if (value = +value, offset |= 0, !noAssert) {
              var limit = Math.pow(2, 8 * byteLength - 1)
              checkInt(this, value, offset, byteLength, limit - 1, -limit)
            }
            var i = byteLength - 1, mul = 1, sub = 0
            for (this[offset + i] = 255 & value; --i >= 0 && (mul *= 256);) value < 0 && 0 === sub && 0 !== this[offset + i + 1] && (sub = 1), this[offset + i] = (value / mul >> 0) - sub & 255
            return offset + byteLength
          }, Buffer.prototype.writeInt8 = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 1, 127, -128), Buffer.TYPED_ARRAY_SUPPORT || (value = Math.floor(value)), value < 0 && (value = 255 + value + 1), this[offset] = 255 & value, offset + 1}, Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 2, 32767, -32768), Buffer.TYPED_ARRAY_SUPPORT ? (this[offset] = 255 & value, this[offset + 1] = value >>> 8) : objectWriteUInt16(this, value, offset, !0), offset + 2}, Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 2, 32767, -32768), Buffer.TYPED_ARRAY_SUPPORT ? (this[offset] = value >>> 8, this[offset + 1] = 255 & value) : objectWriteUInt16(this, value, offset, !1), offset + 2}, Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 4, 2147483647, -2147483648), Buffer.TYPED_ARRAY_SUPPORT ? (this[offset] = 255 & value, this[offset + 1] = value >>> 8, this[offset + 2] = value >>> 16, this[offset + 3] = value >>> 24) : objectWriteUInt32(this, value, offset, !0), offset + 4}, Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {return value = +value, offset |= 0, noAssert || checkInt(this, value, offset, 4, 2147483647, -2147483648), value < 0 && (value = 4294967295 + value + 1), Buffer.TYPED_ARRAY_SUPPORT ? (this[offset] = value >>> 24, this[offset + 1] = value >>> 16, this[offset + 2] = value >>> 8, this[offset + 3] = 255 & value) : objectWriteUInt32(this, value, offset, !1), offset + 4}, Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {return writeFloat(this, value, offset, !0, noAssert)}, Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {return writeFloat(this, value, offset, !1, noAssert)}, Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {return writeDouble(this, value, offset, !0, noAssert)}, Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {return writeDouble(this, value, offset, !1, noAssert)}, Buffer.prototype.copy = function (target, targetStart, start, end) {
            if (start || (start = 0), end || 0 === end || (end = this.length), targetStart >= target.length && (targetStart = target.length), targetStart || (targetStart = 0), end > 0 && end < start && (end = start), end === start) return 0
            if (0 === target.length || 0 === this.length) return 0
            if (targetStart < 0) throw new RangeError('targetStart out of bounds')
            if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
            if (end < 0) throw new RangeError('sourceEnd out of bounds')
            end > this.length && (end = this.length), target.length - targetStart < end - start && (end = target.length - targetStart + start)
            var i, len = end - start
            if (this === target && start < targetStart && targetStart < end) for (i = len - 1; i >= 0; --i) target[i + targetStart] = this[i + start] else if (len < 1e3 || !Buffer.TYPED_ARRAY_SUPPORT) for (i = 0; i < len; ++i) target[i + targetStart] = this[i + start] else Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart)
            return len
          }, Buffer.prototype.fill = function (val, start, end, encoding) {
            if ('string' == typeof val) {
              if ('string' == typeof start ? (encoding = start, start = 0, end = this.length) : 'string' == typeof end && (encoding = end, end = this.length), 1 === val.length) {
                var code = val.charCodeAt(0)
                code < 256 && (val = code)
              }
              if (void 0 !== encoding && 'string' != typeof encoding) throw new TypeError('encoding must be a string')
              if ('string' == typeof encoding && !Buffer.isEncoding(encoding)) throw new TypeError('Unknown encoding: ' + encoding)
            } else 'number' == typeof val && (val &= 255)
            if (start < 0 || this.length < start || this.length < end) throw new RangeError('Out of range index')
            if (end <= start) return this
            var i
            if (start >>>= 0, end = void 0 === end ? this.length : end >>> 0, val || (val = 0), 'number' == typeof val) for (i = start; i < end; ++i) this[i] = val else {
              var bytes = Buffer.isBuffer(val) ? val : utf8ToBytes(new Buffer(val, encoding).toString()),
                len = bytes.length
              for (i = 0; i < end - start; ++i) this[i + start] = bytes[i % len]
            }
            return this
          }
          var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
  
          function toHex (n) {return n < 16 ? '0' + n.toString(16) : n.toString(16)}
  
          function utf8ToBytes (string, units) {
            var codePoint
            units = units || 1 / 0
            for (var length = string.length, leadSurrogate = null, bytes = [], i = 0; i < length; ++i) {
              if ((codePoint = string.charCodeAt(i)) > 55295 && codePoint < 57344) {
                if (!leadSurrogate) {
                  if (codePoint > 56319) {
                    (units -= 3) > -1 && bytes.push(239, 191, 189)
                    continue
                  }
                  if (i + 1 === length) {
                    (units -= 3) > -1 && bytes.push(239, 191, 189)
                    continue
                  }
                  leadSurrogate = codePoint
                  continue
                }
                if (codePoint < 56320) {
                  (units -= 3) > -1 && bytes.push(239, 191, 189), leadSurrogate = codePoint
                  continue
                }
                codePoint = 65536 + (leadSurrogate - 55296 << 10 | codePoint - 56320)
              } else leadSurrogate && (units -= 3) > -1 && bytes.push(239, 191, 189)
              if (leadSurrogate = null, codePoint < 128) {
                if ((units -= 1) < 0) break
                bytes.push(codePoint)
              } else if (codePoint < 2048) {
                if ((units -= 2) < 0) break
                bytes.push(codePoint >> 6 | 192, 63 & codePoint | 128)
              } else if (codePoint < 65536) {
                if ((units -= 3) < 0) break
                bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, 63 & codePoint | 128)
              } else {
                if (!(codePoint < 1114112)) throw new Error('Invalid code point')
                if ((units -= 4) < 0) break
                bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, 63 & codePoint | 128)
              }
            }
            return bytes
          }
  
          function base64ToBytes (str) {
            return base64.toByteArray(function (str) {
              if ((str = function (str) {return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '')}(str).replace(INVALID_BASE64_RE, '')).length < 2) return ''
              for (; str.length % 4 != 0;) str += '='
              return str
            }(str))
          }
  
          function blitBuffer (src, dst, offset, length) {
            for (var i = 0; i < length && !(i + offset >= dst.length || i >= src.length); ++i) dst[i + offset] = src[i]
            return i
          }
        }).call(this, 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {})
      }, { 'base64-js': 26, ieee754: 30, isarray: 31 }],
      29: [function (require, module, exports) {
        function EventEmitter () {this._events = this._events || {}, this._maxListeners = this._maxListeners || void 0}
  
        function isFunction (arg) {return 'function' == typeof arg}
  
        function isObject (arg) {return 'object' == typeof arg && null !== arg}
  
        function isUndefined (arg) {return void 0 === arg}
  
        module.exports = EventEmitter, EventEmitter.EventEmitter = EventEmitter, EventEmitter.prototype._events = void 0, EventEmitter.prototype._maxListeners = void 0, EventEmitter.defaultMaxListeners = 10, EventEmitter.prototype.setMaxListeners = function (n) {
          if ('number' != typeof n || n < 0 || isNaN(n)) throw TypeError('n must be a positive number')
          return this._maxListeners = n, this
        }, EventEmitter.prototype.emit = function (type) {
          var er, handler, len, args, i, listeners
          if (this._events || (this._events = {}), 'error' === type && (!this._events.error || isObject(this._events.error) && !this._events.error.length)) {
            if ((er = arguments[1]) instanceof Error) throw er
            var err = new Error('Uncaught, unspecified "error" event. (' + er + ')')
            throw err.context = er, err
          }
          if (isUndefined(handler = this._events[type])) return !1
          if (isFunction(handler)) switch (arguments.length) {
            case 1:
              handler.call(this)
              break
            case 2:
              handler.call(this, arguments[1])
              break
            case 3:
              handler.call(this, arguments[1], arguments[2])
              break
            default:
              args = Array.prototype.slice.call(arguments, 1), handler.apply(this, args)
          } else if (isObject(handler)) for (args = Array.prototype.slice.call(arguments, 1), len = (listeners = handler.slice()).length, i = 0; i < len; i++) listeners[i].apply(this, args)
          return !0
        }, EventEmitter.prototype.addListener = function (type, listener) {
          var m
          if (!isFunction(listener)) throw TypeError('listener must be a function')
          return this._events || (this._events = {}), this._events.newListener && this.emit('newListener', type, isFunction(listener.listener) ? listener.listener : listener), this._events[type] ? isObject(this._events[type]) ? this._events[type].push(listener) : this._events[type] = [this._events[type], listener] : this._events[type] = listener, isObject(this._events[type]) && !this._events[type].warned && (m = isUndefined(this._maxListeners) ? EventEmitter.defaultMaxListeners : this._maxListeners) && m > 0 && this._events[type].length > m && (this._events[type].warned = !0, console.error('(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.', this._events[type].length), 'function' == typeof console.trace && console.trace()), this
        }, EventEmitter.prototype.on = EventEmitter.prototype.addListener, EventEmitter.prototype.once = function (type, listener) {
          if (!isFunction(listener)) throw TypeError('listener must be a function')
          var fired = !1
  
          function g () {this.removeListener(type, g), fired || (fired = !0, listener.apply(this, arguments))}
  
          return g.listener = listener, this.on(type, g), this
        }, EventEmitter.prototype.removeListener = function (type, listener) {
          var list, position, length, i
          if (!isFunction(listener)) throw TypeError('listener must be a function')
          if (!this._events || !this._events[type]) return this
          if (length = (list = this._events[type]).length, position = -1, list === listener || isFunction(list.listener) && list.listener === listener) delete this._events[type], this._events.removeListener && this.emit('removeListener', type, listener) else if (isObject(list)) {
            for (i = length; i-- > 0;) if (list[i] === listener || list[i].listener && list[i].listener === listener) {
              position = i
              break
            }
            if (position < 0) return this
            1 === list.length ? (list.length = 0, delete this._events[type]) : list.splice(position, 1), this._events.removeListener && this.emit('removeListener', type, listener)
          }
          return this
        }, EventEmitter.prototype.removeAllListeners = function (type) {
          var key, listeners
          if (!this._events) return this
          if (!this._events.removeListener) return 0 === arguments.length ? this._events = {} : this._events[type] && delete this._events[type], this
          if (0 === arguments.length) {
            for (key in this._events) 'removeListener' !== key && this.removeAllListeners(key)
            return this.removeAllListeners('removeListener'), this._events = {}, this
          }
          if (isFunction(listeners = this._events[type])) this.removeListener(type, listeners) else if (listeners) for (; listeners.length;) this.removeListener(type, listeners[listeners.length - 1])
          return delete this._events[type], this
        }, EventEmitter.prototype.listeners = function (type) {return this._events && this._events[type] ? isFunction(this._events[type]) ? [this._events[type]] : this._events[type].slice() : []}, EventEmitter.prototype.listenerCount = function (type) {
          if (this._events) {
            var evlistener = this._events[type]
            if (isFunction(evlistener)) return 1
            if (evlistener) return evlistener.length
          }
          return 0
        }, EventEmitter.listenerCount = function (emitter, type) {return emitter.listenerCount(type)}
      }, {}],
      30: [function (require, module, exports) {
        exports.read = function (buffer, offset, isLE, mLen, nBytes) {
          var e, m, eLen = 8 * nBytes - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1, nBits = -7,
            i = isLE ? nBytes - 1 : 0, d = isLE ? -1 : 1, s = buffer[offset + i]
          for (i += d, e = s & (1 << -nBits) - 1, s >>= -nBits, nBits += eLen; nBits > 0; e = 256 * e + buffer[offset + i], i += d, nBits -= 8)
          for (m = e & (1 << -nBits) - 1, e >>= -nBits, nBits += mLen; nBits > 0; m = 256 * m + buffer[offset + i], i += d, nBits -= 8)
          if (0 === e) e = 1 - eBias else {
            if (e === eMax) return m ? NaN : 1 / 0 * (s ? -1 : 1)
            m += Math.pow(2, mLen), e -= eBias
          }
          return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
        }, exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
          var e, m, c, eLen = 8 * nBytes - mLen - 1, eMax = (1 << eLen) - 1, eBias = eMax >> 1,
            rt = 23 === mLen ? Math.pow(2, -24) - Math.pow(2, -77) : 0, i = isLE ? 0 : nBytes - 1, d = isLE ? 1 : -1,
            s = value < 0 || 0 === value && 1 / value < 0 ? 1 : 0
          for (value = Math.abs(value), isNaN(value) || value === 1 / 0 ? (m = isNaN(value) ? 1 : 0, e = eMax) : (e = Math.floor(Math.log(value) / Math.LN2), value * (c = Math.pow(2, -e)) < 1 && (e--, c *= 2), (value += e + eBias >= 1 ? rt / c : rt * Math.pow(2, 1 - eBias)) * c >= 2 && (e++, c /= 2), e + eBias >= eMax ? (m = 0, e = eMax) : e + eBias >= 1 ? (m = (value * c - 1) * Math.pow(2, mLen), e += eBias) : (m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen), e = 0)); mLen >= 8; buffer[offset + i] = 255 & m, i += d, m /= 256, mLen -= 8)
          for (e = e << mLen | m, eLen += mLen; eLen > 0; buffer[offset + i] = 255 & e, i += d, e /= 256, eLen -= 8)
          buffer[offset + i - d] |= 128 * s
        }
      }, {}],
      31: [function (require, module, exports) {
        var toString = {}.toString
        module.exports = Array.isArray || function (arr) {return '[object Array]' == toString.call(arr)}
      }, {}],
      32: [function (require, module, exports) {
        var cachedSetTimeout, cachedClearTimeout, process = module.exports = {}
  
        function defaultSetTimout () {throw new Error('setTimeout has not been defined')}
  
        function defaultClearTimeout () {throw new Error('clearTimeout has not been defined')}
  
        function runTimeout (fun) {
          if (cachedSetTimeout === setTimeout) return setTimeout(fun, 0)
          if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) return cachedSetTimeout = setTimeout, setTimeout(fun, 0)
          try {return cachedSetTimeout(fun, 0)} catch (e) {try {return cachedSetTimeout.call(null, fun, 0)} catch (e) {return cachedSetTimeout.call(this, fun, 0)}}
        }
  
        !function () {
          try {cachedSetTimeout = 'function' == typeof setTimeout ? setTimeout : defaultSetTimout} catch (e) {cachedSetTimeout = defaultSetTimout}
          try {cachedClearTimeout = 'function' == typeof clearTimeout ? clearTimeout : defaultClearTimeout} catch (e) {cachedClearTimeout = defaultClearTimeout}
        }()
        var currentQueue, queue = [], draining = !1, queueIndex = -1
  
        function cleanUpNextTick () {draining && currentQueue && (draining = !1, currentQueue.length ? queue = currentQueue.concat(queue) : queueIndex = -1, queue.length && drainQueue())}
  
        function drainQueue () {
          if (!draining) {
            var timeout = runTimeout(cleanUpNextTick)
            draining = !0
            for (var len = queue.length; len;) {
              for (currentQueue = queue, queue = []; ++queueIndex < len;) currentQueue && currentQueue[queueIndex].run()
              queueIndex = -1, len = queue.length
            }
            currentQueue = null, draining = !1, function (marker) {
              if (cachedClearTimeout === clearTimeout) return clearTimeout(marker)
              if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) return cachedClearTimeout = clearTimeout, clearTimeout(marker)
              try {cachedClearTimeout(marker)} catch (e) {try {return cachedClearTimeout.call(null, marker)} catch (e) {return cachedClearTimeout.call(this, marker)}}
            }(timeout)
          }
        }
  
        function Item (fun, array) {this.fun = fun, this.array = array}
  
        function noop () {}
  
        process.nextTick = function (fun) {
          var args = new Array(arguments.length - 1)
          if (arguments.length > 1) for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i]
          queue.push(new Item(fun, args)), 1 !== queue.length || draining || runTimeout(drainQueue)
        }, Item.prototype.run = function () {this.fun.apply(null, this.array)}, process.title = 'browser', process.browser = !0, process.env = {}, process.argv = [], process.version = '', process.versions = {}, process.on = noop, process.addListener = noop, process.once = noop, process.off = noop, process.removeListener = noop, process.removeAllListeners = noop, process.emit = noop, process.prependListener = noop, process.prependOnceListener = noop, process.listeners = function (name) {return []}, process.binding = function (name) {throw new Error('process.binding is not supported')}, process.cwd = function () {return '/'}, process.chdir = function (dir) {throw new Error('process.chdir is not supported')}, process.umask = function () {return 0}
      }, {}],
      33: [function (require, module, exports) {
        (function (global) {
          !function (root) {
            var freeExports = 'object' == typeof exports && exports && !exports.nodeType && exports,
              freeModule = 'object' == typeof module && module && !module.nodeType && module,
              freeGlobal = 'object' == typeof global && global
            freeGlobal.global !== freeGlobal && freeGlobal.window !== freeGlobal && freeGlobal.self !== freeGlobal || (root = freeGlobal)
            var punycode, key, maxInt = 2147483647, regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/,
              regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors = {
                overflow: 'Overflow: input needs wider integers to process',
                'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
                'invalid-input': 'Invalid input'
              }, floor = Math.floor, stringFromCharCode = String.fromCharCode
  
            function error (type) {throw new RangeError(errors[type])}
  
            function map (array, fn) {
              for (var length = array.length, result = []; length--;) result[length] = fn(array[length])
              return result
            }
  
            function mapDomain (string, fn) {
              var parts = string.split('@'), result = ''
              return parts.length > 1 && (result = parts[0] + '@', string = parts[1]), result + map((string = string.replace(regexSeparators, '.')).split('.'), fn).join('.')
            }
  
            function ucs2decode (string) {
              for (var value, extra, output = [], counter = 0, length = string.length; counter < length;) (value = string.charCodeAt(counter++)) >= 55296 && value <= 56319 && counter < length ? 56320 == (64512 & (extra = string.charCodeAt(counter++))) ? output.push(((1023 & value) << 10) + (1023 & extra) + 65536) : (output.push(value), counter--) : output.push(value)
              return output
            }
  
            function ucs2encode (array) {
              return map(array, (function (value) {
                var output = ''
                return value > 65535 && (output += stringFromCharCode((value -= 65536) >>> 10 & 1023 | 55296), value = 56320 | 1023 & value), output += stringFromCharCode(value)
              })).join('')
            }
  
            function digitToBasic (digit, flag) {return digit + 22 + 75 * (digit < 26) - ((0 != flag) << 5)}
  
            function adapt (delta, numPoints, firstTime) {
              var k = 0
              for (delta = firstTime ? floor(delta / 700) : delta >> 1, delta += floor(delta / numPoints); delta > 455; k += 36) delta = floor(delta / 35)
              return floor(k + 36 * delta / (delta + 38))
            }
  
            function decode (input) {
              var out, basic, j, index, oldi, w, k, digit, t, baseMinusT, codePoint, output = [],
                inputLength = input.length, i = 0, n = 128, bias = 72
              for ((basic = input.lastIndexOf('-')) < 0 && (basic = 0), j = 0; j < basic; ++j) input.charCodeAt(j) >= 128 && error('not-basic'), output.push(input.charCodeAt(j))
              for (index = basic > 0 ? basic + 1 : 0; index < inputLength;) {
                for (oldi = i, w = 1, k = 36; index >= inputLength && error("invalid-input"), ((digit = (codePoint = input.charCodeAt(index++)) - 48 < 10 ? codePoint - 22 : codePoint - 65 < 26 ? codePoint - 65 : codePoint - 97 < 26 ? codePoint - 97 : 36) >= 36 || digit > floor((maxInt - i) / w)) && error("overflow"), i += digit * w, !(digit < (t = k <= bias ? 1 : k >= bias + 26 ? 26 : k - bias)); k += 36) w > floor(maxInt / (baseMinusT = 36 - t)) && error('overflow'), w *= baseMinusT
                bias = adapt(i - oldi, out = output.length + 1, 0 == oldi), floor(i / out) > maxInt - n && error('overflow'), n += floor(i / out), i %= out, output.splice(i++, 0, n)
              }
              return ucs2encode(output)
            }
  
            function encode (input) {
              var n, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, inputLength,
                handledCPCountPlusOne, baseMinusT, qMinusT, output = []
              for (inputLength = (input = ucs2decode(input)).length, n = 128, delta = 0, bias = 72, j = 0; j < inputLength; ++j) (currentValue = input[j]) < 128 && output.push(stringFromCharCode(currentValue))
              for (handledCPCount = basicLength = output.length, basicLength && output.push('-'); handledCPCount < inputLength;) {
                for (m = maxInt, j = 0; j < inputLength; ++j) (currentValue = input[j]) >= n && currentValue < m && (m = currentValue)
                for (m - n > floor((maxInt - delta) / (handledCPCountPlusOne = handledCPCount + 1)) && error('overflow'), delta += (m - n) * handledCPCountPlusOne, n = m, j = 0; j < inputLength; ++j) if ((currentValue = input[j]) < n && ++delta > maxInt && error('overflow'), currentValue == n) {
                  for (q = delta, k = 36; !(q < (t = k <= bias ? 1 : k >= bias + 26 ? 26 : k - bias)); k += 36) qMinusT = q - t, baseMinusT = 36 - t, output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))), q = floor(qMinusT / baseMinusT)
                  output.push(stringFromCharCode(digitToBasic(q, 0))), bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength), delta = 0, ++handledCPCount
                }
                ++delta, ++n
              }
              return output.join('')
            }
  
            if (punycode = {
              version: '1.4.1',
              ucs2: { decode: ucs2decode, encode: ucs2encode },
              decode: decode,
              encode: encode,
              toASCII: function (input) {return mapDomain(input, (function (string) {return regexNonASCII.test(string) ? 'xn--' + encode(string) : string}))},
              toUnicode: function (input) {return mapDomain(input, (function (string) {return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string}))}
            }, freeExports && freeModule) if (module.exports == freeExports) freeModule.exports = punycode else for (key in punycode) punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]) else root.punycode = punycode
          }(this)
        }).call(this, 'undefined' != typeof global ? global : 'undefined' != typeof self ? self : 'undefined' != typeof window ? window : {})
      }, {}],
      34: [function (require, module, exports) {
        'use strict'
  
        function hasOwnProperty (obj, prop) {return Object.prototype.hasOwnProperty.call(obj, prop)}
  
        module.exports = function (qs, sep, eq, options) {
          sep = sep || '&', eq = eq || '='
          var obj = {}
          if ('string' != typeof qs || 0 === qs.length) return obj
          var regexp = /\+/g
          qs = qs.split(sep)
          var maxKeys = 1e3
          options && 'number' == typeof options.maxKeys && (maxKeys = options.maxKeys)
          var len = qs.length
          maxKeys > 0 && len > maxKeys && (len = maxKeys)
          for (var i = 0; i < len; ++i) {
            var kstr, vstr, k, v, x = qs[i].replace(regexp, '%20'), idx = x.indexOf(eq)
            idx >= 0 ? (kstr = x.substr(0, idx), vstr = x.substr(idx + 1)) : (kstr = x, vstr = ''), k = decodeURIComponent(kstr), v = decodeURIComponent(vstr), hasOwnProperty(obj, k) ? isArray(obj[k]) ? obj[k].push(v) : obj[k] = [obj[k], v] : obj[k] = v
          }
          return obj
        }
        var isArray = Array.isArray || function (xs) {return '[object Array]' === Object.prototype.toString.call(xs)}
      }, {}],
      35: [function (require, module, exports) {
        'use strict'
        var stringifyPrimitive = function (v) {
          switch (typeof v) {
            case'string':
              return v
            case'boolean':
              return v ? 'true' : 'false'
            case'number':
              return isFinite(v) ? v : ''
            default:
              return ''
          }
        }
        module.exports = function (obj, sep, eq, name) {
          return sep = sep || '&', eq = eq || '=', null === obj && (obj = void 0), 'object' == typeof obj ? map(objectKeys(obj), (function (k) {
            var ks = encodeURIComponent(stringifyPrimitive(k)) + eq
            return isArray(obj[k]) ? map(obj[k], (function (v) {return ks + encodeURIComponent(stringifyPrimitive(v))})).join(sep) : ks + encodeURIComponent(stringifyPrimitive(obj[k]))
          })).join(sep) : name ? encodeURIComponent(stringifyPrimitive(name)) + eq + encodeURIComponent(stringifyPrimitive(obj)) : ''
        }
        var isArray = Array.isArray || function (xs) {return '[object Array]' === Object.prototype.toString.call(xs)}
  
        function map (xs, f) {
          if (xs.map) return xs.map(f)
          for (var res = [], i = 0; i < xs.length; i++) res.push(f(xs[i], i))
          return res
        }
  
        var objectKeys = Object.keys || function (obj) {
          var res = []
          for (var key in obj) Object.prototype.hasOwnProperty.call(obj, key) && res.push(key)
          return res
        }
      }, {}],
      36: [function (require, module, exports) {
        'use strict'
        exports.decode = exports.parse = require('./decode'), exports.encode = exports.stringify = require('./encode')
      }, { './decode': 34, './encode': 35 }],
      37: [function (require, module, exports) {
        'use strict'
        var punycode = require('punycode'), util = require('./util')
  
        function Url () {this.protocol = null, this.slashes = null, this.auth = null, this.host = null, this.port = null, this.hostname = null, this.hash = null, this.search = null, this.query = null, this.pathname = null, this.path = null, this.href = null}
  
        exports.parse = urlParse, exports.resolve = function (source, relative) {return urlParse(source, !1, !0).resolve(relative)}, exports.resolveObject = function (source, relative) {return source ? urlParse(source, !1, !0).resolveObject(relative) : relative}, exports.format = function (obj) {
          util.isString(obj) && (obj = urlParse(obj))
          return obj instanceof Url ? obj.format() : Url.prototype.format.call(obj)
        }, exports.Url = Url
        var protocolPattern = /^([a-z0-9.+-]+:)/i, portPattern = /:[0-9]*$/,
          simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
          unwise = ['{', '}', '|', '\\', '^', '`'].concat(['<', '>', '"', '`', ' ', '\r', '\n', '\t']),
          autoEscape = ['\''].concat(unwise), nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
          hostEndingChars = ['/', '?', '#'], hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
          hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/, unsafeProtocol = { javascript: !0, 'javascript:': !0 },
          hostlessProtocol = { javascript: !0, 'javascript:': !0 }, slashedProtocol = {
            http: !0,
            https: !0,
            ftp: !0,
            gopher: !0,
            file: !0,
            'http:': !0,
            'https:': !0,
            'ftp:': !0,
            'gopher:': !0,
            'file:': !0
          }, querystring = require('querystring')
  
        function urlParse (url, parseQueryString, slashesDenoteHost) {
          if (url && util.isObject(url) && url instanceof Url) return url
          var u = new Url
          return u.parse(url, parseQueryString, slashesDenoteHost), u
        }
  
        Url.prototype.parse = function (url, parseQueryString, slashesDenoteHost) {
          if (!util.isString(url)) throw new TypeError('Parameter \'url\' must be a string, not ' + typeof url)
          var queryIndex = url.indexOf('?'), splitter = -1 !== queryIndex && queryIndex < url.indexOf('#') ? '?' : '#',
            uSplit = url.split(splitter)
          uSplit[0] = uSplit[0].replace(/\\/g, '/')
          var rest = url = uSplit.join(splitter)
          if (rest = rest.trim(), !slashesDenoteHost && 1 === url.split('#').length) {
            var simplePath = simplePathPattern.exec(rest)
            if (simplePath) return this.path = rest, this.href = rest, this.pathname = simplePath[1], simplePath[2] ? (this.search = simplePath[2], this.query = parseQueryString ? querystring.parse(this.search.substr(1)) : this.search.substr(1)) : parseQueryString && (this.search = '', this.query = {}), this
          }
          var proto = protocolPattern.exec(rest)
          if (proto) {
            var lowerProto = (proto = proto[0]).toLowerCase()
            this.protocol = lowerProto, rest = rest.substr(proto.length)
          }
          if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
            var slashes = '//' === rest.substr(0, 2)
            !slashes || proto && hostlessProtocol[proto] || (rest = rest.substr(2), this.slashes = !0)
          }
          if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
            for (var auth, atSign, hostEnd = -1, i = 0; i < hostEndingChars.length; i++) {-1 !== (hec = rest.indexOf(hostEndingChars[i])) && (-1 === hostEnd || hec < hostEnd) && (hostEnd = hec)}
            -1 !== (atSign = -1 === hostEnd ? rest.lastIndexOf('@') : rest.lastIndexOf('@', hostEnd)) && (auth = rest.slice(0, atSign), rest = rest.slice(atSign + 1), this.auth = decodeURIComponent(auth)), hostEnd = -1
            for (i = 0; i < nonHostChars.length; i++) {
              var hec;
              -1 !== (hec = rest.indexOf(nonHostChars[i])) && (-1 === hostEnd || hec < hostEnd) && (hostEnd = hec)
            }
            -1 === hostEnd && (hostEnd = rest.length), this.host = rest.slice(0, hostEnd), rest = rest.slice(hostEnd), this.parseHost(), this.hostname = this.hostname || ''
            var ipv6Hostname = '[' === this.hostname[0] && ']' === this.hostname[this.hostname.length - 1]
            if (!ipv6Hostname) for (var hostparts = this.hostname.split(/\./), l = (i = 0, hostparts.length); i < l; i++) {
              var part = hostparts[i]
              if (part && !part.match(hostnamePartPattern)) {
                for (var newpart = '', j = 0, k = part.length; j < k; j++) part.charCodeAt(j) > 127 ? newpart += 'x' : newpart += part[j]
                if (!newpart.match(hostnamePartPattern)) {
                  var validParts = hostparts.slice(0, i), notHost = hostparts.slice(i + 1),
                    bit = part.match(hostnamePartStart)
                  bit && (validParts.push(bit[1]), notHost.unshift(bit[2])), notHost.length && (rest = '/' + notHost.join('.') + rest), this.hostname = validParts.join('.')
                  break
                }
              }
            }
            this.hostname.length > 255 ? this.hostname = '' : this.hostname = this.hostname.toLowerCase(), ipv6Hostname || (this.hostname = punycode.toASCII(this.hostname))
            var p = this.port ? ':' + this.port : '', h = this.hostname || ''
            this.host = h + p, this.href += this.host, ipv6Hostname && (this.hostname = this.hostname.substr(1, this.hostname.length - 2), '/' !== rest[0] && (rest = '/' + rest))
          }
          if (!unsafeProtocol[lowerProto]) for (i = 0, l = autoEscape.length; i < l; i++) {
            var ae = autoEscape[i]
            if (-1 !== rest.indexOf(ae)) {
              var esc = encodeURIComponent(ae)
              esc === ae && (esc = escape(ae)), rest = rest.split(ae).join(esc)
            }
          }
          var hash = rest.indexOf('#');
          -1 !== hash && (this.hash = rest.substr(hash), rest = rest.slice(0, hash))
          var qm = rest.indexOf('?')
          if (-1 !== qm ? (this.search = rest.substr(qm), this.query = rest.substr(qm + 1), parseQueryString && (this.query = querystring.parse(this.query)), rest = rest.slice(0, qm)) : parseQueryString && (this.search = '', this.query = {}), rest && (this.pathname = rest), slashedProtocol[lowerProto] && this.hostname && !this.pathname && (this.pathname = '/'), this.pathname || this.search) {
            p = this.pathname || ''
            var s = this.search || ''
            this.path = p + s
          }
          return this.href = this.format(), this
        }, Url.prototype.format = function () {
          var auth = this.auth || ''
          auth && (auth = (auth = encodeURIComponent(auth)).replace(/%3A/i, ':'), auth += '@')
          var protocol = this.protocol || '', pathname = this.pathname || '', hash = this.hash || '', host = !1,
            query = ''
          this.host ? host = auth + this.host : this.hostname && (host = auth + (-1 === this.hostname.indexOf(':') ? this.hostname : '[' + this.hostname + ']'), this.port && (host += ':' + this.port)), this.query && util.isObject(this.query) && Object.keys(this.query).length && (query = querystring.stringify(this.query))
          var search = this.search || query && '?' + query || ''
          return protocol && ':' !== protocol.substr(-1) && (protocol += ':'), this.slashes || (!protocol || slashedProtocol[protocol]) && !1 !== host ? (host = '//' + (host || ''), pathname && '/' !== pathname.charAt(0) && (pathname = '/' + pathname)) : host || (host = ''), hash && '#' !== hash.charAt(0) && (hash = '#' + hash), search && '?' !== search.charAt(0) && (search = '?' + search), protocol + host + (pathname = pathname.replace(/[?#]/g, (function (match) {return encodeURIComponent(match)}))) + (search = search.replace('#', '%23')) + hash
        }, Url.prototype.resolve = function (relative) {return this.resolveObject(urlParse(relative, !1, !0)).format()}, Url.prototype.resolveObject = function (relative) {
          if (util.isString(relative)) {
            var rel = new Url
            rel.parse(relative, !1, !0), relative = rel
          }
          for (var result = new Url, tkeys = Object.keys(this), tk = 0; tk < tkeys.length; tk++) {
            var tkey = tkeys[tk]
            result[tkey] = this[tkey]
          }
          if (result.hash = relative.hash, '' === relative.href) return result.href = result.format(), result
          if (relative.slashes && !relative.protocol) {
            for (var rkeys = Object.keys(relative), rk = 0; rk < rkeys.length; rk++) {
              var rkey = rkeys[rk]
              'protocol' !== rkey && (result[rkey] = relative[rkey])
            }
            return slashedProtocol[result.protocol] && result.hostname && !result.pathname && (result.path = result.pathname = '/'), result.href = result.format(), result
          }
          if (relative.protocol && relative.protocol !== result.protocol) {
            if (!slashedProtocol[relative.protocol]) {
              for (var keys = Object.keys(relative), v = 0; v < keys.length; v++) {
                var k = keys[v]
                result[k] = relative[k]
              }
              return result.href = result.format(), result
            }
            if (result.protocol = relative.protocol, relative.host || hostlessProtocol[relative.protocol]) result.pathname = relative.pathname else {
              for (var relPath = (relative.pathname || '').split('/'); relPath.length && !(relative.host = relPath.shift());)
              relative.host || (relative.host = ''), relative.hostname || (relative.hostname = ''), '' !== relPath[0] && relPath.unshift(''), relPath.length < 2 && relPath.unshift(''), result.pathname = relPath.join('/')
            }
            if (result.search = relative.search, result.query = relative.query, result.host = relative.host || '', result.auth = relative.auth, result.hostname = relative.hostname || relative.host, result.port = relative.port, result.pathname || result.search) {
              var p = result.pathname || '', s = result.search || ''
              result.path = p + s
            }
            return result.slashes = result.slashes || relative.slashes, result.href = result.format(), result
          }
          var isSourceAbs = result.pathname && '/' === result.pathname.charAt(0),
            isRelAbs = relative.host || relative.pathname && '/' === relative.pathname.charAt(0),
            mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname, removeAllDots = mustEndAbs,
            srcPath = result.pathname && result.pathname.split('/') || [],
            psychotic = (relPath = relative.pathname && relative.pathname.split('/') || [], result.protocol && !slashedProtocol[result.protocol])
          if (psychotic && (result.hostname = '', result.port = null, result.host && ('' === srcPath[0] ? srcPath[0] = result.host : srcPath.unshift(result.host)), result.host = '', relative.protocol && (relative.hostname = null, relative.port = null, relative.host && ('' === relPath[0] ? relPath[0] = relative.host : relPath.unshift(relative.host)), relative.host = null), mustEndAbs = mustEndAbs && ('' === relPath[0] || '' === srcPath[0])), isRelAbs) result.host = relative.host || '' === relative.host ? relative.host : result.host, result.hostname = relative.hostname || '' === relative.hostname ? relative.hostname : result.hostname, result.search = relative.search, result.query = relative.query, srcPath = relPath else if (relPath.length) srcPath || (srcPath = []), srcPath.pop(), srcPath = srcPath.concat(relPath), result.search = relative.search, result.query = relative.query else if (!util.isNullOrUndefined(relative.search)) {
            if (psychotic) result.hostname = result.host = srcPath.shift(), (authInHost = !!(result.host && result.host.indexOf('@') > 0) && result.host.split('@')) && (result.auth = authInHost.shift(), result.host = result.hostname = authInHost.shift())
            return result.search = relative.search, result.query = relative.query, util.isNull(result.pathname) && util.isNull(result.search) || (result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '')), result.href = result.format(), result
          }
          if (!srcPath.length) return result.pathname = null, result.search ? result.path = '/' + result.search : result.path = null, result.href = result.format(), result
          for (var last = srcPath.slice(-1)[0], hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && ('.' === last || '..' === last) || '' === last, up = 0, i = srcPath.length; i >= 0; i--) '.' === (last = srcPath[i]) ? srcPath.splice(i, 1) : '..' === last ? (srcPath.splice(i, 1), up++) : up && (srcPath.splice(i, 1), up--)
          if (!mustEndAbs && !removeAllDots) for (; up--; up) srcPath.unshift('..')
          !mustEndAbs || '' === srcPath[0] || srcPath[0] && '/' === srcPath[0].charAt(0) || srcPath.unshift(''), hasTrailingSlash && '/' !== srcPath.join('/').substr(-1) && srcPath.push('')
          var authInHost, isAbsolute = '' === srcPath[0] || srcPath[0] && '/' === srcPath[0].charAt(0)
          psychotic && (result.hostname = result.host = isAbsolute ? '' : srcPath.length ? srcPath.shift() : '', (authInHost = !!(result.host && result.host.indexOf('@') > 0) && result.host.split('@')) && (result.auth = authInHost.shift(), result.host = result.hostname = authInHost.shift()))
          return (mustEndAbs = mustEndAbs || result.host && srcPath.length) && !isAbsolute && srcPath.unshift(''), srcPath.length ? result.pathname = srcPath.join('/') : (result.pathname = null, result.path = null), util.isNull(result.pathname) && util.isNull(result.search) || (result.path = (result.pathname ? result.pathname : '') + (result.search ? result.search : '')), result.auth = relative.auth || result.auth, result.slashes = result.slashes || relative.slashes, result.href = result.format(), result
        }, Url.prototype.parseHost = function () {
          var host = this.host, port = portPattern.exec(host)
          port && (':' !== (port = port[0]) && (this.port = port.substr(1)), host = host.substr(0, host.length - port.length)), host && (this.hostname = host)
        }
      }, { './util': 38, punycode: 33, querystring: 36 }],
      38: [function (require, module, exports) {
        'use strict'
        module.exports = {
          isString: function (arg) {return 'string' == typeof arg},
          isObject: function (arg) {return 'object' == typeof arg && null !== arg},
          isNull: function (arg) {return null === arg},
          isNullOrUndefined: function (arg) {return null == arg}
        }
      }, {}]
    }, {}, [22])(22)
  }))