(function(f) {
  if (typeof exports === "object" && typeof module !== "undefined") {
    module.exports = f()
  } else if (typeof define === "function" && define.amd) {
    define([], f)
  } else {
    var g;
    if (typeof window !== "undefined") {
      g = window
    } else if (typeof global !== "undefined") {
      g = global
    } else if (typeof self !== "undefined") {
      g = self
    } else {
      g = this
    }
    g.mqtt = f()
  }
})(function() {
  var define, module, exports;
  return (function() {
    function r(e, n, t) {
      function o(i, f) {
        if (!n[i]) {
          if (!e[i]) {
            var c = "function" == typeof require && require;
            if (!f && c) return c(i, !0);
            if (u) return u(i, !0);
            var a = new Error("Cannot find module '" + i + "'");
            throw a.code = "MODULE_NOT_FOUND", a
          }
          var p = n[i] = {
            exports: {}
          };
          e[i][0].call(p.exports, function(r) {
            var n = e[i][1][r];
            return o(n || r)
          }, p, p.exports, r, e, n, t)
        }
        return n[i].exports
      }
      for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
      return o
    }
    return r
  })()({
    1: [function(require, module, exports) {
      (function(process, global) {
        'use strict'

        /**
         * Module dependencies
         */
        var events = require('events')
        var Store = require('./store')
        var eos = require('end-of-stream')
        var mqttPacket = require('mqtt-packet')
        var Writable = require('readable-stream').Writable
        var inherits = require('inherits')
        var reInterval = require('reinterval')
        var validations = require('./validations')
        var xtend = require('xtend')
        var setImmediate = global.setImmediate || function(callback) {
          // works in node v0.8
          process.nextTick(callback)
        }
        var defaultConnectOptions = {
          keepalive: 60,
          reschedulePings: true,
          protocolId: 'MQTT',
          protocolVersion: 4,
          reconnectPeriod: 1000,
          connectTimeout: 30 * 1000,
          clean: true,
          resubscribe: true
        }

        function defaultId() {
          return 'mqttjs_' + Math.random().toString(16).substr(2, 8)
        }

        function sendPacket(client, packet, cb) {
          client.emit('packetsend', packet)

          var result = mqttPacket.writeToStream(packet, client.stream)

          if (!result && cb) {
            client.stream.once('drain', cb)
          } else if (cb) {
            cb()
          }
        }

        function flush(queue) {
          if (queue) {
            Object.keys(queue).forEach(function(messageId) {
              if (typeof queue[messageId] === 'function') {
                queue[messageId](new Error('Connection closed'))
                delete queue[messageId]
              }
            })
          }
        }

        function storeAndSend(client, packet, cb) {
          client.outgoingStore.put(packet, function storedPacket(err) {
            if (err) {
              return cb && cb(err)
            }
            sendPacket(client, packet, cb)
          })
        }

        function nop() {}

        /**
         * MqttClient constructor
         *
         * @param {Stream} stream - stream
         * @param {Object} [options] - connection options
         * (see Connection#connect)
         */
        function MqttClient(streamBuilder, options) {
          var k
          var that = this

          if (!(this instanceof MqttClient)) {
            return new MqttClient(streamBuilder, options)
          }

          this.options = options || {}

          // Defaults
          for (k in defaultConnectOptions) {
            if (typeof this.options[k] === 'undefined') {
              this.options[k] = defaultConnectOptions[k]
            } else {
              this.options[k] = options[k]
            }
          }

          this.options.clientId = (typeof this.options.clientId === 'string') ? this.options.clientId : defaultId()

          this.streamBuilder = streamBuilder

          // Inflight message storages
          this.outgoingStore = this.options.outgoingStore || new Store()
          this.incomingStore = this.options.incomingStore || new Store()

          // Should QoS zero messages be queued when the connection is broken?
          this.queueQoSZero = this.options.queueQoSZero === undefined ? true : this.options.queueQoSZero

          // map of subscribed topics to support reconnection
          this._resubscribeTopics = {}

          // map of a subscribe messageId and a topic
          this.messageIdToTopic = {}

          // Ping timer, setup in _setupPingTimer
          this.pingTimer = null
          // Is the client connected?
          this.connected = false
          // Are we disconnecting?
          this.disconnecting = false
          // Packet queue
          this.queue = []
          // connack timer
          this.connackTimer = null
          // Reconnect timer
          this.reconnectTimer = null
          /**
           * MessageIDs starting with 1
           * ensure that nextId is min. 1, see https://github.com/mqttjs/MQTT.js/issues/810
           */
          this.nextId = Math.max(1, Math.floor(Math.random() * 65535))

          // Inflight callbacks
          this.outgoing = {}

          // Mark connected on connect
          this.on('connect', function() {
            if (this.disconnected) {
              return
            }

            this.connected = true
            var outStore = this.outgoingStore.createStream()

            this.once('close', remove)
            outStore.on('end', function() {
              that.removeListener('close', remove)
            })
            outStore.on('error', function(err) {
              that.removeListener('close', remove)
              that.emit('error', err)
            })

            function remove() {
              outStore.destroy()
              outStore = null
            }

            function storeDeliver() {
              // edge case, we wrapped this twice
              if (!outStore) {
                return
              }

              var packet = outStore.read(1)
              var cb

              if (!packet) {
                // read when data is available in the future
                outStore.once('readable', storeDeliver)
                return
              }

              // Avoid unnecessary stream read operations when disconnected
              if (!that.disconnecting && !that.reconnectTimer) {
                cb = that.outgoing[packet.messageId]
                that.outgoing[packet.messageId] = function(err, status) {
                  // Ensure that the original callback passed in to publish gets invoked
                  if (cb) {
                    cb(err, status)
                  }

                  storeDeliver()
                }
                that._sendPacket(packet)
              } else if (outStore.destroy) {
                outStore.destroy()
              }
            }

            // start flowing
            storeDeliver()
          })

          // Mark disconnected on stream close
          this.on('close', function() {
            this.connected = false
            clearTimeout(this.connackTimer)
          })

          // Setup ping timer
          this.on('connect', this._setupPingTimer)

          // Send queued packets
          this.on('connect', function() {
            var queue = this.queue

            function deliver() {
              var entry = queue.shift()
              var packet = null

              if (!entry) {
                return
              }

              packet = entry.packet

              that._sendPacket(
                packet,
                function(err) {
                  if (entry.cb) {
                    entry.cb(err)
                  }
                  deliver()
                }
              )
            }

            deliver()
          })

          var firstConnection = true
          // resubscribe
          this.on('connect', function() {
            if (!firstConnection &&
              this.options.clean &&
              Object.keys(this._resubscribeTopics).length > 0) {
              if (this.options.resubscribe) {
                this._resubscribeTopics.resubscribe = true
                this.subscribe(this._resubscribeTopics)
              } else {
                this._resubscribeTopics = {}
              }
            }

            firstConnection = false
          })

          // Clear ping timer
          this.on('close', function() {
            if (that.pingTimer !== null) {
              that.pingTimer.clear()
              that.pingTimer = null
            }
          })

          // Setup reconnect timer on disconnect
          this.on('close', this._setupReconnect)

          events.EventEmitter.call(this)

          this._setupStream()
        }
        inherits(MqttClient, events.EventEmitter)

        /**
         * setup the event handlers in the inner stream.
         *
         * @api private
         */
        MqttClient.prototype._setupStream = function() {
          var connectPacket
          var that = this
          var writable = new Writable()
          var parser = mqttPacket.parser(this.options)
          var completeParse = null
          var packets = []

          this._clearReconnect()

          this.stream = this.streamBuilder(this)

          parser.on('packet', function(packet) {
            packets.push(packet)
          })

          function nextTickWork() {
            process.nextTick(work)
          }

          function work() {
            var packet = packets.shift()
            var done = completeParse

            if (packet) {
              that._handlePacket(packet, nextTickWork)
            } else {
              completeParse = null
              done()
            }
          }

          writable._write = function(buf, enc, done) {
            completeParse = done
            parser.parse(buf)
            work()
          }

          this.stream.pipe(writable)

          // Suppress connection errors
          this.stream.on('error', nop)

          // Echo stream close
          eos(this.stream, this.emit.bind(this, 'close'))

          // Send a connect packet
          connectPacket = Object.create(this.options)
          connectPacket.cmd = 'connect'
          // avoid message queue
          sendPacket(this, connectPacket)

          // Echo connection errors
          parser.on('error', this.emit.bind(this, 'error'))

          // many drain listeners are needed for qos 1 callbacks if the connection is intermittent
          this.stream.setMaxListeners(1000)

          clearTimeout(this.connackTimer)
          this.connackTimer = setTimeout(function() {
            that._cleanUp(true)
          }, this.options.connectTimeout)
        }

        MqttClient.prototype._handlePacket = function(packet, done) {
          this.emit('packetreceive', packet)

          switch (packet.cmd) {
            case 'publish':
              this._handlePublish(packet, done)
              break
            case 'puback':
            case 'pubrec':
            case 'pubcomp':
            case 'suback':
            case 'unsuback':
              this._handleAck(packet)
              done()
              break
            case 'pubrel':
              this._handlePubrel(packet, done)
              break
            case 'connack':
              this._handleConnack(packet)
              done()
              break
            case 'pingresp':
              this._handlePingresp(packet)
              done()
              break
            default:
              // do nothing
              // maybe we should do an error handling
              // or just log it
              break
          }
        }

        MqttClient.prototype._checkDisconnecting = function(callback) {
          if (this.disconnecting) {
            if (callback) {
              callback(new Error('client disconnecting'))
            } else {
              this.emit('error', new Error('client disconnecting'))
            }
          }
          return this.disconnecting
        }

        /**
         * publish - publish <message> to <topic>
         *
         * @param {String} topic - topic to publish to
         * @param {String, Buffer} message - message to publish
         * @param {Object} [opts] - publish options, includes:
         *    {Number} qos - qos level to publish on
         *    {Boolean} retain - whether or not to retain the message
         *    {Boolean} dup - whether or not mark a message as duplicate
         * @param {Function} [callback] - function(err){}
         *    called when publish succeeds or fails
         * @returns {MqttClient} this - for chaining
         * @api public
         *
         * @example client.publish('topic', 'message');
         * @example
         *     client.publish('topic', 'message', {qos: 1, retain: true, dup: true});
         * @example client.publish('topic', 'message', console.log);
         */
        MqttClient.prototype.publish = function(topic, message, opts, callback) {
          var packet

          // .publish(topic, payload, cb);
          if (typeof opts === 'function') {
            callback = opts
            opts = null
          }

          // default opts
          var defaultOpts = {
            qos: 0,
            retain: false,
            dup: false
          }
          opts = xtend(defaultOpts, opts)

          if (this._checkDisconnecting(callback)) {
            return this
          }

          packet = {
            cmd: 'publish',
            topic: topic,
            payload: message,
            qos: opts.qos,
            retain: opts.retain,
            messageId: this._nextId(),
            dup: opts.dup
          }

          switch (opts.qos) {
            case 1:
            case 2:

              // Add to callbacks
              this.outgoing[packet.messageId] = callback || nop
              this._sendPacket(packet)
              break
            default:
              this._sendPacket(packet, callback)
              break
          }

          return this
        }

        /**
         * subscribe - subscribe to <topic>
         *
         * @param {String, Array, Object} topic - topic(s) to subscribe to, supports objects in the form {'topic': qos}
         * @param {Object} [opts] - optional subscription options, includes:
         *    {Number} qos - subscribe qos level
         * @param {Function} [callback] - function(err, granted){} where:
         *    {Error} err - subscription error (none at the moment!)
         *    {Array} granted - array of {topic: 't', qos: 0}
         * @returns {MqttClient} this - for chaining
         * @api public
         * @example client.subscribe('topic');
         * @example client.subscribe('topic', {qos: 1});
         * @example client.subscribe({'topic': 0, 'topic2': 1}, console.log);
         * @example client.subscribe('topic', console.log);
         */
        MqttClient.prototype.subscribe = function() {
          var packet
          var args = Array.prototype.slice.call(arguments)
          var subs = []
          var obj = args.shift()
          var resubscribe = obj.resubscribe
          var callback = args.pop() || nop
          var opts = args.pop()
          var invalidTopic
          var that = this

          delete obj.resubscribe

          if (typeof obj === 'string') {
            obj = [obj]
          }

          if (typeof callback !== 'function') {
            opts = callback
            callback = nop
          }

          invalidTopic = validations.validateTopics(obj)
          if (invalidTopic !== null) {
            setImmediate(callback, new Error('Invalid topic ' + invalidTopic))
            return this
          }

          if (this._checkDisconnecting(callback)) {
            return this
          }

          var defaultOpts = {
            qos: 0
          }
          opts = xtend(defaultOpts, opts)

          if (Array.isArray(obj)) {
            obj.forEach(function(topic) {
              if (that._resubscribeTopics[topic] < opts.qos ||
                !that._resubscribeTopics.hasOwnProperty(topic) ||
                resubscribe) {
                subs.push({
                  topic: topic,
                  qos: opts.qos
                })
              }
            })
          } else {
            Object
              .keys(obj)
              .forEach(function(k) {
                if (that._resubscribeTopics[k] < obj[k] ||
                  !that._resubscribeTopics.hasOwnProperty(k) ||
                  resubscribe) {
                  subs.push({
                    topic: k,
                    qos: obj[k]
                  })
                }
              })
          }

          packet = {
            cmd: 'subscribe',
            subscriptions: subs,
            qos: 1,
            retain: false,
            dup: false,
            messageId: this._nextId()
          }

          if (!subs.length) {
            callback(null, [])
            return
          }

          // subscriptions to resubscribe to in case of disconnect
          if (this.options.resubscribe) {
            var topics = []
            subs.forEach(function(sub) {
              if (that.options.reconnectPeriod > 0) {
                that._resubscribeTopics[sub.topic] = sub.qos
                topics.push(sub.topic)
              }
            })
            that.messageIdToTopic[packet.messageId] = topics
          }

          this.outgoing[packet.messageId] = function(err, packet) {
            if (!err) {
              var granted = packet.granted
              for (var i = 0; i < granted.length; i += 1) {
                subs[i].qos = granted[i]
              }
            }

            callback(err, subs)
          }

          this._sendPacket(packet)

          return this
        }

        /**
         * unsubscribe - unsubscribe from topic(s)
         *
         * @param {String, Array} topic - topics to unsubscribe from
         * @param {Function} [callback] - callback fired on unsuback
         * @returns {MqttClient} this - for chaining
         * @api public
         * @example client.unsubscribe('topic');
         * @example client.unsubscribe('topic', console.log);
         */
        MqttClient.prototype.unsubscribe = function(topic, callback) {
          var packet = {
            cmd: 'unsubscribe',
            qos: 1,
            messageId: this._nextId()
          }
          var that = this

          callback = callback || nop

          if (this._checkDisconnecting(callback)) {
            return this
          }

          if (typeof topic === 'string') {
            packet.unsubscriptions = [topic]
          } else if (typeof topic === 'object' && topic.length) {
            packet.unsubscriptions = topic
          }

          if (this.options.resubscribe) {
            packet.unsubscriptions.forEach(function(topic) {
              delete that._resubscribeTopics[topic]
            })
          }

          this.outgoing[packet.messageId] = callback

          this._sendPacket(packet)

          return this
        }

        /**
         * end - close connection
         *
         * @returns {MqttClient} this - for chaining
         * @param {Boolean} force - do not wait for all in-flight messages to be acked
         * @param {Function} cb - called when the client has been closed
         *
         * @api public
         */
        MqttClient.prototype.end = function(force, cb) {
          var that = this

          if (typeof force === 'function') {
            cb = force
            force = false
          }

          function closeStores() {
            that.disconnected = true
            that.incomingStore.close(function() {
              that.outgoingStore.close(function() {
                if (cb) {
                  cb.apply(null, arguments)
                }
                that.emit('end')
              })
            })
            if (that._deferredReconnect) {
              that._deferredReconnect()
            }
          }

          function finish() {
            // defer closesStores of an I/O cycle,
            // just to make sure things are
            // ok for websockets
            that._cleanUp(force, setImmediate.bind(null, closeStores))
          }

          if (this.disconnecting) {
            return this
          }

          this._clearReconnect()

          this.disconnecting = true

          if (!force && Object.keys(this.outgoing).length > 0) {
            // wait 10ms, just to be sure we received all of it
            this.once('outgoingEmpty', setTimeout.bind(null, finish, 10))
          } else {
            finish()
          }

          return this
        }

        /**
         * removeOutgoingMessage - remove a message in outgoing store
         * the outgoing callback will be called withe Error('Message removed') if the message is removed
         *
         * @param {Number} mid - messageId to remove message
         * @returns {MqttClient} this - for chaining
         * @api public
         *
         * @example client.removeOutgoingMessage(client.getLastMessageId());
         */
        MqttClient.prototype.removeOutgoingMessage = function(mid) {
          var cb = this.outgoing[mid]
          delete this.outgoing[mid]
          this.outgoingStore.del({
            messageId: mid
          }, function() {
            cb(new Error('Message removed'))
          })
          return this
        }

        /**
         * reconnect - connect again using the same options as connect()
         *
         * @param {Object} [opts] - optional reconnect options, includes:
         *    {Store} incomingStore - a store for the incoming packets
         *    {Store} outgoingStore - a store for the outgoing packets
         *    if opts is not given, current stores are used
         * @returns {MqttClient} this - for chaining
         *
         * @api public
         */
        MqttClient.prototype.reconnect = function(opts) {
          var that = this
          var f = function() {
            if (opts) {
              that.options.incomingStore = opts.incomingStore
              that.options.outgoingStore = opts.outgoingStore
            } else {
              that.options.incomingStore = null
              that.options.outgoingStore = null
            }
            that.incomingStore = that.options.incomingStore || new Store()
            that.outgoingStore = that.options.outgoingStore || new Store()
            that.disconnecting = false
            that.disconnected = false
            that._deferredReconnect = null
            that._reconnect()
          }

          if (this.disconnecting && !this.disconnected) {
            this._deferredReconnect = f
          } else {
            f()
          }
          return this
        }

        /**
         * _reconnect - implement reconnection
         * @api privateish
         */
        MqttClient.prototype._reconnect = function() {
          this.emit('reconnect')
          this._setupStream()
        }

        /**
         * _setupReconnect - setup reconnect timer
         */
        MqttClient.prototype._setupReconnect = function() {
          var that = this

          if (!that.disconnecting && !that.reconnectTimer && (that.options.reconnectPeriod > 0)) {
            if (!this.reconnecting) {
              this.emit('offline')
              this.reconnecting = true
            }
            that.reconnectTimer = setInterval(function() {
              that._reconnect()
            }, that.options.reconnectPeriod)
          }
        }

        /**
         * _clearReconnect - clear the reconnect timer
         */
        MqttClient.prototype._clearReconnect = function() {
          if (this.reconnectTimer) {
            clearInterval(this.reconnectTimer)
            this.reconnectTimer = null
          }
        }

        /**
         * _cleanUp - clean up on connection end
         * @api private
         */
        MqttClient.prototype._cleanUp = function(forced, done) {
          if (done) {
            this.stream.on('close', done)
          }

          if (forced) {
            if ((this.options.reconnectPeriod === 0) && this.options.clean) {
              flush(this.outgoing)
            }
            this.stream.destroy()
          } else {
            this._sendPacket({
                cmd: 'disconnect'
              },
              setImmediate.bind(
                null,
                this.stream.end.bind(this.stream)
              )
            )
          }

          if (!this.disconnecting) {
            this._clearReconnect()
            this._setupReconnect()
          }

          if (this.pingTimer !== null) {
            this.pingTimer.clear()
            this.pingTimer = null
          }

          if (done && !this.connected) {
            this.stream.removeListener('close', done)
            done()
          }
        }

        /**
         * _sendPacket - send or queue a packet
         * @param {String} type - packet type (see `protocol`)
         * @param {Object} packet - packet options
         * @param {Function} cb - callback when the packet is sent
         * @api private
         */
        MqttClient.prototype._sendPacket = function(packet, cb) {
          if (!this.connected) {
            if (((packet.qos || 0) === 0 && this.queueQoSZero) || packet.cmd !== 'publish') {
              this.queue.push({
                packet: packet,
                cb: cb
              })
            } else if (packet.qos > 0) {
              cb = this.outgoing[packet.messageId]
              this.outgoingStore.put(packet, function(err) {
                if (err) {
                  return cb && cb(err)
                }
              })
            } else if (cb) {
              cb(new Error('No connection to broker'))
            }

            return
          }

          // When sending a packet, reschedule the ping timer
          this._shiftPingInterval()

          switch (packet.cmd) {
            case 'publish':
              break
            case 'pubrel':
              storeAndSend(this, packet, cb)
              return
            default:
              sendPacket(this, packet, cb)
              return
          }

          switch (packet.qos) {
            case 2:
            case 1:
              storeAndSend(this, packet, cb)
              break
              /**
               * no need of case here since it will be caught by default
               * and jshint comply that before default it must be a break
               * anyway it will result in -1 evaluation
               */
            case 0:
              /* falls through */
            default:
              sendPacket(this, packet, cb)
              break
          }
        }

        /**
         * _setupPingTimer - setup the ping timer
         *
         * @api private
         */
        MqttClient.prototype._setupPingTimer = function() {
          var that = this

          if (!this.pingTimer && this.options.keepalive) {
            this.pingResp = true
            this.pingTimer = reInterval(function() {
              that._checkPing()
            }, this.options.keepalive * 1000)
          }
        }

        /**
         * _shiftPingInterval - reschedule the ping interval
         *
         * @api private
         */
        MqttClient.prototype._shiftPingInterval = function() {
          if (this.pingTimer && this.options.keepalive && this.options.reschedulePings) {
            this.pingTimer.reschedule(this.options.keepalive * 1000)
          }
        }
        /**
         * _checkPing - check if a pingresp has come back, and ping the server again
         *
         * @api private
         */
        MqttClient.prototype._checkPing = function() {
          if (this.pingResp) {
            this.pingResp = false
            this._sendPacket({
              cmd: 'pingreq'
            })
          } else {
            // do a forced cleanup since socket will be in bad shape
            this._cleanUp(true)
          }
        }

        /**
         * _handlePingresp - handle a pingresp
         *
         * @api private
         */
        MqttClient.prototype._handlePingresp = function() {
          this.pingResp = true
        }

        /**
         * _handleConnack
         *
         * @param {Object} packet
         * @api private
         */

        MqttClient.prototype._handleConnack = function(packet) {
          var rc = packet.returnCode
          var errors = [
            '',
            'Unacceptable protocol version',
            'Identifier rejected',
            'Server unavailable',
            'Bad username or password',
            'Not authorized'
          ]

          clearTimeout(this.connackTimer)

          if (rc === 0) {
            this.reconnecting = false
            this.emit('connect', packet)
          } else if (rc > 0) {
            var err = new Error('Connection refused: ' + errors[rc])
            err.code = rc
            this.emit('error', err)
          }
        }

        /**
         * _handlePublish
         *
         * @param {Object} packet
         * @api private
         */
        /*
        those late 2 case should be rewrite to comply with coding style:

        case 1:
        case 0:
          // do not wait sending a puback
          // no callback passed
          if (1 === qos) {
            this._sendPacket({
              cmd: 'puback',
              messageId: mid
            });
          }
          // emit the message event for both qos 1 and 0
          this.emit('message', topic, message, packet);
          this.handleMessage(packet, done);
          break;
        default:
          // do nothing but every switch mus have a default
          // log or throw an error about unknown qos
          break;

        for now i just suppressed the warnings
        */
        MqttClient.prototype._handlePublish = function(packet, done) {
          done = typeof done !== 'undefined' ? done : nop
          var topic = packet.topic.toString()
          var message = packet.payload
          var qos = packet.qos
          var mid = packet.messageId
          var that = this

          switch (qos) {
            case 2:
              this.incomingStore.put(packet, function(err) {
                if (err) {
                  return done(err)
                }
                that._sendPacket({
                  cmd: 'pubrec',
                  messageId: mid
                }, done)
              })
              break
            case 1:
              // emit the message event
              this.emit('message', topic, message, packet)
              this.handleMessage(packet, function(err) {
                if (err) {
                  return done(err)
                }
                // send 'puback' if the above 'handleMessage' method executed
                // successfully.
                that._sendPacket({
                  cmd: 'puback',
                  messageId: mid
                }, done)
              })
              break
            case 0:
              // emit the message event
              this.emit('message', topic, message, packet)
              this.handleMessage(packet, done)
              break
            default:
              // do nothing
              // log or throw an error about unknown qos
              break
          }
        }

        /**
         * Handle messages with backpressure support, one at a time.
         * Override at will.
         *
         * @param Packet packet the packet
         * @param Function callback call when finished
         * @api public
         */
        MqttClient.prototype.handleMessage = function(packet, callback) {
          callback()
        }

        /**
         * _handleAck
         *
         * @param {Object} packet
         * @api private
         */

        MqttClient.prototype._handleAck = function(packet) {
          /* eslint no-fallthrough: "off" */
          var mid = packet.messageId
          var type = packet.cmd
          var response = null
          var cb = this.outgoing[mid]
          var that = this

          if (!cb) {
            // Server sent an ack in error, ignore it.
            return
          }

          // Process
          switch (type) {
            case 'pubcomp':
              // same thing as puback for QoS 2
            case 'puback':
              // Callback - we're done
              delete this.outgoing[mid]
              this.outgoingStore.del(packet, cb)
              break
            case 'pubrec':
              response = {
                cmd: 'pubrel',
                qos: 2,
                messageId: mid
              }

              this._sendPacket(response)
              break
            case 'suback':
              delete this.outgoing[mid]
              if (packet.granted.length === 1 && (packet.granted[0] & 0x80) !== 0) {
                // suback with Failure status
                var topics = this.messageIdToTopic[mid]
                if (topics) {
                  topics.forEach(function(topic) {
                    delete that._resubscribeTopics[topic]
                  })
                }
              }
              cb(null, packet)
              break
            case 'unsuback':
              delete this.outgoing[mid]
              cb(null)
              break
            default:
              that.emit('error', new Error('unrecognized packet type'))
          }

          if (this.disconnecting &&
            Object.keys(this.outgoing).length === 0) {
            this.emit('outgoingEmpty')
          }
        }

        /**
         * _handlePubrel
         *
         * @param {Object} packet
         * @api private
         */
        MqttClient.prototype._handlePubrel = function(packet, callback) {
          callback = typeof callback !== 'undefined' ? callback : nop
          var mid = packet.messageId
          var that = this

          var comp = {
            cmd: 'pubcomp',
            messageId: mid
          }

          that.incomingStore.get(packet, function(err, pub) {
            if (!err && pub.cmd !== 'pubrel') {
              that.emit('message', pub.topic, pub.payload, pub)
              that.incomingStore.put(packet, function(err) {
                if (err) {
                  return callback(err)
                }
                that.handleMessage(pub, function(err) {
                  if (err) {
                    return callback(err)
                  }
                  that._sendPacket(comp, callback)
                })
              })
            } else {
              that._sendPacket(comp, callback)
            }
          })
        }

        /**
         * _nextId
         * @return unsigned int
         */
        MqttClient.prototype._nextId = function() {
          // id becomes current state of this.nextId and increments afterwards
          var id = this.nextId++
            // Ensure 16 bit unsigned int (max 65535, nextId got one higher)
            if (this.nextId === 65536) {
              this.nextId = 1
            }
          return id
        }

        /**
         * getLastMessageId
         * @return unsigned int
         */
        MqttClient.prototype.getLastMessageId = function() {
          return (this.nextId === 1) ? 65535 : (this.nextId - 1)
        }

        module.exports = MqttClient

      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./store": 6,
      "./validations": 7,
      "_process": 92,
      "end-of-stream": 17,
      "events": 78,
      "inherits": 80,
      "mqtt-packet": 85,
      "readable-stream": 106,
      "reinterval": 107,
      "xtend": 120
    }],
    2: [function(require, module, exports) {
      'use strict'
      var net = require('net')

      /*
        variables port and host can be removed since
        you have all required information in opts object
      */
      function buildBuilder(client, opts) {
        var port, host
        opts.port = opts.port || 1883
        opts.hostname = opts.hostname || opts.host || 'localhost'

        port = opts.port
        host = opts.hostname

        return net.createConnection(port, host)
      }

      module.exports = buildBuilder

    }, {
      "net": 11
    }],
    3: [function(require, module, exports) {
      'use strict'
      var tls = require('tls')

      function buildBuilder(mqttClient, opts) {
        var connection
        opts.port = opts.port || 8883
        opts.host = opts.hostname || opts.host || 'localhost'

        opts.rejectUnauthorized = opts.rejectUnauthorized !== false

        delete opts.path

        connection = tls.connect(opts)
        /* eslint no-use-before-define: [2, "nofunc"] */
        connection.on('secureConnect', function() {
          if (opts.rejectUnauthorized && !connection.authorized) {
            connection.emit('error', new Error('TLS not authorized'))
          } else {
            connection.removeListener('error', handleTLSerrors)
          }
        })

        function handleTLSerrors(err) {
          // How can I get verify this error is a tls error?
          if (opts.rejectUnauthorized) {
            mqttClient.emit('error', err)
          }

          // close this connection to match the behaviour of net
          // otherwise all we get is an error from the connection
          // and close event doesn't fire. This is a work around
          // to enable the reconnect code to work the same as with
          // net.createConnection
          connection.end()
        }

        connection.on('error', handleTLSerrors)
        return connection
      }

      module.exports = buildBuilder

    }, {
      "tls": 11
    }],
    4: [function(require, module, exports) {
      (function(process) {
        'use strict'

        var websocket = require('websocket-stream')
        var urlModule = require('url')
        var WSS_OPTIONS = [
          'rejectUnauthorized',
          'ca',
          'cert',
          'key',
          'pfx',
          'passphrase'
        ]
        var IS_BROWSER = process.title === 'browser'

        function buildUrl(opts, client) {
          var url = opts.protocol + '://' + opts.hostname + ':' + opts.port + opts.path
          if (typeof(opts.transformWsUrl) === 'function') {
            url = opts.transformWsUrl(url, opts, client)
          }
          return url
        }

        function setDefaultOpts(opts) {
          if (!opts.hostname) {
            opts.hostname = 'localhost'
          }
          if (!opts.port) {
            if (opts.protocol === 'wss') {
              opts.port = 443
            } else {
              opts.port = 80
            }
          }
          if (!opts.path) {
            opts.path = '/'
          }

          if (!opts.wsOptions) {
            opts.wsOptions = {}
          }
          if (!IS_BROWSER && opts.protocol === 'wss') {
            // Add cert/key/ca etc options
            WSS_OPTIONS.forEach(function(prop) {
              if (opts.hasOwnProperty(prop) && !opts.wsOptions.hasOwnProperty(prop)) {
                opts.wsOptions[prop] = opts[prop]
              }
            })
          }
        }

        function createWebSocket(client, opts) {
          var websocketSubProtocol =
            (opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3) ?
            'mqttv3.1' :
            'mqtt'

          setDefaultOpts(opts)
          var url = buildUrl(opts, client)
          return websocket(url, [websocketSubProtocol], opts.wsOptions)
        }

        function buildBuilder(client, opts) {
          return createWebSocket(client, opts)
        }

        function buildBuilderBrowser(client, opts) {
          if (!opts.hostname) {
            opts.hostname = opts.host
          }

          if (!opts.hostname) {
            // Throwing an error in a Web Worker if no `hostname` is given, because we
            // can not determine the `hostname` automatically.  If connecting to
            // localhost, please supply the `hostname` as an argument.
            if (typeof(document) === 'undefined') {
              throw new Error('Could not determine host. Specify host manually.')
            }
            var parsed = urlModule.parse(document.URL)
            opts.hostname = parsed.hostname

            if (!opts.port) {
              opts.port = parsed.port
            }
          }
          return createWebSocket(client, opts)
        }

        if (IS_BROWSER) {
          module.exports = buildBuilderBrowser
        } else {
          module.exports = buildBuilder
        }

      }).call(this, require('_process'))
    }, {
      "_process": 92,
      "url": 112,
      "websocket-stream": 117
    }],
    5: [function(require, module, exports) {
      'use strict'

      /* global wx */
      var socketOpen = false
      var socketMsgQueue = []

      function sendSocketMessage(msg) {
        if (socketOpen) {
          wx.sendSocketMessage({
            data: msg.buffer || msg
          })
        } else {
          socketMsgQueue.push(msg)
        }
      }

      function WebSocket(url, protocols) {
        var ws = {
          OPEN: 1,
          CLOSING: 2,
          CLOSED: 3,
          readyState: socketOpen ? 1 : 0,
          send: sendSocketMessage,
          close: wx.closeSocket,
          onopen: null,
          onmessage: null,
          onclose: null,
          onerror: null
        }

        wx.connectSocket({
          url: url,
          protocols: protocols
        })
        wx.onSocketOpen(function(res) {
          ws.readyState = ws.OPEN
          socketOpen = true
          for (var i = 0; i < socketMsgQueue.length; i++) {
            sendSocketMessage(socketMsgQueue[i])
          }
          socketMsgQueue = []

          ws.onopen && ws.onopen.apply(ws, arguments)
        })
        wx.onSocketMessage(function(res) {
          ws.onmessage && ws.onmessage.apply(ws, arguments)
        })
        wx.onSocketClose(function() {
          ws.onclose && ws.onclose.apply(ws, arguments)
          ws.readyState = ws.CLOSED
          socketOpen = false
        })
        wx.onSocketError(function() {
          ws.onerror && ws.onerror.apply(ws, arguments)
          ws.readyState = ws.CLOSED
          socketOpen = false
        })

        return ws
      }

      var websocket = require('websocket-stream')

      function buildUrl(opts, client) {
        var protocol = opts.protocol === 'wxs' ? 'wss' : 'ws'
        var url = protocol + '://' + opts.hostname + opts.path
        if (opts.port && opts.port !== 80 && opts.port !== 443) {
          url = protocol + '://' + opts.hostname + ':' + opts.port + opts.path
        }
        if (typeof(opts.transformWsUrl) === 'function') {
          url = opts.transformWsUrl(url, opts, client)
        }
        return url
      }

      function setDefaultOpts(opts) {
        if (!opts.hostname) {
          opts.hostname = 'localhost'
        }
        if (!opts.path) {
          opts.path = '/'
        }

        if (!opts.wsOptions) {
          opts.wsOptions = {}
        }
      }

      function createWebSocket(client, opts) {
        var websocketSubProtocol =
          (opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3) ?
          'mqttv3.1' :
          'mqtt'

        setDefaultOpts(opts)
        var url = buildUrl(opts, client)
        return websocket(WebSocket(url, [websocketSubProtocol]))
      }

      function buildBuilder(client, opts) {
        opts.hostname = opts.hostname || opts.host

        if (!opts.hostname) {
          throw new Error('Could not determine host. Specify host manually.')
        }

        return createWebSocket(client, opts)
      }

      module.exports = buildBuilder

    }, {
      "websocket-stream": 117
    }],
    6: [function(require, module, exports) {
      (function(process) {
        'use strict'

        /**
         * Module dependencies
         */
        var xtend = require('xtend')

        var Readable = require('readable-stream').Readable
        var streamsOpts = {
          objectMode: true
        }
        var defaultStoreOptions = {
          clean: true
        }

        /**
         * es6-map can preserve insertion order even if ES version is older.
         *
         * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Description
         * It should be noted that a Map which is a map of an object, especially
         * a dictionary of dictionaries, will only map to the object's insertion
         * order. In ES2015 this is ordered for objects but for older versions of
         * ES, this may be random and not ordered.
         *
         */
        var Map = require('es6-map')

        /**
         * In-memory implementation of the message store
         * This can actually be saved into files.
         *
         * @param {Object} [options] - store options
         */
        function Store(options) {
          if (!(this instanceof Store)) {
            return new Store(options)
          }

          this.options = options || {}

          // Defaults
          this.options = xtend(defaultStoreOptions, options)

          this._inflights = new Map()
        }

        /**
         * Adds a packet to the store, a packet is
         * anything that has a messageId property.
         *
         */
        Store.prototype.put = function(packet, cb) {
          this._inflights.set(packet.messageId, packet)

          if (cb) {
            cb()
          }

          return this
        }

        /**
         * Creates a stream with all the packets in the store
         *
         */
        Store.prototype.createStream = function() {
          var stream = new Readable(streamsOpts)
          var destroyed = false
          var values = []
          var i = 0

          this._inflights.forEach(function(value, key) {
            values.push(value)
          })

          stream._read = function() {
            if (!destroyed && i < values.length) {
              this.push(values[i++])
            } else {
              this.push(null)
            }
          }

          stream.destroy = function() {
            if (destroyed) {
              return
            }

            var self = this

            destroyed = true

            process.nextTick(function() {
              self.emit('close')
            })
          }

          return stream
        }

        /**
         * deletes a packet from the store.
         */
        Store.prototype.del = function(packet, cb) {
          packet = this._inflights.get(packet.messageId)
          if (packet) {
            this._inflights.delete(packet.messageId)
            cb(null, packet)
          } else if (cb) {
            cb(new Error('missing packet'))
          }

          return this
        }

        /**
         * get a packet from the store.
         */
        Store.prototype.get = function(packet, cb) {
          packet = this._inflights.get(packet.messageId)
          if (packet) {
            cb(null, packet)
          } else if (cb) {
            cb(new Error('missing packet'))
          }

          return this
        }

        /**
         * Close the store
         */
        Store.prototype.close = function(cb) {
          if (this.options.clean) {
            this._inflights = null
          }
          if (cb) {
            cb()
          }
        }

        module.exports = Store

      }).call(this, require('_process'))
    }, {
      "_process": 92,
      "es6-map": 66,
      "readable-stream": 106,
      "xtend": 120
    }],
    7: [function(require, module, exports) {
      'use strict'

      /**
       * Validate a topic to see if it's valid or not.
       * A topic is valid if it follow below rules:
       * - Rule #1: If any part of the topic is not `+` or `#`, then it must not contain `+` and '#'
       * - Rule #2: Part `#` must be located at the end of the mailbox
       *
       * @param {String} topic - A topic
       * @returns {Boolean} If the topic is valid, returns true. Otherwise, returns false.
       */
      function validateTopic(topic) {
        var parts = topic.split('/')

        for (var i = 0; i < parts.length; i++) {
          if (parts[i] === '+') {
            continue
          }

          if (parts[i] === '#') {
            // for Rule #2
            return i === parts.length - 1
          }

          if (parts[i].indexOf('+') !== -1 || parts[i].indexOf('#') !== -1) {
            return false
          }
        }

        return true
      }

      /**
       * Validate an array of topics to see if any of them is valid or not
       * @param {Array} topics - Array of topics
       * @returns {String} If the topics is valid, returns null. Otherwise, returns the invalid one
       */
      function validateTopics(topics) {
        if (topics.length === 0) {
          return 'empty_topic_list'
        }
        for (var i = 0; i < topics.length; i++) {
          if (!validateTopic(topics[i])) {
            return topics[i]
          }
        }
        return null
      }

      module.exports = {
        validateTopics: validateTopics
      }

    }, {}],
    8: [function(require, module, exports) {
      (function(process) {
        'use strict'

        var MqttClient = require('../client')
        var Store = require('../store')
        var url = require('url')
        var xtend = require('xtend')
        var protocols = {}

        if (process.title !== 'browser') {
          protocols.mqtt = require('./tcp')
          protocols.tcp = require('./tcp')
          protocols.ssl = require('./tls')
          protocols.tls = require('./tls')
          protocols.mqtts = require('./tls')
        } else {
          protocols.wx = require('./wx')
          protocols.wxs = require('./wx')
        }

        protocols.ws = require('./ws')
        protocols.wss = require('./ws')

        /**
         * Parse the auth attribute and merge username and password in the options object.
         *
         * @param {Object} [opts] option object
         */
        function parseAuthOptions(opts) {
          var matches
          if (opts.auth) {
            matches = opts.auth.match(/^(.+):(.+)$/)
            if (matches) {
              opts.username = matches[1]
              opts.password = matches[2]
            } else {
              opts.username = opts.auth
            }
          }
        }

        /**
         * connect - connect to an MQTT broker.
         *
         * @param {String} [brokerUrl] - url of the broker, optional
         * @param {Object} opts - see MqttClient#constructor
         */
        function connect(brokerUrl, opts) {
          if ((typeof brokerUrl === 'object') && !opts) {
            opts = brokerUrl
            brokerUrl = null
          }

          opts = opts || {}

          if (brokerUrl) {
            var parsed = url.parse(brokerUrl, true)
            if (parsed.port != null) {
              parsed.port = Number(parsed.port)
            }

            opts = xtend(parsed, opts)

            if (opts.protocol === null) {
              throw new Error('Missing protocol')
            }
            opts.protocol = opts.protocol.replace(/:$/, '')
          }

          // merge in the auth options if supplied
          parseAuthOptions(opts)

          // support clientId passed in the query string of the url
          if (opts.query && typeof opts.query.clientId === 'string') {
            opts.clientId = opts.query.clientId
          }

          if (opts.cert && opts.key) {
            if (opts.protocol) {
              if (['mqtts', 'wss', 'wxs'].indexOf(opts.protocol) === -1) {
                switch (opts.protocol) {
                  case 'mqtt':
                    opts.protocol = 'mqtts'
                    break
                  case 'ws':
                    opts.protocol = 'wss'
                    break
                  case 'wx':
                    opts.protocol = 'wxs'
                    break
                  default:
                    throw new Error('Unknown protocol for secure connection: "' + opts.protocol + '"!')
                }
              }
            } else {
              // don't know what protocol he want to use, mqtts or wss
              throw new Error('Missing secure protocol key')
            }
          }

          if (!protocols[opts.protocol]) {
            var isSecure = ['mqtts', 'wss'].indexOf(opts.protocol) !== -1
            opts.protocol = [
              'mqtt',
              'mqtts',
              'ws',
              'wss',
              'wx',
              'wxs'
            ].filter(function(key, index) {
              if (isSecure && index % 2 === 0) {
                // Skip insecure protocols when requesting a secure one.
                return false
              }
              return (typeof protocols[key] === 'function')
            })[0]
          }

          if (opts.clean === false && !opts.clientId) {
            throw new Error('Missing clientId for unclean clients')
          }

          if (opts.protocol) {
            opts.defaultProtocol = opts.protocol
          }

          function wrapper(client) {
            if (opts.servers) {
              if (!client._reconnectCount || client._reconnectCount === opts.servers.length) {
                client._reconnectCount = 0
              }

              opts.host = opts.servers[client._reconnectCount].host
              opts.port = opts.servers[client._reconnectCount].port
              opts.protocol = (!opts.servers[client._reconnectCount].protocol ? opts.defaultProtocol : opts.servers[client._reconnectCount].protocol)
              opts.hostname = opts.host

              client._reconnectCount++
            }

            return protocols[opts.protocol](client, opts)
          }

          return new MqttClient(wrapper, opts)
        }

        module.exports = connect
        module.exports.connect = connect
        module.exports.MqttClient = MqttClient
        module.exports.Store = Store

      }).call(this, require('_process'))
    }, {
      "../client": 1,
      "../store": 6,
      "./tcp": 2,
      "./tls": 3,
      "./ws": 4,
      "./wx": 5,
      "_process": 92,
      "url": 112,
      "xtend": 120
    }],
    9: [function(require, module, exports) {
      'use strict'

      exports.byteLength = byteLength
      exports.toByteArray = toByteArray
      exports.fromByteArray = fromByteArray

      var lookup = []
      var revLookup = []
      var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

      var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
      for (var i = 0, len = code.length; i < len; ++i) {
        lookup[i] = code[i]
        revLookup[code.charCodeAt(i)] = i
      }

      // Support decoding URL-safe base64 strings, as Node.js does.
      // See: https://en.wikipedia.org/wiki/Base64#URL_applications
      revLookup['-'.charCodeAt(0)] = 62
      revLookup['_'.charCodeAt(0)] = 63

      function getLens(b64) {
        var len = b64.length

        if (len % 4 > 0) {
          throw new Error('Invalid string. Length must be a multiple of 4')
        }

        // Trim off extra bytes after placeholder bytes are found
        // See: https://github.com/beatgammit/base64-js/issues/42
        var validLen = b64.indexOf('=')
        if (validLen === -1) validLen = len

        var placeHoldersLen = validLen === len ?
          0 :
          4 - (validLen % 4)

        return [validLen, placeHoldersLen]
      }

      // base64 is 4/3 + up to two characters of the original data
      function byteLength(b64) {
        var lens = getLens(b64)
        var validLen = lens[0]
        var placeHoldersLen = lens[1]
        return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
      }

      function _byteLength(b64, validLen, placeHoldersLen) {
        return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
      }

      function toByteArray(b64) {
        var tmp
        var lens = getLens(b64)
        var validLen = lens[0]
        var placeHoldersLen = lens[1]

        var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))

        var curByte = 0

        // if there are placeholders, only get up to the last complete 4 chars
        var len = placeHoldersLen > 0 ?
          validLen - 4 :
          validLen

        for (var i = 0; i < len; 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[curByte++] = (tmp >> 16) & 0xFF
          arr[curByte++] = (tmp >> 8) & 0xFF
          arr[curByte++] = tmp & 0xFF
        }

        if (placeHoldersLen === 2) {
          tmp =
            (revLookup[b64.charCodeAt(i)] << 2) |
            (revLookup[b64.charCodeAt(i + 1)] >> 4)
          arr[curByte++] = tmp & 0xFF
        }

        if (placeHoldersLen === 1) {
          tmp =
            (revLookup[b64.charCodeAt(i)] << 10) |
            (revLookup[b64.charCodeAt(i + 1)] << 4) |
            (revLookup[b64.charCodeAt(i + 2)] >> 2)
          arr[curByte++] = (tmp >> 8) & 0xFF
          arr[curByte++] = tmp & 0xFF
        }

        return arr
      }

      function tripletToBase64(num) {
        return lookup[num >> 18 & 0x3F] +
          lookup[num >> 12 & 0x3F] +
          lookup[num >> 6 & 0x3F] +
          lookup[num & 0x3F]
      }

      function encodeChunk(uint8, start, end) {
        var tmp
        var output = []
        for (var i = start; i < end; i += 3) {
          tmp =
            ((uint8[i] << 16) & 0xFF0000) +
            ((uint8[i + 1] << 8) & 0xFF00) +
            (uint8[i + 2] & 0xFF)
          output.push(tripletToBase64(tmp))
        }
        return output.join('')
      }

      function fromByteArray(uint8) {
        var tmp
        var len = uint8.length
        var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
        var parts = []
        var maxChunkLength = 16383 // must be multiple of 3

        // go through the array every three bytes, we'll deal with trailing stuff later
        for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
          parts.push(encodeChunk(
            uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
          ))
        }

        // pad the end with zeros, but make sure to not forget the extra bytes
        if (extraBytes === 1) {
          tmp = uint8[len - 1]
          parts.push(
            lookup[tmp >> 2] +
            lookup[(tmp << 4) & 0x3F] +
            '=='
          )
        } else if (extraBytes === 2) {
          tmp = (uint8[len - 2] << 8) + uint8[len - 1]
          parts.push(
            lookup[tmp >> 10] +
            lookup[(tmp >> 4) & 0x3F] +
            lookup[(tmp << 2) & 0x3F] +
            '='
          )
        }

        return parts.join('')
      }

    }, {}],
    10: [function(require, module, exports) {
      var DuplexStream = require('readable-stream/duplex'),
        util = require('util'),
        Buffer = require('safe-buffer').Buffer


      function BufferList(callback) {
        if (!(this instanceof BufferList))
          return new BufferList(callback)

        this._bufs = []
        this.length = 0

        if (typeof callback == 'function') {
          this._callback = callback

          var piper = function piper(err) {
            if (this._callback) {
              this._callback(err)
              this._callback = null
            }
          }.bind(this)

          this.on('pipe', function onPipe(src) {
            src.on('error', piper)
          })
          this.on('unpipe', function onUnpipe(src) {
            src.removeListener('error', piper)
          })
        } else {
          this.append(callback)
        }

        DuplexStream.call(this)
      }


      util.inherits(BufferList, DuplexStream)


      BufferList.prototype._offset = function _offset(offset) {
        var tot = 0,
          i = 0,
          _t
        if (offset === 0) return [0, 0]
        for (; i < this._bufs.length; i++) {
          _t = tot + this._bufs[i].length
          if (offset < _t || i == this._bufs.length - 1)
            return [i, offset - tot]
          tot = _t
        }
      }


      BufferList.prototype.append = function append(buf) {
        var i = 0

        if (Buffer.isBuffer(buf)) {
          this._appendBuffer(buf);
        } else if (Array.isArray(buf)) {
          for (; i < buf.length; i++)
            this.append(buf[i])
        } else if (buf instanceof BufferList) {
          // unwrap argument into individual BufferLists
          for (; i < buf._bufs.length; i++)
            this.append(buf._bufs[i])
        } else if (buf != null) {
          // coerce number arguments to strings, since Buffer(number) does
          // uninitialized memory allocation
          if (typeof buf == 'number')
            buf = buf.toString()

          this._appendBuffer(Buffer.from(buf));
        }

        return this
      }


      BufferList.prototype._appendBuffer = function appendBuffer(buf) {
        this._bufs.push(buf)
        this.length += buf.length
      }


      BufferList.prototype._write = function _write(buf, encoding, callback) {
        this._appendBuffer(buf)

        if (typeof callback == 'function')
          callback()
      }


      BufferList.prototype._read = function _read(size) {
        if (!this.length)
          return this.push(null)

        size = Math.min(size, this.length)
        this.push(this.slice(0, size))
        this.consume(size)
      }


      BufferList.prototype.end = function end(chunk) {
        DuplexStream.prototype.end.call(this, chunk)

        if (this._callback) {
          this._callback(null, this.slice())
          this._callback = null
        }
      }


      BufferList.prototype.get = function get(index) {
        return this.slice(index, index + 1)[0]
      }


      BufferList.prototype.slice = function slice(start, end) {
        if (typeof start == 'number' && start < 0)
          start += this.length
        if (typeof end == 'number' && end < 0)
          end += this.length
        return this.copy(null, 0, start, end)
      }


      BufferList.prototype.copy = function copy(dst, dstStart, srcStart, srcEnd) {
        if (typeof srcStart != 'number' || srcStart < 0)
          srcStart = 0
        if (typeof srcEnd != 'number' || srcEnd > this.length)
          srcEnd = this.length
        if (srcStart >= this.length)
          return dst || Buffer.alloc(0)
        if (srcEnd <= 0)
          return dst || Buffer.alloc(0)

        var copy = !!dst,
          off = this._offset(srcStart),
          len = srcEnd - srcStart,
          bytes = len,
          bufoff = (copy && dstStart) || 0,
          start = off[1],
          l, i

        // copy/slice everything
        if (srcStart === 0 && srcEnd == this.length) {
          if (!copy) { // slice, but full concat if multiple buffers
            return this._bufs.length === 1 ?
              this._bufs[0] :
              Buffer.concat(this._bufs, this.length)
          }

          // copy, need to copy individual buffers
          for (i = 0; i < this._bufs.length; i++) {
            this._bufs[i].copy(dst, bufoff)
            bufoff += this._bufs[i].length
          }

          return dst
        }

        // easy, cheap case where it's a subset of one of the buffers
        if (bytes <= this._bufs[off[0]].length - start) {
          return copy ?
            this._bufs[off[0]].copy(dst, dstStart, start, start + bytes) :
            this._bufs[off[0]].slice(start, start + bytes)
        }

        if (!copy) // a slice, we need something to copy in to
          dst = Buffer.allocUnsafe(len)

        for (i = off[0]; i < this._bufs.length; i++) {
          l = this._bufs[i].length - start

          if (bytes > l) {
            this._bufs[i].copy(dst, bufoff, start)
          } else {
            this._bufs[i].copy(dst, bufoff, start, start + bytes)
            break
          }

          bufoff += l
          bytes -= l

          if (start)
            start = 0
        }

        return dst
      }

      BufferList.prototype.shallowSlice = function shallowSlice(start, end) {
        start = start || 0
        end = end || this.length

        if (start < 0)
          start += this.length
        if (end < 0)
          end += this.length

        var startOffset = this._offset(start),
          endOffset = this._offset(end),
          buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)

        if (endOffset[1] == 0)
          buffers.pop()
        else
          buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1])

        if (startOffset[1] != 0)
          buffers[0] = buffers[0].slice(startOffset[1])

        return new BufferList(buffers)
      }

      BufferList.prototype.toString = function toString(encoding, start, end) {
        return this.slice(start, end).toString(encoding)
      }

      BufferList.prototype.consume = function consume(bytes) {
        while (this._bufs.length) {
          if (bytes >= this._bufs[0].length) {
            bytes -= this._bufs[0].length
            this.length -= this._bufs[0].length
            this._bufs.shift()
          } else {
            this._bufs[0] = this._bufs[0].slice(bytes)
            this.length -= bytes
            break
          }
        }
        return this
      }


      BufferList.prototype.duplicate = function duplicate() {
        var i = 0,
          copy = new BufferList()

        for (; i < this._bufs.length; i++)
          copy.append(this._bufs[i])

        return copy
      }


      BufferList.prototype.destroy = function destroy() {
        this._bufs.length = 0
        this.length = 0
        this.push(null)
      }


      ;
      (function() {
        var methods = {
          'readDoubleBE': 8,
          'readDoubleLE': 8,
          'readFloatBE': 4,
          'readFloatLE': 4,
          'readInt32BE': 4,
          'readInt32LE': 4,
          'readUInt32BE': 4,
          'readUInt32LE': 4,
          'readInt16BE': 2,
          'readInt16LE': 2,
          'readUInt16BE': 2,
          'readUInt16LE': 2,
          'readInt8': 1,
          'readUInt8': 1
        }

        for (var m in methods) {
          (function(m) {
            BufferList.prototype[m] = function(offset) {
              return this.slice(offset, offset + methods[m])[m](0)
            }
          }(m))
        }
      }())


      module.exports = BufferList

    }, {
      "readable-stream/duplex": 97,
      "safe-buffer": 108,
      "util": 116
    }],
    11: [function(require, module, exports) {

    }, {}],
    12: [function(require, module, exports) {
      /*!
       * The buffer module from node.js, for the browser.
       *
       * @author   Feross Aboukhadijeh <https://feross.org>
       * @license  MIT
       */
      /* eslint-disable no-proto */

      'use strict'

      var base64 = require('base64-js')
      var ieee754 = require('ieee754')

      exports.Buffer = Buffer
      exports.SlowBuffer = SlowBuffer
      exports.INSPECT_MAX_BYTES = 50

      var K_MAX_LENGTH = 0x7fffffff
      exports.kMaxLength = K_MAX_LENGTH

      /**
       * If `Buffer.TYPED_ARRAY_SUPPORT`:
       *   === true    Use Uint8Array implementation (fastest)
       *   === false   Print warning and recommend using `buffer` v4.x which has an Object
       *               implementation (most compatible, even IE6)
       *
       * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
       * Opera 11.6+, iOS 4.2+.
       *
       * We report that the browser does not support typed arrays if the are not subclassable
       * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
       * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
       * for __proto__ and has a buggy typed array implementation.
       */
      Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()

      if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
        typeof console.error === 'function') {
        console.error(
          'This browser lacks typed array (Uint8Array) support which is required by ' +
          '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
        )
      }

      function typedArraySupport() {
        // Can typed array instances can be augmented?
        try {
          var arr = new Uint8Array(1)
          arr.__proto__ = {
            __proto__: Uint8Array.prototype,
            foo: function() {
              return 42
            }
          }
          return arr.foo() === 42
        } catch (e) {
          return false
        }
      }

      Object.defineProperty(Buffer.prototype, 'parent', {
        enumerable: true,
        get: function() {
          if (!Buffer.isBuffer(this)) return undefined
          return this.buffer
        }
      })

      Object.defineProperty(Buffer.prototype, 'offset', {
        enumerable: true,
        get: function() {
          if (!Buffer.isBuffer(this)) return undefined
          return this.byteOffset
        }
      })

      function createBuffer(length) {
        if (length > K_MAX_LENGTH) {
          throw new RangeError('The value "' + length + '" is invalid for option "size"')
        }
        // Return an augmented `Uint8Array` instance
        var buf = new Uint8Array(length)
        buf.__proto__ = Buffer.prototype
        return buf
      }

      /**
       * The Buffer constructor returns instances of `Uint8Array` that have their
       * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
       * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
       * and the `Uint8Array` methods. Square bracket notation works as expected -- it
       * returns a single octet.
       *
       * The `Uint8Array` prototype remains unmodified.
       */

      function Buffer(arg, encodingOrOffset, length) {
        // Common case.
        if (typeof arg === 'number') {
          if (typeof encodingOrOffset === 'string') {
            throw new TypeError(
              'The "string" argument must be of type string. Received type number'
            )
          }
          return allocUnsafe(arg)
        }
        return from(arg, encodingOrOffset, length)
      }

      // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
      if (typeof Symbol !== 'undefined' && Symbol.species != null &&
        Buffer[Symbol.species] === Buffer) {
        Object.defineProperty(Buffer, Symbol.species, {
          value: null,
          configurable: true,
          enumerable: false,
          writable: false
        })
      }

      Buffer.poolSize = 8192 // not used by this implementation

      function from(value, encodingOrOffset, length) {
        if (typeof value === 'string') {
          return fromString(value, encodingOrOffset)
        }

        if (ArrayBuffer.isView(value)) {
          return fromArrayLike(value)
        }

        if (value == null) {
          throw TypeError(
            'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
            'or Array-like Object. Received type ' + (typeof value)
          )
        }

        if (isInstance(value, ArrayBuffer) ||
          (value && isInstance(value.buffer, ArrayBuffer))) {
          return fromArrayBuffer(value, encodingOrOffset, length)
        }

        if (typeof value === 'number') {
          throw new TypeError(
            'The "value" argument must not be of type number. Received type number'
          )
        }

        var valueOf = value.valueOf && value.valueOf()
        if (valueOf != null && valueOf !== value) {
          return Buffer.from(valueOf, encodingOrOffset, length)
        }

        var b = fromObject(value)
        if (b) return b

        if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
          typeof value[Symbol.toPrimitive] === 'function') {
          return Buffer.from(
            value[Symbol.toPrimitive]('string'), encodingOrOffset, length
          )
        }

        throw new TypeError(
          'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
          'or Array-like Object. Received type ' + (typeof value)
        )
      }

      /**
       * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
       * if value is a number.
       * Buffer.from(str[, encoding])
       * Buffer.from(array)
       * Buffer.from(buffer)
       * Buffer.from(arrayBuffer[, byteOffset[, length]])
       **/
      Buffer.from = function(value, encodingOrOffset, length) {
        return from(value, encodingOrOffset, length)
      }

      // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
      // https://github.com/feross/buffer/pull/148
      Buffer.prototype.__proto__ = Uint8Array.prototype
      Buffer.__proto__ = Uint8Array

      function assertSize(size) {
        if (typeof size !== 'number') {
          throw new TypeError('"size" argument must be of type number')
        } else if (size < 0) {
          throw new RangeError('The value "' + size + '" is invalid for option "size"')
        }
      }

      function alloc(size, fill, encoding) {
        assertSize(size)
        if (size <= 0) {
          return createBuffer(size)
        }
        if (fill !== undefined) {
          // Only pay attention to encoding if it's a string. This
          // prevents accidentally sending in a number that would
          // be interpretted as a start offset.
          return typeof encoding === 'string' ?
            createBuffer(size).fill(fill, encoding) :
            createBuffer(size).fill(fill)
        }
        return createBuffer(size)
      }

      /**
       * Creates a new filled Buffer instance.
       * alloc(size[, fill[, encoding]])
       **/
      Buffer.alloc = function(size, fill, encoding) {
        return alloc(size, fill, encoding)
      }

      function allocUnsafe(size) {
        assertSize(size)
        return createBuffer(size < 0 ? 0 : checked(size) | 0)
      }

      /**
       * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
       * */
      Buffer.allocUnsafe = function(size) {
        return allocUnsafe(size)
      }
      /**
       * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
       */
      Buffer.allocUnsafeSlow = function(size) {
        return allocUnsafe(size)
      }

      function fromString(string, encoding) {
        if (typeof encoding !== 'string' || encoding === '') {
          encoding = 'utf8'
        }

        if (!Buffer.isEncoding(encoding)) {
          throw new TypeError('Unknown encoding: ' + encoding)
        }

        var length = byteLength(string, encoding) | 0
        var buf = createBuffer(length)

        var actual = buf.write(string, encoding)

        if (actual !== length) {
          // Writing a hex string, for example, that contains invalid characters will
          // cause everything after the first invalid character to be ignored. (e.g.
          // 'abxxcd' will be treated as 'ab')
          buf = buf.slice(0, actual)
        }

        return buf
      }

      function fromArrayLike(array) {
        var length = array.length < 0 ? 0 : checked(array.length) | 0
        var buf = createBuffer(length)
        for (var i = 0; i < length; i += 1) {
          buf[i] = array[i] & 255
        }
        return buf
      }

      function fromArrayBuffer(array, byteOffset, length) {
        if (byteOffset < 0 || array.byteLength < byteOffset) {
          throw new RangeError('"offset" is outside of buffer bounds')
        }

        if (array.byteLength < byteOffset + (length || 0)) {
          throw new RangeError('"length" is outside of buffer bounds')
        }

        var buf
        if (byteOffset === undefined && length === undefined) {
          buf = new Uint8Array(array)
        } else if (length === undefined) {
          buf = new Uint8Array(array, byteOffset)
        } else {
          buf = new Uint8Array(array, byteOffset, length)
        }

        // Return an augmented `Uint8Array` instance
        buf.__proto__ = Buffer.prototype
        return buf
      }

      function fromObject(obj) {
        if (Buffer.isBuffer(obj)) {
          var len = checked(obj.length) | 0
          var buf = createBuffer(len)

          if (buf.length === 0) {
            return buf
          }

          obj.copy(buf, 0, 0, len)
          return buf
        }

        if (obj.length !== undefined) {
          if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
            return createBuffer(0)
          }
          return fromArrayLike(obj)
        }

        if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
          return fromArrayLike(obj.data)
        }
      }

      function checked(length) {
        // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
        // length is NaN (which is otherwise coerced to zero.)
        if (length >= K_MAX_LENGTH) {
          throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
            'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
        }
        return length | 0
      }

      function SlowBuffer(length) {
        if (+length != length) { // eslint-disable-line eqeqeq
          length = 0
        }
        return Buffer.alloc(+length)
      }

      Buffer.isBuffer = function isBuffer(b) {
        return b != null && b._isBuffer === true &&
          b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
      }

      Buffer.compare = function compare(a, b) {
        if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
        if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
        if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
          throw new TypeError(
            'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
          )
        }

        if (a === b) return 0

        var x = a.length
        var y = b.length

        for (var i = 0, len = Math.min(x, y); i < len; ++i) {
          if (a[i] !== b[i]) {
            x = a[i]
            y = b[i]
            break
          }
        }

        if (x < y) return -1
        if (y < x) return 1
        return 0
      }

      Buffer.isEncoding = function isEncoding(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 true
          default:
            return false
        }
      }

      Buffer.concat = function concat(list, length) {
        if (!Array.isArray(list)) {
          throw new TypeError('"list" argument must be an Array of Buffers')
        }

        if (list.length === 0) {
          return Buffer.alloc(0)
        }

        var i
        if (length === undefined) {
          length = 0
          for (i = 0; i < list.length; ++i) {
            length += list[i].length
          }
        }

        var buffer = Buffer.allocUnsafe(length)
        var pos = 0
        for (i = 0; i < list.length; ++i) {
          var buf = list[i]
          if (isInstance(buf, Uint8Array)) {
            buf = Buffer.from(buf)
          }
          if (!Buffer.isBuffer(buf)) {
            throw new TypeError('"list" argument must be an Array of Buffers')
          }
          buf.copy(buffer, pos)
          pos += buf.length
        }
        return buffer
      }

      function byteLength(string, encoding) {
        if (Buffer.isBuffer(string)) {
          return string.length
        }
        if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
          return string.byteLength
        }
        if (typeof string !== 'string') {
          throw new TypeError(
            'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
            'Received type ' + typeof string
          )
        }

        var len = string.length
        var mustMatch = (arguments.length > 2 && arguments[2] === true)
        if (!mustMatch && len === 0) return 0

        // Use a for loop to avoid recursion
        var loweredCase = false
        for (;;) {
          switch (encoding) {
            case 'ascii':
            case 'latin1':
            case 'binary':
              return len
            case 'utf8':
            case 'utf-8':
              return utf8ToBytes(string).length
            case 'ucs2':
            case 'ucs-2':
            case 'utf16le':
            case 'utf-16le':
              return len * 2
            case 'hex':
              return len >>> 1
            case 'base64':
              return base64ToBytes(string).length
            default:
              if (loweredCase) {
                return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
              }
              encoding = ('' + encoding).toLowerCase()
              loweredCase = true
          }
        }
      }
      Buffer.byteLength = byteLength

      function slowToString(encoding, start, end) {
        var loweredCase = false

        // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
        // property of a typed array.

        // This behaves neither like String nor Uint8Array in that we set start/end
        // to their upper/lower bounds if the value passed is out of range.
        // undefined is handled specially as per ECMA-262 6th Edition,
        // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
        if (start === undefined || start < 0) {
          start = 0
        }
        // Return early if start > this.length. Done here to prevent potential uint32
        // coercion fail below.
        if (start > this.length) {
          return ''
        }

        if (end === undefined || end > this.length) {
          end = this.length
        }

        if (end <= 0) {
          return ''
        }

        // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
        end >>>= 0
        start >>>= 0

        if (end <= start) {
          return ''
        }

        if (!encoding) encoding = 'utf8'

        while (true) {
          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 = true
          }
        }
      }

      // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
      // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
      // reliably in a browserify context because there could be multiple different
      // copies of the 'buffer' package in use. This method works even for Buffer
      // instances that were created from another copy of the `buffer` package.
      // See: https://github.com/feross/buffer/issues/154
      Buffer.prototype._isBuffer = true

      function swap(b, n, m) {
        var i = b[n]
        b[n] = b[m]
        b[m] = i
      }

      Buffer.prototype.swap16 = function swap16() {
        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 swap32() {
        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 swap64() {
        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 toString() {
        var length = this.length
        if (length === 0) return ''
        if (arguments.length === 0) return utf8Slice(this, 0, length)
        return slowToString.apply(this, arguments)
      }

      Buffer.prototype.toLocaleString = Buffer.prototype.toString

      Buffer.prototype.equals = function equals(b) {
        if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
        if (this === b) return true
        return Buffer.compare(this, b) === 0
      }

      Buffer.prototype.inspect = function inspect() {
        var str = ''
        var max = exports.INSPECT_MAX_BYTES
        str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
        if (this.length > max) str += ' ... '
        return '<Buffer ' + str + '>'
      }

      Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
        if (isInstance(target, Uint8Array)) {
          target = Buffer.from(target, target.offset, target.byteLength)
        }
        if (!Buffer.isBuffer(target)) {
          throw new TypeError(
            'The "target" argument must be one of type Buffer or Uint8Array. ' +
            'Received type ' + (typeof target)
          )
        }

        if (start === undefined) {
          start = 0
        }
        if (end === undefined) {
          end = target ? target.length : 0
        }
        if (thisStart === undefined) {
          thisStart = 0
        }
        if (thisEnd === undefined) {
          thisEnd = this.length
        }

        if (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
        }

        start >>>= 0
        end >>>= 0
        thisStart >>>= 0
        thisEnd >>>= 0

        if (this === target) return 0

        var x = thisEnd - thisStart
        var y = end - start
        var len = Math.min(x, y)

        var thisCopy = this.slice(thisStart, thisEnd)
        var targetCopy = target.slice(start, end)

        for (var i = 0; i < len; ++i) {
          if (thisCopy[i] !== targetCopy[i]) {
            x = thisCopy[i]
            y = targetCopy[i]
            break
          }
        }

        if (x < y) return -1
        if (y < x) return 1
        return 0
      }

      // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
      // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
      //
      // Arguments:
      // - buffer - a Buffer to search
      // - val - a string, Buffer, or number
      // - byteOffset - an index into `buffer`; will be clamped to an int32
      // - encoding - an optional encoding, relevant is val is a string
      // - dir - true for indexOf, false for lastIndexOf
      function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
        // Empty buffer means no match
        if (buffer.length === 0) return -1

        // Normalize byteOffset
        if (typeof byteOffset === 'string') {
          encoding = byteOffset
          byteOffset = 0
        } else if (byteOffset > 0x7fffffff) {
          byteOffset = 0x7fffffff
        } else if (byteOffset < -0x80000000) {
          byteOffset = -0x80000000
        }
        byteOffset = +byteOffset // Coerce to Number.
        if (numberIsNaN(byteOffset)) {
          // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
          byteOffset = dir ? 0 : (buffer.length - 1)
        }

        // Normalize byteOffset: negative offsets start from the end of the buffer
        if (byteOffset < 0) byteOffset = buffer.length + byteOffset
        if (byteOffset >= buffer.length) {
          if (dir) return -1
          else byteOffset = buffer.length - 1
        } else if (byteOffset < 0) {
          if (dir) byteOffset = 0
          else return -1
        }

        // Normalize val
        if (typeof val === 'string') {
          val = Buffer.from(val, encoding)
        }

        // Finally, search either indexOf (if dir is true) or lastIndexOf
        if (Buffer.isBuffer(val)) {
          // Special case: looking for empty string/buffer always fails
          if (val.length === 0) {
            return -1
          }
          return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
        } else if (typeof val === 'number') {
          val = val & 0xFF // Search for a byte value [0-255]
          if (typeof Uint8Array.prototype.indexOf === 'function') {
            if (dir) {
              return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
            } else {
              return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
            }
          }
          return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)
        }

        throw new TypeError('val must be string, number or Buffer')
      }

      function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
        var indexSize = 1
        var arrLength = arr.length
        var valLength = val.length

        if (encoding !== undefined) {
          encoding = String(encoding).toLowerCase()
          if (encoding === 'ucs2' || encoding === 'ucs-2' ||
            encoding === 'utf16le' || encoding === 'utf-16le') {
            if (arr.length < 2 || val.length < 2) {
              return -1
            }
            indexSize = 2
            arrLength /= 2
            valLength /= 2
            byteOffset /= 2
          }
        }

        function read(buf, i) {
          if (indexSize === 1) {
            return buf[i]
          } else {
            return buf.readUInt16BE(i * indexSize)
          }
        }

        var i
        if (dir) {
          var foundIndex = -1
          for (i = byteOffset; i < arrLength; i++) {
            if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
              if (foundIndex === -1) foundIndex = i
              if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
            } else {
              if (foundIndex !== -1) i -= i - foundIndex
              foundIndex = -1
            }
          }
        } else {
          if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
          for (i = byteOffset; i >= 0; i--) {
            var found = true
            for (var j = 0; j < valLength; j++) {
              if (read(arr, i + j) !== read(val, j)) {
                found = false
                break
              }
            }
            if (found) return i
          }
        }

        return -1
      }

      Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
        return this.indexOf(val, byteOffset, encoding) !== -1
      }

      Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
        return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
      }

      Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
        return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
      }

      function hexWrite(buf, string, offset, length) {
        offset = Number(offset) || 0
        var remaining = buf.length - offset
        if (!length) {
          length = remaining
        } else {
          length = Number(length)
          if (length > remaining) {
            length = remaining
          }
        }

        var strLen = string.length

        if (length > strLen / 2) {
          length = strLen / 2
        }
        for (var i = 0; i < length; ++i) {
          var parsed = parseInt(string.substr(i * 2, 2), 16)
          if (numberIsNaN(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(asciiToBytes(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(utf16leToBytes(string, buf.length - offset), buf, offset, length)
      }

      Buffer.prototype.write = function write(string, offset, length, encoding) {
        // Buffer#write(string)
        if (offset === undefined) {
          encoding = 'utf8'
          length = this.length
          offset = 0
          // Buffer#write(string, encoding)
        } else if (length === undefined && typeof offset === 'string') {
          encoding = offset
          length = this.length
          offset = 0
          // Buffer#write(string, offset[, length][, encoding])
        } else if (isFinite(offset)) {
          offset = offset >>> 0
          if (isFinite(length)) {
            length = length >>> 0
            if (encoding === undefined) encoding = 'utf8'
          } else {
            encoding = length
            length = undefined
          }
        } else {
          throw new Error(
            'Buffer.write(string, encoding, offset[, length]) is no longer supported'
          )
        }

        var remaining = this.length - offset
        if (length === undefined || length > remaining) length = remaining

        if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
          throw new RangeError('Attempt to write outside buffer bounds')
        }

        if (!encoding) encoding = 'utf8'

        var loweredCase = false
        for (;;) {
          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':
              // Warning: maxLength not taken into account in base64Write
              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 = true
          }
        }
      }

      Buffer.prototype.toJSON = function toJSON() {
        return {
          type: 'Buffer',
          data: Array.prototype.slice.call(this._arr || this, 0)
        }
      }

      function base64Slice(buf, start, end) {
        if (start === 0 && end === buf.length) {
          return base64.fromByteArray(buf)
        } else {
          return base64.fromByteArray(buf.slice(start, end))
        }
      }

      function utf8Slice(buf, start, end) {
        end = Math.min(buf.length, end)
        var res = []

        var i = start
        while (i < end) {
          var firstByte = buf[i]
          var codePoint = null
          var bytesPerSequence = (firstByte > 0xEF) ? 4 :
            (firstByte > 0xDF) ? 3 :
            (firstByte > 0xBF) ? 2 :
            1

          if (i + bytesPerSequence <= end) {
            var secondByte, thirdByte, fourthByte, tempCodePoint

            switch (bytesPerSequence) {
              case 1:
                if (firstByte < 0x80) {
                  codePoint = firstByte
                }
                break
              case 2:
                secondByte = buf[i + 1]
                if ((secondByte & 0xC0) === 0x80) {
                  tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
                  if (tempCodePoint > 0x7F) {
                    codePoint = tempCodePoint
                  }
                }
                break
              case 3:
                secondByte = buf[i + 1]
                thirdByte = buf[i + 2]
                if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
                  tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
                  if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
                    codePoint = tempCodePoint
                  }
                }
                break
              case 4:
                secondByte = buf[i + 1]
                thirdByte = buf[i + 2]
                fourthByte = buf[i + 3]
                if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
                  tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
                  if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                    codePoint = tempCodePoint
                  }
                }
            }
          }

          if (codePoint === null) {
            // we did not generate a valid codePoint so insert a
            // replacement char (U+FFFD) and advance only 1 byte
            codePoint = 0xFFFD
            bytesPerSequence = 1
          } else if (codePoint > 0xFFFF) {
            // encode to utf16 (surrogate pair dance)
            codePoint -= 0x10000
            res.push(codePoint >>> 10 & 0x3FF | 0xD800)
            codePoint = 0xDC00 | codePoint & 0x3FF
          }

          res.push(codePoint)
          i += bytesPerSequence
        }

        return decodeCodePointsArray(res)
      }

      // Based on http://stackoverflow.com/a/22747272/680742, the browser with
      // the lowest limit is Chrome, with 0x10000 args.
      // We go 1 magnitude less, for safety
      var MAX_ARGUMENTS_LENGTH = 0x1000

      function decodeCodePointsArray(codePoints) {
        var len = codePoints.length
        if (len <= MAX_ARGUMENTS_LENGTH) {
          return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
        }

        // Decode in chunks to avoid "call stack size exceeded".
        var res = ''
        var i = 0
        while (i < len) {
          res += String.fromCharCode.apply(
            String,
            codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
          )
        }
        return res
      }

      function asciiSlice(buf, start, end) {
        var ret = ''
        end = Math.min(buf.length, end)

        for (var i = start; i < end; ++i) {
          ret += String.fromCharCode(buf[i] & 0x7F)
        }
        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

        if (!start || start < 0) start = 0
        if (!end || end < 0 || end > len) end = len

        var out = ''
        for (var i = start; i < end; ++i) {
          out += toHex(buf[i])
        }
        return out
      }

      function utf16leSlice(buf, start, end) {
        var bytes = buf.slice(start, end)
        var res = ''
        for (var i = 0; i < bytes.length; i += 2) {
          res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
        }
        return res
      }

      Buffer.prototype.slice = function slice(start, end) {
        var len = this.length
        start = ~~start
        end = end === undefined ? len : ~~end

        if (start < 0) {
          start += len
          if (start < 0) start = 0
        } else if (start > len) {
          start = len
        }

        if (end < 0) {
          end += len
          if (end < 0) end = 0
        } else if (end > len) {
          end = len
        }

        if (end < start) end = start

        var newBuf = this.subarray(start, end)
        // Return an augmented `Uint8Array` instance
        newBuf.__proto__ = Buffer.prototype
        return newBuf
      }

      /*
       * Need to make sure that buffer isn't trying to write out of bounds.
       */
      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')
      }

      Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
        offset = offset >>> 0
        byteLength = byteLength >>> 0
        if (!noAssert) checkOffset(offset, byteLength, this.length)

        var val = this[offset]
        var mul = 1
        var i = 0
        while (++i < byteLength && (mul *= 0x100)) {
          val += this[offset + i] * mul
        }

        return val
      }

      Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
        offset = offset >>> 0
        byteLength = byteLength >>> 0
        if (!noAssert) {
          checkOffset(offset, byteLength, this.length)
        }

        var val = this[offset + --byteLength]
        var mul = 1
        while (byteLength > 0 && (mul *= 0x100)) {
          val += this[offset + --byteLength] * mul
        }

        return val
      }

      Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 1, this.length)
        return this[offset]
      }

      Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 2, this.length)
        return this[offset] | (this[offset + 1] << 8)
      }

      Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 2, this.length)
        return (this[offset] << 8) | this[offset + 1]
      }

      Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 4, this.length)

        return ((this[offset]) |
            (this[offset + 1] << 8) |
            (this[offset + 2] << 16)) +
          (this[offset + 3] * 0x1000000)
      }

      Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 4, this.length)

        return (this[offset] * 0x1000000) +
          ((this[offset + 1] << 16) |
            (this[offset + 2] << 8) |
            this[offset + 3])
      }

      Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
        offset = offset >>> 0
        byteLength = byteLength >>> 0
        if (!noAssert) checkOffset(offset, byteLength, this.length)

        var val = this[offset]
        var mul = 1
        var i = 0
        while (++i < byteLength && (mul *= 0x100)) {
          val += this[offset + i] * mul
        }
        mul *= 0x80

        if (val >= mul) val -= Math.pow(2, 8 * byteLength)

        return val
      }

      Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
        offset = offset >>> 0
        byteLength = byteLength >>> 0
        if (!noAssert) checkOffset(offset, byteLength, this.length)

        var i = byteLength
        var mul = 1
        var val = this[offset + --i]
        while (i > 0 && (mul *= 0x100)) {
          val += this[offset + --i] * mul
        }
        mul *= 0x80

        if (val >= mul) val -= Math.pow(2, 8 * byteLength)

        return val
      }

      Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 1, this.length)
        if (!(this[offset] & 0x80)) return (this[offset])
        return ((0xff - this[offset] + 1) * -1)
      }

      Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 2, this.length)
        var val = this[offset] | (this[offset + 1] << 8)
        return (val & 0x8000) ? val | 0xFFFF0000 : val
      }

      Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 2, this.length)
        var val = this[offset + 1] | (this[offset] << 8)
        return (val & 0x8000) ? val | 0xFFFF0000 : val
      }

      Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 4, this.length)

        return (this[offset]) |
          (this[offset + 1] << 8) |
          (this[offset + 2] << 16) |
          (this[offset + 3] << 24)
      }

      Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 4, this.length)

        return (this[offset] << 24) |
          (this[offset + 1] << 16) |
          (this[offset + 2] << 8) |
          (this[offset + 3])
      }

      Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 4, this.length)
        return ieee754.read(this, offset, true, 23, 4)
      }

      Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 4, this.length)
        return ieee754.read(this, offset, false, 23, 4)
      }

      Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 8, this.length)
        return ieee754.read(this, offset, true, 52, 8)
      }

      Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
        offset = offset >>> 0
        if (!noAssert) checkOffset(offset, 8, this.length)
        return ieee754.read(this, offset, false, 52, 8)
      }

      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')
      }

      Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
        value = +value
        offset = offset >>> 0
        byteLength = byteLength >>> 0
        if (!noAssert) {
          var maxBytes = Math.pow(2, 8 * byteLength) - 1
          checkInt(this, value, offset, byteLength, maxBytes, 0)
        }

        var mul = 1
        var i = 0
        this[offset] = value & 0xFF
        while (++i < byteLength && (mul *= 0x100)) {
          this[offset + i] = (value / mul) & 0xFF
        }

        return offset + byteLength
      }

      Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
        value = +value
        offset = offset >>> 0
        byteLength = byteLength >>> 0
        if (!noAssert) {
          var maxBytes = Math.pow(2, 8 * byteLength) - 1
          checkInt(this, value, offset, byteLength, maxBytes, 0)
        }

        var i = byteLength - 1
        var mul = 1
        this[offset + i] = value & 0xFF
        while (--i >= 0 && (mul *= 0x100)) {
          this[offset + i] = (value / mul) & 0xFF
        }

        return offset + byteLength
      }

      Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
        this[offset] = (value & 0xff)
        return offset + 1
      }

      Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
        this[offset] = (value & 0xff)
        this[offset + 1] = (value >>> 8)
        return offset + 2
      }

      Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
        this[offset] = (value >>> 8)
        this[offset + 1] = (value & 0xff)
        return offset + 2
      }

      Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
        this[offset + 3] = (value >>> 24)
        this[offset + 2] = (value >>> 16)
        this[offset + 1] = (value >>> 8)
        this[offset] = (value & 0xff)
        return offset + 4
      }

      Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
        this[offset] = (value >>> 24)
        this[offset + 1] = (value >>> 16)
        this[offset + 2] = (value >>> 8)
        this[offset + 3] = (value & 0xff)
        return offset + 4
      }

      Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) {
          var limit = Math.pow(2, (8 * byteLength) - 1)

          checkInt(this, value, offset, byteLength, limit - 1, -limit)
        }

        var i = 0
        var mul = 1
        var sub = 0
        this[offset] = value & 0xFF
        while (++i < byteLength && (mul *= 0x100)) {
          if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
            sub = 1
          }
          this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
        }

        return offset + byteLength
      }

      Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) {
          var limit = Math.pow(2, (8 * byteLength) - 1)

          checkInt(this, value, offset, byteLength, limit - 1, -limit)
        }

        var i = byteLength - 1
        var mul = 1
        var sub = 0
        this[offset + i] = value & 0xFF
        while (--i >= 0 && (mul *= 0x100)) {
          if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
            sub = 1
          }
          this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
        }

        return offset + byteLength
      }

      Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
        if (value < 0) value = 0xff + value + 1
        this[offset] = (value & 0xff)
        return offset + 1
      }

      Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
        this[offset] = (value & 0xff)
        this[offset + 1] = (value >>> 8)
        return offset + 2
      }

      Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
        this[offset] = (value >>> 8)
        this[offset + 1] = (value & 0xff)
        return offset + 2
      }

      Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
        this[offset] = (value & 0xff)
        this[offset + 1] = (value >>> 8)
        this[offset + 2] = (value >>> 16)
        this[offset + 3] = (value >>> 24)
        return offset + 4
      }

      Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
        if (value < 0) value = 0xffffffff + value + 1
        this[offset] = (value >>> 24)
        this[offset + 1] = (value >>> 16)
        this[offset + 2] = (value >>> 8)
        this[offset + 3] = (value & 0xff)
        return offset + 4
      }

      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) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) {
          checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
        }
        ieee754.write(buf, value, offset, littleEndian, 23, 4)
        return offset + 4
      }

      Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
        return writeFloat(this, value, offset, true, noAssert)
      }

      Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
        return writeFloat(this, value, offset, false, noAssert)
      }

      function writeDouble(buf, value, offset, littleEndian, noAssert) {
        value = +value
        offset = offset >>> 0
        if (!noAssert) {
          checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
        }
        ieee754.write(buf, value, offset, littleEndian, 52, 8)
        return offset + 8
      }

      Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
        return writeDouble(this, value, offset, true, noAssert)
      }

      Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
        return writeDouble(this, value, offset, false, noAssert)
      }

      // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
      Buffer.prototype.copy = function copy(target, targetStart, start, end) {
        if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
        if (!start) start = 0
        if (!end && end !== 0) end = this.length
        if (targetStart >= target.length) targetStart = target.length
        if (!targetStart) targetStart = 0
        if (end > 0 && end < start) end = start

        // Copy 0 bytes; we're done
        if (end === start) return 0
        if (target.length === 0 || this.length === 0) return 0

        // Fatal error conditions
        if (targetStart < 0) {
          throw new RangeError('targetStart out of bounds')
        }
        if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
        if (end < 0) throw new RangeError('sourceEnd out of bounds')

        // Are we oob?
        if (end > this.length) end = this.length
        if (target.length - targetStart < end - start) {
          end = target.length - targetStart + start
        }

        var len = end - start

        if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
          // Use built-in when available, missing from IE11
          this.copyWithin(targetStart, start, end)
        } else if (this === target && start < targetStart && targetStart < end) {
          // descending copy from end
          for (var i = len - 1; i >= 0; --i) {
            target[i + targetStart] = this[i + start]
          }
        } else {
          Uint8Array.prototype.set.call(
            target,
            this.subarray(start, end),
            targetStart
          )
        }

        return len
      }

      // Usage:
      //    buffer.fill(number[, offset[, end]])
      //    buffer.fill(buffer[, offset[, end]])
      //    buffer.fill(string[, offset[, end]][, encoding])
      Buffer.prototype.fill = function fill(val, start, end, encoding) {
        // Handle string cases:
        if (typeof val === 'string') {
          if (typeof start === 'string') {
            encoding = start
            start = 0
            end = this.length
          } else if (typeof end === 'string') {
            encoding = end
            end = this.length
          }
          if (encoding !== undefined && typeof encoding !== 'string') {
            throw new TypeError('encoding must be a string')
          }
          if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
            throw new TypeError('Unknown encoding: ' + encoding)
          }
          if (val.length === 1) {
            var code = val.charCodeAt(0)
            if ((encoding === 'utf8' && code < 128) ||
              encoding === 'latin1') {
              // Fast path: If `val` fits into a single byte, use that numeric value.
              val = code
            }
          }
        } else if (typeof val === 'number') {
          val = val & 255
        }

        // Invalid ranges are not set to a default, so can range check early.
        if (start < 0 || this.length < start || this.length < end) {
          throw new RangeError('Out of range index')
        }

        if (end <= start) {
          return this
        }

        start = start >>> 0
        end = end === undefined ? this.length : end >>> 0

        if (!val) val = 0

        var i
        if (typeof val === 'number') {
          for (i = start; i < end; ++i) {
            this[i] = val
          }
        } else {
          var bytes = Buffer.isBuffer(val) ?
            val :
            Buffer.from(val, encoding)
          var len = bytes.length
          if (len === 0) {
            throw new TypeError('The value "' + val +
              '" is invalid for argument "value"')
          }
          for (i = 0; i < end - start; ++i) {
            this[i + start] = bytes[i % len]
          }
        }

        return this
      }

      // HELPER FUNCTIONS
      // ================

      var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g

      function base64clean(str) {
        // Node takes equal signs as end of the Base64 encoding
        str = str.split('=')[0]
        // Node strips out invalid characters like \n and \t from the string, base64-js does not
        str = str.trim().replace(INVALID_BASE64_RE, '')
        // Node converts strings with length < 2 to ''
        if (str.length < 2) return ''
        // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
        while (str.length % 4 !== 0) {
          str = str + '='
        }
        return str
      }

      function toHex(n) {
        if (n < 16) return '0' + n.toString(16)
        return n.toString(16)
      }

      function utf8ToBytes(string, units) {
        units = units || Infinity
        var codePoint
        var length = string.length
        var leadSurrogate = null
        var bytes = []

        for (var i = 0; i < length; ++i) {
          codePoint = string.charCodeAt(i)

          // is surrogate component
          if (codePoint > 0xD7FF && codePoint < 0xE000) {
            // last char was a lead
            if (!leadSurrogate) {
              // no lead yet
              if (codePoint > 0xDBFF) {
                // unexpected trail
                if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                continue
              } else if (i + 1 === length) {
                // unpaired lead
                if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
                continue
              }

              // valid lead
              leadSurrogate = codePoint

              continue
            }

            // 2 leads in a row
            if (codePoint < 0xDC00) {
              if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
              leadSurrogate = codePoint
              continue
            }

            // valid surrogate pair
            codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
          } else if (leadSurrogate) {
            // valid bmp char, but last char was a lead
            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          }

          leadSurrogate = null

          // encode utf8
          if (codePoint < 0x80) {
            if ((units -= 1) < 0) break
            bytes.push(codePoint)
          } else if (codePoint < 0x800) {
            if ((units -= 2) < 0) break
            bytes.push(
              codePoint >> 0x6 | 0xC0,
              codePoint & 0x3F | 0x80
            )
          } else if (codePoint < 0x10000) {
            if ((units -= 3) < 0) break
            bytes.push(
              codePoint >> 0xC | 0xE0,
              codePoint >> 0x6 & 0x3F | 0x80,
              codePoint & 0x3F | 0x80
            )
          } else if (codePoint < 0x110000) {
            if ((units -= 4) < 0) break
            bytes.push(
              codePoint >> 0x12 | 0xF0,
              codePoint >> 0xC & 0x3F | 0x80,
              codePoint >> 0x6 & 0x3F | 0x80,
              codePoint & 0x3F | 0x80
            )
          } else {
            throw new Error('Invalid code point')
          }
        }

        return bytes
      }

      function asciiToBytes(str) {
        var byteArray = []
        for (var i = 0; i < str.length; ++i) {
          // Node's code seems to be doing this and not & 0x7F..
          byteArray.push(str.charCodeAt(i) & 0xFF)
        }
        return byteArray
      }

      function utf16leToBytes(str, units) {
        var c, hi, lo
        var byteArray = []
        for (var i = 0; i < str.length; ++i) {
          if ((units -= 2) < 0) break

          c = str.charCodeAt(i)
          hi = c >> 8
          lo = c % 256
          byteArray.push(lo)
          byteArray.push(hi)
        }

        return byteArray
      }

      function base64ToBytes(str) {
        return base64.toByteArray(base64clean(str))
      }

      function blitBuffer(src, dst, offset, length) {
        for (var i = 0; i < length; ++i) {
          if ((i + offset >= dst.length) || (i >= src.length)) break
          dst[i + offset] = src[i]
        }
        return i
      }

      // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
      // the `instanceof` check but they should be treated as of that type.
      // See: https://github.com/feross/buffer/issues/166
      function isInstance(obj, type) {
        return obj instanceof type ||
          (obj != null && obj.constructor != null && obj.constructor.name != null &&
            obj.constructor.name === type.name)
      }

      function numberIsNaN(obj) {
        // For IE11 support
        return obj !== obj // eslint-disable-line no-self-compare
      }

    }, {
      "base64-js": 9,
      "ieee754": 79
    }],
    13: [function(require, module, exports) {
      (function(Buffer) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        // NOTE: These type checking functions intentionally don't use `instanceof`
        // because it is fragile and can be easily faked with `Object.create()`.

        function isArray(arg) {
          if (Array.isArray) {
            return Array.isArray(arg);
          }
          return objectToString(arg) === '[object Array]';
        }
        exports.isArray = isArray;

        function isBoolean(arg) {
          return typeof arg === 'boolean';
        }
        exports.isBoolean = isBoolean;

        function isNull(arg) {
          return arg === null;
        }
        exports.isNull = isNull;

        function isNullOrUndefined(arg) {
          return arg == null;
        }
        exports.isNullOrUndefined = isNullOrUndefined;

        function isNumber(arg) {
          return typeof arg === 'number';
        }
        exports.isNumber = isNumber;

        function isString(arg) {
          return typeof arg === 'string';
        }
        exports.isString = isString;

        function isSymbol(arg) {
          return typeof arg === 'symbol';
        }
        exports.isSymbol = isSymbol;

        function isUndefined(arg) {
          return arg === void 0;
        }
        exports.isUndefined = isUndefined;

        function isRegExp(re) {
          return objectToString(re) === '[object RegExp]';
        }
        exports.isRegExp = isRegExp;

        function isObject(arg) {
          return typeof arg === 'object' && arg !== null;
        }
        exports.isObject = isObject;

        function isDate(d) {
          return objectToString(d) === '[object Date]';
        }
        exports.isDate = isDate;

        function isError(e) {
          return (objectToString(e) === '[object Error]' || e instanceof Error);
        }
        exports.isError = isError;

        function isFunction(arg) {
          return typeof arg === 'function';
        }
        exports.isFunction = isFunction;

        function isPrimitive(arg) {
          return arg === null ||
            typeof arg === 'boolean' ||
            typeof arg === 'number' ||
            typeof arg === 'string' ||
            typeof arg === 'symbol' || // ES6 symbol
            typeof arg === 'undefined';
        }
        exports.isPrimitive = isPrimitive;

        exports.isBuffer = Buffer.isBuffer;

        function objectToString(o) {
          return Object.prototype.toString.call(o);
        }

      }).call(this, {
        "isBuffer": require("../../is-buffer/index.js")
      })
    }, {
      "../../is-buffer/index.js": 81
    }],
    14: [function(require, module, exports) {
      'use strict';

      var copy = require('es5-ext/object/copy'),
        normalizeOptions = require('es5-ext/object/normalize-options'),
        ensureCallable = require('es5-ext/object/valid-callable'),
        map = require('es5-ext/object/map'),
        callable = require('es5-ext/object/valid-callable'),
        validValue = require('es5-ext/object/valid-value')

        ,
        bind = Function.prototype.bind,
        defineProperty = Object.defineProperty,
        hasOwnProperty = Object.prototype.hasOwnProperty,
        define;

      define = function(name, desc, options) {
        var value = validValue(desc) && callable(desc.value),
          dgs;
        dgs = copy(desc);
        delete dgs.writable;
        delete dgs.value;
        dgs.get = function() {
          if (!options.overwriteDefinition && hasOwnProperty.call(this, name)) return value;
          desc.value = bind.call(value, options.resolveContext ? options.resolveContext(this) : this);
          defineProperty(this, name, desc);
          return this[name];
        };
        return dgs;
      };

      module.exports = function(props /*, options*/ ) {
        var options = normalizeOptions(arguments[1]);
        if (options.resolveContext != null) ensureCallable(options.resolveContext);
        return map(props, function(desc, name) {
          return define(name, desc, options);
        });
      };

    }, {
      "es5-ext/object/copy": 38,
      "es5-ext/object/map": 47,
      "es5-ext/object/normalize-options": 48,
      "es5-ext/object/valid-callable": 53,
      "es5-ext/object/valid-value": 54
    }],
    15: [function(require, module, exports) {
      'use strict';

      var assign = require('es5-ext/object/assign'),
        normalizeOpts = require('es5-ext/object/normalize-options'),
        isCallable = require('es5-ext/object/is-callable'),
        contains = require('es5-ext/string/#/contains')

        ,
        d;

      d = module.exports = function(dscr, value /*, options*/ ) {
        var c, e, w, options, desc;
        if ((arguments.length < 2) || (typeof dscr !== 'string')) {
          options = value;
          value = dscr;
          dscr = null;
        } else {
          options = arguments[2];
        }
        if (dscr == null) {
          c = w = true;
          e = false;
        } else {
          c = contains.call(dscr, 'c');
          e = contains.call(dscr, 'e');
          w = contains.call(dscr, 'w');
        }

        desc = {
          value: value,
          configurable: c,
          enumerable: e,
          writable: w
        };
        return !options ? desc : assign(normalizeOpts(options), desc);
      };

      d.gs = function(dscr, get, set /*, options*/ ) {
        var c, e, options, desc;
        if (typeof dscr !== 'string') {
          options = set;
          set = get;
          get = dscr;
          dscr = null;
        } else {
          options = arguments[3];
        }
        if (get == null) {
          get = undefined;
        } else if (!isCallable(get)) {
          options = get;
          get = set = undefined;
        } else if (set == null) {
          set = undefined;
        } else if (!isCallable(set)) {
          options = set;
          set = undefined;
        }
        if (dscr == null) {
          c = true;
          e = false;
        } else {
          c = contains.call(dscr, 'c');
          e = contains.call(dscr, 'e');
        }

        desc = {
          get: get,
          set: set,
          configurable: c,
          enumerable: e
        };
        return !options ? desc : assign(normalizeOpts(options), desc);
      };

    }, {
      "es5-ext/object/assign": 35,
      "es5-ext/object/is-callable": 41,
      "es5-ext/object/normalize-options": 48,
      "es5-ext/string/#/contains": 55
    }],
    16: [function(require, module, exports) {
      (function(process, Buffer) {
        var stream = require('readable-stream')
        var eos = require('end-of-stream')
        var inherits = require('inherits')
        var shift = require('stream-shift')

        var SIGNAL_FLUSH = (Buffer.from && Buffer.from !== Uint8Array.from) ?
          Buffer.from([0]) :
          new Buffer([0])

        var onuncork = function(self, fn) {
          if (self._corked) self.once('uncork', fn)
          else fn()
        }

        var autoDestroy = function(self, err) {
          if (self._autoDestroy) self.destroy(err)
        }

        var destroyer = function(self, end) {
          return function(err) {
            if (err) autoDestroy(self, err.message === 'premature close' ? null : err)
            else if (end && !self._ended) self.end()
          }
        }

        var end = function(ws, fn) {
          if (!ws) return fn()
          if (ws._writableState && ws._writableState.finished) return fn()
          if (ws._writableState) return ws.end(fn)
          ws.end()
          fn()
        }

        var toStreams2 = function(rs) {
          return new(stream.Readable)({
            objectMode: true,
            highWaterMark: 16
          }).wrap(rs)
        }

        var Duplexify = function(writable, readable, opts) {
          if (!(this instanceof Duplexify)) return new Duplexify(writable, readable, opts)
          stream.Duplex.call(this, opts)

          this._writable = null
          this._readable = null
          this._readable2 = null

          this._autoDestroy = !opts || opts.autoDestroy !== false
          this._forwardDestroy = !opts || opts.destroy !== false
          this._forwardEnd = !opts || opts.end !== false
          this._corked = 1 // start corked
          this._ondrain = null
          this._drained = false
          this._forwarding = false
          this._unwrite = null
          this._unread = null
          this._ended = false

          this.destroyed = false

          if (writable) this.setWritable(writable)
          if (readable) this.setReadable(readable)
        }

        inherits(Duplexify, stream.Duplex)

        Duplexify.obj = function(writable, readable, opts) {
          if (!opts) opts = {}
          opts.objectMode = true
          opts.highWaterMark = 16
          return new Duplexify(writable, readable, opts)
        }

        Duplexify.prototype.cork = function() {
          if (++this._corked === 1) this.emit('cork')
        }

        Duplexify.prototype.uncork = function() {
          if (this._corked && --this._corked === 0) this.emit('uncork')
        }

        Duplexify.prototype.setWritable = function(writable) {
          if (this._unwrite) this._unwrite()

          if (this.destroyed) {
            if (writable && writable.destroy) writable.destroy()
            return
          }

          if (writable === null || writable === false) {
            this.end()
            return
          }

          var self = this
          var unend = eos(writable, {
            writable: true,
            readable: false
          }, destroyer(this, this._forwardEnd))

          var ondrain = function() {
            var ondrain = self._ondrain
            self._ondrain = null
            if (ondrain) ondrain()
          }

          var clear = function() {
            self._writable.removeListener('drain', ondrain)
            unend()
          }

          if (this._unwrite) process.nextTick(ondrain) // force a drain on stream reset to avoid livelocks

          this._writable = writable
          this._writable.on('drain', ondrain)
          this._unwrite = clear

          this.uncork() // always uncork setWritable
        }

        Duplexify.prototype.setReadable = function(readable) {
          if (this._unread) this._unread()

          if (this.destroyed) {
            if (readable && readable.destroy) readable.destroy()
            return
          }

          if (readable === null || readable === false) {
            this.push(null)
            this.resume()
            return
          }

          var self = this
          var unend = eos(readable, {
            writable: false,
            readable: true
          }, destroyer(this))

          var onreadable = function() {
            self._forward()
          }

          var onend = function() {
            self.push(null)
          }

          var clear = function() {
            self._readable2.removeListener('readable', onreadable)
            self._readable2.removeListener('end', onend)
            unend()
          }

          this._drained = true
          this._readable = readable
          this._readable2 = readable._readableState ? readable : toStreams2(readable)
          this._readable2.on('readable', onreadable)
          this._readable2.on('end', onend)
          this._unread = clear

          this._forward()
        }

        Duplexify.prototype._read = function() {
          this._drained = true
          this._forward()
        }

        Duplexify.prototype._forward = function() {
          if (this._forwarding || !this._readable2 || !this._drained) return
          this._forwarding = true

          var data

          while (this._drained && (data = shift(this._readable2)) !== null) {
            if (this.destroyed) continue
            this._drained = this.push(data)
          }

          this._forwarding = false
        }

        Duplexify.prototype.destroy = function(err) {
          if (this.destroyed) return
          this.destroyed = true

          var self = this
          process.nextTick(function() {
            self._destroy(err)
          })
        }

        Duplexify.prototype._destroy = function(err) {
          if (err) {
            var ondrain = this._ondrain
            this._ondrain = null
            if (ondrain) ondrain(err)
            else this.emit('error', err)
          }

          if (this._forwardDestroy) {
            if (this._readable && this._readable.destroy) this._readable.destroy()
            if (this._writable && this._writable.destroy) this._writable.destroy()
          }

          this.emit('close')
        }

        Duplexify.prototype._write = function(data, enc, cb) {
          if (this.destroyed) return cb()
          if (this._corked) return onuncork(this, this._write.bind(this, data, enc, cb))
          if (data === SIGNAL_FLUSH) return this._finish(cb)
          if (!this._writable) return cb()

          if (this._writable.write(data) === false) this._ondrain = cb
          else cb()
        }


        Duplexify.prototype._finish = function(cb) {
          var self = this
          this.emit('preend')
          onuncork(this, function() {
            end(self._forwardEnd && self._writable, function() {
              // haxx to not emit prefinish twice
              if (self._writableState.prefinished === false) self._writableState.prefinished = true
              self.emit('prefinish')
              onuncork(self, cb)
            })
          })
        }

        Duplexify.prototype.end = function(data, enc, cb) {
          if (typeof data === 'function') return this.end(null, null, data)
          if (typeof enc === 'function') return this.end(data, null, enc)
          this._ended = true
          if (data) this.write(data)
          if (!this._writableState.ending) this.write(SIGNAL_FLUSH)
          return stream.Writable.prototype.end.call(this, cb)
        }

        module.exports = Duplexify

      }).call(this, require('_process'), require("buffer").Buffer)
    }, {
      "_process": 92,
      "buffer": 12,
      "end-of-stream": 17,
      "inherits": 80,
      "readable-stream": 106,
      "stream-shift": 109
    }],
    17: [function(require, module, exports) {
      var once = require('once');

      var noop = function() {};

      var isRequest = function(stream) {
        return stream.setHeader && typeof stream.abort === 'function';
      };

      var isChildProcess = function(stream) {
        return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
      };

      var eos = function(stream, opts, callback) {
        if (typeof opts === 'function') return eos(stream, null, opts);
        if (!opts) opts = {};

        callback = once(callback || noop);

        var ws = stream._writableState;
        var rs = stream._readableState;
        var readable = opts.readable || (opts.readable !== false && stream.readable);
        var writable = opts.writable || (opts.writable !== false && stream.writable);

        var onlegacyfinish = function() {
          if (!stream.writable) onfinish();
        };

        var onfinish = function() {
          writable = false;
          if (!readable) callback.call(stream);
        };

        var onend = function() {
          readable = false;
          if (!writable) callback.call(stream);
        };

        var onexit = function(exitCode) {
          callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
        };

        var onerror = function(err) {
          callback.call(stream, err);
        };

        var onclose = function() {
          if (readable && !(rs && rs.ended)) return callback.call(stream, new Error('premature close'));
          if (writable && !(ws && ws.ended)) return callback.call(stream, new Error('premature close'));
        };

        var onrequest = function() {
          stream.req.on('finish', onfinish);
        };

        if (isRequest(stream)) {
          stream.on('complete', onfinish);
          stream.on('abort', onclose);
          if (stream.req) onrequest();
          else stream.on('request', onrequest);
        } else if (writable && !ws) { // legacy streams
          stream.on('end', onlegacyfinish);
          stream.on('close', onlegacyfinish);
        }

        if (isChildProcess(stream)) stream.on('exit', onexit);

        stream.on('end', onend);
        stream.on('finish', onfinish);
        if (opts.error !== false) stream.on('error', onerror);
        stream.on('close', onclose);

        return function() {
          stream.removeListener('complete', onfinish);
          stream.removeListener('abort', onclose);
          stream.removeListener('request', onrequest);
          if (stream.req) stream.req.removeListener('finish', onfinish);
          stream.removeListener('end', onlegacyfinish);
          stream.removeListener('close', onlegacyfinish);
          stream.removeListener('finish', onfinish);
          stream.removeListener('exit', onexit);
          stream.removeListener('end', onend);
          stream.removeListener('error', onerror);
          stream.removeListener('close', onclose);
        };
      };

      module.exports = eos;

    }, {
      "once": 90
    }],
    18: [function(require, module, exports) {
      // Inspired by Google Closure:
      // http://closure-library.googlecode.com/svn/docs/
      // closure_goog_array_array.js.html#goog.array.clear

      "use strict";

      var value = require("../../object/valid-value");

      module.exports = function() {
        value(this).length = 0;
        return this;
      };

    }, {
      "../../object/valid-value": 54
    }],
    19: [function(require, module, exports) {
      "use strict";

      var numberIsNaN = require("../../number/is-nan"),
        toPosInt = require("../../number/to-pos-integer"),
        value = require("../../object/valid-value"),
        indexOf = Array.prototype.indexOf,
        objHasOwnProperty = Object.prototype.hasOwnProperty,
        abs = Math.abs,
        floor = Math.floor;

      module.exports = function(searchElement /*, fromIndex*/ ) {
        var i, length, fromIndex, val;
        if (!numberIsNaN(searchElement)) return indexOf.apply(this, arguments);

        length = toPosInt(value(this).length);
        fromIndex = arguments[1];
        if (isNaN(fromIndex)) fromIndex = 0;
        else if (fromIndex >= 0) fromIndex = floor(fromIndex);
        else fromIndex = toPosInt(this.length) - floor(abs(fromIndex));

        for (i = fromIndex; i < length; ++i) {
          if (objHasOwnProperty.call(this, i)) {
            val = this[i];
            if (numberIsNaN(val)) return i; // Jslint: ignore
          }
        }
        return -1;
      };

    }, {
      "../../number/is-nan": 29,
      "../../number/to-pos-integer": 33,
      "../../object/valid-value": 54
    }],
    20: [function(require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ?
        Array.from :
        require("./shim");

    }, {
      "./is-implemented": 21,
      "./shim": 22
    }],
    21: [function(require, module, exports) {
      "use strict";

      module.exports = function() {
        var from = Array.from,
          arr, result;
        if (typeof from !== "function") return false;
        arr = ["raz", "dwa"];
        result = from(arr);
        return Boolean(result && (result !== arr) && (result[1] === "dwa"));
      };

    }, {}],
    22: [function(require, module, exports) {
      "use strict";

      var iteratorSymbol = require("es6-symbol").iterator,
        isArguments = require("../../function/is-arguments"),
        isFunction = require("../../function/is-function"),
        toPosInt = require("../../number/to-pos-integer"),
        callable = require("../../object/valid-callable"),
        validValue = require("../../object/valid-value"),
        isValue = require("../../object/is-value"),
        isString = require("../../string/is-string"),
        isArray = Array.isArray,
        call = Function.prototype.call,
        desc = {
          configurable: true,
          enumerable: true,
          writable: true,
          value: null
        },
        defineProperty = Object.defineProperty;

      // eslint-disable-next-line complexity
      module.exports = function(arrayLike /*, mapFn, thisArg*/ ) {
        var mapFn = arguments[1],
          thisArg = arguments[2],
          Context, i, j, arr, length, code, iterator, result, getIterator, value;

        arrayLike = Object(validValue(arrayLike));

        if (isValue(mapFn)) callable(mapFn);
        if (!this || this === Array || !isFunction(this)) {
          // Result: Plain array
          if (!mapFn) {
            if (isArguments(arrayLike)) {
              // Source: Arguments
              length = arrayLike.length;
              if (length !== 1) return Array.apply(null, arrayLike);
              arr = new Array(1);
              arr[0] = arrayLike[0];
              return arr;
            }
            if (isArray(arrayLike)) {
              // Source: Array
              arr = new Array(length = arrayLike.length);
              for (i = 0; i < length; ++i) arr[i] = arrayLike[i];
              return arr;
            }
          }
          arr = [];
        } else {
          // Result: Non plain array
          Context = this;
        }

        if (!isArray(arrayLike)) {
          if ((getIterator = arrayLike[iteratorSymbol]) !== undefined) {
            // Source: Iterator
            iterator = callable(getIterator).call(arrayLike);
            if (Context) arr = new Context();
            result = iterator.next();
            i = 0;
            while (!result.done) {
              value = mapFn ? call.call(mapFn, thisArg, result.value, i) : result.value;
              if (Context) {
                desc.value = value;
                defineProperty(arr, i, desc);
              } else {
                arr[i] = value;
              }
              result = iterator.next();
              ++i;
            }
            length = i;
          } else if (isString(arrayLike)) {
            // Source: String
            length = arrayLike.length;
            if (Context) arr = new Context();
            for (i = 0, j = 0; i < length; ++i) {
              value = arrayLike[i];
              if (i + 1 < length) {
                code = value.charCodeAt(0);
                // eslint-disable-next-line max-depth
                if (code >= 0xd800 && code <= 0xdbff) value += arrayLike[++i];
              }
              value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
              if (Context) {
                desc.value = value;
                defineProperty(arr, j, desc);
              } else {
                arr[j] = value;
              }
              ++j;
            }
            length = j;
          }
        }
        if (length === undefined) {
          // Source: array or array-like
          length = toPosInt(arrayLike.length);
          if (Context) arr = new Context(length);
          for (i = 0; i < length; ++i) {
            value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
            if (Context) {
              desc.value = value;
              defineProperty(arr, i, desc);
            } else {
              arr[i] = value;
            }
          }
        }
        if (Context) {
          desc.value = null;
          arr.length = length;
        }
        return arr;
      };

    }, {
      "../../function/is-arguments": 23,
      "../../function/is-function": 24,
      "../../number/to-pos-integer": 33,
      "../../object/is-value": 43,
      "../../object/valid-callable": 53,
      "../../object/valid-value": 54,
      "../../string/is-string": 58,
      "es6-symbol": 72
    }],
    23: [function(require, module, exports) {
      "use strict";

      var objToString = Object.prototype.toString,
        id = objToString.call(
          (function() {
            return arguments;
          })()
        );

      module.exports = function(value) {
        return objToString.call(value) === id;
      };

    }, {}],
    24: [function(require, module, exports) {
      "use strict";

      var objToString = Object.prototype.toString,
        id = objToString.call(require("./noop"));

      module.exports = function(value) {
        return typeof value === "function" && objToString.call(value) === id;
      };

    }, {
      "./noop": 25
    }],
    25: [function(require, module, exports) {
      "use strict";

      // eslint-disable-next-line no-empty-function
      module.exports = function() {};

    }, {}],
    26: [function(require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ?
        Math.sign :
        require("./shim");

    }, {
      "./is-implemented": 27,
      "./shim": 28
    }],
    27: [function(require, module, exports) {
      "use strict";

      module.exports = function() {
        var sign = Math.sign;
        if (typeof sign !== "function") return false;
        return (sign(10) === 1) && (sign(-20) === -1);
      };

    }, {}],
    28: [function(require, module, exports) {
      "use strict";

      module.exports = function(value) {
        value = Number(value);
        if (isNaN(value) || (value === 0)) return value;
        return value > 0 ? 1 : -1;
      };

    }, {}],
    29: [function(require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ?
        Number.isNaN :
        require("./shim");

    }, {
      "./is-implemented": 30,
      "./shim": 31
    }],
    30: [function(require, module, exports) {
      "use strict";

      module.exports = function() {
        var numberIsNaN = Number.isNaN;
        if (typeof numberIsNaN !== "function") return false;
        return !numberIsNaN({}) && numberIsNaN(NaN) && !numberIsNaN(34);
      };

    }, {}],
    31: [function(require, module, exports) {
      "use strict";

      module.exports = function(value) {
        // eslint-disable-next-line no-self-compare
        return value !== value;
      };

    }, {}],
    32: [function(require, module, exports) {
      "use strict";

      var sign = require("../math/sign")

        ,
        abs = Math.abs,
        floor = Math.floor;

      module.exports = function(value) {
        if (isNaN(value)) return 0;
        value = Number(value);
        if ((value === 0) || !isFinite(value)) return value;
        return sign(value) * floor(abs(value));
      };

    }, {
      "../math/sign": 26
    }],
    33: [function(require, module, exports) {
      "use strict";

      var toInteger = require("./to-integer")

        ,
        max = Math.max;

      module.exports = function(value) {
        return max(0, toInteger(value));
      };

    }, {
      "./to-integer": 32
    }],
    34: [function(require, module, exports) {
      // Internal method, used by iteration functions.
      // Calls a function for each key-value pair found in object
      // Optionally takes compareFn to iterate object in specific order

      "use strict";

      var callable = require("./valid-callable"),
        value = require("./valid-value"),
        bind = Function.prototype.bind,
        call = Function.prototype.call,
        keys = Object.keys,
        objPropertyIsEnumerable = Object.prototype.propertyIsEnumerable;

      module.exports = function(method, defVal) {
        return function(obj, cb /*, thisArg, compareFn*/ ) {
          var list, thisArg = arguments[2],
            compareFn = arguments[3];
          obj = Object(value(obj));
          callable(cb);

          list = keys(obj);
          if (compareFn) {
            list.sort(typeof compareFn === "function" ? bind.call(compareFn, obj) : undefined);
          }
          if (typeof method !== "function") method = list[method];
          return call.call(method, list, function(key, index) {
            if (!objPropertyIsEnumerable.call(obj, key)) return defVal;
            return call.call(cb, thisArg, obj[key], key, obj, index);
          });
        };
      };

    }, {
      "./valid-callable": 53,
      "./valid-value": 54
    }],
    35: [function(require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ?
        Object.assign :
        require("./shim");

    }, {
      "./is-implemented": 36,
      "./shim": 37
    }],
    36: [function(require, module, exports) {
      "use strict";

      module.exports = function() {
        var assign = Object.assign,
          obj;
        if (typeof assign !== "function") return false;
        obj = {
          foo: "raz"
        };
        assign(obj, {
          bar: "dwa"
        }, {
          trzy: "trzy"
        });
        return (obj.foo + obj.bar + obj.trzy) === "razdwatrzy";
      };

    }, {}],
    37: [function(require, module, exports) {
      "use strict";

      var keys = require("../keys"),
        value = require("../valid-value"),
        max = Math.max;

      module.exports = function(dest, src /*, …srcn*/ ) {
        var error, i, length = max(arguments.length, 2),
          assign;
        dest = Object(value(dest));
        assign = function(key) {
          try {
            dest[key] = src[key];
          } catch (e) {
            if (!error) error = e;
          }
        };
        for (i = 1; i < length; ++i) {
          src = arguments[i];
          keys(src).forEach(assign);
        }
        if (error !== undefined) throw error;
        return dest;
      };

    }, {
      "../keys": 44,
      "../valid-value": 54
    }],
    38: [function(require, module, exports) {
      "use strict";

      var aFrom = require("../array/from"),
        assign = require("./assign"),
        value = require("./valid-value");

      module.exports = function(obj /*, propertyNames, options*/ ) {
        var copy = Object(value(obj)),
          propertyNames = arguments[1],
          options = Object(arguments[2]);
        if (copy !== obj && !propertyNames) return copy;
        var result = {};
        if (propertyNames) {
          aFrom(propertyNames, function(propertyName) {
            if (options.ensure || propertyName in obj) result[propertyName] = obj[propertyName];
          });
        } else {
          assign(result, obj);
        }
        return result;
      };

    }, {
      "../array/from": 20,
      "./assign": 35,
      "./valid-value": 54
    }],
    39: [function(require, module, exports) {
      // Workaround for http://code.google.com/p/v8/issues/detail?id=2804

      "use strict";

      var create = Object.create,
        shim;

      if (!require("./set-prototype-of/is-implemented")()) {
        shim = require("./set-prototype-of/shim");
      }

      module.exports = (function() {
        var nullObject, polyProps, desc;
        if (!shim) return create;
        if (shim.level !== 1) return create;

        nullObject = {};
        polyProps = {};
        desc = {
          configurable: false,
          enumerable: false,
          writable: true,
          value: undefined
        };
        Object.getOwnPropertyNames(Object.prototype).forEach(function(name) {
          if (name === "__proto__") {
            polyProps[name] = {
              configurable: true,
              enumerable: false,
              writable: true,
              value: undefined
            };
            return;
          }
          polyProps[name] = desc;
        });
        Object.defineProperties(nullObject, polyProps);

        Object.defineProperty(shim, "nullPolyfill", {
          configurable: false,
          enumerable: false,
          writable: false,
          value: nullObject
        });

        return function(prototype, props) {
          return create(prototype === null ? nullObject : prototype, props);
        };
      }());

    }, {
      "./set-prototype-of/is-implemented": 51,
      "./set-prototype-of/shim": 52
    }],
    40: [function(require, module, exports) {
      "use strict";

      module.exports = require("./_iterate")("forEach");

    }, {
      "./_iterate": 34
    }],
    41: [function(require, module, exports) {
      // Deprecated

      "use strict";

      module.exports = function(obj) {
        return typeof obj === "function";
      };

    }, {}],
    42: [function(require, module, exports) {
      "use strict";

      var isValue = require("./is-value");

      var map = {
        function: true,
        object: true
      };

      module.exports = function(value) {
        return (isValue(value) && map[typeof value]) || false;
      };

    }, {
      "./is-value": 43
    }],
    43: [function(require, module, exports) {
      "use strict";

      var _undefined = require("../function/noop")(); // Support ES3 engines

      module.exports = function(val) {
        return (val !== _undefined) && (val !== null);
      };

    }, {
      "../function/noop": 25
    }],
    44: [function(require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ? Object.keys : require("./shim");

    }, {
      "./is-implemented": 45,
      "./shim": 46
    }],
    45: [function(require, module, exports) {
      "use strict";

      module.exports = function() {
        try {
          Object.keys("primitive");
          return true;
        } catch (e) {
          return false;
        }
      };

    }, {}],
    46: [function(require, module, exports) {
      "use strict";

      var isValue = require("../is-value");

      var keys = Object.keys;

      module.exports = function(object) {
        return keys(isValue(object) ? Object(object) : object);
      };

    }, {
      "../is-value": 43
    }],
    47: [function(require, module, exports) {
      "use strict";

      var callable = require("./valid-callable"),
        forEach = require("./for-each"),
        call = Function.prototype.call;

      module.exports = function(obj, cb /*, thisArg*/ ) {
        var result = {},
          thisArg = arguments[2];
        callable(cb);
        forEach(obj, function(value, key, targetObj, index) {
          result[key] = call.call(cb, thisArg, value, key, targetObj, index);
        });
        return result;
      };

    }, {
      "./for-each": 40,
      "./valid-callable": 53
    }],
    48: [function(require, module, exports) {
      "use strict";

      var isValue = require("./is-value");

      var forEach = Array.prototype.forEach,
        create = Object.create;

      var process = function(src, obj) {
        var key;
        for (key in src) obj[key] = src[key];
      };

      // eslint-disable-next-line no-unused-vars
      module.exports = function(opts1 /*, …options*/ ) {
        var result = create(null);
        forEach.call(arguments, function(options) {
          if (!isValue(options)) return;
          process(Object(options), result);
        });
        return result;
      };

    }, {
      "./is-value": 43
    }],
    49: [function(require, module, exports) {
      "use strict";

      var forEach = Array.prototype.forEach,
        create = Object.create;

      // eslint-disable-next-line no-unused-vars
      module.exports = function(arg /*, …args*/ ) {
        var set = create(null);
        forEach.call(arguments, function(name) {
          set[name] = true;
        });
        return set;
      };

    }, {}],
    50: [function(require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ?
        Object.setPrototypeOf :
        require("./shim");

    }, {
      "./is-implemented": 51,
      "./shim": 52
    }],
    51: [function(require, module, exports) {
      "use strict";

      var create = Object.create,
        getPrototypeOf = Object.getPrototypeOf,
        plainObject = {};

      module.exports = function( /* CustomCreate*/ ) {
        var setPrototypeOf = Object.setPrototypeOf,
          customCreate = arguments[0] || create;
        if (typeof setPrototypeOf !== "function") return false;
        return getPrototypeOf(setPrototypeOf(customCreate(null), plainObject)) === plainObject;
      };

    }, {}],
    52: [function(require, module, exports) {
      /* eslint no-proto: "off" */

      // Big thanks to @WebReflection for sorting this out
      // https://gist.github.com/WebReflection/5593554

      "use strict";

      var isObject = require("../is-object"),
        value = require("../valid-value"),
        objIsPrototypeOf = Object.prototype.isPrototypeOf,
        defineProperty = Object.defineProperty,
        nullDesc = {
          configurable: true,
          enumerable: false,
          writable: true,
          value: undefined
        },
        validate;

      validate = function(obj, prototype) {
        value(obj);
        if (prototype === null || isObject(prototype)) return obj;
        throw new TypeError("Prototype must be null or an object");
      };

      module.exports = (function(status) {
        var fn, set;
        if (!status) return null;
        if (status.level === 2) {
          if (status.set) {
            set = status.set;
            fn = function(obj, prototype) {
              set.call(validate(obj, prototype), prototype);
              return obj;
            };
          } else {
            fn = function(obj, prototype) {
              validate(obj, prototype).__proto__ = prototype;
              return obj;
            };
          }
        } else {
          fn = function self(obj, prototype) {
            var isNullBase;
            validate(obj, prototype);
            isNullBase = objIsPrototypeOf.call(self.nullPolyfill, obj);
            if (isNullBase) delete self.nullPolyfill.__proto__;
            if (prototype === null) prototype = self.nullPolyfill;
            obj.__proto__ = prototype;
            if (isNullBase) defineProperty(self.nullPolyfill, "__proto__", nullDesc);
            return obj;
          };
        }
        return Object.defineProperty(fn, "level", {
          configurable: false,
          enumerable: false,
          writable: false,
          value: status.level
        });
      }(
        (function() {
          var tmpObj1 = Object.create(null),
            tmpObj2 = {},
            set, desc = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__");

          if (desc) {
            try {
              set = desc.set; // Opera crashes at this point
              set.call(tmpObj1, tmpObj2);
            } catch (ignore) {}
            if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return {
              set: set,
              level: 2
            };
          }

          tmpObj1.__proto__ = tmpObj2;
          if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return {
            level: 2
          };

          tmpObj1 = {};
          tmpObj1.__proto__ = tmpObj2;
          if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return {
            level: 1
          };

          return false;
        })()
      ));

      require("../create");

    }, {
      "../create": 39,
      "../is-object": 42,
      "../valid-value": 54
    }],
    53: [function(require, module, exports) {
      "use strict";

      module.exports = function(fn) {
        if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
        return fn;
      };

    }, {}],
    54: [function(require, module, exports) {
      "use strict";

      var isValue = require("./is-value");

      module.exports = function(value) {
        if (!isValue(value)) throw new TypeError("Cannot use null or undefined");
        return value;
      };

    }, {
      "./is-value": 43
    }],
    55: [function(require, module, exports) {
      "use strict";

      module.exports = require("./is-implemented")() ?
        String.prototype.contains :
        require("./shim");

    }, {
      "./is-implemented": 56,
      "./shim": 57
    }],
    56: [function(require, module, exports) {
      "use strict";

      var str = "razdwatrzy";

      module.exports = function() {
        if (typeof str.contains !== "function") return false;
        return (str.contains("dwa") === true) && (str.contains("foo") === false);
      };

    }, {}],
    57: [function(require, module, exports) {
      "use strict";

      var indexOf = String.prototype.indexOf;

      module.exports = function(searchString /*, position*/ ) {
        return indexOf.call(this, searchString, arguments[1]) > -1;
      };

    }, {}],
    58: [function(require, module, exports) {
      "use strict";

      var objToString = Object.prototype.toString,
        id = objToString.call("");

      module.exports = function(value) {
        return (
          typeof value === "string" ||
          (value &&
            typeof value === "object" &&
            (value instanceof String || objToString.call(value) === id)) ||
          false
        );
      };

    }, {}],
    59: [function(require, module, exports) {
      "use strict";

      var setPrototypeOf = require("es5-ext/object/set-prototype-of"),
        contains = require("es5-ext/string/#/contains"),
        d = require("d"),
        Symbol = require("es6-symbol"),
        Iterator = require("./");

      var defineProperty = Object.defineProperty,
        ArrayIterator;

      ArrayIterator = module.exports = function(arr, kind) {
        if (!(this instanceof ArrayIterator)) throw new TypeError("Constructor requires 'new'");
        Iterator.call(this, arr);
        if (!kind) kind = "value";
        else if (contains.call(kind, "key+value")) kind = "key+value";
        else if (contains.call(kind, "key")) kind = "key";
        else kind = "value";
        defineProperty(this, "__kind__", d("", kind));
      };
      if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator);

      // Internal %ArrayIteratorPrototype% doesn't expose its constructor
      delete ArrayIterator.prototype.constructor;

      ArrayIterator.prototype = Object.create(Iterator.prototype, {
        _resolve: d(function(i) {
          if (this.__kind__ === "value") return this.__list__[i];
          if (this.__kind__ === "key+value") return [i, this.__list__[i]];
          return i;
        })
      });
      defineProperty(ArrayIterator.prototype, Symbol.toStringTag, d("c", "Array Iterator"));

    }, {
      "./": 62,
      "d": 15,
      "es5-ext/object/set-prototype-of": 50,
      "es5-ext/string/#/contains": 55,
      "es6-symbol": 72
    }],
    60: [function(require, module, exports) {
      "use strict";

      var isArguments = require("es5-ext/function/is-arguments"),
        callable = require("es5-ext/object/valid-callable"),
        isString = require("es5-ext/string/is-string"),
        get = require("./get");

      var isArray = Array.isArray,
        call = Function.prototype.call,
        some = Array.prototype.some;

      module.exports = function(iterable, cb /*, thisArg*/ ) {
        var mode, thisArg = arguments[2],
          result, doBreak, broken, i, length, char, code;
        if (isArray(iterable) || isArguments(iterable)) mode = "array";
        else if (isString(iterable)) mode = "string";
        else iterable = get(iterable);

        callable(cb);
        doBreak = function() {
          broken = true;
        };
        if (mode === "array") {
          some.call(iterable, function(value) {
            call.call(cb, thisArg, value, doBreak);
            return broken;
          });
          return;
        }
        if (mode === "string") {
          length = iterable.length;
          for (i = 0; i < length; ++i) {
            char = iterable[i];
            if (i + 1 < length) {
              code = char.charCodeAt(0);
              if (code >= 0xd800 && code <= 0xdbff) char += iterable[++i];
            }
            call.call(cb, thisArg, char, doBreak);
            if (broken) break;
          }
          return;
        }
        result = iterable.next();

        while (!result.done) {
          call.call(cb, thisArg, result.value, doBreak);
          if (broken) return;
          result = iterable.next();
        }
      };

    }, {
      "./get": 61,
      "es5-ext/function/is-arguments": 23,
      "es5-ext/object/valid-callable": 53,
      "es5-ext/string/is-string": 58
    }],
    61: [function(require, module, exports) {
      "use strict";

      var isArguments = require("es5-ext/function/is-arguments"),
        isString = require("es5-ext/string/is-string"),
        ArrayIterator = require("./array"),
        StringIterator = require("./string"),
        iterable = require("./valid-iterable"),
        iteratorSymbol = require("es6-symbol").iterator;

      module.exports = function(obj) {
        if (typeof iterable(obj)[iteratorSymbol] === "function") return obj[iteratorSymbol]();
        if (isArguments(obj)) return new ArrayIterator(obj);
        if (isString(obj)) return new StringIterator(obj);
        return new ArrayIterator(obj);
      };

    }, {
      "./array": 59,
      "./string": 64,
      "./valid-iterable": 65,
      "es5-ext/function/is-arguments": 23,
      "es5-ext/string/is-string": 58,
      "es6-symbol": 72
    }],
    62: [function(require, module, exports) {
      "use strict";

      var clear = require("es5-ext/array/#/clear"),
        assign = require("es5-ext/object/assign"),
        callable = require("es5-ext/object/valid-callable"),
        value = require("es5-ext/object/valid-value"),
        d = require("d"),
        autoBind = require("d/auto-bind"),
        Symbol = require("es6-symbol");

      var defineProperty = Object.defineProperty,
        defineProperties = Object.defineProperties,
        Iterator;

      module.exports = Iterator = function(list, context) {
        if (!(this instanceof Iterator)) throw new TypeError("Constructor requires 'new'");
        defineProperties(this, {
          __list__: d("w", value(list)),
          __context__: d("w", context),
          __nextIndex__: d("w", 0)
        });
        if (!context) return;
        callable(context.on);
        context.on("_add", this._onAdd);
        context.on("_delete", this._onDelete);
        context.on("_clear", this._onClear);
      };

      // Internal %IteratorPrototype% doesn't expose its constructor
      delete Iterator.prototype.constructor;

      defineProperties(
        Iterator.prototype,
        assign({
            _next: d(function() {
              var i;
              if (!this.__list__) return undefined;
              if (this.__redo__) {
                i = this.__redo__.shift();
                if (i !== undefined) return i;
              }
              if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
              this._unBind();
              return undefined;
            }),
            next: d(function() {
              return this._createResult(this._next());
            }),
            _createResult: d(function(i) {
              if (i === undefined) return {
                done: true,
                value: undefined
              };
              return {
                done: false,
                value: this._resolve(i)
              };
            }),
            _resolve: d(function(i) {
              return this.__list__[i];
            }),
            _unBind: d(function() {
              this.__list__ = null;
              delete this.__redo__;
              if (!this.__context__) return;
              this.__context__.off("_add", this._onAdd);
              this.__context__.off("_delete", this._onDelete);
              this.__context__.off("_clear", this._onClear);
              this.__context__ = null;
            }),
            toString: d(function() {
              return "[object " + (this[Symbol.toStringTag] || "Object") + "]";
            })
          },
          autoBind({
            _onAdd: d(function(index) {
              if (index >= this.__nextIndex__) return;
              ++this.__nextIndex__;
              if (!this.__redo__) {
                defineProperty(this, "__redo__", d("c", [index]));
                return;
              }
              this.__redo__.forEach(function(redo, i) {
                if (redo >= index) this.__redo__[i] = ++redo;
              }, this);
              this.__redo__.push(index);
            }),
            _onDelete: d(function(index) {
              var i;
              if (index >= this.__nextIndex__) return;
              --this.__nextIndex__;
              if (!this.__redo__) return;
              i = this.__redo__.indexOf(index);
              if (i !== -1) this.__redo__.splice(i, 1);
              this.__redo__.forEach(function(redo, j) {
                if (redo > index) this.__redo__[j] = --redo;
              }, this);
            }),
            _onClear: d(function() {
              if (this.__redo__) clear.call(this.__redo__);
              this.__nextIndex__ = 0;
            })
          })
        )
      );

      defineProperty(
        Iterator.prototype,
        Symbol.iterator,
        d(function() {
          return this;
        })
      );

    }, {
      "d": 15,
      "d/auto-bind": 14,
      "es5-ext/array/#/clear": 18,
      "es5-ext/object/assign": 35,
      "es5-ext/object/valid-callable": 53,
      "es5-ext/object/valid-value": 54,
      "es6-symbol": 72
    }],
    63: [function(require, module, exports) {
      "use strict";

      var isArguments = require("es5-ext/function/is-arguments"),
        isValue = require("es5-ext/object/is-value"),
        isString = require("es5-ext/string/is-string");

      var iteratorSymbol = require("es6-symbol").iterator,
        isArray = Array.isArray;

      module.exports = function(value) {
        if (!isValue(value)) return false;
        if (isArray(value)) return true;
        if (isString(value)) return true;
        if (isArguments(value)) return true;
        return typeof value[iteratorSymbol] === "function";
      };

    }, {
      "es5-ext/function/is-arguments": 23,
      "es5-ext/object/is-value": 43,
      "es5-ext/string/is-string": 58,
      "es6-symbol": 72
    }],
    64: [function(require, module, exports) {
      // Thanks @mathiasbynens
      // http://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols

      "use strict";

      var setPrototypeOf = require("es5-ext/object/set-prototype-of"),
        d = require("d"),
        Symbol = require("es6-symbol"),
        Iterator = require("./");

      var defineProperty = Object.defineProperty,
        StringIterator;

      StringIterator = module.exports = function(str) {
        if (!(this instanceof StringIterator)) throw new TypeError("Constructor requires 'new'");
        str = String(str);
        Iterator.call(this, str);
        defineProperty(this, "__length__", d("", str.length));
      };
      if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);

      // Internal %ArrayIteratorPrototype% doesn't expose its constructor
      delete StringIterator.prototype.constructor;

      StringIterator.prototype = Object.create(Iterator.prototype, {
        _next: d(function() {
          if (!this.__list__) return undefined;
          if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
          this._unBind();
          return undefined;
        }),
        _resolve: d(function(i) {
          var char = this.__list__[i],
            code;
          if (this.__nextIndex__ === this.__length__) return char;
          code = char.charCodeAt(0);
          if (code >= 0xd800 && code <= 0xdbff) return char + this.__list__[this.__nextIndex__++];
          return char;
        })
      });
      defineProperty(StringIterator.prototype, Symbol.toStringTag, d("c", "String Iterator"));

    }, {
      "./": 62,
      "d": 15,
      "es5-ext/object/set-prototype-of": 50,
      "es6-symbol": 72
    }],
    65: [function(require, module, exports) {
      "use strict";

      var isIterable = require("./is-iterable");

      module.exports = function(value) {
        if (!isIterable(value)) throw new TypeError(value + " is not iterable");
        return value;
      };

    }, {
      "./is-iterable": 63
    }],
    66: [function(require, module, exports) {
      'use strict';

      module.exports = require('./is-implemented')() ? Map : require('./polyfill');

    }, {
      "./is-implemented": 67,
      "./polyfill": 71
    }],
    67: [function(require, module, exports) {
      'use strict';

      module.exports = function() {
        var map, iterator, result;
        if (typeof Map !== 'function') return false;
        try {
          // WebKit doesn't support arguments and crashes
          map = new Map([
            ['raz', 'one'],
            ['dwa', 'two'],
            ['trzy', 'three']
          ]);
        } catch (e) {
          return false;
        }
        if (String(map) !== '[object Map]') return false;
        if (map.size !== 3) return false;
        if (typeof map.clear !== 'function') return false;
        if (typeof map.delete !== 'function') return false;
        if (typeof map.entries !== 'function') return false;
        if (typeof map.forEach !== 'function') return false;
        if (typeof map.get !== 'function') return false;
        if (typeof map.has !== 'function') return false;
        if (typeof map.keys !== 'function') return false;
        if (typeof map.set !== 'function') return false;
        if (typeof map.values !== 'function') return false;

        iterator = map.entries();
        result = iterator.next();
        if (result.done !== false) return false;
        if (!result.value) return false;
        if (result.value[0] !== 'raz') return false;
        if (result.value[1] !== 'one') return false;

        return true;
      };

    }, {}],
    68: [function(require, module, exports) {
      // Exports true if environment provides native `Map` implementation,
      // whatever that is.

      'use strict';

      module.exports = (function() {
        if (typeof Map === 'undefined') return false;
        return (Object.prototype.toString.call(new Map()) === '[object Map]');
      }());

    }, {}],
    69: [function(require, module, exports) {
      'use strict';

      module.exports = require('es5-ext/object/primitive-set')('key',
        'value', 'key+value');

    }, {
      "es5-ext/object/primitive-set": 49
    }],
    70: [function(require, module, exports) {
      'use strict';

      var setPrototypeOf = require('es5-ext/object/set-prototype-of'),
        d = require('d'),
        Iterator = require('es6-iterator'),
        toStringTagSymbol = require('es6-symbol').toStringTag,
        kinds = require('./iterator-kinds')

        ,
        defineProperties = Object.defineProperties,
        unBind = Iterator.prototype._unBind,
        MapIterator;

      MapIterator = module.exports = function(map, kind) {
        if (!(this instanceof MapIterator)) return new MapIterator(map, kind);
        Iterator.call(this, map.__mapKeysData__, map);
        if (!kind || !kinds[kind]) kind = 'key+value';
        defineProperties(this, {
          __kind__: d('', kind),
          __values__: d('w', map.__mapValuesData__)
        });
      };
      if (setPrototypeOf) setPrototypeOf(MapIterator, Iterator);

      MapIterator.prototype = Object.create(Iterator.prototype, {
        constructor: d(MapIterator),
        _resolve: d(function(i) {
          if (this.__kind__ === 'value') return this.__values__[i];
          if (this.__kind__ === 'key') return this.__list__[i];
          return [this.__list__[i], this.__values__[i]];
        }),
        _unBind: d(function() {
          this.__values__ = null;
          unBind.call(this);
        }),
        toString: d(function() {
          return '[object Map Iterator]';
        })
      });
      Object.defineProperty(MapIterator.prototype, toStringTagSymbol,
        d('c', 'Map Iterator'));

    }, {
      "./iterator-kinds": 69,
      "d": 15,
      "es5-ext/object/set-prototype-of": 50,
      "es6-iterator": 62,
      "es6-symbol": 72
    }],
    71: [function(require, module, exports) {
      'use strict';

      var clear = require('es5-ext/array/#/clear'),
        eIndexOf = require('es5-ext/array/#/e-index-of'),
        setPrototypeOf = require('es5-ext/object/set-prototype-of'),
        callable = require('es5-ext/object/valid-callable'),
        validValue = require('es5-ext/object/valid-value'),
        d = require('d'),
        ee = require('event-emitter'),
        Symbol = require('es6-symbol'),
        iterator = require('es6-iterator/valid-iterable'),
        forOf = require('es6-iterator/for-of'),
        Iterator = require('./lib/iterator'),
        isNative = require('./is-native-implemented')

        ,
        call = Function.prototype.call,
        defineProperties = Object.defineProperties,
        getPrototypeOf = Object.getPrototypeOf,
        MapPoly;

      module.exports = MapPoly = function( /*iterable*/ ) {
        var iterable = arguments[0],
          keys, values, self;
        if (!(this instanceof MapPoly)) throw new TypeError('Constructor requires \'new\'');
        if (isNative && setPrototypeOf && (Map !== MapPoly)) {
          self = setPrototypeOf(new Map(), getPrototypeOf(this));
        } else {
          self = this;
        }
        if (iterable != null) iterator(iterable);
        defineProperties(self, {
          __mapKeysData__: d('c', keys = []),
          __mapValuesData__: d('c', values = [])
        });
        if (!iterable) return self;
        forOf(iterable, function(value) {
          var key = validValue(value)[0];
          value = value[1];
          if (eIndexOf.call(keys, key) !== -1) return;
          keys.push(key);
          values.push(value);
        }, self);
        return self;
      };

      if (isNative) {
        if (setPrototypeOf) setPrototypeOf(MapPoly, Map);
        MapPoly.prototype = Object.create(Map.prototype, {
          constructor: d(MapPoly)
        });
      }

      ee(defineProperties(MapPoly.prototype, {
        clear: d(function() {
          if (!this.__mapKeysData__.length) return;
          clear.call(this.__mapKeysData__);
          clear.call(this.__mapValuesData__);
          this.emit('_clear');
        }),
        delete: d(function(key) {
          var index = eIndexOf.call(this.__mapKeysData__, key);
          if (index === -1) return false;
          this.__mapKeysData__.splice(index, 1);
          this.__mapValuesData__.splice(index, 1);
          this.emit('_delete', index, key);
          return true;
        }),
        entries: d(function() {
          return new Iterator(this, 'key+value');
        }),
        forEach: d(function(cb /*, thisArg*/ ) {
          var thisArg = arguments[1],
            iterator, result;
          callable(cb);
          iterator = this.entries();
          result = iterator._next();
          while (result !== undefined) {
            call.call(cb, thisArg, this.__mapValuesData__[result],
              this.__mapKeysData__[result], this);
            result = iterator._next();
          }
        }),
        get: d(function(key) {
          var index = eIndexOf.call(this.__mapKeysData__, key);
          if (index === -1) return;
          return this.__mapValuesData__[index];
        }),
        has: d(function(key) {
          return (eIndexOf.call(this.__mapKeysData__, key) !== -1);
        }),
        keys: d(function() {
          return new Iterator(this, 'key');
        }),
        set: d(function(key, value) {
          var index = eIndexOf.call(this.__mapKeysData__, key),
            emit;
          if (index === -1) {
            index = this.__mapKeysData__.push(key) - 1;
            emit = true;
          }
          this.__mapValuesData__[index] = value;
          if (emit) this.emit('_add', index, key);
          return this;
        }),
        size: d.gs(function() {
          return this.__mapKeysData__.length;
        }),
        values: d(function() {
          return new Iterator(this, 'value');
        }),
        toString: d(function() {
          return '[object Map]';
        })
      }));
      Object.defineProperty(MapPoly.prototype, Symbol.iterator, d(function() {
        return this.entries();
      }));
      Object.defineProperty(MapPoly.prototype, Symbol.toStringTag, d('c', 'Map'));

    }, {
      "./is-native-implemented": 68,
      "./lib/iterator": 70,
      "d": 15,
      "es5-ext/array/#/clear": 18,
      "es5-ext/array/#/e-index-of": 19,
      "es5-ext/object/set-prototype-of": 50,
      "es5-ext/object/valid-callable": 53,
      "es5-ext/object/valid-value": 54,
      "es6-iterator/for-of": 60,
      "es6-iterator/valid-iterable": 65,
      "es6-symbol": 72,
      "event-emitter": 77
    }],
    72: [function(require, module, exports) {
      'use strict';

      module.exports = require('./is-implemented')() ? Symbol : require('./polyfill');

    }, {
      "./is-implemented": 73,
      "./polyfill": 75
    }],
    73: [function(require, module, exports) {
      'use strict';

      var validTypes = {
        object: true,
        symbol: true
      };

      module.exports = function() {
        var symbol;
        if (typeof Symbol !== 'function') return false;
        symbol = Symbol('test symbol');
        try {
          String(symbol);
        } catch (e) {
          return false;
        }

        // Return 'true' also for polyfills
        if (!validTypes[typeof Symbol.iterator]) return false;
        if (!validTypes[typeof Symbol.toPrimitive]) return false;
        if (!validTypes[typeof Symbol.toStringTag]) return false;

        return true;
      };

    }, {}],
    74: [function(require, module, exports) {
      'use strict';

      module.exports = function(x) {
        if (!x) return false;
        if (typeof x === 'symbol') return true;
        if (!x.constructor) return false;
        if (x.constructor.name !== 'Symbol') return false;
        return (x[x.constructor.toStringTag] === 'Symbol');
      };

    }, {}],
    75: [function(require, module, exports) {
      // ES2015 Symbol polyfill for environments that do not (or partially) support it

      'use strict';

      var d = require('d'),
        validateSymbol = require('./validate-symbol')

        ,
        create = Object.create,
        defineProperties = Object.defineProperties,
        defineProperty = Object.defineProperty,
        objPrototype = Object.prototype,
        NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null),
        isNativeSafe;

      if (typeof Symbol === 'function') {
        NativeSymbol = Symbol;
        try {
          String(NativeSymbol());
          isNativeSafe = true;
        } catch (ignore) {}
      }

      var generateName = (function() {
        var created = create(null);
        return function(desc) {
          var postfix = 0,
            name, ie11BugWorkaround;
          while (created[desc + (postfix || '')]) ++postfix;
          desc += (postfix || '');
          created[desc] = true;
          name = '@@' + desc;
          defineProperty(objPrototype, name, d.gs(null, function(value) {
            // For IE11 issue see:
            // https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
            //    ie11-broken-getters-on-dom-objects
            // https://github.com/medikoo/es6-symbol/issues/12
            if (ie11BugWorkaround) return;
            ie11BugWorkaround = true;
            defineProperty(this, name, d(value));
            ie11BugWorkaround = false;
          }));
          return name;
        };
      }());

      // Internal constructor (not one exposed) for creating Symbol instances.
      // This one is used to ensure that `someSymbol instanceof Symbol` always return false
      HiddenSymbol = function Symbol(description) {
        if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');
        return SymbolPolyfill(description);
      };

      // Exposed `Symbol` constructor
      // (returns instances of HiddenSymbol)
      module.exports = SymbolPolyfill = function Symbol(description) {
        var symbol;
        if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');
        if (isNativeSafe) return NativeSymbol(description);
        symbol = create(HiddenSymbol.prototype);
        description = (description === undefined ? '' : String(description));
        return defineProperties(symbol, {
          __description__: d('', description),
          __name__: d('', generateName(description))
        });
      };
      defineProperties(SymbolPolyfill, {
        for: d(function(key) {
          if (globalSymbols[key]) return globalSymbols[key];
          return (globalSymbols[key] = SymbolPolyfill(String(key)));
        }),
        keyFor: d(function(s) {
          var key;
          validateSymbol(s);
          for (key in globalSymbols)
            if (globalSymbols[key] === s) return key;
        }),

        // To ensure proper interoperability with other native functions (e.g. Array.from)
        // fallback to eventual native implementation of given symbol
        hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
        isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
          SymbolPolyfill('isConcatSpreadable')),
        iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
        match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
        replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
        search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
        species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
        split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
        toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
        toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
        unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
      });

      // Internal tweaks for real symbol producer
      defineProperties(HiddenSymbol.prototype, {
        constructor: d(SymbolPolyfill),
        toString: d('', function() {
          return this.__name__;
        })
      });

      // Proper implementation of methods exposed on Symbol.prototype
      // They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
      defineProperties(SymbolPolyfill.prototype, {
        toString: d(function() {
          return 'Symbol (' + validateSymbol(this).__description__ + ')';
        }),
        valueOf: d(function() {
          return validateSymbol(this);
        })
      });
      defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('', function() {
        var symbol = validateSymbol(this);
        if (typeof symbol === 'symbol') return symbol;
        return symbol.toString();
      }));
      defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol'));

      // Proper implementaton of toPrimitive and toStringTag for returned symbol instances
      defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
        d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));

      // Note: It's important to define `toPrimitive` as last one, as some implementations
      // implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
      // And that may invoke error in definition flow:
      // See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
      defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
        d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));

    }, {
      "./validate-symbol": 76,
      "d": 15
    }],
    76: [function(require, module, exports) {
      'use strict';

      var isSymbol = require('./is-symbol');

      module.exports = function(value) {
        if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
        return value;
      };

    }, {
      "./is-symbol": 74
    }],
    77: [function(require, module, exports) {
      'use strict';

      var d = require('d'),
        callable = require('es5-ext/object/valid-callable')

        ,
        apply = Function.prototype.apply,
        call = Function.prototype.call,
        create = Object.create,
        defineProperty = Object.defineProperty,
        defineProperties = Object.defineProperties,
        hasOwnProperty = Object.prototype.hasOwnProperty,
        descriptor = {
          configurable: true,
          enumerable: false,
          writable: true
        }

        ,
        on, once, off, emit, methods, descriptors, base;

      on = function(type, listener) {
        var data;

        callable(listener);

        if (!hasOwnProperty.call(this, '__ee__')) {
          data = descriptor.value = create(null);
          defineProperty(this, '__ee__', descriptor);
          descriptor.value = null;
        } else {
          data = this.__ee__;
        }
        if (!data[type]) data[type] = listener;
        else if (typeof data[type] === 'object') data[type].push(listener);
        else data[type] = [data[type], listener];

        return this;
      };

      once = function(type, listener) {
        var once, self;

        callable(listener);
        self = this;
        on.call(this, type, once = function() {
          off.call(self, type, once);
          apply.call(listener, this, arguments);
        });

        once.__eeOnceListener__ = listener;
        return this;
      };

      off = function(type, listener) {
        var data, listeners, candidate, i;

        callable(listener);

        if (!hasOwnProperty.call(this, '__ee__')) return this;
        data = this.__ee__;
        if (!data[type]) return this;
        listeners = data[type];

        if (typeof listeners === 'object') {
          for (i = 0;
            (candidate = listeners[i]); ++i) {
            if ((candidate === listener) ||
              (candidate.__eeOnceListener__ === listener)) {
              if (listeners.length === 2) data[type] = listeners[i ? 0 : 1];
              else listeners.splice(i, 1);
            }
          }
        } else {
          if ((listeners === listener) ||
            (listeners.__eeOnceListener__ === listener)) {
            delete data[type];
          }
        }

        return this;
      };

      emit = function(type) {
        var i, l, listener, listeners, args;

        if (!hasOwnProperty.call(this, '__ee__')) return;
        listeners = this.__ee__[type];
        if (!listeners) return;

        if (typeof listeners === 'object') {
          l = arguments.length;
          args = new Array(l - 1);
          for (i = 1; i < l; ++i) args[i - 1] = arguments[i];

          listeners = listeners.slice();
          for (i = 0;
            (listener = listeners[i]); ++i) {
            apply.call(listener, this, args);
          }
        } else {
          switch (arguments.length) {
            case 1:
              call.call(listeners, this);
              break;
            case 2:
              call.call(listeners, this, arguments[1]);
              break;
            case 3:
              call.call(listeners, this, arguments[1], arguments[2]);
              break;
            default:
              l = arguments.length;
              args = new Array(l - 1);
              for (i = 1; i < l; ++i) {
                args[i - 1] = arguments[i];
              }
              apply.call(listeners, this, args);
          }
        }
      };

      methods = {
        on: on,
        once: once,
        off: off,
        emit: emit
      };

      descriptors = {
        on: d(on),
        once: d(once),
        off: d(off),
        emit: d(emit)
      };

      base = defineProperties({}, descriptors);

      module.exports = exports = function(o) {
        return (o == null) ? create(base) : defineProperties(Object(o), descriptors);
      };
      exports.methods = methods;

    }, {
      "d": 15,
      "es5-ext/object/valid-callable": 53
    }],
    78: [function(require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      var objectCreate = Object.create || objectCreatePolyfill
      var objectKeys = Object.keys || objectKeysPolyfill
      var bind = Function.prototype.bind || functionBindPolyfill

      function EventEmitter() {
        if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
          this._events = objectCreate(null);
          this._eventsCount = 0;
        }

        this._maxListeners = this._maxListeners || undefined;
      }
      module.exports = EventEmitter;

      // Backwards-compat with node 0.10.x
      EventEmitter.EventEmitter = EventEmitter;

      EventEmitter.prototype._events = undefined;
      EventEmitter.prototype._maxListeners = undefined;

      // By default EventEmitters will print a warning if more than 10 listeners are
      // added to it. This is a useful default which helps finding memory leaks.
      var defaultMaxListeners = 10;

      var hasDefineProperty;
      try {
        var o = {};
        if (Object.defineProperty) Object.defineProperty(o, 'x', {
          value: 0
        });
        hasDefineProperty = o.x === 0;
      } catch (err) {
        hasDefineProperty = false
      }
      if (hasDefineProperty) {
        Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
          enumerable: true,
          get: function() {
            return defaultMaxListeners;
          },
          set: function(arg) {
            // check whether the input is a positive number (whose value is zero or
            // greater and not a NaN).
            if (typeof arg !== 'number' || arg < 0 || arg !== arg)
              throw new TypeError('"defaultMaxListeners" must be a positive number');
            defaultMaxListeners = arg;
          }
        });
      } else {
        EventEmitter.defaultMaxListeners = defaultMaxListeners;
      }

      // Obviously not all Emitters should be limited to 10. This function allows
      // that to be increased. Set to zero for unlimited.
      EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
        if (typeof n !== 'number' || n < 0 || isNaN(n))
          throw new TypeError('"n" argument must be a positive number');
        this._maxListeners = n;
        return this;
      };

      function $getMaxListeners(that) {
        if (that._maxListeners === undefined)
          return EventEmitter.defaultMaxListeners;
        return that._maxListeners;
      }

      EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
        return $getMaxListeners(this);
      };

      // These standalone emit* functions are used to optimize calling of event
      // handlers for fast cases because emit() itself often has a variable number of
      // arguments and can be deoptimized because of that. These functions always have
      // the same number of arguments and thus do not get deoptimized, so the code
      // inside them can execute faster.
      function emitNone(handler, isFn, self) {
        if (isFn)
          handler.call(self);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].call(self);
        }
      }

      function emitOne(handler, isFn, self, arg1) {
        if (isFn)
          handler.call(self, arg1);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].call(self, arg1);
        }
      }

      function emitTwo(handler, isFn, self, arg1, arg2) {
        if (isFn)
          handler.call(self, arg1, arg2);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].call(self, arg1, arg2);
        }
      }

      function emitThree(handler, isFn, self, arg1, arg2, arg3) {
        if (isFn)
          handler.call(self, arg1, arg2, arg3);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].call(self, arg1, arg2, arg3);
        }
      }

      function emitMany(handler, isFn, self, args) {
        if (isFn)
          handler.apply(self, args);
        else {
          var len = handler.length;
          var listeners = arrayClone(handler, len);
          for (var i = 0; i < len; ++i)
            listeners[i].apply(self, args);
        }
      }

      EventEmitter.prototype.emit = function emit(type) {
        var er, handler, len, args, i, events;
        var doError = (type === 'error');

        events = this._events;
        if (events)
          doError = (doError && events.error == null);
        else if (!doError)
          return false;

        // If there is no 'error' event listener then throw.
        if (doError) {
          if (arguments.length > 1)
            er = arguments[1];
          if (er instanceof Error) {
            throw er; // Unhandled 'error' event
          } else {
            // At least give some kind of context to the user
            var err = new Error('Unhandled "error" event. (' + er + ')');
            err.context = er;
            throw err;
          }
          return false;
        }

        handler = events[type];

        if (!handler)
          return false;

        var isFn = typeof handler === 'function';
        len = arguments.length;
        switch (len) {
          // fast cases
          case 1:
            emitNone(handler, isFn, this);
            break;
          case 2:
            emitOne(handler, isFn, this, arguments[1]);
            break;
          case 3:
            emitTwo(handler, isFn, this, arguments[1], arguments[2]);
            break;
          case 4:
            emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
            break;
            // slower
          default:
            args = new Array(len - 1);
            for (i = 1; i < len; i++)
              args[i - 1] = arguments[i];
            emitMany(handler, isFn, this, args);
        }

        return true;
      };

      function _addListener(target, type, listener, prepend) {
        var m;
        var events;
        var existing;

        if (typeof listener !== 'function')
          throw new TypeError('"listener" argument must be a function');

        events = target._events;
        if (!events) {
          events = target._events = objectCreate(null);
          target._eventsCount = 0;
        } else {
          // To avoid recursion in the case that type === "newListener"! Before
          // adding it to the listeners, first emit "newListener".
          if (events.newListener) {
            target.emit('newListener', type,
              listener.listener ? listener.listener : listener);

            // Re-assign `events` because a newListener handler could have caused the
            // this._events to be assigned to a new object
            events = target._events;
          }
          existing = events[type];
        }

        if (!existing) {
          // Optimize the case of one listener. Don't need the extra array object.
          existing = events[type] = listener;
          ++target._eventsCount;
        } else {
          if (typeof existing === 'function') {
            // Adding the second element, need to change to array.
            existing = events[type] =
              prepend ? [listener, existing] : [existing, listener];
          } else {
            // If we've already got an array, just append.
            if (prepend) {
              existing.unshift(listener);
            } else {
              existing.push(listener);
            }
          }

          // Check for listener leak
          if (!existing.warned) {
            m = $getMaxListeners(target);
            if (m && m > 0 && existing.length > m) {
              existing.warned = true;
              var w = new Error('Possible EventEmitter memory leak detected. ' +
                existing.length + ' "' + String(type) + '" listeners ' +
                'added. Use emitter.setMaxListeners() to ' +
                'increase limit.');
              w.name = 'MaxListenersExceededWarning';
              w.emitter = target;
              w.type = type;
              w.count = existing.length;
              if (typeof console === 'object' && console.warn) {
                console.warn('%s: %s', w.name, w.message);
              }
            }
          }
        }

        return target;
      }

      EventEmitter.prototype.addListener = function addListener(type, listener) {
        return _addListener(this, type, listener, false);
      };

      EventEmitter.prototype.on = EventEmitter.prototype.addListener;

      EventEmitter.prototype.prependListener =
        function prependListener(type, listener) {
          return _addListener(this, type, listener, true);
        };

      function onceWrapper() {
        if (!this.fired) {
          this.target.removeListener(this.type, this.wrapFn);
          this.fired = true;
          switch (arguments.length) {
            case 0:
              return this.listener.call(this.target);
            case 1:
              return this.listener.call(this.target, arguments[0]);
            case 2:
              return this.listener.call(this.target, arguments[0], arguments[1]);
            case 3:
              return this.listener.call(this.target, arguments[0], arguments[1],
                arguments[2]);
            default:
              var args = new Array(arguments.length);
              for (var i = 0; i < args.length; ++i)
                args[i] = arguments[i];
              this.listener.apply(this.target, args);
          }
        }
      }

      function _onceWrap(target, type, listener) {
        var state = {
          fired: false,
          wrapFn: undefined,
          target: target,
          type: type,
          listener: listener
        };
        var wrapped = bind.call(onceWrapper, state);
        wrapped.listener = listener;
        state.wrapFn = wrapped;
        return wrapped;
      }

      EventEmitter.prototype.once = function once(type, listener) {
        if (typeof listener !== 'function')
          throw new TypeError('"listener" argument must be a function');
        this.on(type, _onceWrap(this, type, listener));
        return this;
      };

      EventEmitter.prototype.prependOnceListener =
        function prependOnceListener(type, listener) {
          if (typeof listener !== 'function')
            throw new TypeError('"listener" argument must be a function');
          this.prependListener(type, _onceWrap(this, type, listener));
          return this;
        };

      // Emits a 'removeListener' event if and only if the listener was removed.
      EventEmitter.prototype.removeListener =
        function removeListener(type, listener) {
          var list, events, position, i, originalListener;

          if (typeof listener !== 'function')
            throw new TypeError('"listener" argument must be a function');

          events = this._events;
          if (!events)
            return this;

          list = events[type];
          if (!list)
            return this;

          if (list === listener || list.listener === listener) {
            if (--this._eventsCount === 0)
              this._events = objectCreate(null);
            else {
              delete events[type];
              if (events.removeListener)
                this.emit('removeListener', type, list.listener || listener);
            }
          } else if (typeof list !== 'function') {
            position = -1;

            for (i = list.length - 1; i >= 0; i--) {
              if (list[i] === listener || list[i].listener === listener) {
                originalListener = list[i].listener;
                position = i;
                break;
              }
            }

            if (position < 0)
              return this;

            if (position === 0)
              list.shift();
            else
              spliceOne(list, position);

            if (list.length === 1)
              events[type] = list[0];

            if (events.removeListener)
              this.emit('removeListener', type, originalListener || listener);
          }

          return this;
        };

      EventEmitter.prototype.removeAllListeners =
        function removeAllListeners(type) {
          var listeners, events, i;

          events = this._events;
          if (!events)
            return this;

          // not listening for removeListener, no need to emit
          if (!events.removeListener) {
            if (arguments.length === 0) {
              this._events = objectCreate(null);
              this._eventsCount = 0;
            } else if (events[type]) {
              if (--this._eventsCount === 0)
                this._events = objectCreate(null);
              else
                delete events[type];
            }
            return this;
          }

          // emit removeListener for all listeners on all events
          if (arguments.length === 0) {
            var keys = objectKeys(events);
            var key;
            for (i = 0; i < keys.length; ++i) {
              key = keys[i];
              if (key === 'removeListener') continue;
              this.removeAllListeners(key);
            }
            this.removeAllListeners('removeListener');
            this._events = objectCreate(null);
            this._eventsCount = 0;
            return this;
          }

          listeners = events[type];

          if (typeof listeners === 'function') {
            this.removeListener(type, listeners);
          } else if (listeners) {
            // LIFO order
            for (i = listeners.length - 1; i >= 0; i--) {
              this.removeListener(type, listeners[i]);
            }
          }

          return this;
        };

      function _listeners(target, type, unwrap) {
        var events = target._events;

        if (!events)
          return [];

        var evlistener = events[type];
        if (!evlistener)
          return [];

        if (typeof evlistener === 'function')
          return unwrap ? [evlistener.listener || evlistener] : [evlistener];

        return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
      }

      EventEmitter.prototype.listeners = function listeners(type) {
        return _listeners(this, type, true);
      };

      EventEmitter.prototype.rawListeners = function rawListeners(type) {
        return _listeners(this, type, false);
      };

      EventEmitter.listenerCount = function(emitter, type) {
        if (typeof emitter.listenerCount === 'function') {
          return emitter.listenerCount(type);
        } else {
          return listenerCount.call(emitter, type);
        }
      };

      EventEmitter.prototype.listenerCount = listenerCount;

      function listenerCount(type) {
        var events = this._events;

        if (events) {
          var evlistener = events[type];

          if (typeof evlistener === 'function') {
            return 1;
          } else if (evlistener) {
            return evlistener.length;
          }
        }

        return 0;
      }

      EventEmitter.prototype.eventNames = function eventNames() {
        return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
      };

      // About 1.5x faster than the two-arg version of Array#splice().
      function spliceOne(list, index) {
        for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
          list[i] = list[k];
        list.pop();
      }

      function arrayClone(arr, n) {
        var copy = new Array(n);
        for (var i = 0; i < n; ++i)
          copy[i] = arr[i];
        return copy;
      }

      function unwrapListeners(arr) {
        var ret = new Array(arr.length);
        for (var i = 0; i < ret.length; ++i) {
          ret[i] = arr[i].listener || arr[i];
        }
        return ret;
      }

      function objectCreatePolyfill(proto) {
        var F = function() {};
        F.prototype = proto;
        return new F;
      }

      function objectKeysPolyfill(obj) {
        var keys = [];
        for (var k in obj)
          if (Object.prototype.hasOwnProperty.call(obj, k)) {
            keys.push(k);
          }
        return k;
      }

      function functionBindPolyfill(context) {
        var fn = this;
        return function() {
          return fn.apply(context, arguments);
        };
      }

    }, {}],
    79: [function(require, module, exports) {
      exports.read = function(buffer, offset, isLE, mLen, nBytes) {
        var e, m
        var eLen = (nBytes * 8) - mLen - 1
        var eMax = (1 << eLen) - 1
        var eBias = eMax >> 1
        var nBits = -7
        var i = isLE ? (nBytes - 1) : 0
        var d = isLE ? -1 : 1
        var s = buffer[offset + i]

        i += d

        e = s & ((1 << (-nBits)) - 1)
        s >>= (-nBits)
        nBits += eLen
        for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}

        m = e & ((1 << (-nBits)) - 1)
        e >>= (-nBits)
        nBits += mLen
        for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}

        if (e === 0) {
          e = 1 - eBias
        } else if (e === eMax) {
          return m ? NaN : ((s ? -1 : 1) * Infinity)
        } else {
          m = m + Math.pow(2, mLen)
          e = 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
        var eLen = (nBytes * 8) - mLen - 1
        var eMax = (1 << eLen) - 1
        var eBias = eMax >> 1
        var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
        var i = isLE ? 0 : (nBytes - 1)
        var d = isLE ? 1 : -1
        var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

        value = Math.abs(value)

        if (isNaN(value) || value === Infinity) {
          m = isNaN(value) ? 1 : 0
          e = eMax
        } else {
          e = Math.floor(Math.log(value) / Math.LN2)
          if (value * (c = Math.pow(2, -e)) < 1) {
            e--
            c *= 2
          }
          if (e + eBias >= 1) {
            value += rt / c
          } else {
            value += rt * Math.pow(2, 1 - eBias)
          }
          if (value * c >= 2) {
            e++
            c /= 2
          }

          if (e + eBias >= eMax) {
            m = 0
            e = eMax
          } else if (e + eBias >= 1) {
            m = ((value * c) - 1) * Math.pow(2, mLen)
            e = e + eBias
          } else {
            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
            e = 0
          }
        }

        for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

        e = (e << mLen) | m
        eLen += mLen
        for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

        buffer[offset + i - d] |= s * 128
      }

    }, {}],
    80: [function(require, module, exports) {
      if (typeof Object.create === 'function') {
        // implementation from standard node.js 'util' module
        module.exports = function inherits(ctor, superCtor) {
          ctor.super_ = superCtor
          ctor.prototype = Object.create(superCtor.prototype, {
            constructor: {
              value: ctor,
              enumerable: false,
              writable: true,
              configurable: true
            }
          });
        };
      } else {
        // old school shim for old browsers
        module.exports = function inherits(ctor, superCtor) {
          ctor.super_ = superCtor
          var TempCtor = function() {}
          TempCtor.prototype = superCtor.prototype
          ctor.prototype = new TempCtor()
          ctor.prototype.constructor = ctor
        }
      }

    }, {}],
    81: [function(require, module, exports) {
      /*!
       * Determine if an object is a Buffer
       *
       * @author   Feross Aboukhadijeh <https://feross.org>
       * @license  MIT
       */

      // The _isBuffer check is for Safari 5-7 support, because it's missing
      // Object.prototype.constructor. Remove this eventually
      module.exports = function(obj) {
        return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
      }

      function isBuffer(obj) {
        return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
      }

      // For Node v0.10 support. Remove this eventually.
      function isSlowBuffer(obj) {
        return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
      }

    }, {}],
    82: [function(require, module, exports) {
      var toString = {}.toString;

      module.exports = Array.isArray || function(arr) {
        return toString.call(arr) == '[object Array]';
      };

    }, {}],
    83: [function(require, module, exports) {
      'use strict'

      var Buffer = require('safe-buffer').Buffer

      /* Protocol - protocol constants */
      var protocol = module.exports

      /* Command code => mnemonic */
      protocol.types = {
        0: 'reserved',
        1: 'connect',
        2: 'connack',
        3: 'publish',
        4: 'puback',
        5: 'pubrec',
        6: 'pubrel',
        7: 'pubcomp',
        8: 'subscribe',
        9: 'suback',
        10: 'unsubscribe',
        11: 'unsuback',
        12: 'pingreq',
        13: 'pingresp',
        14: 'disconnect',
        15: 'reserved'
      }

      /* Mnemonic => Command code */
      protocol.codes = {}
      for (var k in protocol.types) {
        var v = protocol.types[k]
        protocol.codes[v] = k
      }

      /* Header */
      protocol.CMD_SHIFT = 4
      protocol.CMD_MASK = 0xF0
      protocol.DUP_MASK = 0x08
      protocol.QOS_MASK = 0x03
      protocol.QOS_SHIFT = 1
      protocol.RETAIN_MASK = 0x01

      /* Length */
      protocol.LENGTH_MASK = 0x7F
      protocol.LENGTH_FIN_MASK = 0x80

      /* Connack */
      protocol.SESSIONPRESENT_MASK = 0x01
      protocol.SESSIONPRESENT_HEADER = Buffer.from([protocol.SESSIONPRESENT_MASK])
      protocol.CONNACK_HEADER = Buffer.from([protocol.codes['connack'] << protocol.CMD_SHIFT])

      /* Connect */
      protocol.USERNAME_MASK = 0x80
      protocol.PASSWORD_MASK = 0x40
      protocol.WILL_RETAIN_MASK = 0x20
      protocol.WILL_QOS_MASK = 0x18
      protocol.WILL_QOS_SHIFT = 3
      protocol.WILL_FLAG_MASK = 0x04
      protocol.CLEAN_SESSION_MASK = 0x02
      protocol.CONNECT_HEADER = Buffer.from([protocol.codes['connect'] << protocol.CMD_SHIFT])

      function genHeader(type) {
        return [0, 1, 2].map(function(qos) {
          return [0, 1].map(function(dup) {
            return [0, 1].map(function(retain) {
              var buf = new Buffer(1)
              buf.writeUInt8(
                protocol.codes[type] << protocol.CMD_SHIFT |
                (dup ? protocol.DUP_MASK : 0) |
                qos << protocol.QOS_SHIFT | retain, 0, true)
              return buf
            })
          })
        })
      }

      /* Publish */
      protocol.PUBLISH_HEADER = genHeader('publish')

      /* Subscribe */
      protocol.SUBSCRIBE_HEADER = genHeader('subscribe')

      /* Unsubscribe */
      protocol.UNSUBSCRIBE_HEADER = genHeader('unsubscribe')

      /* Confirmations */
      protocol.ACKS = {
        unsuback: genHeader('unsuback'),
        puback: genHeader('puback'),
        pubcomp: genHeader('pubcomp'),
        pubrel: genHeader('pubrel'),
        pubrec: genHeader('pubrec')
      }

      protocol.SUBACK_HEADER = Buffer.from([protocol.codes['suback'] << protocol.CMD_SHIFT])

      /* Protocol versions */
      protocol.VERSION3 = Buffer.from([3])
      protocol.VERSION4 = Buffer.from([4])

      /* QoS */
      protocol.QOS = [0, 1, 2].map(function(qos) {
        return Buffer.from([qos])
      })

      /* Empty packets */
      protocol.EMPTY = {
        pingreq: Buffer.from([protocol.codes['pingreq'] << 4, 0]),
        pingresp: Buffer.from([protocol.codes['pingresp'] << 4, 0]),
        disconnect: Buffer.from([protocol.codes['disconnect'] << 4, 0])
      }

    }, {
      "safe-buffer": 108
    }],
    84: [function(require, module, exports) {
      'use strict'

      var Buffer = require('safe-buffer').Buffer
      var writeToStream = require('./writeToStream')
      var EE = require('events').EventEmitter
      var inherits = require('inherits')

      function generate(packet) {
        var stream = new Accumulator()
        writeToStream(packet, stream)
        return stream.concat()
      }

      function Accumulator() {
        this._array = new Array(20)
        this._i = 0
      }

      inherits(Accumulator, EE)

      Accumulator.prototype.write = function(chunk) {
        this._array[this._i++] = chunk
        return true
      }

      Accumulator.prototype.concat = function() {
        var length = 0
        var lengths = new Array(this._array.length)
        var list = this._array
        var pos = 0
        var i
        var result

        for (i = 0; i < list.length && list[i] !== undefined; i++) {
          if (typeof list[i] !== 'string') lengths[i] = list[i].length
          else lengths[i] = Buffer.byteLength(list[i])

          length += lengths[i]
        }

        result = Buffer.allocUnsafe(length)

        for (i = 0; i < list.length && list[i] !== undefined; i++) {
          if (typeof list[i] !== 'string') {
            list[i].copy(result, pos)
            pos += lengths[i]
          } else {
            result.write(list[i], pos)
            pos += lengths[i]
          }
        }

        return result
      }

      module.exports = generate

    }, {
      "./writeToStream": 89,
      "events": 78,
      "inherits": 80,
      "safe-buffer": 108
    }],
    85: [function(require, module, exports) {
      'use strict'

      exports.parser = require('./parser')
      exports.generate = require('./generate')
      exports.writeToStream = require('./writeToStream')

    }, {
      "./generate": 84,
      "./parser": 88,
      "./writeToStream": 89
    }],
    86: [function(require, module, exports) {
      'use strict'

      var Buffer = require('safe-buffer').Buffer
      var max = 65536
      var cache = {}

      function generateBuffer(i) {
        var buffer = Buffer.allocUnsafe(2)
        buffer.writeUInt8(i >> 8, 0)
        buffer.writeUInt8(i & 0x00FF, 0 + 1)

        return buffer
      }

      function generateCache() {
        for (var i = 0; i < max; i++) {
          cache[i] = generateBuffer(i)
        }
      }

      module.exports = {
        cache: cache,
        generateCache: generateCache,
        generateNumber: generateBuffer
      }

    }, {
      "safe-buffer": 108
    }],
    87: [function(require, module, exports) {

      function Packet() {
        this.cmd = null
        this.retain = false
        this.qos = 0
        this.dup = false
        this.length = -1
        this.topic = null
        this.payload = null
      }

      module.exports = Packet

    }, {}],
    88: [function(require, module, exports) {
      'use strict'

      var bl = require('bl')
      var inherits = require('inherits')
      var EE = require('events').EventEmitter
      var Packet = require('./packet')
      var constants = require('./constants')

      function Parser() {
        if (!(this instanceof Parser)) return new Parser()

        this._states = [
          '_parseHeader',
          '_parseLength',
          '_parsePayload',
          '_newPacket'
        ]

        this._resetState()
      }

      inherits(Parser, EE)

      Parser.prototype._resetState = function() {
        this.packet = new Packet()
        this.error = null
        this._list = bl()
        this._stateCounter = 0
      }

      Parser.prototype.parse = function(buf) {
        if (this.error) this._resetState()

        this._list.append(buf)

        while ((this.packet.length !== -1 || this._list.length > 0) &&
          this[this._states[this._stateCounter]]() &&
          !this.error) {
          this._stateCounter++

            if (this._stateCounter >= this._states.length) this._stateCounter = 0
        }

        return this._list.length
      }

      Parser.prototype._parseHeader = function() {
        // There is at least one byte in the buffer
        var zero = this._list.readUInt8(0)
        this.packet.cmd = constants.types[zero >> constants.CMD_SHIFT]
        this.packet.retain = (zero & constants.RETAIN_MASK) !== 0
        this.packet.qos = (zero >> constants.QOS_SHIFT) & constants.QOS_MASK
        this.packet.dup = (zero & constants.DUP_MASK) !== 0

        this._list.consume(1)

        return true
      }

      Parser.prototype._parseLength = function() {
        // There is at least one byte in the list
        var bytes = 0
        var mul = 1
        var length = 0
        var result = true
        var current

        while (bytes < 5) {
          current = this._list.readUInt8(bytes++)
          length += mul * (current & constants.LENGTH_MASK)
          mul *= 0x80

          if ((current & constants.LENGTH_FIN_MASK) === 0) break
          if (this._list.length <= bytes) {
            result = false
            break
          }
        }

        if (result) {
          this.packet.length = length
          this._list.consume(bytes)
        }

        return result
      }

      Parser.prototype._parsePayload = function() {
        var result = false

        // Do we have a payload? Do we have enough data to complete the payload?
        // PINGs have no payload
        if (this.packet.length === 0 || this._list.length >= this.packet.length) {
          this._pos = 0

          switch (this.packet.cmd) {
            case 'connect':
              this._parseConnect()
              break
            case 'connack':
              this._parseConnack()
              break
            case 'publish':
              this._parsePublish()
              break
            case 'puback':
            case 'pubrec':
            case 'pubrel':
            case 'pubcomp':
              this._parseMessageId()
              break
            case 'subscribe':
              this._parseSubscribe()
              break
            case 'suback':
              this._parseSuback()
              break
            case 'unsubscribe':
              this._parseUnsubscribe()
              break
            case 'unsuback':
              this._parseUnsuback()
              break
            case 'pingreq':
            case 'pingresp':
            case 'disconnect':
              // These are empty, nothing to do
              break
            default:
              this._emitError(new Error('Not supported'))
          }

          result = true
        }

        return result
      }

      Parser.prototype._parseConnect = function() {
        var protocolId // Protocol ID
        var clientId // Client ID
        var topic // Will topic
        var payload // Will payload
        var password // Password
        var username // Username
        var flags = {}
        var packet = this.packet

        // Parse protocolId
        protocolId = this._parseString()

        if (protocolId === null) return this._emitError(new Error('Cannot parse protocolId'))
        if (protocolId !== 'MQTT' && protocolId !== 'MQIsdp') {
          return this._emitError(new Error('Invalid protocolId'))
        }

        packet.protocolId = protocolId

        // Parse constants version number
        if (this._pos >= this._list.length) return this._emitError(new Error('Packet too short'))

        packet.protocolVersion = this._list.readUInt8(this._pos)

        if (packet.protocolVersion !== 3 && packet.protocolVersion !== 4) {
          return this._emitError(new Error('Invalid protocol version'))
        }

        this._pos++

          if (this._pos >= this._list.length) {
            return this._emitError(new Error('Packet too short'))
          }

        // Parse connect flags
        flags.username = (this._list.readUInt8(this._pos) & constants.USERNAME_MASK)
        flags.password = (this._list.readUInt8(this._pos) & constants.PASSWORD_MASK)
        flags.will = (this._list.readUInt8(this._pos) & constants.WILL_FLAG_MASK)

        if (flags.will) {
          packet.will = {}
          packet.will.retain = (this._list.readUInt8(this._pos) & constants.WILL_RETAIN_MASK) !== 0
          packet.will.qos = (this._list.readUInt8(this._pos) &
            constants.WILL_QOS_MASK) >> constants.WILL_QOS_SHIFT
        }

        packet.clean = (this._list.readUInt8(this._pos) & constants.CLEAN_SESSION_MASK) !== 0
        this._pos++

          // Parse keepalive
          packet.keepalive = this._parseNum()
        if (packet.keepalive === -1) return this._emitError(new Error('Packet too short'))

        // Parse clientId
        clientId = this._parseString()
        if (clientId === null) return this._emitError(new Error('Packet too short'))
        packet.clientId = clientId

        if (flags.will) {
          // Parse will topic
          topic = this._parseString()
          if (topic === null) return this._emitError(new Error('Cannot parse will topic'))
          packet.will.topic = topic

          // Parse will payload
          payload = this._parseBuffer()
          if (payload === null) return this._emitError(new Error('Cannot parse will payload'))
          packet.will.payload = payload
        }

        // Parse username
        if (flags.username) {
          username = this._parseString()
          if (username === null) return this._emitError(new Error('Cannot parse username'))
          packet.username = username
        }

        // Parse password
        if (flags.password) {
          password = this._parseBuffer()
          if (password === null) return this._emitError(new Error('Cannot parse password'))
          packet.password = password
        }

        return packet
      }

      Parser.prototype._parseConnack = function() {
        var packet = this.packet

        if (this._list.length < 2) return null

        packet.sessionPresent = !!(this._list.readUInt8(this._pos++) & constants.SESSIONPRESENT_MASK)
        packet.returnCode = this._list.readUInt8(this._pos)

        if (packet.returnCode === -1) return this._emitError(new Error('Cannot parse return code'))
      }

      Parser.prototype._parsePublish = function() {
        var packet = this.packet
        packet.topic = this._parseString()

        if (packet.topic === null) return this._emitError(new Error('Cannot parse topic'))

        // Parse messageId
        if (packet.qos > 0)
          if (!this._parseMessageId()) {
            return
          }

        packet.payload = this._list.slice(this._pos, packet.length)
      }

      Parser.prototype._parseSubscribe = function() {
        var packet = this.packet
        var topic
        var qos

        if (packet.qos !== 1) {
          return this._emitError(new Error('Wrong subscribe header'))
        }

        packet.subscriptions = []

        if (!this._parseMessageId()) {
          return
        }

        while (this._pos < packet.length) {
          // Parse topic
          topic = this._parseString()
          if (topic === null) return this._emitError(new Error('Cannot parse topic'))

          qos = this._list.readUInt8(this._pos++)

          // Push pair to subscriptions
          packet.subscriptions.push({
            topic: topic,
            qos: qos
          })
        }
      }

      Parser.prototype._parseSuback = function() {
        this.packet.granted = []

        if (!this._parseMessageId()) {
          return
        }

        // Parse granted QoSes
        while (this._pos < this.packet.length) {
          this.packet.granted.push(this._list.readUInt8(this._pos++))
        }
      }

      Parser.prototype._parseUnsubscribe = function() {
        var packet = this.packet

        packet.unsubscriptions = []

        // Parse messageId
        if (!this._parseMessageId()) {
          return
        }

        while (this._pos < packet.length) {
          var topic

          // Parse topic
          topic = this._parseString()
          if (topic === null) return this._emitError(new Error('Cannot parse topic'))

          // Push topic to unsubscriptions
          packet.unsubscriptions.push(topic)
        }
      }

      Parser.prototype._parseUnsuback = function() {
        if (!this._parseMessageId()) return this._emitError(new Error('Cannot parse messageId'))
      }

      Parser.prototype._parseMessageId = function() {
        var packet = this.packet

        packet.messageId = this._parseNum()

        if (packet.messageId === null) {
          this._emitError(new Error('Cannot parse messageId'))
          return false
        }

        return true
      }

      Parser.prototype._parseString = function(maybeBuffer) {
        var length = this._parseNum()
        var result
        var end = length + this._pos

        if (length === -1 || end > this._list.length || end > this.packet.length) return null

        result = this._list.toString('utf8', this._pos, end)
        this._pos += length

        return result
      }

      Parser.prototype._parseBuffer = function() {
        var length = this._parseNum()
        var result
        var end = length + this._pos

        if (length === -1 || end > this._list.length || end > this.packet.length) return null

        result = this._list.slice(this._pos, end)

        this._pos += length

        return result
      }

      Parser.prototype._parseNum = function() {
        if (this._list.length - this._pos < 2) return -1

        var result = this._list.readUInt16BE(this._pos)
        this._pos += 2

        return result
      }

      Parser.prototype._newPacket = function() {
        if (this.packet) {
          this._list.consume(this.packet.length)
          this.emit('packet', this.packet)
        }

        this.packet = new Packet()

        return true
      }

      Parser.prototype._emitError = function(err) {
        this.error = err
        this.emit('error', err)
      }

      module.exports = Parser

    }, {
      "./constants": 83,
      "./packet": 87,
      "bl": 10,
      "events": 78,
      "inherits": 80
    }],
    89: [function(require, module, exports) {
      'use strict'

      var protocol = require('./constants')
      var Buffer = require('safe-buffer').Buffer
      var empty = Buffer.allocUnsafe(0)
      var zeroBuf = Buffer.from([0])
      var numbers = require('./numbers')
      var nextTick = require('process-nextick-args').nextTick

      var numCache = numbers.cache
      var generateNumber = numbers.generateNumber
      var generateCache = numbers.generateCache
      var writeNumber = writeNumberCached
      var toGenerate = true

      function generate(packet, stream) {
        if (stream.cork) {
          stream.cork()
          nextTick(uncork, stream)
        }

        if (toGenerate) {
          toGenerate = false
          generateCache()
        }

        switch (packet.cmd) {
          case 'connect':
            return connect(packet, stream)
          case 'connack':
            return connack(packet, stream)
          case 'publish':
            return publish(packet, stream)
          case 'puback':
          case 'pubrec':
          case 'pubrel':
          case 'pubcomp':
          case 'unsuback':
            return confirmation(packet, stream)
          case 'subscribe':
            return subscribe(packet, stream)
          case 'suback':
            return suback(packet, stream)
          case 'unsubscribe':
            return unsubscribe(packet, stream)
          case 'pingreq':
          case 'pingresp':
          case 'disconnect':
            return emptyPacket(packet, stream)
          default:
            stream.emit('error', new Error('Unknown command'))
            return false
        }
      }
      /**
       * Controls numbers cache.
       * Set to "false" to allocate buffers on-the-flight instead of pre-generated cache
       */
      Object.defineProperty(generate, 'cacheNumbers', {
        get: function() {
          return writeNumber === writeNumberCached
        },
        set: function(value) {
          if (value) {
            if (!numCache || Object.keys(numCache).length === 0) toGenerate = true
            writeNumber = writeNumberCached
          } else {
            toGenerate = false
            writeNumber = writeNumberGenerated
          }
        }
      })

      function uncork(stream) {
        stream.uncork()
      }

      function connect(opts, stream) {
        var settings = opts || {}
        var protocolId = settings.protocolId || 'MQTT'
        var protocolVersion = settings.protocolVersion || 4
        var will = settings.will
        var clean = settings.clean
        var keepalive = settings.keepalive || 0
        var clientId = settings.clientId || ''
        var username = settings.username
        var password = settings.password

        if (clean === undefined) clean = true

        var length = 0

        // Must be a string and non-falsy
        if (!protocolId ||
          (typeof protocolId !== 'string' && !Buffer.isBuffer(protocolId))) {
          stream.emit('error', new Error('Invalid protocolId'))
          return false
        } else length += protocolId.length + 2

        // Must be 3 or 4
        if (protocolVersion !== 3 && protocolVersion !== 4) {
          stream.emit('error', new Error('Invalid protocol version'))
          return false
        } else length += 1

        // ClientId might be omitted in 3.1.1, but only if cleanSession is set to 1
        if ((typeof clientId === 'string' || Buffer.isBuffer(clientId)) &&
          (clientId || protocolVersion === 4) && (clientId || clean)) {
          length += clientId.length + 2
        } else {
          if (protocolVersion < 4) {
            stream.emit('error', new Error('clientId must be supplied before 3.1.1'))
            return false
          }
          if ((clean * 1) === 0) {
            stream.emit('error', new Error('clientId must be given if cleanSession set to 0'))
            return false
          }
        }

        // Must be a two byte number
        if (typeof keepalive !== 'number' ||
          keepalive < 0 ||
          keepalive > 65535 ||
          keepalive % 1 !== 0) {
          stream.emit('error', new Error('Invalid keepalive'))
          return false
        } else length += 2

        // Connect flags
        length += 1

        // If will exists...
        if (will) {
          // It must be an object
          if (typeof will !== 'object') {
            stream.emit('error', new Error('Invalid will'))
            return false
          }
          // It must have topic typeof string
          if (!will.topic || typeof will.topic !== 'string') {
            stream.emit('error', new Error('Invalid will topic'))
            return false
          } else {
            length += Buffer.byteLength(will.topic) + 2
          }

          // Payload
          if (will.payload && will.payload) {
            if (will.payload.length >= 0) {
              if (typeof will.payload === 'string') {
                length += Buffer.byteLength(will.payload) + 2
              } else {
                length += will.payload.length + 2
              }
            } else {
              stream.emit('error', new Error('Invalid will payload'))
              return false
            }
          } else {
            length += 2
          }
        }

        // Username
        var providedUsername = false
        if (username != null) {
          if (isStringOrBuffer(username)) {
            providedUsername = true
            length += Buffer.byteLength(username) + 2
          } else {
            stream.emit('error', new Error('Invalid username'))
            return false
          }
        }

        // Password
        if (password != null) {
          if (!providedUsername) {
            stream.emit('error', new Error('Username is required to use password'))
            return false
          }

          if (isStringOrBuffer(password)) {
            length += byteLength(password) + 2
          } else {
            stream.emit('error', new Error('Invalid password'))
            return false
          }
        }

        // Generate header
        stream.write(protocol.CONNECT_HEADER)

        // Generate length
        writeLength(stream, length)

        // Generate protocol ID
        writeStringOrBuffer(stream, protocolId)
        stream.write(
          protocolVersion === 4 ? protocol.VERSION4 : protocol.VERSION3
        )

        // Connect flags
        var flags = 0
        flags |= (username != null) ? protocol.USERNAME_MASK : 0
        flags |= (password != null) ? protocol.PASSWORD_MASK : 0
        flags |= (will && will.retain) ? protocol.WILL_RETAIN_MASK : 0
        flags |= (will && will.qos) ? will.qos << protocol.WILL_QOS_SHIFT : 0
        flags |= will ? protocol.WILL_FLAG_MASK : 0
        flags |= clean ? protocol.CLEAN_SESSION_MASK : 0

        stream.write(Buffer.from([flags]))

        // Keepalive
        writeNumber(stream, keepalive)

        // Client ID
        writeStringOrBuffer(stream, clientId)

        // Will
        if (will) {
          writeString(stream, will.topic)
          writeStringOrBuffer(stream, will.payload)
        }

        // Username and password
        if (username != null) {
          writeStringOrBuffer(stream, username)
        }
        if (password != null) {
          writeStringOrBuffer(stream, password)
        }
        // This is a small packet that happens only once on a stream
        // We assume the stream is always free to receive more data after this
        return true
      }

      function connack(opts, stream) {
        var settings = opts || {}
        var rc = settings.returnCode

        // Check return code
        if (typeof rc !== 'number') {
          stream.emit('error', new Error('Invalid return code'))
          return false
        }

        stream.write(protocol.CONNACK_HEADER)
        writeLength(stream, 2)
        stream.write(opts.sessionPresent ? protocol.SESSIONPRESENT_HEADER : zeroBuf)

        return stream.write(Buffer.from([rc]))
      }

      function publish(opts, stream) {
        var settings = opts || {}
        var qos = settings.qos || 0
        var retain = settings.retain ? protocol.RETAIN_MASK : 0
        var topic = settings.topic
        var payload = settings.payload || empty
        var id = settings.messageId

        var length = 0

        // Topic must be a non-empty string or Buffer
        if (typeof topic === 'string') length += Buffer.byteLength(topic) + 2
        else if (Buffer.isBuffer(topic)) length += topic.length + 2
        else {
          stream.emit('error', new Error('Invalid topic'))
          return false
        }

        // Get the payload length
        if (!Buffer.isBuffer(payload)) length += Buffer.byteLength(payload)
        else length += payload.length

        // Message ID must a number if qos > 0
        if (qos && typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        } else if (qos) length += 2

        // Header
        stream.write(protocol.PUBLISH_HEADER[qos][opts.dup ? 1 : 0][retain ? 1 : 0])

        // Remaining length
        writeLength(stream, length)

        // Topic
        writeNumber(stream, byteLength(topic))
        stream.write(topic)

        // Message ID
        if (qos > 0) writeNumber(stream, id)

        // Payload
        return stream.write(payload)
      }

      /* Puback, pubrec, pubrel and pubcomp */
      function confirmation(opts, stream) {
        var settings = opts || {}
        var type = settings.cmd || 'puback'
        var id = settings.messageId
        var dup = (settings.dup && type === 'pubrel') ? protocol.DUP_MASK : 0
        var qos = 0

        if (type === 'pubrel') qos = 1

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        }

        // Header
        stream.write(protocol.ACKS[type][qos][dup][0])

        // Length
        writeLength(stream, 2)

        // Message ID
        return writeNumber(stream, id)
      }

      function subscribe(opts, stream) {
        var settings = opts || {}
        var dup = settings.dup ? protocol.DUP_MASK : 0
        var id = settings.messageId
        var subs = settings.subscriptions

        var length = 0

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        } else length += 2

        // Check subscriptions
        if (typeof subs === 'object' && subs.length) {
          for (var i = 0; i < subs.length; i += 1) {
            var itopic = subs[i].topic
            var iqos = subs[i].qos

            if (typeof itopic !== 'string') {
              stream.emit('error', new Error('Invalid subscriptions - invalid topic'))
              return false
            }
            if (typeof iqos !== 'number') {
              stream.emit('error', new Error('Invalid subscriptions - invalid qos'))
              return false
            }

            length += Buffer.byteLength(itopic) + 2 + 1
          }
        } else {
          stream.emit('error', new Error('Invalid subscriptions'))
          return false
        }

        // Generate header
        stream.write(protocol.SUBSCRIBE_HEADER[1][dup ? 1 : 0][0])

        // Generate length
        writeLength(stream, length)

        // Generate message ID
        writeNumber(stream, id)

        var result = true

        // Generate subs
        for (var j = 0; j < subs.length; j++) {
          var sub = subs[j]
          var jtopic = sub.topic
          var jqos = sub.qos

          // Write topic string
          writeString(stream, jtopic)

          // Write qos
          result = stream.write(protocol.QOS[jqos])
        }

        return result
      }

      function suback(opts, stream) {
        var settings = opts || {}
        var id = settings.messageId
        var granted = settings.granted

        var length = 0

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        } else length += 2

        // Check granted qos vector
        if (typeof granted === 'object' && granted.length) {
          for (var i = 0; i < granted.length; i += 1) {
            if (typeof granted[i] !== 'number') {
              stream.emit('error', new Error('Invalid qos vector'))
              return false
            }
            length += 1
          }
        } else {
          stream.emit('error', new Error('Invalid qos vector'))
          return false
        }

        // header
        stream.write(protocol.SUBACK_HEADER)

        // Length
        writeLength(stream, length)

        // Message ID
        writeNumber(stream, id)

        return stream.write(Buffer.from(granted))
      }

      function unsubscribe(opts, stream) {
        var settings = opts || {}
        var id = settings.messageId
        var dup = settings.dup ? protocol.DUP_MASK : 0
        var unsubs = settings.unsubscriptions

        var length = 0

        // Check message ID
        if (typeof id !== 'number') {
          stream.emit('error', new Error('Invalid messageId'))
          return false
        } else {
          length += 2
        }
        // Check unsubs
        if (typeof unsubs === 'object' && unsubs.length) {
          for (var i = 0; i < unsubs.length; i += 1) {
            if (typeof unsubs[i] !== 'string') {
              stream.emit('error', new Error('Invalid unsubscriptions'))
              return false
            }
            length += Buffer.byteLength(unsubs[i]) + 2
          }
        } else {
          stream.emit('error', new Error('Invalid unsubscriptions'))
          return false
        }

        // Header
        stream.write(protocol.UNSUBSCRIBE_HEADER[1][dup ? 1 : 0][0])

        // Length
        writeLength(stream, length)

        // Message ID
        writeNumber(stream, id)

        // Unsubs
        var result = true
        for (var j = 0; j < unsubs.length; j++) {
          result = writeString(stream, unsubs[j])
        }

        return result
      }

      function emptyPacket(opts, stream) {
        return stream.write(protocol.EMPTY[opts.cmd])
      }

      /**
       * calcLengthLength - calculate the length of the remaining
       * length field
       *
       * @api private
       */
      function calcLengthLength(length) {
        if (length >= 0 && length < 128) return 1
        else if (length >= 128 && length < 16384) return 2
        else if (length >= 16384 && length < 2097152) return 3
        else if (length >= 2097152 && length < 268435456) return 4
        else return 0
      }

      function genBufLength(length) {
        var digit = 0
        var pos = 0
        var buffer = Buffer.allocUnsafe(calcLengthLength(length))

        do {
          digit = length % 128 | 0
          length = length / 128 | 0
          if (length > 0) digit = digit | 0x80

          buffer.writeUInt8(digit, pos++)
        } while (length > 0)

        return buffer
      }

      /**
       * writeLength - write an MQTT style length field to the buffer
       *
       * @param <Buffer> buffer - destination
       * @param <Number> pos - offset
       * @param <Number> length - length (>0)
       * @returns <Number> number of bytes written
       *
       * @api private
       */

      var lengthCache = {}

      function writeLength(stream, length) {
        var buffer = lengthCache[length]

        if (!buffer) {
          buffer = genBufLength(length)
          if (length < 16384) lengthCache[length] = buffer
        }

        stream.write(buffer)
      }

      /**
       * writeString - write a utf8 string to the buffer
       *
       * @param <Buffer> buffer - destination
       * @param <Number> pos - offset
       * @param <String> string - string to write
       * @return <Number> number of bytes written
       *
       * @api private
       */

      function writeString(stream, string) {
        var strlen = Buffer.byteLength(string)
        writeNumber(stream, strlen)

        stream.write(string, 'utf8')
      }

      /**
       * writeNumber - write a two byte number to the buffer
       *
       * @param <Buffer> buffer - destination
       * @param <Number> pos - offset
       * @param <String> number - number to write
       * @return <Number> number of bytes written
       *
       * @api private
       */
      function writeNumberCached(stream, number) {
        return stream.write(numCache[number])
      }

      function writeNumberGenerated(stream, number) {
        return stream.write(generateNumber(number))
      }

      /**
       * writeStringOrBuffer - write a String or Buffer with the its length prefix
       *
       * @param <Buffer> buffer - destination
       * @param <Number> pos - offset
       * @param <String> toWrite - String or Buffer
       * @return <Number> number of bytes written
       */
      function writeStringOrBuffer(stream, toWrite) {
        if (typeof toWrite === 'string') {
          writeString(stream, toWrite)
        } else if (toWrite) {
          writeNumber(stream, toWrite.length)
          stream.write(toWrite)
        } else writeNumber(stream, 0)
      }

      function byteLength(bufOrString) {
        if (!bufOrString) return 0
        else if (bufOrString instanceof Buffer) return bufOrString.length
        else return Buffer.byteLength(bufOrString)
      }

      function isStringOrBuffer(field) {
        return typeof field === 'string' || field instanceof Buffer
      }

      module.exports = generate

    }, {
      "./constants": 83,
      "./numbers": 86,
      "process-nextick-args": 91,
      "safe-buffer": 108
    }],
    90: [function(require, module, exports) {
      var wrappy = require('wrappy')
      module.exports = wrappy(once)
      module.exports.strict = wrappy(onceStrict)

      once.proto = once(function() {
        Object.defineProperty(Function.prototype, 'once', {
          value: function() {
            return once(this)
          },
          configurable: true
        })

        Object.defineProperty(Function.prototype, 'onceStrict', {
          value: function() {
            return onceStrict(this)
          },
          configurable: true
        })
      })

      function once(fn) {
        var f = function() {
          if (f.called) return f.value
          f.called = true
          return f.value = fn.apply(this, arguments)
        }
        f.called = false
        return f
      }

      function onceStrict(fn) {
        var f = function() {
          if (f.called)
            throw new Error(f.onceError)
          f.called = true
          return f.value = fn.apply(this, arguments)
        }
        var name = fn.name || 'Function wrapped with `once`'
        f.onceError = name + " shouldn't be called more than once"
        f.called = false
        return f
      }

    }, {
      "wrappy": 119
    }],
    91: [function(require, module, exports) {
      (function(process) {
        'use strict';

        if (!process.version ||
          process.version.indexOf('v0.') === 0 ||
          process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
          module.exports = {
            nextTick: nextTick
          };
        } else {
          module.exports = process
        }

        function nextTick(fn, arg1, arg2, arg3) {
          if (typeof fn !== 'function') {
            throw new TypeError('"callback" argument must be a function');
          }
          var len = arguments.length;
          var args, i;
          switch (len) {
            case 0:
            case 1:
              return process.nextTick(fn);
            case 2:
              return process.nextTick(function afterTickOne() {
                fn.call(null, arg1);
              });
            case 3:
              return process.nextTick(function afterTickTwo() {
                fn.call(null, arg1, arg2);
              });
            case 4:
              return process.nextTick(function afterTickThree() {
                fn.call(null, arg1, arg2, arg3);
              });
            default:
              args = new Array(len - 1);
              i = 0;
              while (i < args.length) {
                args[i++] = arguments[i];
              }
              return process.nextTick(function afterTick() {
                fn.apply(null, args);
              });
          }
        }


      }).call(this, require('_process'))
    }, {
      "_process": 92
    }],
    92: [function(require, module, exports) {
      // shim for using process in browser
      var process = module.exports = {};

      // cached from whatever global is present so that test runners that stub it
      // don't break things.  But we need to wrap it in a try catch in case it is
      // wrapped in strict mode code which doesn't define any globals.  It's inside a
      // function because try/catches deoptimize in certain engines.

      var cachedSetTimeout;
      var cachedClearTimeout;

      function defaultSetTimout() {
        throw new Error('setTimeout has not been defined');
      }

      function defaultClearTimeout() {
        throw new Error('clearTimeout has not been defined');
      }
      (function() {
        try {
          if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
          } else {
            cachedSetTimeout = defaultSetTimout;
          }
        } catch (e) {
          cachedSetTimeout = defaultSetTimout;
        }
        try {
          if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
          } else {
            cachedClearTimeout = defaultClearTimeout;
          }
        } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
        }
      }())

      function runTimeout(fun) {
        if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
        }
        // if setTimeout wasn't available but was latter defined
        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
        }
        try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
        } catch (e) {
          try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
          } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
          }
        }


      }

      function runClearTimeout(marker) {
        if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
        }
        // if clearTimeout wasn't available but was latter defined
        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
        }
        try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
        } catch (e) {
          try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
          } catch (e) {
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
          }
        }



      }
      var queue = [];
      var draining = false;
      var currentQueue;
      var queueIndex = -1;

      function cleanUpNextTick() {
        if (!draining || !currentQueue) {
          return;
        }
        draining = false;
        if (currentQueue.length) {
          queue = currentQueue.concat(queue);
        } else {
          queueIndex = -1;
        }
        if (queue.length) {
          drainQueue();
        }
      }

      function drainQueue() {
        if (draining) {
          return;
        }
        var timeout = runTimeout(cleanUpNextTick);
        draining = true;

        var len = queue.length;
        while (len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
            if (currentQueue) {
              currentQueue[queueIndex].run();
            }
          }
          queueIndex = -1;
          len = queue.length;
        }
        currentQueue = null;
        draining = false;
        runClearTimeout(timeout);
      }

      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));
        if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
        }
      };

      // v8 likes predictible objects
      function Item(fun, array) {
        this.fun = fun;
        this.array = array;
      }
      Item.prototype.run = function() {
        this.fun.apply(null, this.array);
      };
      process.title = 'browser';
      process.browser = true;
      process.env = {};
      process.argv = [];
      process.version = ''; // empty string to avoid regexp issues
      process.versions = {};

      function noop() {}

      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;
      };

    }, {}],
    93: [function(require, module, exports) {
      (function(global) {
        /*! https://mths.be/punycode v1.4.1 by @mathias */
        ;
        (function(root) {

          /** Detect free variables */
          var freeExports = typeof exports == 'object' && exports &&
            !exports.nodeType && exports;
          var freeModule = typeof module == 'object' && module &&
            !module.nodeType && module;
          var freeGlobal = typeof global == 'object' && global;
          if (
            freeGlobal.global === freeGlobal ||
            freeGlobal.window === freeGlobal ||
            freeGlobal.self === freeGlobal
          ) {
            root = freeGlobal;
          }

          /**
           * The `punycode` object.
           * @name punycode
           * @type Object
           */
          var punycode,

            /** Highest positive signed 32-bit float value */
            maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1

            /** Bootstring parameters */
            base = 36,
            tMin = 1,
            tMax = 26,
            skew = 38,
            damp = 700,
            initialBias = 72,
            initialN = 128, // 0x80
            delimiter = '-', // '\x2D'

            /** Regular expressions */
            regexPunycode = /^xn--/,
            regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
            regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators

            /** Error messages */
            errors = {
              'overflow': 'Overflow: input needs wider integers to process',
              'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
              'invalid-input': 'Invalid input'
            },

            /** Convenience shortcuts */
            baseMinusTMin = base - tMin,
            floor = Math.floor,
            stringFromCharCode = String.fromCharCode,

            /** Temporary variable */
            key;

          /*--------------------------------------------------------------------------*/

          /**
           * A generic error utility function.
           * @private
           * @param {String} type The error type.
           * @returns {Error} Throws a `RangeError` with the applicable error message.
           */
          function error(type) {
            throw new RangeError(errors[type]);
          }

          /**
           * A generic `Array#map` utility function.
           * @private
           * @param {Array} array The array to iterate over.
           * @param {Function} callback The function that gets called for every array
           * item.
           * @returns {Array} A new array of values returned by the callback function.
           */
          function map(array, fn) {
            var length = array.length;
            var result = [];
            while (length--) {
              result[length] = fn(array[length]);
            }
            return result;
          }

          /**
           * A simple `Array#map`-like wrapper to work with domain name strings or email
           * addresses.
           * @private
           * @param {String} domain The domain name or email address.
           * @param {Function} callback The function that gets called for every
           * character.
           * @returns {Array} A new string of characters returned by the callback
           * function.
           */
          function mapDomain(string, fn) {
            var parts = string.split('@');
            var result = '';
            if (parts.length > 1) {
              // In email addresses, only the domain name should be punycoded. Leave
              // the local part (i.e. everything up to `@`) intact.
              result = parts[0] + '@';
              string = parts[1];
            }
            // Avoid `split(regex)` for IE8 compatibility. See #17.
            string = string.replace(regexSeparators, '\x2E');
            var labels = string.split('.');
            var encoded = map(labels, fn).join('.');
            return result + encoded;
          }

          /**
           * Creates an array containing the numeric code points of each Unicode
           * character in the string. While JavaScript uses UCS-2 internally,
           * this function will convert a pair of surrogate halves (each of which
           * UCS-2 exposes as separate characters) into a single code point,
           * matching UTF-16.
           * @see `punycode.ucs2.encode`
           * @see <https://mathiasbynens.be/notes/javascript-encoding>
           * @memberOf punycode.ucs2
           * @name decode
           * @param {String} string The Unicode input string (UCS-2).
           * @returns {Array} The new array of code points.
           */
          function ucs2decode(string) {
            var output = [],
              counter = 0,
              length = string.length,
              value,
              extra;
            while (counter < length) {
              value = string.charCodeAt(counter++);
              if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
                // high surrogate, and there is a next character
                extra = string.charCodeAt(counter++);
                if ((extra & 0xFC00) == 0xDC00) { // low surrogate
                  output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
                } else {
                  // unmatched surrogate; only append this code unit, in case the next
                  // code unit is the high surrogate of a surrogate pair
                  output.push(value);
                  counter--;
                }
              } else {
                output.push(value);
              }
            }
            return output;
          }

          /**
           * Creates a string based on an array of numeric code points.
           * @see `punycode.ucs2.decode`
           * @memberOf punycode.ucs2
           * @name encode
           * @param {Array} codePoints The array of numeric code points.
           * @returns {String} The new Unicode string (UCS-2).
           */
          function ucs2encode(array) {
            return map(array, function(value) {
              var output = '';
              if (value > 0xFFFF) {
                value -= 0x10000;
                output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
                value = 0xDC00 | value & 0x3FF;
              }
              output += stringFromCharCode(value);
              return output;
            }).join('');
          }

          /**
           * Converts a basic code point into a digit/integer.
           * @see `digitToBasic()`
           * @private
           * @param {Number} codePoint The basic numeric code point value.
           * @returns {Number} The numeric value of a basic code point (for use in
           * representing integers) in the range `0` to `base - 1`, or `base` if
           * the code point does not represent a value.
           */
          function basicToDigit(codePoint) {
            if (codePoint - 48 < 10) {
              return codePoint - 22;
            }
            if (codePoint - 65 < 26) {
              return codePoint - 65;
            }
            if (codePoint - 97 < 26) {
              return codePoint - 97;
            }
            return base;
          }

          /**
           * Converts a digit/integer into a basic code point.
           * @see `basicToDigit()`
           * @private
           * @param {Number} digit The numeric value of a basic code point.
           * @returns {Number} The basic code point whose value (when used for
           * representing integers) is `digit`, which needs to be in the range
           * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
           * used; else, the lowercase form is used. The behavior is undefined
           * if `flag` is non-zero and `digit` has no uppercase form.
           */
          function digitToBasic(digit, flag) {
            //  0..25 map to ASCII a..z or A..Z
            // 26..35 map to ASCII 0..9
            return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
          }

          /**
           * Bias adaptation function as per section 3.4 of RFC 3492.
           * https://tools.ietf.org/html/rfc3492#section-3.4
           * @private
           */
          function adapt(delta, numPoints, firstTime) {
            var k = 0;
            delta = firstTime ? floor(delta / damp) : delta >> 1;
            delta += floor(delta / numPoints);
            for ( /* no initialization */ ; delta > baseMinusTMin * tMax >> 1; k += base) {
              delta = floor(delta / baseMinusTMin);
            }
            return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
          }

          /**
           * Converts a Punycode string of ASCII-only symbols to a string of Unicode
           * symbols.
           * @memberOf punycode
           * @param {String} input The Punycode string of ASCII-only symbols.
           * @returns {String} The resulting string of Unicode symbols.
           */
          function decode(input) {
            // Don't use UCS-2
            var output = [],
              inputLength = input.length,
              out,
              i = 0,
              n = initialN,
              bias = initialBias,
              basic,
              j,
              index,
              oldi,
              w,
              k,
              digit,
              t,
              /** Cached calculation results */
              baseMinusT;

            // Handle the basic code points: let `basic` be the number of input code
            // points before the last delimiter, or `0` if there is none, then copy
            // the first basic code points to the output.

            basic = input.lastIndexOf(delimiter);
            if (basic < 0) {
              basic = 0;
            }

            for (j = 0; j < basic; ++j) {
              // if it's not a basic code point
              if (input.charCodeAt(j) >= 0x80) {
                error('not-basic');
              }
              output.push(input.charCodeAt(j));
            }

            // Main decoding loop: start just after the last delimiter if any basic code
            // points were copied; start at the beginning otherwise.

            for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */ ) {

              // `index` is the index of the next character to be consumed.
              // Decode a generalized variable-length integer into `delta`,
              // which gets added to `i`. The overflow checking is easier
              // if we increase `i` as we go, then subtract off its starting
              // value at the end to obtain `delta`.
              for (oldi = i, w = 1, k = base; /* no condition */ ; k += base) {

                if (index >= inputLength) {
                  error('invalid-input');
                }

                digit = basicToDigit(input.charCodeAt(index++));

                if (digit >= base || digit > floor((maxInt - i) / w)) {
                  error('overflow');
                }

                i += digit * w;
                t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

                if (digit < t) {
                  break;
                }

                baseMinusT = base - t;
                if (w > floor(maxInt / baseMinusT)) {
                  error('overflow');
                }

                w *= baseMinusT;

              }

              out = output.length + 1;
              bias = adapt(i - oldi, out, oldi == 0);

              // `i` was supposed to wrap around from `out` to `0`,
              // incrementing `n` each time, so we'll fix that now:
              if (floor(i / out) > maxInt - n) {
                error('overflow');
              }

              n += floor(i / out);
              i %= out;

              // Insert `n` at position `i` of the output
              output.splice(i++, 0, n);

            }

            return ucs2encode(output);
          }

          /**
           * Converts a string of Unicode symbols (e.g. a domain name label) to a
           * Punycode string of ASCII-only symbols.
           * @memberOf punycode
           * @param {String} input The string of Unicode symbols.
           * @returns {String} The resulting Punycode string of ASCII-only symbols.
           */
          function encode(input) {
            var n,
              delta,
              handledCPCount,
              basicLength,
              bias,
              j,
              m,
              q,
              k,
              t,
              currentValue,
              output = [],
              /** `inputLength` will hold the number of code points in `input`. */
              inputLength,
              /** Cached calculation results */
              handledCPCountPlusOne,
              baseMinusT,
              qMinusT;

            // Convert the input in UCS-2 to Unicode
            input = ucs2decode(input);

            // Cache the length
            inputLength = input.length;

            // Initialize the state
            n = initialN;
            delta = 0;
            bias = initialBias;

            // Handle the basic code points
            for (j = 0; j < inputLength; ++j) {
              currentValue = input[j];
              if (currentValue < 0x80) {
                output.push(stringFromCharCode(currentValue));
              }
            }

            handledCPCount = basicLength = output.length;

            // `handledCPCount` is the number of code points that have been handled;
            // `basicLength` is the number of basic code points.

            // Finish the basic string - if it is not empty - with a delimiter
            if (basicLength) {
              output.push(delimiter);
            }

            // Main encoding loop:
            while (handledCPCount < inputLength) {

              // All non-basic code points < n have been handled already. Find the next
              // larger one:
              for (m = maxInt, j = 0; j < inputLength; ++j) {
                currentValue = input[j];
                if (currentValue >= n && currentValue < m) {
                  m = currentValue;
                }
              }

              // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
              // but guard against overflow
              handledCPCountPlusOne = handledCPCount + 1;
              if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
                error('overflow');
              }

              delta += (m - n) * handledCPCountPlusOne;
              n = m;

              for (j = 0; j < inputLength; ++j) {
                currentValue = input[j];

                if (currentValue < n && ++delta > maxInt) {
                  error('overflow');
                }

                if (currentValue == n) {
                  // Represent delta as a generalized variable-length integer
                  for (q = delta, k = base; /* no condition */ ; k += base) {
                    t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
                    if (q < t) {
                      break;
                    }
                    qMinusT = q - t;
                    baseMinusT = base - 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('');
          }

          /**
           * Converts a Punycode string representing a domain name or an email address
           * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
           * it doesn't matter if you call it on a string that has already been
           * converted to Unicode.
           * @memberOf punycode
           * @param {String} input The Punycoded domain name or email address to
           * convert to Unicode.
           * @returns {String} The Unicode representation of the given Punycode
           * string.
           */
          function toUnicode(input) {
            return mapDomain(input, function(string) {
              return regexPunycode.test(string) ?
                decode(string.slice(4).toLowerCase()) :
                string;
            });
          }

          /**
           * Converts a Unicode string representing a domain name or an email address to
           * Punycode. Only the non-ASCII parts of the domain name will be converted,
           * i.e. it doesn't matter if you call it with a domain that's already in
           * ASCII.
           * @memberOf punycode
           * @param {String} input The domain name or email address to convert, as a
           * Unicode string.
           * @returns {String} The Punycode representation of the given domain name or
           * email address.
           */
          function toASCII(input) {
            return mapDomain(input, function(string) {
              return regexNonASCII.test(string) ?
                'xn--' + encode(string) :
                string;
            });
          }

          /*--------------------------------------------------------------------------*/

          /** Define the public API */
          punycode = {
            /**
             * A string representing the current Punycode.js version number.
             * @memberOf punycode
             * @type String
             */
            'version': '1.4.1',
            /**
             * An object of methods to convert from JavaScript's internal character
             * representation (UCS-2) to Unicode code points, and back.
             * @see <https://mathiasbynens.be/notes/javascript-encoding>
             * @memberOf punycode
             * @type Object
             */
            'ucs2': {
              'decode': ucs2decode,
              'encode': ucs2encode
            },
            'decode': decode,
            'encode': encode,
            'toASCII': toASCII,
            'toUnicode': toUnicode
          };

          /** Expose `punycode` */
          // Some AMD build optimizers, like r.js, check for specific condition patterns
          // like the following:
          if (
            typeof define == 'function' &&
            typeof define.amd == 'object' &&
            define.amd
          ) {
            define('punycode', function() {
              return punycode;
            });
          } else if (freeExports && freeModule) {
            if (module.exports == freeExports) {
              // in Node.js, io.js, or RingoJS v0.8.0+
              freeModule.exports = punycode;
            } else {
              // in Narwhal or RingoJS v0.7.0-
              for (key in punycode) {
                punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
              }
            }
          } else {
            // in Rhino or a web browser
            root.punycode = punycode;
          }

        }(this));

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {}],
    94: [function(require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      'use strict';

      // If obj.hasOwnProperty has been overridden, then calling
      // obj.hasOwnProperty(prop) will break.
      // See: https://github.com/joyent/node/issues/1707
      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 (typeof qs !== 'string' || qs.length === 0) {
          return obj;
        }

        var regexp = /\+/g;
        qs = qs.split(sep);

        var maxKeys = 1000;
        if (options && typeof options.maxKeys === 'number') {
          maxKeys = options.maxKeys;
        }

        var len = qs.length;
        // maxKeys <= 0 means that we should not limit keys count
        if (maxKeys > 0 && len > maxKeys) {
          len = maxKeys;
        }

        for (var i = 0; i < len; ++i) {
          var x = qs[i].replace(regexp, '%20'),
            idx = x.indexOf(eq),
            kstr, vstr, k, v;

          if (idx >= 0) {
            kstr = x.substr(0, idx);
            vstr = x.substr(idx + 1);
          } else {
            kstr = x;
            vstr = '';
          }

          k = decodeURIComponent(kstr);
          v = decodeURIComponent(vstr);

          if (!hasOwnProperty(obj, k)) {
            obj[k] = v;
          } else if (isArray(obj[k])) {
            obj[k].push(v);
          } else {
            obj[k] = [obj[k], v];
          }
        }

        return obj;
      };

      var isArray = Array.isArray || function(xs) {
        return Object.prototype.toString.call(xs) === '[object Array]';
      };

    }, {}],
    95: [function(require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      '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) {
        sep = sep || '&';
        eq = eq || '=';
        if (obj === null) {
          obj = undefined;
        }

        if (typeof obj === 'object') {
          return map(objectKeys(obj), function(k) {
            var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
            if (isArray(obj[k])) {
              return map(obj[k], function(v) {
                return ks + encodeURIComponent(stringifyPrimitive(v));
              }).join(sep);
            } else {
              return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
            }
          }).join(sep);

        }

        if (!name) return '';
        return encodeURIComponent(stringifyPrimitive(name)) + eq +
          encodeURIComponent(stringifyPrimitive(obj));
      };

      var isArray = Array.isArray || function(xs) {
        return Object.prototype.toString.call(xs) === '[object Array]';
      };

      function map(xs, f) {
        if (xs.map) return xs.map(f);
        var res = [];
        for (var 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) {
          if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
        }
        return res;
      };

    }, {}],
    96: [function(require, module, exports) {
      'use strict';

      exports.decode = exports.parse = require('./decode');
      exports.encode = exports.stringify = require('./encode');

    }, {
      "./decode": 94,
      "./encode": 95
    }],
    97: [function(require, module, exports) {
      module.exports = require('./lib/_stream_duplex.js');

    }, {
      "./lib/_stream_duplex.js": 98
    }],
    98: [function(require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      // a duplex stream is just a stream that is both readable and writable.
      // Since JS doesn't have multiple prototypal inheritance, this class
      // prototypally inherits from Readable, and then parasitically from
      // Writable.

      'use strict';

      /*<replacement>*/

      var pna = require('process-nextick-args');
      /*</replacement>*/

      /*<replacement>*/
      var objectKeys = Object.keys || function(obj) {
        var keys = [];
        for (var key in obj) {
          keys.push(key);
        }
        return keys;
      };
      /*</replacement>*/

      module.exports = Duplex;

      /*<replacement>*/
      var util = require('core-util-is');
      util.inherits = require('inherits');
      /*</replacement>*/

      var Readable = require('./_stream_readable');
      var Writable = require('./_stream_writable');

      util.inherits(Duplex, Readable);

      {
        // avoid scope creep, the keys array can then be collected
        var keys = objectKeys(Writable.prototype);
        for (var v = 0; v < keys.length; v++) {
          var method = keys[v];
          if (!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);

        if (options && options.readable === false) this.readable = false;

        if (options && options.writable === false) this.writable = false;

        this.allowHalfOpen = true;
        if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;

        this.once('end', onend);
      }

      Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
        // making it explicit this property is not enumerable
        // because otherwise some prototype manipulation in
        // userland will fail
        enumerable: false,
        get: function() {
          return this._writableState.highWaterMark;
        }
      });

      // the no-half-open enforcer
      function onend() {
        // if we allow half-open state, or if the writable side ended,
        // then we're ok.
        if (this.allowHalfOpen || this._writableState.ended) return;

        // no more data can be written.
        // But allow more writes to happen in this tick.
        pna.nextTick(onEndNT, this);
      }

      function onEndNT(self) {
        self.end();
      }

      Object.defineProperty(Duplex.prototype, 'destroyed', {
        get: function() {
          if (this._readableState === undefined || this._writableState === undefined) {
            return false;
          }
          return this._readableState.destroyed && this._writableState.destroyed;
        },
        set: function(value) {
          // we ignore the value if the stream
          // has not been initialized yet
          if (this._readableState === undefined || this._writableState === undefined) {
            return;
          }

          // backward compatibility, the user is explicitly
          // managing destroyed
          this._readableState.destroyed = value;
          this._writableState.destroyed = value;
        }
      });

      Duplex.prototype._destroy = function(err, cb) {
        this.push(null);
        this.end();

        pna.nextTick(cb, err);
      };
    }, {
      "./_stream_readable": 100,
      "./_stream_writable": 102,
      "core-util-is": 13,
      "inherits": 80,
      "process-nextick-args": 91
    }],
    99: [function(require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      // a passthrough stream.
      // basically just the most minimal sort of Transform stream.
      // Every written chunk gets output as-is.

      'use strict';

      module.exports = PassThrough;

      var Transform = require('./_stream_transform');

      /*<replacement>*/
      var util = require('core-util-is');
      util.inherits = require('inherits');
      /*</replacement>*/

      util.inherits(PassThrough, Transform);

      function PassThrough(options) {
        if (!(this instanceof PassThrough)) return new PassThrough(options);

        Transform.call(this, options);
      }

      PassThrough.prototype._transform = function(chunk, encoding, cb) {
        cb(null, chunk);
      };
    }, {
      "./_stream_transform": 101,
      "core-util-is": 13,
      "inherits": 80
    }],
    100: [function(require, module, exports) {
      (function(process, global) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        'use strict';

        /*<replacement>*/

        var pna = require('process-nextick-args');
        /*</replacement>*/

        module.exports = Readable;

        /*<replacement>*/
        var isArray = require('isarray');
        /*</replacement>*/

        /*<replacement>*/
        var Duplex;
        /*</replacement>*/

        Readable.ReadableState = ReadableState;

        /*<replacement>*/
        var EE = require('events').EventEmitter;

        var EElistenerCount = function(emitter, type) {
          return emitter.listeners(type).length;
        };
        /*</replacement>*/

        /*<replacement>*/
        var Stream = require('./internal/streams/stream');
        /*</replacement>*/

        /*<replacement>*/

        var Buffer = require('safe-buffer').Buffer;
        var OurUint8Array = global.Uint8Array || function() {};

        function _uint8ArrayToBuffer(chunk) {
          return Buffer.from(chunk);
        }

        function _isUint8Array(obj) {
          return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
        }

        /*</replacement>*/

        /*<replacement>*/
        var util = require('core-util-is');
        util.inherits = require('inherits');
        /*</replacement>*/

        /*<replacement>*/
        var debugUtil = require('util');
        var debug = void 0;
        if (debugUtil && debugUtil.debuglog) {
          debug = debugUtil.debuglog('stream');
        } else {
          debug = function() {};
        }
        /*</replacement>*/

        var BufferList = require('./internal/streams/BufferList');
        var destroyImpl = require('./internal/streams/destroy');
        var StringDecoder;

        util.inherits(Readable, Stream);

        var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];

        function prependListener(emitter, event, fn) {
          // Sadly this is not cacheable as some libraries bundle their own
          // event emitter implementation with them.
          if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);

          // This is a hack to make sure that our error handler is attached before any
          // userland ones.  NEVER DO THIS. This is here only because this code needs
          // to continue to work with older versions of Node.js that do not include
          // the prependListener() method. The goal is to eventually remove this hack.
          if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
          else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);
          else emitter._events[event] = [fn, emitter._events[event]];
        }

        function ReadableState(options, stream) {
          Duplex = Duplex || require('./_stream_duplex');

          options = options || {};

          // Duplex streams are both readable and writable, but share
          // the same options object.
          // However, some cases require setting options to different
          // values for the readable and the writable sides of the duplex stream.
          // These options can be provided separately as readableXXX and writableXXX.
          var isDuplex = stream instanceof Duplex;

          // object stream flag. Used to make read(n) ignore n and to
          // make all the buffer merging and length checks go away
          this.objectMode = !!options.objectMode;

          if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;

          // the point at which it stops calling _read() to fill the buffer
          // Note: 0 is a valid value, means "don't call _read preemptively ever"
          var hwm = options.highWaterMark;
          var readableHwm = options.readableHighWaterMark;
          var defaultHwm = this.objectMode ? 16 : 16 * 1024;

          if (hwm || hwm === 0) this.highWaterMark = hwm;
          else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;
          else this.highWaterMark = defaultHwm;

          // cast to ints.
          this.highWaterMark = Math.floor(this.highWaterMark);

          // A linked list is used to store data chunks instead of an array because the
          // linked list can remove elements from the beginning faster than
          // array.shift()
          this.buffer = new BufferList();
          this.length = 0;
          this.pipes = null;
          this.pipesCount = 0;
          this.flowing = null;
          this.ended = false;
          this.endEmitted = false;
          this.reading = false;

          // a flag to be able to tell if the event 'readable'/'data' is emitted
          // immediately, or on a later tick.  We set this to true at first, because
          // any actions that shouldn't happen until "later" should generally also
          // not happen before the first read call.
          this.sync = true;

          // whenever we return null, then we set a flag to say
          // that we're awaiting a 'readable' event emission.
          this.needReadable = false;
          this.emittedReadable = false;
          this.readableListening = false;
          this.resumeScheduled = false;

          // has it been destroyed
          this.destroyed = false;

          // Crypto is kind of old and crusty.  Historically, its default string
          // encoding is 'binary' so we have to make this configurable.
          // Everything else in the universe uses 'utf8', though.
          this.defaultEncoding = options.defaultEncoding || 'utf8';

          // the number of writers that are awaiting a drain event in .pipe()s
          this.awaitDrain = 0;

          // if true, a maybeReadMore has been scheduled
          this.readingMore = false;

          this.decoder = null;
          this.encoding = null;
          if (options.encoding) {
            if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
            this.decoder = new StringDecoder(options.encoding);
            this.encoding = options.encoding;
          }
        }

        function Readable(options) {
          Duplex = Duplex || require('./_stream_duplex');

          if (!(this instanceof Readable)) return new Readable(options);

          this._readableState = new ReadableState(options, this);

          // legacy
          this.readable = true;

          if (options) {
            if (typeof options.read === 'function') this._read = options.read;

            if (typeof options.destroy === 'function') this._destroy = options.destroy;
          }

          Stream.call(this);
        }

        Object.defineProperty(Readable.prototype, 'destroyed', {
          get: function() {
            if (this._readableState === undefined) {
              return false;
            }
            return this._readableState.destroyed;
          },
          set: function(value) {
            // we ignore the value if the stream
            // has not been initialized yet
            if (!this._readableState) {
              return;
            }

            // backward compatibility, the user is explicitly
            // managing destroyed
            this._readableState.destroyed = value;
          }
        });

        Readable.prototype.destroy = destroyImpl.destroy;
        Readable.prototype._undestroy = destroyImpl.undestroy;
        Readable.prototype._destroy = function(err, cb) {
          this.push(null);
          cb(err);
        };

        // Manually shove something into the read() buffer.
        // This returns true if the highWaterMark has not been hit yet,
        // similar to how Writable.write() returns true if you should
        // write() some more.
        Readable.prototype.push = function(chunk, encoding) {
          var state = this._readableState;
          var skipChunkCheck;

          if (!state.objectMode) {
            if (typeof chunk === 'string') {
              encoding = encoding || state.defaultEncoding;
              if (encoding !== state.encoding) {
                chunk = Buffer.from(chunk, encoding);
                encoding = '';
              }
              skipChunkCheck = true;
            }
          } else {
            skipChunkCheck = true;
          }

          return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
        };

        // Unshift should *always* be something directly out of read()
        Readable.prototype.unshift = function(chunk) {
          return readableAddChunk(this, chunk, null, true, false);
        };

        function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
          var state = stream._readableState;
          if (chunk === null) {
            state.reading = false;
            onEofChunk(stream, state);
          } else {
            var er;
            if (!skipChunkCheck) er = chunkInvalid(state, chunk);
            if (er) {
              stream.emit('error', er);
            } else if (state.objectMode || chunk && chunk.length > 0) {
              if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
                chunk = _uint8ArrayToBuffer(chunk);
              }

              if (addToFront) {
                if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));
                else addChunk(stream, state, chunk, true);
              } else if (state.ended) {
                stream.emit('error', new Error('stream.push() after EOF'));
              } else {
                state.reading = false;
                if (state.decoder && !encoding) {
                  chunk = state.decoder.write(chunk);
                  if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);
                  else maybeReadMore(stream, state);
                } else {
                  addChunk(stream, state, chunk, false);
                }
              }
            } else if (!addToFront) {
              state.reading = false;
            }
          }

          return needMoreData(state);
        }

        function addChunk(stream, state, chunk, addToFront) {
          if (state.flowing && state.length === 0 && !state.sync) {
            stream.emit('data', chunk);
            stream.read(0);
          } else {
            // update the buffer info.
            state.length += state.objectMode ? 1 : chunk.length;
            if (addToFront) state.buffer.unshift(chunk);
            else state.buffer.push(chunk);

            if (state.needReadable) emitReadable(stream);
          }
          maybeReadMore(stream, state);
        }

        function chunkInvalid(state, chunk) {
          var er;
          if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
            er = new TypeError('Invalid non-string/buffer chunk');
          }
          return er;
        }

        // if it's past the high water mark, we can push in some more.
        // Also, if we have no data yet, we can stand some
        // more bytes.  This is to work around cases where hwm=0,
        // such as the repl.  Also, if the push() triggered a
        // readable event, and the user called read(largeNumber) such that
        // needReadable was set, then we ought to push more, so that another
        // 'readable' event will be triggered.
        function needMoreData(state) {
          return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
        }

        Readable.prototype.isPaused = function() {
          return this._readableState.flowing === false;
        };

        // backwards compatibility.
        Readable.prototype.setEncoding = function(enc) {
          if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
          this._readableState.decoder = new StringDecoder(enc);
          this._readableState.encoding = enc;
          return this;
        };

        // Don't raise the hwm > 8MB
        var MAX_HWM = 0x800000;

        function computeNewHighWaterMark(n) {
          if (n >= MAX_HWM) {
            n = MAX_HWM;
          } else {
            // Get the next highest power of 2 to prevent increasing hwm excessively in
            // tiny amounts
            n--;
            n |= n >>> 1;
            n |= n >>> 2;
            n |= n >>> 4;
            n |= n >>> 8;
            n |= n >>> 16;
            n++;
          }
          return n;
        }

        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function howMuchToRead(n, state) {
          if (n <= 0 || state.length === 0 && state.ended) return 0;
          if (state.objectMode) return 1;
          if (n !== n) {
            // Only flow one buffer at a time
            if (state.flowing && state.length) return state.buffer.head.data.length;
            else return state.length;
          }
          // If we're asking for more than the current hwm, then raise the hwm.
          if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
          if (n <= state.length) return n;
          // Don't have enough
          if (!state.ended) {
            state.needReadable = true;
            return 0;
          }
          return state.length;
        }

        // you can override either this method, or the async _read(n) below.
        Readable.prototype.read = function(n) {
          debug('read', n);
          n = parseInt(n, 10);
          var state = this._readableState;
          var nOrig = n;

          if (n !== 0) state.emittedReadable = false;

          // if we're doing read(0) to trigger a readable event, but we
          // already have a bunch of data in the buffer, then just trigger
          // the 'readable' event and move on.
          if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
            debug('read: emitReadable', state.length, state.ended);
            if (state.length === 0 && state.ended) endReadable(this);
            else emitReadable(this);
            return null;
          }

          n = howMuchToRead(n, state);

          // if we've ended, and we're now clear, then finish it up.
          if (n === 0 && state.ended) {
            if (state.length === 0) endReadable(this);
            return null;
          }

          // All the actual chunk generation logic needs to be
          // *below* the call to _read.  The reason is that in certain
          // synthetic stream cases, such as passthrough streams, _read
          // may be a completely synchronous operation which may change
          // the state of the read buffer, providing enough data when
          // before there was *not* enough.
          //
          // So, the steps are:
          // 1. Figure out what the state of things will be after we do
          // a read from the buffer.
          //
          // 2. If that resulting state will trigger a _read, then call _read.
          // Note that this may be asynchronous, or synchronous.  Yes, it is
          // deeply ugly to write APIs this way, but that still doesn't mean
          // that the Readable class should behave improperly, as streams are
          // designed to be sync/async agnostic.
          // Take note if the _read call is sync or async (ie, if the read call
          // has returned yet), so that we know whether or not it's safe to emit
          // 'readable' etc.
          //
          // 3. Actually pull the requested chunks out of the buffer and return.

          // if we need a readable event, then we need to do some reading.
          var doRead = state.needReadable;
          debug('need readable', doRead);

          // if we currently have less than the highWaterMark, then also read some
          if (state.length === 0 || state.length - n < state.highWaterMark) {
            doRead = true;
            debug('length less than watermark', doRead);
          }

          // however, if we've ended, then there's no point, and if we're already
          // reading, then it's unnecessary.
          if (state.ended || state.reading) {
            doRead = false;
            debug('reading or ended', doRead);
          } else if (doRead) {
            debug('do read');
            state.reading = true;
            state.sync = true;
            // if the length is currently zero, then we *need* a readable event.
            if (state.length === 0) state.needReadable = true;
            // call internal read method
            this._read(state.highWaterMark);
            state.sync = false;
            // If _read pushed data synchronously, then `reading` will be false,
            // and we need to re-evaluate how much data we can return to the user.
            if (!state.reading) n = howMuchToRead(nOrig, state);
          }

          var ret;
          if (n > 0) ret = fromList(n, state);
          else ret = null;

          if (ret === null) {
            state.needReadable = true;
            n = 0;
          } else {
            state.length -= n;
          }

          if (state.length === 0) {
            // If we have nothing in the buffer, then we want to know
            // as soon as we *do* get something into the buffer.
            if (!state.ended) state.needReadable = true;

            // If we tried to read() past the EOF, then emit end on the next tick.
            if (nOrig !== n && state.ended) endReadable(this);
          }

          if (ret !== null) this.emit('data', ret);

          return ret;
        };

        function onEofChunk(stream, state) {
          if (state.ended) return;
          if (state.decoder) {
            var chunk = state.decoder.end();
            if (chunk && chunk.length) {
              state.buffer.push(chunk);
              state.length += state.objectMode ? 1 : chunk.length;
            }
          }
          state.ended = true;

          // emit 'readable' now to make sure it gets picked up.
          emitReadable(stream);
        }

        // Don't emit readable right away in sync mode, because this can trigger
        // another read() call => stack overflow.  This way, it might trigger
        // a nextTick recursion warning, but that's not so bad.
        function emitReadable(stream) {
          var state = stream._readableState;
          state.needReadable = false;
          if (!state.emittedReadable) {
            debug('emitReadable', state.flowing);
            state.emittedReadable = true;
            if (state.sync) pna.nextTick(emitReadable_, stream);
            else emitReadable_(stream);
          }
        }

        function emitReadable_(stream) {
          debug('emit readable');
          stream.emit('readable');
          flow(stream);
        }

        // at this point, the user has presumably seen the 'readable' event,
        // and called read() to consume some data.  that may have triggered
        // in turn another _read(n) call, in which case reading = true if
        // it's in progress.
        // However, if we're not ended, or reading, and the length < hwm,
        // then go ahead and try to read some more preemptively.
        function maybeReadMore(stream, state) {
          if (!state.readingMore) {
            state.readingMore = true;
            pna.nextTick(maybeReadMore_, stream, state);
          }
        }

        function maybeReadMore_(stream, state) {
          var len = state.length;
          while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
            debug('maybeReadMore read 0');
            stream.read(0);
            if (len === state.length)
              // didn't get any data, stop spinning.
              break;
            else len = state.length;
          }
          state.readingMore = false;
        }

        // abstract method.  to be overridden in specific implementation classes.
        // call cb(er, data) where data is <= n in length.
        // for virtual (non-string, non-buffer) streams, "length" is somewhat
        // arbitrary, and perhaps not very meaningful.
        Readable.prototype._read = function(n) {
          this.emit('error', new Error('_read() is not implemented'));
        };

        Readable.prototype.pipe = function(dest, pipeOpts) {
          var src = this;
          var 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);
              break;
          }
          state.pipesCount += 1;
          debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);

          var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;

          var endFn = doEnd ? onend : unpipe;
          if (state.endEmitted) pna.nextTick(endFn);
          else src.once('end', endFn);

          dest.on('unpipe', onunpipe);

          function onunpipe(readable, unpipeInfo) {
            debug('onunpipe');
            if (readable === src) {
              if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
                unpipeInfo.hasUnpiped = true;
                cleanup();
              }
            }
          }

          function onend() {
            debug('onend');
            dest.end();
          }

          // when the dest drains, it reduces the awaitDrain counter
          // on the source.  This would be more elegant with a .once()
          // handler in flow(), but adding and removing repeatedly is
          // too slow.
          var ondrain = pipeOnDrain(src);
          dest.on('drain', ondrain);

          var cleanedUp = false;

          function cleanup() {
            debug('cleanup');
            // cleanup event handlers once the pipe is broken
            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 = true;

            // if the reader is waiting for a drain event from this
            // specific writer, then it would cause it to never start
            // flowing again.
            // So, if this is awaiting a drain, then we just call it now.
            // If we don't know, then assume that we are waiting for one.
            if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
          }

          // If the user pushes more data while we're writing to dest then we'll end up
          // in ondata again. However, we only want to increase awaitDrain once because
          // dest will only emit one 'drain' event for the multiple writes.
          // => Introduce a guard on increasing awaitDrain.
          var increasedAwaitDrain = false;
          src.on('data', ondata);

          function ondata(chunk) {
            debug('ondata');
            increasedAwaitDrain = false;
            var ret = dest.write(chunk);
            if (false === ret && !increasedAwaitDrain) {
              // If the user unpiped during `dest.write()`, it is possible
              // to get stuck in a permanently paused state if that write
              // also returned false.
              // => Check whether `dest` is still a piping destination.
              if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
                debug('false write response, pause', src._readableState.awaitDrain);
                src._readableState.awaitDrain++;
                increasedAwaitDrain = true;
              }
              src.pause();
            }
          }

          // if the dest has an error, then stop piping into it.
          // however, don't suppress the throwing behavior for this.
          function onerror(er) {
            debug('onerror', er);
            unpipe();
            dest.removeListener('error', onerror);
            if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
          }

          // Make sure our error handler is attached before userland ones.
          prependListener(dest, 'error', onerror);

          // Both close and finish should trigger unpipe, but only once.
          function onclose() {
            dest.removeListener('finish', onfinish);
            unpipe();
          }
          dest.once('close', onclose);

          function onfinish() {
            debug('onfinish');
            dest.removeListener('close', onclose);
            unpipe();
          }
          dest.once('finish', onfinish);

          function unpipe() {
            debug('unpipe');
            src.unpipe(dest);
          }

          // tell the dest that it's being piped to
          dest.emit('pipe', src);

          // start the flow if it hasn't been started already.
          if (!state.flowing) {
            debug('pipe resume');
            src.resume();
          }

          return dest;
        };

        function pipeOnDrain(src) {
          return function() {
            var state = src._readableState;
            debug('pipeOnDrain', state.awaitDrain);
            if (state.awaitDrain) state.awaitDrain--;
            if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
              state.flowing = true;
              flow(src);
            }
          };
        }

        Readable.prototype.unpipe = function(dest) {
          var state = this._readableState;
          var unpipeInfo = {
            hasUnpiped: false
          };

          // if we're not piping anywhere, then do nothing.
          if (state.pipesCount === 0) return this;

          // just one destination.  most common case.
          if (state.pipesCount === 1) {
            // passed in one, but it's not the right one.
            if (dest && dest !== state.pipes) return this;

            if (!dest) dest = state.pipes;

            // got a match.
            state.pipes = null;
            state.pipesCount = 0;
            state.flowing = false;
            if (dest) dest.emit('unpipe', this, unpipeInfo);
            return this;
          }

          // slow case. multiple pipe destinations.

          if (!dest) {
            // remove all.
            var dests = state.pipes;
            var len = state.pipesCount;
            state.pipes = null;
            state.pipesCount = 0;
            state.flowing = false;

            for (var i = 0; i < len; i++) {
              dests[i].emit('unpipe', this, unpipeInfo);
            }
            return this;
          }

          // try to find the right one.
          var index = indexOf(state.pipes, dest);
          if (index === -1) return this;

          state.pipes.splice(index, 1);
          state.pipesCount -= 1;
          if (state.pipesCount === 1) state.pipes = state.pipes[0];

          dest.emit('unpipe', this, unpipeInfo);

          return this;
        };

        // set up data events if they are asked for
        // Ensure readable listeners eventually get something
        Readable.prototype.on = function(ev, fn) {
          var res = Stream.prototype.on.call(this, ev, fn);

          if (ev === 'data') {
            // Start flowing on next tick if stream isn't explicitly paused
            if (this._readableState.flowing !== false) this.resume();
          } else if (ev === 'readable') {
            var state = this._readableState;
            if (!state.endEmitted && !state.readableListening) {
              state.readableListening = state.needReadable = true;
              state.emittedReadable = false;
              if (!state.reading) {
                pna.nextTick(nReadingNextTick, this);
              } else if (state.length) {
                emitReadable(this);
              }
            }
          }

          return res;
        };
        Readable.prototype.addListener = Readable.prototype.on;

        function nReadingNextTick(self) {
          debug('readable nexttick read 0');
          self.read(0);
        }

        // pause() and resume() are remnants of the legacy readable stream API
        // If the user uses them, then switch into old mode.
        Readable.prototype.resume = function() {
          var state = this._readableState;
          if (!state.flowing) {
            debug('resume');
            state.flowing = true;
            resume(this, state);
          }
          return this;
        };

        function resume(stream, state) {
          if (!state.resumeScheduled) {
            state.resumeScheduled = true;
            pna.nextTick(resume_, stream, state);
          }
        }

        function resume_(stream, state) {
          if (!state.reading) {
            debug('resume read 0');
            stream.read(0);
          }

          state.resumeScheduled = false;
          state.awaitDrain = 0;
          stream.emit('resume');
          flow(stream);
          if (state.flowing && !state.reading) stream.read(0);
        }

        Readable.prototype.pause = function() {
          debug('call pause flowing=%j', this._readableState.flowing);
          if (false !== this._readableState.flowing) {
            debug('pause');
            this._readableState.flowing = false;
            this.emit('pause');
          }
          return this;
        };

        function flow(stream) {
          var state = stream._readableState;
          debug('flow', state.flowing);
          while (state.flowing && stream.read() !== null) {}
        }

        // wrap an old-style stream as the async data source.
        // This is *not* part of the readable stream interface.
        // It is an ugly unfortunate mess of history.
        Readable.prototype.wrap = function(stream) {
          var _this = this;

          var state = this._readableState;
          var paused = false;

          stream.on('end', function() {
            debug('wrapped end');
            if (state.decoder && !state.ended) {
              var chunk = state.decoder.end();
              if (chunk && chunk.length) _this.push(chunk);
            }

            _this.push(null);
          });

          stream.on('data', function(chunk) {
            debug('wrapped data');
            if (state.decoder) chunk = state.decoder.write(chunk);

            // don't skip over falsy values in objectMode
            if (state.objectMode && (chunk === null || chunk === undefined)) return;
            else if (!state.objectMode && (!chunk || !chunk.length)) return;

            var ret = _this.push(chunk);
            if (!ret) {
              paused = true;
              stream.pause();
            }
          });

          // proxy all the other methods.
          // important when wrapping filters and duplexes.
          for (var i in stream) {
            if (this[i] === undefined && typeof stream[i] === 'function') {
              this[i] = function(method) {
                return function() {
                  return stream[method].apply(stream, arguments);
                };
              }(i);
            }
          }

          // proxy certain important events.
          for (var n = 0; n < kProxyEvents.length; n++) {
            stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
          }

          // when we try to consume some more bytes, simply unpause the
          // underlying stream.
          this._read = function(n) {
            debug('wrapped _read', n);
            if (paused) {
              paused = false;
              stream.resume();
            }
          };

          return this;
        };

        Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
          // making it explicit this property is not enumerable
          // because otherwise some prototype manipulation in
          // userland will fail
          enumerable: false,
          get: function() {
            return this._readableState.highWaterMark;
          }
        });

        // exposed for testing purposes only.
        Readable._fromList = fromList;

        // Pluck off n bytes from an array of buffers.
        // Length is the combined lengths of all the buffers in the list.
        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function fromList(n, state) {
          // nothing buffered
          if (state.length === 0) return null;

          var ret;
          if (state.objectMode) ret = state.buffer.shift();
          else if (!n || n >= state.length) {
            // read it all, truncate the list
            if (state.decoder) ret = state.buffer.join('');
            else if (state.buffer.length === 1) ret = state.buffer.head.data;
            else ret = state.buffer.concat(state.length);
            state.buffer.clear();
          } else {
            // read part of list
            ret = fromListPartial(n, state.buffer, state.decoder);
          }

          return ret;
        }

        // Extracts only enough buffered data to satisfy the amount requested.
        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function fromListPartial(n, list, hasStrings) {
          var ret;
          if (n < list.head.data.length) {
            // slice is the same for buffers and strings
            ret = list.head.data.slice(0, n);
            list.head.data = list.head.data.slice(n);
          } else if (n === list.head.data.length) {
            // first chunk is a perfect match
            ret = list.shift();
          } else {
            // result spans more than one buffer
            ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
          }
          return ret;
        }

        // Copies a specified amount of characters from the list of buffered data
        // chunks.
        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function copyFromBufferString(n, list) {
          var p = list.head;
          var c = 1;
          var ret = p.data;
          n -= ret.length;
          while (p = p.next) {
            var str = p.data;
            var nb = n > str.length ? str.length : n;
            if (nb === str.length) ret += str;
            else ret += str.slice(0, n);
            n -= nb;
            if (n === 0) {
              if (nb === str.length) {
                ++c;
                if (p.next) list.head = p.next;
                else list.head = list.tail = null;
              } else {
                list.head = p;
                p.data = str.slice(nb);
              }
              break;
            }
            ++c;
          }
          list.length -= c;
          return ret;
        }

        // Copies a specified amount of bytes from the list of buffered data chunks.
        // This function is designed to be inlinable, so please take care when making
        // changes to the function body.
        function copyFromBuffer(n, list) {
          var ret = Buffer.allocUnsafe(n);
          var p = list.head;
          var c = 1;
          p.data.copy(ret);
          n -= p.data.length;
          while (p = p.next) {
            var buf = p.data;
            var nb = n > buf.length ? buf.length : n;
            buf.copy(ret, ret.length - n, 0, nb);
            n -= nb;
            if (n === 0) {
              if (nb === buf.length) {
                ++c;
                if (p.next) list.head = p.next;
                else list.head = list.tail = null;
              } else {
                list.head = p;
                p.data = buf.slice(nb);
              }
              break;
            }
            ++c;
          }
          list.length -= c;
          return ret;
        }

        function endReadable(stream) {
          var state = stream._readableState;

          // If we get here before consuming all the bytes, then that is a
          // bug in node.  Should never happen.
          if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');

          if (!state.endEmitted) {
            state.ended = true;
            pna.nextTick(endReadableNT, state, stream);
          }
        }

        function endReadableNT(state, stream) {
          // Check that we didn't get one last unshift.
          if (!state.endEmitted && state.length === 0) {
            state.endEmitted = true;
            stream.readable = false;
            stream.emit('end');
          }
        }

        function indexOf(xs, x) {
          for (var i = 0, l = xs.length; i < l; i++) {
            if (xs[i] === x) return i;
          }
          return -1;
        }
      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./_stream_duplex": 98,
      "./internal/streams/BufferList": 103,
      "./internal/streams/destroy": 104,
      "./internal/streams/stream": 105,
      "_process": 92,
      "core-util-is": 13,
      "events": 78,
      "inherits": 80,
      "isarray": 82,
      "process-nextick-args": 91,
      "safe-buffer": 108,
      "string_decoder/": 110,
      "util": 11
    }],
    101: [function(require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      // a transform stream is a readable/writable stream where you do
      // something with the data.  Sometimes it's called a "filter",
      // but that's not a great name for it, since that implies a thing where
      // some bits pass through, and others are simply ignored.  (That would
      // be a valid example of a transform, of course.)
      //
      // While the output is causally related to the input, it's not a
      // necessarily symmetric or synchronous transformation.  For example,
      // a zlib stream might take multiple plain-text writes(), and then
      // emit a single compressed chunk some time in the future.
      //
      // Here's how this works:
      //
      // The Transform stream has all the aspects of the readable and writable
      // stream classes.  When you write(chunk), that calls _write(chunk,cb)
      // internally, and returns false if there's a lot of pending writes
      // buffered up.  When you call read(), that calls _read(n) until
      // there's enough pending readable data buffered up.
      //
      // In a transform stream, the written data is placed in a buffer.  When
      // _read(n) is called, it transforms the queued up data, calling the
      // buffered _write cb's as it consumes chunks.  If consuming a single
      // written chunk would result in multiple output chunks, then the first
      // outputted bit calls the readcb, and subsequent chunks just go into
      // the read buffer, and will cause it to emit 'readable' if necessary.
      //
      // This way, back-pressure is actually determined by the reading side,
      // since _read has to be called to start processing a new chunk.  However,
      // a pathological inflate type of transform can cause excessive buffering
      // here.  For example, imagine a stream where every byte of input is
      // interpreted as an integer from 0-255, and then results in that many
      // bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
      // 1kb of data being output.  In this case, you could write a very small
      // amount of input, and end up with a very large amount of output.  In
      // such a pathological inflating mechanism, there'd be no way to tell
      // the system to stop doing the transform.  A single 4MB write could
      // cause the system to run out of memory.
      //
      // However, even in such a pathological case, only a single written chunk
      // would be consumed, and then the rest would wait (un-transformed) until
      // the results of the previous transformed chunk were consumed.

      'use strict';

      module.exports = Transform;

      var Duplex = require('./_stream_duplex');

      /*<replacement>*/
      var util = require('core-util-is');
      util.inherits = require('inherits');
      /*</replacement>*/

      util.inherits(Transform, Duplex);

      function afterTransform(er, data) {
        var ts = this._transformState;
        ts.transforming = false;

        var cb = ts.writecb;

        if (!cb) {
          return this.emit('error', new Error('write callback called multiple times'));
        }

        ts.writechunk = null;
        ts.writecb = null;

        if (data != null) // single equals check for both `null` and `undefined`
          this.push(data);

        cb(er);

        var rs = this._readableState;
        rs.reading = false;
        if (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: false,
          transforming: false,
          writecb: null,
          writechunk: null,
          writeencoding: null
        };

        // start out asking for a readable event once data is transformed.
        this._readableState.needReadable = true;

        // we have implemented the _read method, and done the other things
        // that Readable wants before the first _read call, so unset the
        // sync guard flag.
        this._readableState.sync = false;

        if (options) {
          if (typeof options.transform === 'function') this._transform = options.transform;

          if (typeof options.flush === 'function') this._flush = options.flush;
        }

        // When the writable side finishes, then flush out anything remaining.
        this.on('prefinish', prefinish);
      }

      function prefinish() {
        var _this = this;

        if (typeof this._flush === 'function') {
          this._flush(function(er, data) {
            done(_this, er, data);
          });
        } else {
          done(this, null, null);
        }
      }

      Transform.prototype.push = function(chunk, encoding) {
        this._transformState.needTransform = false;
        return Duplex.prototype.push.call(this, chunk, encoding);
      };

      // This is the part where you do stuff!
      // override this function in implementation classes.
      // 'chunk' is an input chunk.
      //
      // Call `push(newChunk)` to pass along transformed output
      // to the readable side.  You may call 'push' zero or more times.
      //
      // Call `cb(err)` when you are done with this chunk.  If you pass
      // an error, then that'll put the hurt on the whole operation.  If you
      // never call cb(), then you'll never get another chunk.
      Transform.prototype._transform = function(chunk, encoding, cb) {
        throw new Error('_transform() is not implemented');
      };

      Transform.prototype._write = function(chunk, encoding, cb) {
        var ts = this._transformState;
        ts.writecb = cb;
        ts.writechunk = chunk;
        ts.writeencoding = encoding;
        if (!ts.transforming) {
          var rs = this._readableState;
          if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
        }
      };

      // Doesn't matter what the args are here.
      // _transform does all the work.
      // That we got here means that the readable side wants more data.
      Transform.prototype._read = function(n) {
        var ts = this._transformState;

        if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
          ts.transforming = true;
          this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
        } else {
          // mark that we need a transform, so that any data that comes in
          // will get processed, now that we've asked for it.
          ts.needTransform = true;
        }
      };

      Transform.prototype._destroy = function(err, cb) {
        var _this2 = this;

        Duplex.prototype._destroy.call(this, err, function(err2) {
          cb(err2);
          _this2.emit('close');
        });
      };

      function done(stream, er, data) {
        if (er) return stream.emit('error', er);

        if (data != null) // single equals check for both `null` and `undefined`
          stream.push(data);

        // if there's nothing in the write buffer, then that means
        // that nothing more will ever be provided
        if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');

        if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');

        return stream.push(null);
      }
    }, {
      "./_stream_duplex": 98,
      "core-util-is": 13,
      "inherits": 80
    }],
    102: [function(require, module, exports) {
      (function(process, global, setImmediate) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        // A bit simpler than readable streams.
        // Implement an async ._write(chunk, encoding, cb), and it'll handle all
        // the drain event emission and buffering.

        'use strict';

        /*<replacement>*/

        var pna = require('process-nextick-args');
        /*</replacement>*/

        module.exports = Writable;

        /* <replacement> */
        function WriteReq(chunk, encoding, cb) {
          this.chunk = chunk;
          this.encoding = encoding;
          this.callback = cb;
          this.next = null;
        }

        // It seems a linked list but it is not
        // there will be only 2 of these for each stream
        function CorkedRequest(state) {
          var _this = this;

          this.next = null;
          this.entry = null;
          this.finish = function() {
            onCorkedFinish(_this, state);
          };
        }
        /* </replacement> */

        /*<replacement>*/
        var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
        /*</replacement>*/

        /*<replacement>*/
        var Duplex;
        /*</replacement>*/

        Writable.WritableState = WritableState;

        /*<replacement>*/
        var util = require('core-util-is');
        util.inherits = require('inherits');
        /*</replacement>*/

        /*<replacement>*/
        var internalUtil = {
          deprecate: require('util-deprecate')
        };
        /*</replacement>*/

        /*<replacement>*/
        var Stream = require('./internal/streams/stream');
        /*</replacement>*/

        /*<replacement>*/

        var Buffer = require('safe-buffer').Buffer;
        var OurUint8Array = global.Uint8Array || function() {};

        function _uint8ArrayToBuffer(chunk) {
          return Buffer.from(chunk);
        }

        function _isUint8Array(obj) {
          return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
        }

        /*</replacement>*/

        var destroyImpl = require('./internal/streams/destroy');

        util.inherits(Writable, Stream);

        function nop() {}

        function WritableState(options, stream) {
          Duplex = Duplex || require('./_stream_duplex');

          options = options || {};

          // Duplex streams are both readable and writable, but share
          // the same options object.
          // However, some cases require setting options to different
          // values for the readable and the writable sides of the duplex stream.
          // These options can be provided separately as readableXXX and writableXXX.
          var isDuplex = stream instanceof Duplex;

          // object stream flag to indicate whether or not this stream
          // contains buffers or objects.
          this.objectMode = !!options.objectMode;

          if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;

          // the point at which write() starts returning false
          // Note: 0 is a valid value, means that we always return false if
          // the entire buffer is not flushed immediately on write()
          var hwm = options.highWaterMark;
          var writableHwm = options.writableHighWaterMark;
          var defaultHwm = this.objectMode ? 16 : 16 * 1024;

          if (hwm || hwm === 0) this.highWaterMark = hwm;
          else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;
          else this.highWaterMark = defaultHwm;

          // cast to ints.
          this.highWaterMark = Math.floor(this.highWaterMark);

          // if _final has been called
          this.finalCalled = false;

          // drain event flag.
          this.needDrain = false;
          // at the start of calling end()
          this.ending = false;
          // when end() has been called, and returned
          this.ended = false;
          // when 'finish' is emitted
          this.finished = false;

          // has it been destroyed
          this.destroyed = false;

          // should we decode strings into buffers before passing to _write?
          // this is here so that some node-core streams can optimize string
          // handling at a lower level.
          var noDecode = options.decodeStrings === false;
          this.decodeStrings = !noDecode;

          // Crypto is kind of old and crusty.  Historically, its default string
          // encoding is 'binary' so we have to make this configurable.
          // Everything else in the universe uses 'utf8', though.
          this.defaultEncoding = options.defaultEncoding || 'utf8';

          // not an actual buffer we keep track of, but a measurement
          // of how much we're waiting to get pushed to some underlying
          // socket or file.
          this.length = 0;

          // a flag to see when we're in the middle of a write.
          this.writing = false;

          // when true all writes will be buffered until .uncork() call
          this.corked = 0;

          // a flag to be able to tell if the onwrite cb is called immediately,
          // or on a later tick.  We set this to true at first, because any
          // actions that shouldn't happen until "later" should generally also
          // not happen before the first write call.
          this.sync = true;

          // a flag to know if we're processing previously buffered items, which
          // may call the _write() callback in the same tick, so that we don't
          // end up in an overlapped onwrite situation.
          this.bufferProcessing = false;

          // the callback that's passed to _write(chunk,cb)
          this.onwrite = function(er) {
            onwrite(stream, er);
          };

          // the callback that the user supplies to write(chunk,encoding,cb)
          this.writecb = null;

          // the amount that is being written when _write is called.
          this.writelen = 0;

          this.bufferedRequest = null;
          this.lastBufferedRequest = null;

          // number of pending user-supplied write callbacks
          // this must be 0 before 'finish' can be emitted
          this.pendingcb = 0;

          // emit prefinish if the only thing we're waiting for is _write cbs
          // This is relevant for synchronous Transform streams
          this.prefinished = false;

          // True if the error was already emitted and should not be thrown again
          this.errorEmitted = false;

          // count buffered requests
          this.bufferedRequestCount = 0;

          // allocate the first CorkedRequest, there is always
          // one allocated and free to use, and we maintain at most two
          this.corkedRequestsFree = new CorkedRequest(this);
        }

        WritableState.prototype.getBuffer = function getBuffer() {
          var current = this.bufferedRequest;
          var out = [];
          while (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 (_) {}
        })();

        // Test _writableState for inheritance to account for Duplex streams,
        // whose prototype chain only points to Readable.
        var realHasInstance;
        if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
          realHasInstance = Function.prototype[Symbol.hasInstance];
          Object.defineProperty(Writable, Symbol.hasInstance, {
            value: function(object) {
              if (realHasInstance.call(this, object)) return true;
              if (this !== Writable) return false;

              return object && object._writableState instanceof WritableState;
            }
          });
        } else {
          realHasInstance = function(object) {
            return object instanceof this;
          };
        }

        function Writable(options) {
          Duplex = Duplex || require('./_stream_duplex');

          // Writable ctor is applied to Duplexes, too.
          // `realHasInstance` is necessary because using plain `instanceof`
          // would return false, as no `_writableState` property is attached.

          // Trying to use the custom `instanceof` for Writable here will also break the
          // Node.js LazyTransform implementation, which has a non-trivial getter for
          // `_writableState` that would lead to infinite recursion.
          if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
            return new Writable(options);
          }

          this._writableState = new WritableState(options, this);

          // legacy.
          this.writable = true;

          if (options) {
            if (typeof options.write === 'function') this._write = options.write;

            if (typeof options.writev === 'function') this._writev = options.writev;

            if (typeof options.destroy === 'function') this._destroy = options.destroy;

            if (typeof options.final === 'function') this._final = options.final;
          }

          Stream.call(this);
        }

        // Otherwise people can pipe Writable streams, which is just wrong.
        Writable.prototype.pipe = function() {
          this.emit('error', new Error('Cannot pipe, not readable'));
        };

        function writeAfterEnd(stream, cb) {
          var er = new Error('write after end');
          // TODO: defer error events consistently everywhere, not just the cb
          stream.emit('error', er);
          pna.nextTick(cb, er);
        }

        // Checks that a user-supplied chunk is valid, especially for the particular
        // mode the stream is in. Currently this means that `null` is never accepted
        // and undefined/non-string values are only allowed in object mode.
        function validChunk(stream, state, chunk, cb) {
          var valid = true;
          var er = false;

          if (chunk === null) {
            er = new TypeError('May not write null values to stream');
          } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
            er = new TypeError('Invalid non-string/buffer chunk');
          }
          if (er) {
            stream.emit('error', er);
            pna.nextTick(cb, er);
            valid = false;
          }
          return valid;
        }

        Writable.prototype.write = function(chunk, encoding, cb) {
          var state = this._writableState;
          var ret = false;
          var isBuf = !state.objectMode && _isUint8Array(chunk);

          if (isBuf && !Buffer.isBuffer(chunk)) {
            chunk = _uint8ArrayToBuffer(chunk);
          }

          if (typeof encoding === 'function') {
            cb = encoding;
            encoding = null;
          }

          if (isBuf) encoding = 'buffer';
          else if (!encoding) encoding = state.defaultEncoding;

          if (typeof cb !== 'function') cb = nop;

          if (state.ended) writeAfterEnd(this, cb);
          else if (isBuf || validChunk(this, state, chunk, cb)) {
            state.pendingcb++;
            ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
          }

          return ret;
        };

        Writable.prototype.cork = function() {
          var state = this._writableState;

          state.corked++;
        };

        Writable.prototype.uncork = function() {
          var state = this._writableState;

          if (state.corked) {
            state.corked--;

            if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
          }
        };

        Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
          // node::ParseEncoding() requires lower case.
          if (typeof encoding === 'string') encoding = encoding.toLowerCase();
          if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
          this._writableState.defaultEncoding = encoding;
          return this;
        };

        function decodeChunk(state, chunk, encoding) {
          if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
            chunk = Buffer.from(chunk, encoding);
          }
          return chunk;
        }

        Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
          // making it explicit this property is not enumerable
          // because otherwise some prototype manipulation in
          // userland will fail
          enumerable: false,
          get: function() {
            return this._writableState.highWaterMark;
          }
        });

        // if we're already writing something, then just put this
        // in the queue, and wait our turn.  Otherwise, call _write
        // If we return false, then we need a drain event, so set that flag.
        function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
          if (!isBuf) {
            var newChunk = decodeChunk(state, chunk, encoding);
            if (chunk !== newChunk) {
              isBuf = true;
              encoding = 'buffer';
              chunk = newChunk;
            }
          }
          var len = state.objectMode ? 1 : chunk.length;

          state.length += len;

          var ret = state.length < state.highWaterMark;
          // we must ensure that previous needDrain will not be reset to false.
          if (!ret) state.needDrain = true;

          if (state.writing || state.corked) {
            var last = state.lastBufferedRequest;
            state.lastBufferedRequest = {
              chunk: chunk,
              encoding: encoding,
              isBuf: isBuf,
              callback: cb,
              next: null
            };
            if (last) {
              last.next = state.lastBufferedRequest;
            } else {
              state.bufferedRequest = state.lastBufferedRequest;
            }
            state.bufferedRequestCount += 1;
          } else {
            doWrite(stream, state, false, len, chunk, encoding, cb);
          }

          return ret;
        }

        function doWrite(stream, state, writev, len, chunk, encoding, cb) {
          state.writelen = len;
          state.writecb = cb;
          state.writing = true;
          state.sync = true;
          if (writev) stream._writev(chunk, state.onwrite);
          else stream._write(chunk, encoding, state.onwrite);
          state.sync = false;
        }

        function onwriteError(stream, state, sync, er, cb) {
          --state.pendingcb;

          if (sync) {
            // defer the callback if we are being called synchronously
            // to avoid piling up things on the stack
            pna.nextTick(cb, er);
            // this can emit finish, and it will always happen
            // after error
            pna.nextTick(finishMaybe, stream, state);
            stream._writableState.errorEmitted = true;
            stream.emit('error', er);
          } else {
            // the caller expect this to happen before if
            // it is async
            cb(er);
            stream._writableState.errorEmitted = true;
            stream.emit('error', er);
            // this can emit finish, but finish must
            // always follow error
            finishMaybe(stream, state);
          }
        }

        function onwriteStateUpdate(state) {
          state.writing = false;
          state.writecb = null;
          state.length -= state.writelen;
          state.writelen = 0;
        }

        function onwrite(stream, er) {
          var state = stream._writableState;
          var sync = state.sync;
          var cb = state.writecb;

          onwriteStateUpdate(state);

          if (er) onwriteError(stream, state, sync, er, cb);
          else {
            // Check if we're actually ready to finish, but don't emit yet
            var finished = needFinish(state);

            if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
              clearBuffer(stream, state);
            }

            if (sync) {
              /*<replacement>*/
              asyncWrite(afterWrite, stream, state, finished, cb);
              /*</replacement>*/
            } else {
              afterWrite(stream, state, finished, cb);
            }
          }
        }

        function afterWrite(stream, state, finished, cb) {
          if (!finished) onwriteDrain(stream, state);
          state.pendingcb--;
          cb();
          finishMaybe(stream, state);
        }

        // Must force callback to be called on nextTick, so that we don't
        // emit 'drain' before the write() consumer gets the 'false' return
        // value, and has a chance to attach a 'drain' listener.
        function onwriteDrain(stream, state) {
          if (state.length === 0 && state.needDrain) {
            state.needDrain = false;
            stream.emit('drain');
          }
        }

        // if there's something in the buffer waiting, then process it
        function clearBuffer(stream, state) {
          state.bufferProcessing = true;
          var entry = state.bufferedRequest;

          if (stream._writev && entry && entry.next) {
            // Fast case, write everything using _writev()
            var l = state.bufferedRequestCount;
            var buffer = new Array(l);
            var holder = state.corkedRequestsFree;
            holder.entry = entry;

            var count = 0;
            var allBuffers = true;
            while (entry) {
              buffer[count] = entry;
              if (!entry.isBuf) allBuffers = false;
              entry = entry.next;
              count += 1;
            }
            buffer.allBuffers = allBuffers;

            doWrite(stream, state, true, state.length, buffer, '', holder.finish);

            // doWrite is almost always async, defer these to save a bit of time
            // as the hot path ends with doWrite
            state.pendingcb++;
            state.lastBufferedRequest = null;
            if (holder.next) {
              state.corkedRequestsFree = holder.next;
              holder.next = null;
            } else {
              state.corkedRequestsFree = new CorkedRequest(state);
            }
            state.bufferedRequestCount = 0;
          } else {
            // Slow case, write chunks one-by-one
            while (entry) {
              var chunk = entry.chunk;
              var encoding = entry.encoding;
              var cb = entry.callback;
              var len = state.objectMode ? 1 : chunk.length;

              doWrite(stream, state, false, len, chunk, encoding, cb);
              entry = entry.next;
              state.bufferedRequestCount--;
              // if we didn't call the onwrite immediately, then
              // it means that we need to wait until it does.
              // also, that means that the chunk and cb are currently
              // being processed, so move the buffer counter past them.
              if (state.writing) {
                break;
              }
            }

            if (entry === null) state.lastBufferedRequest = null;
          }

          state.bufferedRequest = entry;
          state.bufferProcessing = false;
        }

        Writable.prototype._write = function(chunk, encoding, cb) {
          cb(new Error('_write() is not implemented'));
        };

        Writable.prototype._writev = null;

        Writable.prototype.end = function(chunk, encoding, cb) {
          var state = this._writableState;

          if (typeof chunk === 'function') {
            cb = chunk;
            chunk = null;
            encoding = null;
          } else if (typeof encoding === 'function') {
            cb = encoding;
            encoding = null;
          }

          if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);

          // .end() fully uncorks
          if (state.corked) {
            state.corked = 1;
            this.uncork();
          }

          // ignore unnecessary end() calls.
          if (!state.ending && !state.finished) endWritable(this, state, cb);
        };

        function needFinish(state) {
          return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
        }

        function callFinal(stream, state) {
          stream._final(function(err) {
            state.pendingcb--;
            if (err) {
              stream.emit('error', err);
            }
            state.prefinished = true;
            stream.emit('prefinish');
            finishMaybe(stream, state);
          });
        }

        function prefinish(stream, state) {
          if (!state.prefinished && !state.finalCalled) {
            if (typeof stream._final === 'function') {
              state.pendingcb++;
              state.finalCalled = true;
              pna.nextTick(callFinal, stream, state);
            } else {
              state.prefinished = true;
              stream.emit('prefinish');
            }
          }
        }

        function finishMaybe(stream, state) {
          var need = needFinish(state);
          if (need) {
            prefinish(stream, state);
            if (state.pendingcb === 0) {
              state.finished = true;
              stream.emit('finish');
            }
          }
          return need;
        }

        function endWritable(stream, state, cb) {
          state.ending = true;
          finishMaybe(stream, state);
          if (cb) {
            if (state.finished) pna.nextTick(cb);
            else stream.once('finish', cb);
          }
          state.ended = true;
          stream.writable = false;
        }

        function onCorkedFinish(corkReq, state, err) {
          var entry = corkReq.entry;
          corkReq.entry = null;
          while (entry) {
            var cb = entry.callback;
            state.pendingcb--;
            cb(err);
            entry = entry.next;
          }
          if (state.corkedRequestsFree) {
            state.corkedRequestsFree.next = corkReq;
          } else {
            state.corkedRequestsFree = corkReq;
          }
        }

        Object.defineProperty(Writable.prototype, 'destroyed', {
          get: function() {
            if (this._writableState === undefined) {
              return false;
            }
            return this._writableState.destroyed;
          },
          set: function(value) {
            // we ignore the value if the stream
            // has not been initialized yet
            if (!this._writableState) {
              return;
            }

            // backward compatibility, the user is explicitly
            // managing destroyed
            this._writableState.destroyed = value;
          }
        });

        Writable.prototype.destroy = destroyImpl.destroy;
        Writable.prototype._undestroy = destroyImpl.undestroy;
        Writable.prototype._destroy = function(err, cb) {
          this.end();
          cb(err);
        };
      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}, require("timers").setImmediate)
    }, {
      "./_stream_duplex": 98,
      "./internal/streams/destroy": 104,
      "./internal/streams/stream": 105,
      "_process": 92,
      "core-util-is": 13,
      "inherits": 80,
      "process-nextick-args": 91,
      "safe-buffer": 108,
      "timers": 111,
      "util-deprecate": 114
    }],
    103: [function(require, module, exports) {
      'use strict';

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      var Buffer = require('safe-buffer').Buffer;
      var util = require('util');

      function copyBuffer(src, target, offset) {
        src.copy(target, offset);
      }

      module.exports = function() {
        function BufferList() {
          _classCallCheck(this, BufferList);

          this.head = null;
          this.tail = null;
          this.length = 0;
        }

        BufferList.prototype.push = function push(v) {
          var entry = {
            data: v,
            next: null
          };
          if (this.length > 0) this.tail.next = entry;
          else this.head = entry;
          this.tail = entry;
          ++this.length;
        };

        BufferList.prototype.unshift = function unshift(v) {
          var entry = {
            data: v,
            next: this.head
          };
          if (this.length === 0) this.tail = entry;
          this.head = entry;
          ++this.length;
        };

        BufferList.prototype.shift = function shift() {
          if (this.length === 0) return;
          var ret = this.head.data;
          if (this.length === 1) this.head = this.tail = null;
          else this.head = this.head.next;
          --this.length;
          return ret;
        };

        BufferList.prototype.clear = function clear() {
          this.head = this.tail = null;
          this.length = 0;
        };

        BufferList.prototype.join = function join(s) {
          if (this.length === 0) return '';
          var p = this.head;
          var ret = '' + p.data;
          while (p = p.next) {
            ret += s + p.data;
          }
          return ret;
        };

        BufferList.prototype.concat = function concat(n) {
          if (this.length === 0) return Buffer.alloc(0);
          if (this.length === 1) return this.head.data;
          var ret = Buffer.allocUnsafe(n >>> 0);
          var p = this.head;
          var i = 0;
          while (p) {
            copyBuffer(p.data, ret, i);
            i += p.data.length;
            p = p.next;
          }
          return ret;
        };

        return BufferList;
      }();

      if (util && util.inspect && util.inspect.custom) {
        module.exports.prototype[util.inspect.custom] = function() {
          var obj = util.inspect({
            length: this.length
          });
          return this.constructor.name + ' ' + obj;
        };
      }
    }, {
      "safe-buffer": 108,
      "util": 11
    }],
    104: [function(require, module, exports) {
      'use strict';

      /*<replacement>*/

      var pna = require('process-nextick-args');
      /*</replacement>*/

      // undocumented cb() API, needed for core, not for public API
      function destroy(err, cb) {
        var _this = this;

        var readableDestroyed = this._readableState && this._readableState.destroyed;
        var writableDestroyed = this._writableState && this._writableState.destroyed;

        if (readableDestroyed || writableDestroyed) {
          if (cb) {
            cb(err);
          } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
            pna.nextTick(emitErrorNT, this, err);
          }
          return this;
        }

        // we set destroyed to true before firing error callbacks in order
        // to make it re-entrance safe in case destroy() is called within callbacks

        if (this._readableState) {
          this._readableState.destroyed = true;
        }

        // if this is a duplex stream mark the writable part as destroyed as well
        if (this._writableState) {
          this._writableState.destroyed = true;
        }

        this._destroy(err || null, function(err) {
          if (!cb && err) {
            pna.nextTick(emitErrorNT, _this, err);
            if (_this._writableState) {
              _this._writableState.errorEmitted = true;
            }
          } else if (cb) {
            cb(err);
          }
        });

        return this;
      }

      function undestroy() {
        if (this._readableState) {
          this._readableState.destroyed = false;
          this._readableState.reading = false;
          this._readableState.ended = false;
          this._readableState.endEmitted = false;
        }

        if (this._writableState) {
          this._writableState.destroyed = false;
          this._writableState.ended = false;
          this._writableState.ending = false;
          this._writableState.finished = false;
          this._writableState.errorEmitted = false;
        }
      }

      function emitErrorNT(self, err) {
        self.emit('error', err);
      }

      module.exports = {
        destroy: destroy,
        undestroy: undestroy
      };
    }, {
      "process-nextick-args": 91
    }],
    105: [function(require, module, exports) {
      module.exports = require('events').EventEmitter;

    }, {
      "events": 78
    }],
    106: [function(require, module, exports) {
      exports = module.exports = require('./lib/_stream_readable.js');
      exports.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');

    }, {
      "./lib/_stream_duplex.js": 98,
      "./lib/_stream_passthrough.js": 99,
      "./lib/_stream_readable.js": 100,
      "./lib/_stream_transform.js": 101,
      "./lib/_stream_writable.js": 102
    }],
    107: [function(require, module, exports) {
      'use strict'

      function ReInterval(callback, interval, args) {
        var self = this;

        this._callback = callback;
        this._args = args;

        this._interval = setInterval(callback, interval, this._args);

        this.reschedule = function(interval) {
          // if no interval entered, use the interval passed in on creation
          if (!interval)
            interval = self._interval;

          if (self._interval)
            clearInterval(self._interval);
          self._interval = setInterval(self._callback, interval, self._args);
        };

        this.clear = function() {
          if (self._interval) {
            clearInterval(self._interval);
            self._interval = undefined;
          }
        };

        this.destroy = function() {
          if (self._interval) {
            clearInterval(self._interval);
          }
          self._callback = undefined;
          self._interval = undefined;
          self._args = undefined;
        };
      }

      function reInterval() {
        if (typeof arguments[0] !== 'function')
          throw new Error('callback needed');
        if (typeof arguments[1] !== 'number')
          throw new Error('interval needed');

        var args;

        if (arguments.length > 0) {
          args = new Array(arguments.length - 2);

          for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i + 2];
          }
        }

        return new ReInterval(arguments[0], arguments[1], args);
      }

      module.exports = reInterval;

    }, {}],
    108: [function(require, module, exports) {
      /* eslint-disable node/no-deprecated-api */
      var buffer = require('buffer')
      var Buffer = buffer.Buffer

      // alternative to using Object.keys for old browsers
      function copyProps(src, dst) {
        for (var key in src) {
          dst[key] = src[key]
        }
      }
      if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
        module.exports = buffer
      } else {
        // Copy properties from require('buffer')
        copyProps(buffer, exports)
        exports.Buffer = SafeBuffer
      }

      function SafeBuffer(arg, encodingOrOffset, length) {
        return Buffer(arg, encodingOrOffset, length)
      }

      // Copy static methods from Buffer
      copyProps(Buffer, SafeBuffer)

      SafeBuffer.from = function(arg, encodingOrOffset, length) {
        if (typeof arg === 'number') {
          throw new TypeError('Argument must not be a number')
        }
        return Buffer(arg, encodingOrOffset, length)
      }

      SafeBuffer.alloc = function(size, fill, encoding) {
        if (typeof size !== 'number') {
          throw new TypeError('Argument must be a number')
        }
        var buf = Buffer(size)
        if (fill !== undefined) {
          if (typeof encoding === 'string') {
            buf.fill(fill, encoding)
          } else {
            buf.fill(fill)
          }
        } else {
          buf.fill(0)
        }
        return buf
      }

      SafeBuffer.allocUnsafe = function(size) {
        if (typeof size !== 'number') {
          throw new TypeError('Argument must be a number')
        }
        return Buffer(size)
      }

      SafeBuffer.allocUnsafeSlow = function(size) {
        if (typeof size !== 'number') {
          throw new TypeError('Argument must be a number')
        }
        return buffer.SlowBuffer(size)
      }

    }, {
      "buffer": 12
    }],
    109: [function(require, module, exports) {
      module.exports = shift

      function shift(stream) {
        var rs = stream._readableState
        if (!rs) return null
        return rs.objectMode ? stream.read() : stream.read(getStateLength(rs))
      }

      function getStateLength(state) {
        if (state.buffer.length) {
          // Since node 6.3.0 state.buffer is a BufferList not an array
          if (state.buffer.head) {
            return state.buffer.head.data.length
          }

          return state.buffer[0].length
        }

        return state.length
      }

    }, {}],
    110: [function(require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      'use strict';

      /*<replacement>*/

      var Buffer = require('safe-buffer').Buffer;
      /*</replacement>*/

      var isEncoding = Buffer.isEncoding || function(encoding) {
        encoding = '' + encoding;
        switch (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 true;
          default:
            return false;
        }
      };

      function _normalizeEncoding(enc) {
        if (!enc) return 'utf8';
        var retried;
        while (true) {
          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; // undefined
              enc = ('' + enc).toLowerCase();
              retried = true;
          }
        }
      };

      // Do not cache `Buffer.isEncoding` when checking encoding names as some
      // modules monkey-patch it to support additional encodings
      function normalizeEncoding(enc) {
        var nenc = _normalizeEncoding(enc);
        if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
        return nenc || enc;
      }

      // StringDecoder provides an interface for efficiently splitting a series of
      // buffers into a series of JS strings without breaking apart multi-byte
      // characters.
      exports.StringDecoder = StringDecoder;

      function StringDecoder(encoding) {
        this.encoding = normalizeEncoding(encoding);
        var nb;
        switch (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:
            this.write = simpleWrite;
            this.end = simpleEnd;
            return;
        }
        this.lastNeed = 0;
        this.lastTotal = 0;
        this.lastChar = Buffer.allocUnsafe(nb);
      }

      StringDecoder.prototype.write = function(buf) {
        if (buf.length === 0) return '';
        var r;
        var i;
        if (this.lastNeed) {
          r = this.fillLast(buf);
          if (r === undefined) return '';
          i = this.lastNeed;
          this.lastNeed = 0;
        } else {
          i = 0;
        }
        if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
        return r || '';
      };

      StringDecoder.prototype.end = utf8End;

      // Returns only complete characters in a Buffer
      StringDecoder.prototype.text = utf8Text;

      // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
      StringDecoder.prototype.fillLast = function(buf) {
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
        this.lastNeed -= buf.length;
      };

      // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
      // continuation byte. If an invalid byte is detected, -2 is returned.
      function utf8CheckByte(byte) {
        if (byte <= 0x7F) return 0;
        else if (byte >> 5 === 0x06) return 2;
        else if (byte >> 4 === 0x0E) return 3;
        else if (byte >> 3 === 0x1E) return 4;
        return byte >> 6 === 0x02 ? -1 : -2;
      }

      // Checks at most 3 bytes at the end of a Buffer in order to detect an
      // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
      // needed to complete the UTF-8 character (if applicable) are returned.
      function utf8CheckIncomplete(self, buf, i) {
        var j = buf.length - 1;
        if (j < i) return 0;
        var nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) self.lastNeed = nb - 1;
          return nb;
        }
        if (--j < i || nb === -2) return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) self.lastNeed = nb - 2;
          return nb;
        }
        if (--j < i || nb === -2) return 0;
        nb = utf8CheckByte(buf[j]);
        if (nb >= 0) {
          if (nb > 0) {
            if (nb === 2) nb = 0;
            else self.lastNeed = nb - 3;
          }
          return nb;
        }
        return 0;
      }

      // Validates as many continuation bytes for a multi-byte UTF-8 character as
      // needed or are available. If we see a non-continuation byte where we expect
      // one, we "replace" the validated continuation bytes we've seen so far with
      // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
      // behavior. The continuation byte check is included three times in the case
      // where all of the continuation bytes for a character exist in the same buffer.
      // It is also done this way as a slight performance increase instead of using a
      // loop.
      function utf8CheckExtraBytes(self, buf, p) {
        if ((buf[0] & 0xC0) !== 0x80) {
          self.lastNeed = 0;
          return '\ufffd';
        }
        if (self.lastNeed > 1 && buf.length > 1) {
          if ((buf[1] & 0xC0) !== 0x80) {
            self.lastNeed = 1;
            return '\ufffd';
          }
          if (self.lastNeed > 2 && buf.length > 2) {
            if ((buf[2] & 0xC0) !== 0x80) {
              self.lastNeed = 2;
              return '\ufffd';
            }
          }
        }
      }

      // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
      function utf8FillLast(buf) {
        var p = this.lastTotal - this.lastNeed;
        var r = utf8CheckExtraBytes(this, buf, p);
        if (r !== undefined) return r;
        if (this.lastNeed <= buf.length) {
          buf.copy(this.lastChar, p, 0, this.lastNeed);
          return this.lastChar.toString(this.encoding, 0, this.lastTotal);
        }
        buf.copy(this.lastChar, p, 0, buf.length);
        this.lastNeed -= buf.length;
      }

      // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
      // partial character, the character's bytes are buffered until the required
      // number of bytes are available.
      function utf8Text(buf, i) {
        var total = utf8CheckIncomplete(this, buf, i);
        if (!this.lastNeed) return buf.toString('utf8', i);
        this.lastTotal = total;
        var end = buf.length - (total - this.lastNeed);
        buf.copy(this.lastChar, 0, end);
        return buf.toString('utf8', i, end);
      }

      // For UTF-8, a replacement character is added when ending on a partial
      // character.
      function utf8End(buf) {
        var r = buf && buf.length ? this.write(buf) : '';
        if (this.lastNeed) return r + '\ufffd';
        return r;
      }

      // UTF-16LE typically needs two bytes per character, but even if we have an even
      // number of bytes available, we need to check if we end on a leading/high
      // surrogate. In that case, we need to wait for the next two bytes in order to
      // decode the last character properly.
      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 >= 0xD800 && c <= 0xDBFF) {
              this.lastNeed = 2;
              this.lastTotal = 4;
              this.lastChar[0] = buf[buf.length - 2];
              this.lastChar[1] = buf[buf.length - 1];
              return r.slice(0, -1);
            }
          }
          return r;
        }
        this.lastNeed = 1;
        this.lastTotal = 2;
        this.lastChar[0] = buf[buf.length - 1];
        return buf.toString('utf16le', i, buf.length - 1);
      }

      // For UTF-16LE we do not explicitly append special replacement characters if we
      // end on a partial character, we simply let v8 handle that.
      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;
        if (n === 0) return buf.toString('base64', i);
        this.lastNeed = 3 - n;
        this.lastTotal = 3;
        if (n === 1) {
          this.lastChar[0] = buf[buf.length - 1];
        } else {
          this.lastChar[0] = buf[buf.length - 2];
          this.lastChar[1] = buf[buf.length - 1];
        }
        return buf.toString('base64', i, buf.length - n);
      }

      function base64End(buf) {
        var r = buf && buf.length ? this.write(buf) : '';
        if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
        return r;
      }

      // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
      function simpleWrite(buf) {
        return buf.toString(this.encoding);
      }

      function simpleEnd(buf) {
        return buf && buf.length ? this.write(buf) : '';
      }
    }, {
      "safe-buffer": 108
    }],
    111: [function(require, module, exports) {
      (function(setImmediate, clearImmediate) {
        var nextTick = require('process/browser.js').nextTick;
        var apply = Function.prototype.apply;
        var slice = Array.prototype.slice;
        var immediateIds = {};
        var nextImmediateId = 0;

        // DOM APIs, for completeness

        exports.setTimeout = function() {
          return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
        };
        exports.setInterval = function() {
          return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
        };
        exports.clearTimeout =
          exports.clearInterval = function(timeout) {
            timeout.close();
          };

        function Timeout(id, clearFn) {
          this._id = id;
          this._clearFn = clearFn;
        }
        Timeout.prototype.unref = Timeout.prototype.ref = function() {};
        Timeout.prototype.close = function() {
          this._clearFn.call(window, this._id);
        };

        // Does not start the time, just sets up the members needed.
        exports.enroll = function(item, msecs) {
          clearTimeout(item._idleTimeoutId);
          item._idleTimeout = msecs;
        };

        exports.unenroll = function(item) {
          clearTimeout(item._idleTimeoutId);
          item._idleTimeout = -1;
        };

        exports._unrefActive = exports.active = function(item) {
          clearTimeout(item._idleTimeoutId);

          var msecs = item._idleTimeout;
          if (msecs >= 0) {
            item._idleTimeoutId = setTimeout(function onTimeout() {
              if (item._onTimeout)
                item._onTimeout();
            }, msecs);
          }
        };

        // That's not how node.js implements it but the exposed api is the same.
        exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
          var id = nextImmediateId++;
          var args = arguments.length < 2 ? false : slice.call(arguments, 1);

          immediateIds[id] = true;

          nextTick(function onNextTick() {
            if (immediateIds[id]) {
              // fn.call() is faster so we optimize for the common use-case
              // @see http://jsperf.com/call-apply-segu
              if (args) {
                fn.apply(null, args);
              } else {
                fn.call(null);
              }
              // Prevent ids from leaking
              exports.clearImmediate(id);
            }
          });

          return id;
        };

        exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
          delete immediateIds[id];
        };
      }).call(this, require("timers").setImmediate, require("timers").clearImmediate)
    }, {
      "process/browser.js": 92,
      "timers": 111
    }],
    112: [function(require, module, exports) {
      // Copyright Joyent, Inc. and other Node contributors.
      //
      // Permission is hereby granted, free of charge, to any person obtaining a
      // copy of this software and associated documentation files (the
      // "Software"), to deal in the Software without restriction, including
      // without limitation the rights to use, copy, modify, merge, publish,
      // distribute, sublicense, and/or sell copies of the Software, and to permit
      // persons to whom the Software is furnished to do so, subject to the
      // following conditions:
      //
      // The above copyright notice and this permission notice shall be included
      // in all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
      // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
      // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
      // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
      // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
      // USE OR OTHER DEALINGS IN THE SOFTWARE.

      'use strict';

      var punycode = require('punycode');
      var util = require('./util');

      exports.parse = urlParse;
      exports.resolve = urlResolve;
      exports.resolveObject = urlResolveObject;
      exports.format = urlFormat;

      exports.Url = Url;

      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;
      }

      // Reference: RFC 3986, RFC 1808, RFC 2396

      // define these here so at least they only have to be
      // compiled once on the first module load.
      var protocolPattern = /^([a-z0-9.+-]+:)/i,
        portPattern = /:[0-9]*$/,

        // Special case for a simple path URL
        simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,

        // RFC 2396: characters reserved for delimiting URLs.
        // We actually just auto-escape these.
        delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],

        // RFC 2396: characters not allowed for various reasons.
        unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),

        // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
        autoEscape = ['\''].concat(unwise),
        // Characters that are never ever allowed in a hostname.
        // Note that any invalid chars are also handled, but these
        // are the ones that are *expected* to be seen, so we fast-path
        // them.
        nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
        hostEndingChars = ['/', '?', '#'],
        hostnameMaxLen = 255,
        hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
        hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
        // protocols that can allow "unsafe" and "unwise" chars.
        unsafeProtocol = {
          'javascript': true,
          'javascript:': true
        },
        // protocols that never have a hostname.
        hostlessProtocol = {
          'javascript': true,
          'javascript:': true
        },
        // protocols that always contain a // bit.
        slashedProtocol = {
          'http': true,
          'https': true,
          'ftp': true,
          'gopher': true,
          'file': true,
          'http:': true,
          'https:': true,
          'ftp:': true,
          'gopher:': true,
          'file:': true
        },
        querystring = require('querystring');

      function urlParse(url, parseQueryString, slashesDenoteHost) {
        if (url && util.isObject(url) && url instanceof Url) return url;

        var u = new Url;
        u.parse(url, parseQueryString, slashesDenoteHost);
        return u;
      }

      Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
        if (!util.isString(url)) {
          throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
        }

        // Copy chrome, IE, opera backslash-handling behavior.
        // Back slashes before the query string get converted to forward slashes
        // See: https://code.google.com/p/chromium/issues/detail?id=25916
        var queryIndex = url.indexOf('?'),
          splitter =
          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
          uSplit = url.split(splitter),
          slashRegex = /\\/g;
        uSplit[0] = uSplit[0].replace(slashRegex, '/');
        url = uSplit.join(splitter);

        var rest = url;

        // trim before proceeding.
        // This is to support parse stuff like "  http://foo.com  \n"
        rest = rest.trim();

        if (!slashesDenoteHost && url.split('#').length === 1) {
          // Try fast path regexp
          var simplePath = simplePathPattern.exec(rest);
          if (simplePath) {
            this.path = rest;
            this.href = rest;
            this.pathname = simplePath[1];
            if (simplePath[2]) {
              this.search = simplePath[2];
              if (parseQueryString) {
                this.query = querystring.parse(this.search.substr(1));
              } else {
                this.query = this.search.substr(1);
              }
            } else if (parseQueryString) {
              this.search = '';
              this.query = {};
            }
            return this;
          }
        }

        var proto = protocolPattern.exec(rest);
        if (proto) {
          proto = proto[0];
          var lowerProto = proto.toLowerCase();
          this.protocol = lowerProto;
          rest = rest.substr(proto.length);
        }

        // figure out if it's got a host
        // user@server is *always* interpreted as a hostname, and url
        // resolution will treat //foo/bar as host=foo,path=bar because that's
        // how the browser resolves relative URLs.
        if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
          var slashes = rest.substr(0, 2) === '//';
          if (slashes && !(proto && hostlessProtocol[proto])) {
            rest = rest.substr(2);
            this.slashes = true;
          }
        }

        if (!hostlessProtocol[proto] &&
          (slashes || (proto && !slashedProtocol[proto]))) {

          // there's a hostname.
          // the first instance of /, ?, ;, or # ends the host.
          //
          // If there is an @ in the hostname, then non-host chars *are* allowed
          // to the left of the last @ sign, unless some host-ending character
          // comes *before* the @-sign.
          // URLs are obnoxious.
          //
          // ex:
          // http://a@b@c/ => user:a@b host:c
          // http://a@b?@c => user:a host:c path:/?@c

          // v0.12 TODO(isaacs): This is not quite how Chrome does things.
          // Review our test case against browsers more comprehensively.

          // find the first instance of any hostEndingChars
          var hostEnd = -1;
          for (var i = 0; i < hostEndingChars.length; i++) {
            var hec = rest.indexOf(hostEndingChars[i]);
            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
              hostEnd = hec;
          }

          // at this point, either we have an explicit point where the
          // auth portion cannot go past, or the last @ char is the decider.
          var auth, atSign;
          if (hostEnd === -1) {
            // atSign can be anywhere.
            atSign = rest.lastIndexOf('@');
          } else {
            // atSign must be in auth portion.
            // http://a@b/c@d => host:b auth:a path:/c@d
            atSign = rest.lastIndexOf('@', hostEnd);
          }

          // Now we have a portion which is definitely the auth.
          // Pull that off.
          if (atSign !== -1) {
            auth = rest.slice(0, atSign);
            rest = rest.slice(atSign + 1);
            this.auth = decodeURIComponent(auth);
          }

          // the host is the remaining to the left of the first non-host char
          hostEnd = -1;
          for (var i = 0; i < nonHostChars.length; i++) {
            var hec = rest.indexOf(nonHostChars[i]);
            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
              hostEnd = hec;
          }
          // if we still have not hit it, then the entire thing is a host.
          if (hostEnd === -1)
            hostEnd = rest.length;

          this.host = rest.slice(0, hostEnd);
          rest = rest.slice(hostEnd);

          // pull out port.
          this.parseHost();

          // we've indicated that there is a hostname,
          // so even if it's empty, it has to be present.
          this.hostname = this.hostname || '';

          // if hostname begins with [ and ends with ]
          // assume that it's an IPv6 address.
          var ipv6Hostname = this.hostname[0] === '[' &&
            this.hostname[this.hostname.length - 1] === ']';

          // validate a little.
          if (!ipv6Hostname) {
            var hostparts = this.hostname.split(/\./);
            for (var i = 0, l = hostparts.length; i < l; i++) {
              var part = hostparts[i];
              if (!part) continue;
              if (!part.match(hostnamePartPattern)) {
                var newpart = '';
                for (var j = 0, k = part.length; j < k; j++) {
                  if (part.charCodeAt(j) > 127) {
                    // we replace non-ASCII char with a temporary placeholder
                    // we need this to make sure size of hostname is not
                    // broken by replacing non-ASCII by nothing
                    newpart += 'x';
                  } else {
                    newpart += part[j];
                  }
                }
                // we test again with ASCII char only
                if (!newpart.match(hostnamePartPattern)) {
                  var validParts = hostparts.slice(0, i);
                  var notHost = hostparts.slice(i + 1);
                  var bit = part.match(hostnamePartStart);
                  if (bit) {
                    validParts.push(bit[1]);
                    notHost.unshift(bit[2]);
                  }
                  if (notHost.length) {
                    rest = '/' + notHost.join('.') + rest;
                  }
                  this.hostname = validParts.join('.');
                  break;
                }
              }
            }
          }

          if (this.hostname.length > hostnameMaxLen) {
            this.hostname = '';
          } else {
            // hostnames are always lower case.
            this.hostname = this.hostname.toLowerCase();
          }

          if (!ipv6Hostname) {
            // IDNA Support: Returns a punycoded representation of "domain".
            // It only converts parts of the domain name that
            // have non-ASCII characters, i.e. it doesn't matter if
            // you call it with a domain that already is ASCII-only.
            this.hostname = punycode.toASCII(this.hostname);
          }

          var p = this.port ? ':' + this.port : '';
          var h = this.hostname || '';
          this.host = h + p;
          this.href += this.host;

          // strip [ and ] from the hostname
          // the host field still retains them, though
          if (ipv6Hostname) {
            this.hostname = this.hostname.substr(1, this.hostname.length - 2);
            if (rest[0] !== '/') {
              rest = '/' + rest;
            }
          }
        }

        // now rest is set to the post-host stuff.
        // chop off any delim chars.
        if (!unsafeProtocol[lowerProto]) {

          // First, make 100% sure that any "autoEscape" chars get
          // escaped, even if encodeURIComponent doesn't think they
          // need to be.
          for (var i = 0, l = autoEscape.length; i < l; i++) {
            var ae = autoEscape[i];
            if (rest.indexOf(ae) === -1)
              continue;
            var esc = encodeURIComponent(ae);
            if (esc === ae) {
              esc = escape(ae);
            }
            rest = rest.split(ae).join(esc);
          }
        }


        // chop off from the tail first.
        var hash = rest.indexOf('#');
        if (hash !== -1) {
          // got a fragment string.
          this.hash = rest.substr(hash);
          rest = rest.slice(0, hash);
        }
        var qm = rest.indexOf('?');
        if (qm !== -1) {
          this.search = rest.substr(qm);
          this.query = rest.substr(qm + 1);
          if (parseQueryString) {
            this.query = querystring.parse(this.query);
          }
          rest = rest.slice(0, qm);
        } else if (parseQueryString) {
          // no query string, but parseQueryString still requested
          this.search = '';
          this.query = {};
        }
        if (rest) this.pathname = rest;
        if (slashedProtocol[lowerProto] &&
          this.hostname && !this.pathname) {
          this.pathname = '/';
        }

        //to support http.request
        if (this.pathname || this.search) {
          var p = this.pathname || '';
          var s = this.search || '';
          this.path = p + s;
        }

        // finally, reconstruct the href based on what has been validated.
        this.href = this.format();
        return this;
      };

      // format a parsed object into a url string
      function urlFormat(obj) {
        // ensure it's an object, and not a string url.
        // If it's an obj, this is a no-op.
        // this way, you can call url_format() on strings
        // to clean up potentially wonky urls.
        if (util.isString(obj)) obj = urlParse(obj);
        if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
        return obj.format();
      }

      Url.prototype.format = function() {
        var auth = this.auth || '';
        if (auth) {
          auth = encodeURIComponent(auth);
          auth = auth.replace(/%3A/i, ':');
          auth += '@';
        }

        var protocol = this.protocol || '',
          pathname = this.pathname || '',
          hash = this.hash || '',
          host = false,
          query = '';

        if (this.host) {
          host = auth + this.host;
        } else if (this.hostname) {
          host = auth + (this.hostname.indexOf(':') === -1 ?
            this.hostname :
            '[' + this.hostname + ']');
          if (this.port) {
            host += ':' + this.port;
          }
        }

        if (this.query &&
          util.isObject(this.query) &&
          Object.keys(this.query).length) {
          query = querystring.stringify(this.query);
        }

        var search = this.search || (query && ('?' + query)) || '';

        if (protocol && protocol.substr(-1) !== ':') protocol += ':';

        // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
        // unless they had them to begin with.
        if (this.slashes ||
          (!protocol || slashedProtocol[protocol]) && host !== false) {
          host = '//' + (host || '');
          if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
        } else if (!host) {
          host = '';
        }

        if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
        if (search && search.charAt(0) !== '?') search = '?' + search;

        pathname = pathname.replace(/[?#]/g, function(match) {
          return encodeURIComponent(match);
        });
        search = search.replace('#', '%23');

        return protocol + host + pathname + search + hash;
      };

      function urlResolve(source, relative) {
        return urlParse(source, false, true).resolve(relative);
      }

      Url.prototype.resolve = function(relative) {
        return this.resolveObject(urlParse(relative, false, true)).format();
      };

      function urlResolveObject(source, relative) {
        if (!source) return relative;
        return urlParse(source, false, true).resolveObject(relative);
      }

      Url.prototype.resolveObject = function(relative) {
        if (util.isString(relative)) {
          var rel = new Url();
          rel.parse(relative, false, true);
          relative = rel;
        }

        var result = new Url();
        var tkeys = Object.keys(this);
        for (var tk = 0; tk < tkeys.length; tk++) {
          var tkey = tkeys[tk];
          result[tkey] = this[tkey];
        }

        // hash is always overridden, no matter what.
        // even href="" will remove it.
        result.hash = relative.hash;

        // if the relative url is empty, then there's nothing left to do here.
        if (relative.href === '') {
          result.href = result.format();
          return result;
        }

        // hrefs like //foo/bar always cut to the protocol.
        if (relative.slashes && !relative.protocol) {
          // take everything except the protocol from relative
          var rkeys = Object.keys(relative);
          for (var rk = 0; rk < rkeys.length; rk++) {
            var rkey = rkeys[rk];
            if (rkey !== 'protocol')
              result[rkey] = relative[rkey];
          }

          //urlParse appends trailing / to urls like http://www.example.com
          if (slashedProtocol[result.protocol] &&
            result.hostname && !result.pathname) {
            result.path = result.pathname = '/';
          }

          result.href = result.format();
          return result;
        }

        if (relative.protocol && relative.protocol !== result.protocol) {
          // if it's a known url protocol, then changing
          // the protocol does weird things
          // first, if it's not file:, then we MUST have a host,
          // and if there was a path
          // to begin with, then we MUST have a path.
          // if it is file:, then the host is dropped,
          // because that's known to be hostless.
          // anything else is assumed to be absolute.
          if (!slashedProtocol[relative.protocol]) {
            var keys = Object.keys(relative);
            for (var v = 0; v < keys.length; v++) {
              var k = keys[v];
              result[k] = relative[k];
            }
            result.href = result.format();
            return result;
          }

          result.protocol = relative.protocol;
          if (!relative.host && !hostlessProtocol[relative.protocol]) {
            var relPath = (relative.pathname || '').split('/');
            while (relPath.length && !(relative.host = relPath.shift()));
            if (!relative.host) relative.host = '';
            if (!relative.hostname) relative.hostname = '';
            if (relPath[0] !== '') relPath.unshift('');
            if (relPath.length < 2) relPath.unshift('');
            result.pathname = relPath.join('/');
          } else {
            result.pathname = relative.pathname;
          }
          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;
          // to support http.request
          if (result.pathname || result.search) {
            var p = result.pathname || '';
            var s = result.search || '';
            result.path = p + s;
          }
          result.slashes = result.slashes || relative.slashes;
          result.href = result.format();
          return 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('/') || [],
          relPath = relative.pathname && relative.pathname.split('/') || [],
          psychotic = result.protocol && !slashedProtocol[result.protocol];

        // if the url is a non-slashed url, then relative
        // links like ../.. should be able
        // to crawl up to the hostname, as well.  This is strange.
        // result.protocol has already been set by now.
        // Later on, put the first path part into the host field.
        if (psychotic) {
          result.hostname = '';
          result.port = null;
          if (result.host) {
            if (srcPath[0] === '') srcPath[0] = result.host;
            else srcPath.unshift(result.host);
          }
          result.host = '';
          if (relative.protocol) {
            relative.hostname = null;
            relative.port = null;
            if (relative.host) {
              if (relPath[0] === '') relPath[0] = relative.host;
              else relPath.unshift(relative.host);
            }
            relative.host = null;
          }
          mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
        }

        if (isRelAbs) {
          // it's absolute.
          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;
          // fall through to the dot-handling below.
        } else if (relPath.length) {
          // it's relative
          // throw away the existing file, and take the new path instead.
          if (!srcPath) srcPath = [];
          srcPath.pop();
          srcPath = srcPath.concat(relPath);
          result.search = relative.search;
          result.query = relative.query;
        } else if (!util.isNullOrUndefined(relative.search)) {
          // just pull out the search.
          // like href='?foo'.
          // Put this after the other two cases because it simplifies the booleans
          if (psychotic) {
            result.hostname = result.host = srcPath.shift();
            //occationaly the auth can get stuck only in host
            //this especially happens in cases like
            //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
            var authInHost = result.host && result.host.indexOf('@') > 0 ?
              result.host.split('@') : false;
            if (authInHost) {
              result.auth = authInHost.shift();
              result.host = result.hostname = authInHost.shift();
            }
          }
          result.search = relative.search;
          result.query = relative.query;
          //to support http.request
          if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
            result.path = (result.pathname ? result.pathname : '') +
              (result.search ? result.search : '');
          }
          result.href = result.format();
          return result;
        }

        if (!srcPath.length) {
          // no path at all.  easy.
          // we've already handled the other stuff above.
          result.pathname = null;
          //to support http.request
          if (result.search) {
            result.path = '/' + result.search;
          } else {
            result.path = null;
          }
          result.href = result.format();
          return result;
        }

        // if a url ENDs in . or .., then it must get a trailing slash.
        // however, if it ends in anything else non-slashy,
        // then it must NOT get a trailing slash.
        var last = srcPath.slice(-1)[0];
        var hasTrailingSlash = (
          (result.host || relative.host || srcPath.length > 1) &&
          (last === '.' || last === '..') || last === '');

        // strip single dots, resolve double dots to parent dir
        // if the path tries to go above the root, `up` ends up > 0
        var up = 0;
        for (var i = srcPath.length; i >= 0; i--) {
          last = srcPath[i];
          if (last === '.') {
            srcPath.splice(i, 1);
          } else if (last === '..') {
            srcPath.splice(i, 1);
            up++;
          } else if (up) {
            srcPath.splice(i, 1);
            up--;
          }
        }

        // if the path is allowed to go above the root, restore leading ..s
        if (!mustEndAbs && !removeAllDots) {
          for (; up--; up) {
            srcPath.unshift('..');
          }
        }

        if (mustEndAbs && srcPath[0] !== '' &&
          (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
          srcPath.unshift('');
        }

        if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
          srcPath.push('');
        }

        var isAbsolute = srcPath[0] === '' ||
          (srcPath[0] && srcPath[0].charAt(0) === '/');

        // put the host back
        if (psychotic) {
          result.hostname = result.host = isAbsolute ? '' :
            srcPath.length ? srcPath.shift() : '';
          //occationaly the auth can get stuck only in host
          //this especially happens in cases like
          //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
          var authInHost = result.host && result.host.indexOf('@') > 0 ?
            result.host.split('@') : false;
          if (authInHost) {
            result.auth = authInHost.shift();
            result.host = result.hostname = authInHost.shift();
          }
        }

        mustEndAbs = mustEndAbs || (result.host && srcPath.length);

        if (mustEndAbs && !isAbsolute) {
          srcPath.unshift('');
        }

        if (!srcPath.length) {
          result.pathname = null;
          result.path = null;
        } else {
          result.pathname = srcPath.join('/');
        }

        //to support request.http
        if (!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();
        return result;
      };

      Url.prototype.parseHost = function() {
        var host = this.host;
        var port = portPattern.exec(host);
        if (port) {
          port = port[0];
          if (port !== ':') {
            this.port = port.substr(1);
          }
          host = host.substr(0, host.length - port.length);
        }
        if (host) this.hostname = host;
      };

    }, {
      "./util": 113,
      "punycode": 93,
      "querystring": 96
    }],
    113: [function(require, module, exports) {
      'use strict';

      module.exports = {
        isString: function(arg) {
          return typeof(arg) === 'string';
        },
        isObject: function(arg) {
          return typeof(arg) === 'object' && arg !== null;
        },
        isNull: function(arg) {
          return arg === null;
        },
        isNullOrUndefined: function(arg) {
          return arg == null;
        }
      };

    }, {}],
    114: [function(require, module, exports) {
      (function(global) {

        /**
         * Module exports.
         */

        module.exports = deprecate;

        /**
         * Mark that a method should not be used.
         * Returns a modified function which warns once by default.
         *
         * If `localStorage.noDeprecation = true` is set, then it is a no-op.
         *
         * If `localStorage.throwDeprecation = true` is set, then deprecated functions
         * will throw an Error when invoked.
         *
         * If `localStorage.traceDeprecation = true` is set, then deprecated functions
         * will invoke `console.trace()` instead of `console.error()`.
         *
         * @param {Function} fn - the function to deprecate
         * @param {String} msg - the string to print to the console when `fn` is invoked
         * @returns {Function} a new "deprecated" version of `fn`
         * @api public
         */

        function deprecate(fn, msg) {
          if (config('noDeprecation')) {
            return fn;
          }

          var warned = false;

          function deprecated() {
            if (!warned) {
              if (config('throwDeprecation')) {
                throw new Error(msg);
              } else if (config('traceDeprecation')) {
                console.trace(msg);
              } else {
                console.warn(msg);
              }
              warned = true;
            }
            return fn.apply(this, arguments);
          }

          return deprecated;
        }

        /**
         * Checks `localStorage` for boolean values for the given `name`.
         *
         * @param {String} name
         * @returns {Boolean}
         * @api private
         */

        function config(name) {
          // accessing global.localStorage can trigger a DOMException in sandboxed iframes
          try {
            if (!global.localStorage) return false;
          } catch (_) {
            return false;
          }
          var val = global.localStorage[name];
          if (null == val) return false;
          return String(val).toLowerCase() === 'true';
        }

      }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {}],
    115: [function(require, module, exports) {
      module.exports = function isBuffer(arg) {
        return arg && typeof arg === 'object' &&
          typeof arg.copy === 'function' &&
          typeof arg.fill === 'function' &&
          typeof arg.readUInt8 === 'function';
      }
    }, {}],
    116: [function(require, module, exports) {
      (function(process, global) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        var formatRegExp = /%[sdj%]/g;
        exports.format = function(f) {
          if (!isString(f)) {
            var objects = [];
            for (var i = 0; i < arguments.length; i++) {
              objects.push(inspect(arguments[i]));
            }
            return objects.join(' ');
          }

          var i = 1;
          var args = arguments;
          var len = args.length;
          var str = String(f).replace(formatRegExp, function(x) {
            if (x === '%%') return '%';
            if (i >= len) return x;
            switch (x) {
              case '%s':
                return String(args[i++]);
              case '%d':
                return Number(args[i++]);
              case '%j':
                try {
                  return JSON.stringify(args[i++]);
                } catch (_) {
                  return '[Circular]';
                }
              default:
                return x;
            }
          });
          for (var x = args[i]; i < len; x = args[++i]) {
            if (isNull(x) || !isObject(x)) {
              str += ' ' + x;
            } else {
              str += ' ' + inspect(x);
            }
          }
          return str;
        };


        // Mark that a method should not be used.
        // Returns a modified function which warns once by default.
        // If --no-deprecation is set, then it is a no-op.
        exports.deprecate = function(fn, msg) {
          // Allow for deprecating things in the process of starting up.
          if (isUndefined(global.process)) {
            return function() {
              return exports.deprecate(fn, msg).apply(this, arguments);
            };
          }

          if (process.noDeprecation === true) {
            return fn;
          }

          var warned = false;

          function deprecated() {
            if (!warned) {
              if (process.throwDeprecation) {
                throw new Error(msg);
              } else if (process.traceDeprecation) {
                console.trace(msg);
              } else {
                console.error(msg);
              }
              warned = true;
            }
            return fn.apply(this, arguments);
          }

          return deprecated;
        };


        var debugs = {};
        var debugEnviron;
        exports.debuglog = function(set) {
          if (isUndefined(debugEnviron))
            debugEnviron = process.env.NODE_DEBUG || '';
          set = set.toUpperCase();
          if (!debugs[set]) {
            if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
              var pid = process.pid;
              debugs[set] = function() {
                var msg = exports.format.apply(exports, arguments);
                console.error('%s %d: %s', set, pid, msg);
              };
            } else {
              debugs[set] = function() {};
            }
          }
          return debugs[set];
        };


        /**
         * Echos the value of a value. Trys to print the value out
         * in the best way possible given the different types.
         *
         * @param {Object} obj The object to print out.
         * @param {Object} opts Optional options object that alters the output.
         */
        /* legacy: obj, showHidden, depth, colors*/
        function inspect(obj, opts) {
          // default options
          var ctx = {
            seen: [],
            stylize: stylizeNoColor
          };
          // legacy...
          if (arguments.length >= 3) ctx.depth = arguments[2];
          if (arguments.length >= 4) ctx.colors = arguments[3];
          if (isBoolean(opts)) {
            // legacy...
            ctx.showHidden = opts;
          } else if (opts) {
            // got an "options" object
            exports._extend(ctx, opts);
          }
          // set default options
          if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
          if (isUndefined(ctx.depth)) ctx.depth = 2;
          if (isUndefined(ctx.colors)) ctx.colors = false;
          if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
          if (ctx.colors) ctx.stylize = stylizeWithColor;
          return formatValue(ctx, obj, ctx.depth);
        }
        exports.inspect = inspect;


        // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
        inspect.colors = {
          'bold': [1, 22],
          'italic': [3, 23],
          'underline': [4, 24],
          'inverse': [7, 27],
          'white': [37, 39],
          'grey': [90, 39],
          'black': [30, 39],
          'blue': [34, 39],
          'cyan': [36, 39],
          'green': [32, 39],
          'magenta': [35, 39],
          'red': [31, 39],
          'yellow': [33, 39]
        };

        // Don't use 'blue' not visible on cmd.exe
        inspect.styles = {
          'special': 'cyan',
          'number': 'yellow',
          'boolean': 'yellow',
          'undefined': 'grey',
          'null': 'bold',
          'string': 'green',
          'date': 'magenta',
          // "name": intentionally not styling
          'regexp': 'red'
        };


        function stylizeWithColor(str, styleType) {
          var style = inspect.styles[styleType];

          if (style) {
            return '\u001b[' + inspect.colors[style][0] + 'm' + str +
              '\u001b[' + inspect.colors[style][1] + 'm';
          } else {
            return str;
          }
        }


        function stylizeNoColor(str, styleType) {
          return str;
        }


        function arrayToHash(array) {
          var hash = {};

          array.forEach(function(val, idx) {
            hash[val] = true;
          });

          return hash;
        }


        function formatValue(ctx, value, recurseTimes) {
          // Provide a hook for user-specified inspect functions.
          // Check that value is an object with an inspect function on it
          if (ctx.customInspect &&
            value &&
            isFunction(value.inspect) &&
            // Filter out the util module, it's inspect function is special
            value.inspect !== exports.inspect &&
            // Also filter out any prototype objects using the circular check.
            !(value.constructor && value.constructor.prototype === value)) {
            var ret = value.inspect(recurseTimes, ctx);
            if (!isString(ret)) {
              ret = formatValue(ctx, ret, recurseTimes);
            }
            return ret;
          }

          // Primitive types cannot have properties
          var primitive = formatPrimitive(ctx, value);
          if (primitive) {
            return primitive;
          }

          // Look up the keys of the object.
          var keys = Object.keys(value);
          var visibleKeys = arrayToHash(keys);

          if (ctx.showHidden) {
            keys = Object.getOwnPropertyNames(value);
          }

          // IE doesn't make error fields non-enumerable
          // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
          if (isError(value) &&
            (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
            return formatError(value);
          }

          // Some type of object without properties can be shortcutted.
          if (keys.length === 0) {
            if (isFunction(value)) {
              var name = value.name ? ': ' + value.name : '';
              return ctx.stylize('[Function' + name + ']', 'special');
            }
            if (isRegExp(value)) {
              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
            }
            if (isDate(value)) {
              return ctx.stylize(Date.prototype.toString.call(value), 'date');
            }
            if (isError(value)) {
              return formatError(value);
            }
          }

          var base = '',
            array = false,
            braces = ['{', '}'];

          // Make Array say that they are Array
          if (isArray(value)) {
            array = true;
            braces = ['[', ']'];
          }

          // Make functions say that they are functions
          if (isFunction(value)) {
            var n = value.name ? ': ' + value.name : '';
            base = ' [Function' + n + ']';
          }

          // Make RegExps say that they are RegExps
          if (isRegExp(value)) {
            base = ' ' + RegExp.prototype.toString.call(value);
          }

          // Make dates with properties first say the date
          if (isDate(value)) {
            base = ' ' + Date.prototype.toUTCString.call(value);
          }

          // Make error with message first say the error
          if (isError(value)) {
            base = ' ' + formatError(value);
          }

          if (keys.length === 0 && (!array || value.length == 0)) {
            return braces[0] + base + braces[1];
          }

          if (recurseTimes < 0) {
            if (isRegExp(value)) {
              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
            } else {
              return ctx.stylize('[Object]', 'special');
            }
          }

          ctx.seen.push(value);

          var output;
          if (array) {
            output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
          } else {
            output = keys.map(function(key) {
              return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
            });
          }

          ctx.seen.pop();

          return reduceToSingleString(output, base, braces);
        }


        function formatPrimitive(ctx, value) {
          if (isUndefined(value))
            return ctx.stylize('undefined', 'undefined');
          if (isString(value)) {
            var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
              .replace(/'/g, "\\'")
              .replace(/\\"/g, '"') + '\'';
            return ctx.stylize(simple, 'string');
          }
          if (isNumber(value))
            return ctx.stylize('' + value, 'number');
          if (isBoolean(value))
            return ctx.stylize('' + value, 'boolean');
          // For some reason typeof null is "object", so special case here.
          if (isNull(value))
            return ctx.stylize('null', 'null');
        }


        function formatError(value) {
          return '[' + Error.prototype.toString.call(value) + ']';
        }


        function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
          var output = [];
          for (var i = 0, l = value.length; i < l; ++i) {
            if (hasOwnProperty(value, String(i))) {
              output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
                String(i), true));
            } else {
              output.push('');
            }
          }
          keys.forEach(function(key) {
            if (!key.match(/^\d+$/)) {
              output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
                key, true));
            }
          });
          return output;
        }


        function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
          var name, str, desc;
          desc = Object.getOwnPropertyDescriptor(value, key) || {
            value: value[key]
          };
          if (desc.get) {
            if (desc.set) {
              str = ctx.stylize('[Getter/Setter]', 'special');
            } else {
              str = ctx.stylize('[Getter]', 'special');
            }
          } else {
            if (desc.set) {
              str = ctx.stylize('[Setter]', 'special');
            }
          }
          if (!hasOwnProperty(visibleKeys, key)) {
            name = '[' + key + ']';
          }
          if (!str) {
            if (ctx.seen.indexOf(desc.value) < 0) {
              if (isNull(recurseTimes)) {
                str = formatValue(ctx, desc.value, null);
              } else {
                str = formatValue(ctx, desc.value, recurseTimes - 1);
              }
              if (str.indexOf('\n') > -1) {
                if (array) {
                  str = str.split('\n').map(function(line) {
                    return '  ' + line;
                  }).join('\n').substr(2);
                } else {
                  str = '\n' + str.split('\n').map(function(line) {
                    return '   ' + line;
                  }).join('\n');
                }
              }
            } else {
              str = ctx.stylize('[Circular]', 'special');
            }
          }
          if (isUndefined(name)) {
            if (array && key.match(/^\d+$/)) {
              return str;
            }
            name = JSON.stringify('' + key);
            if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
              name = name.substr(1, name.length - 2);
              name = ctx.stylize(name, 'name');
            } else {
              name = name.replace(/'/g, "\\'")
                .replace(/\\"/g, '"')
                .replace(/(^"|"$)/g, "'");
              name = ctx.stylize(name, 'string');
            }
          }

          return name + ': ' + str;
        }


        function reduceToSingleString(output, base, braces) {
          var numLinesEst = 0;
          var length = output.reduce(function(prev, cur) {
            numLinesEst++;
            if (cur.indexOf('\n') >= 0) numLinesEst++;
            return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
          }, 0);

          if (length > 60) {
            return braces[0] +
              (base === '' ? '' : base + '\n ') +
              ' ' +
              output.join(',\n  ') +
              ' ' +
              braces[1];
          }

          return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
        }


        // NOTE: These type checking functions intentionally don't use `instanceof`
        // because it is fragile and can be easily faked with `Object.create()`.
        function isArray(ar) {
          return Array.isArray(ar);
        }
        exports.isArray = isArray;

        function isBoolean(arg) {
          return typeof arg === 'boolean';
        }
        exports.isBoolean = isBoolean;

        function isNull(arg) {
          return arg === null;
        }
        exports.isNull = isNull;

        function isNullOrUndefined(arg) {
          return arg == null;
        }
        exports.isNullOrUndefined = isNullOrUndefined;

        function isNumber(arg) {
          return typeof arg === 'number';
        }
        exports.isNumber = isNumber;

        function isString(arg) {
          return typeof arg === 'string';
        }
        exports.isString = isString;

        function isSymbol(arg) {
          return typeof arg === 'symbol';
        }
        exports.isSymbol = isSymbol;

        function isUndefined(arg) {
          return arg === void 0;
        }
        exports.isUndefined = isUndefined;

        function isRegExp(re) {
          return isObject(re) && objectToString(re) === '[object RegExp]';
        }
        exports.isRegExp = isRegExp;

        function isObject(arg) {
          return typeof arg === 'object' && arg !== null;
        }
        exports.isObject = isObject;

        function isDate(d) {
          return isObject(d) && objectToString(d) === '[object Date]';
        }
        exports.isDate = isDate;

        function isError(e) {
          return isObject(e) &&
            (objectToString(e) === '[object Error]' || e instanceof Error);
        }
        exports.isError = isError;

        function isFunction(arg) {
          return typeof arg === 'function';
        }
        exports.isFunction = isFunction;

        function isPrimitive(arg) {
          return arg === null ||
            typeof arg === 'boolean' ||
            typeof arg === 'number' ||
            typeof arg === 'string' ||
            typeof arg === 'symbol' || // ES6 symbol
            typeof arg === 'undefined';
        }
        exports.isPrimitive = isPrimitive;

        exports.isBuffer = require('./support/isBuffer');

        function objectToString(o) {
          return Object.prototype.toString.call(o);
        }


        function pad(n) {
          return n < 10 ? '0' + n.toString(10) : n.toString(10);
        }


        var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
          'Oct', 'Nov', 'Dec'
        ];

        // 26 Feb 16:19:34
        function timestamp() {
          var d = new Date();
          var time = [pad(d.getHours()),
            pad(d.getMinutes()),
            pad(d.getSeconds())
          ].join(':');
          return [d.getDate(), months[d.getMonth()], time].join(' ');
        }


        // log is just a thin wrapper to console.log that prepends a timestamp
        exports.log = function() {
          console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
        };


        /**
         * Inherit the prototype methods from one constructor into another.
         *
         * The Function.prototype.inherits from lang.js rewritten as a standalone
         * function (not on Function.prototype). NOTE: If this file is to be loaded
         * during bootstrapping this function needs to be rewritten using some native
         * functions as prototype setup using normal JavaScript does not work as
         * expected during bootstrapping (see mirror.js in r114903).
         *
         * @param {function} ctor Constructor function which needs to inherit the
         *     prototype.
         * @param {function} superCtor Constructor function to inherit prototype from.
         */
        exports.inherits = require('inherits');

        exports._extend = function(origin, add) {
          // Don't do anything if add isn't an object
          if (!add || !isObject(add)) return origin;

          var keys = Object.keys(add);
          var i = keys.length;
          while (i--) {
            origin[keys[i]] = add[keys[i]];
          }
          return origin;
        };

        function hasOwnProperty(obj, prop) {
          return Object.prototype.hasOwnProperty.call(obj, prop);
        }

      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "./support/isBuffer": 115,
      "_process": 92,
      "inherits": 80
    }],
    117: [function(require, module, exports) {
      (function(process, global) {
        'use strict'

        var Transform = require('readable-stream').Transform
        var duplexify = require('duplexify')
        var WS = require('ws')
        var Buffer = require('safe-buffer').Buffer

        module.exports = WebSocketStream

        function buildProxy(options, socketWrite, socketEnd) {
          var proxy = new Transform({
            objectMode: options.objectMode
          })

          proxy._write = socketWrite
          proxy._flush = socketEnd

          return proxy
        }

        function WebSocketStream(target, protocols, options) {
          var stream, socket

          var isBrowser = process.title === 'browser'
          var isNative = !!global.WebSocket
          var socketWrite = isBrowser ? socketWriteBrowser : socketWriteNode

          if (protocols && !Array.isArray(protocols) && 'object' === typeof protocols) {
            // accept the "options" Object as the 2nd argument
            options = protocols
            protocols = null

            if (typeof options.protocol === 'string' || Array.isArray(options.protocol)) {
              protocols = options.protocol;
            }
          }

          if (!options) options = {}

          if (options.objectMode === undefined) {
            options.objectMode = !(options.binary === true || options.binary === undefined)
          }

          var proxy = buildProxy(options, socketWrite, socketEnd)

          if (!options.objectMode) {
            proxy._writev = writev
          }

          // browser only: sets the maximum socket buffer size before throttling
          var bufferSize = options.browserBufferSize || 1024 * 512

          // browser only: how long to wait when throttling
          var bufferTimeout = options.browserBufferTimeout || 1000

          // use existing WebSocket object that was passed in
          if (typeof target === 'object') {
            socket = target
            // otherwise make a new one
          } else {
            // special constructor treatment for native websockets in browsers, see
            // https://github.com/maxogden/websocket-stream/issues/82
            if (isNative && isBrowser) {
              socket = new WS(target, protocols)
            } else {
              socket = new WS(target, protocols, options)
            }

            socket.binaryType = 'arraybuffer'
          }

          // was already open when passed in
          if (socket.readyState === socket.OPEN) {
            stream = proxy
          } else {
            stream = duplexify.obj()
            socket.onopen = onopen
          }

          stream.socket = socket

          socket.onclose = onclose
          socket.onerror = onerror
          socket.onmessage = onmessage

          proxy.on('close', destroy)

          var coerceToBuffer = !options.objectMode

          function socketWriteNode(chunk, enc, next) {
            // avoid errors, this never happens unless
            // destroy() is called
            if (socket.readyState !== socket.OPEN) {
              next()
              return
            }

            if (coerceToBuffer && typeof chunk === 'string') {
              chunk = Buffer.from(chunk, 'utf8')
            }
            socket.send(chunk, next)
          }

          function socketWriteBrowser(chunk, enc, next) {
            if (socket.bufferedAmount > bufferSize) {
              setTimeout(socketWriteBrowser, bufferTimeout, chunk, enc, next)
              return
            }

            if (coerceToBuffer && typeof chunk === 'string') {
              chunk = Buffer.from(chunk, 'utf8')
            }

            try {
              socket.send(chunk)
            } catch (err) {
              return next(err)
            }

            next()
          }

          function socketEnd(done) {
            socket.close()
            done()
          }

          function onopen() {
            stream.setReadable(proxy)
            stream.setWritable(proxy)
            stream.emit('connect')
          }

          function onclose() {
            stream.end()
            stream.destroy()
          }

          function onerror(err) {
            stream.destroy(err)
          }

          function onmessage(event) {
            var data = event.data
            if (data instanceof ArrayBuffer) data = Buffer.from(data)
            else data = Buffer.from(data, 'utf8')
            proxy.push(data)
          }

          function destroy() {
            socket.close()
          }

          // this is to be enabled only if objectMode is false
          function writev(chunks, cb) {
            var buffers = new Array(chunks.length)
            for (var i = 0; i < chunks.length; i++) {
              if (typeof chunks[i].chunk === 'string') {
                buffers[i] = Buffer.from(chunks[i], 'utf8')
              } else {
                buffers[i] = chunks[i].chunk
              }
            }

            this._write(Buffer.concat(buffers), 'binary', cb)
          }

          return stream
        }

      }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
      "_process": 92,
      "duplexify": 16,
      "readable-stream": 106,
      "safe-buffer": 108,
      "ws": 118
    }],
    118: [function(require, module, exports) {

      var ws = null

      if (typeof WebSocket !== 'undefined') {
        ws = WebSocket
      } else if (typeof MozWebSocket !== 'undefined') {
        ws = MozWebSocket
      } else if (typeof window !== 'undefined') {
        ws = window.WebSocket || window.MozWebSocket
      }

      module.exports = ws

    }, {}],
    119: [function(require, module, exports) {
      // Returns a wrapper function that returns a wrapped callback
      // The wrapper function should do some stuff, and return a
      // presumably different callback function.
      // This makes sure that own properties are retained, so that
      // decorations and such are not lost along the way.
      module.exports = wrappy

      function wrappy(fn, cb) {
        if (fn && cb) return wrappy(fn)(cb)

        if (typeof fn !== 'function')
          throw new TypeError('need wrapper function')

        Object.keys(fn).forEach(function(k) {
          wrapper[k] = fn[k]
        })

        return wrapper

        function wrapper() {
          var args = new Array(arguments.length)
          for (var i = 0; i < args.length; i++) {
            args[i] = arguments[i]
          }
          var ret = fn.apply(this, args)
          var cb = args[args.length - 1]
          if (typeof ret === 'function' && ret !== cb) {
            Object.keys(cb).forEach(function(k) {
              ret[k] = cb[k]
            })
          }
          return ret
        }
      }

    }, {}],
    120: [function(require, module, exports) {
      module.exports = extend

      var hasOwnProperty = Object.prototype.hasOwnProperty;

      function extend() {
        var target = {}

        for (var i = 0; i < arguments.length; i++) {
          var source = arguments[i]

          for (var key in source) {
            if (hasOwnProperty.call(source, key)) {
              target[key] = source[key]
            }
          }
        }

        return target
      }

    }, {}]
  }, {}, [8])(8)
});