// function vilidator(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()
// 	}
// }
// 解决vite引入报错问题
const init = 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 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
				}
				var errors = {
					0: '',
					1: 'Unacceptable protocol version',
					2: 'Identifier rejected',
					3: 'Server unavailable',
					4: 'Bad username or password',
					5: 'Not authorized',
					16: 'No matching subscribers',
					17: 'No subscription existed',
					128: 'Unspecified error',
					129: 'Malformed Packet',
					130: 'Protocol Error',
					131: 'Implementation specific error',
					132: 'Unsupported Protocol Version',
					133: 'Client Identifier not valid',
					134: 'Bad User Name or Password',
					135: 'Not authorized',
					136: 'Server unavailable',
					137: 'Server busy',
					138: 'Banned',
					139: 'Server shutting down',
					140: 'Bad authentication method',
					141: 'Keep Alive timeout',
					142: 'Session taken over',
					143: 'Topic Filter invalid',
					144: 'Topic Name invalid',
					145: 'Packet identifier in use',
					146: 'Packet Identifier not found',
					147: 'Receive Maximum exceeded',
					148: 'Topic Alias invalid',
					149: 'Packet too large',
					150: 'Message rate too high',
					151: 'Quota exceeded',
					152: 'Administrative action',
					153: 'Payload format invalid',
					154: 'Retain not supported',
					155: 'QoS not supported',
					156: 'Use another server',
					157: 'Server moved',
					158: 'Shared Subscriptions not supported',
					159: 'Connection rate exceeded',
					160: 'Maximum connect time',
					161: 'Subscription Identifiers not supported',
					162: 'Wildcard Subscriptions not supported'
				}

				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, client.options)

					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].cb === 'function') {
								queue[messageId].cb(new Error('Connection closed'))
								delete queue[messageId]
							}
						})
					}
				}

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

				function storeAndSend(client, packet, cb, cbStorePut) {
					client.outgoingStore.put(packet, function storedPacket(err) {
						if (err) {
							return cb && cb(err)
						}
						cbStorePut()
						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 options.clientId === 'string') ? options
						.clientId : defaultId()

					this.options.customHandleAcks = (options.protocolVersion === 5 && options
						.customHandleAcks) ? options.customHandleAcks : function() {
						arguments[3](0)
					}

					this.streamBuilder = streamBuilder

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

					// Should QoS zero messages be queued when the connection is broken?
					this.queueQoSZero = options.queueQoSZero === undefined ? true : 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
					// Is processing store?
					this._storeProcessing = false
					// Packet Ids are put into the store during store processing
					this._packetIdsDuringStoreProcessing = {}
					/**
					 * 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 = {}

					// True if connection is first time.
					this._firstConnection = true

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

					// 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()
					})

					// 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() {
						if (packets.length) {
							process.nextTick(work)
						} else {
							var done = completeParse
							completeParse = null
							done()
						}
					}

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

						if (packet) {
							that._handlePacket(packet, nextTickWork)
						} else {
							var done = completeParse
							completeParse = null
							if (done) 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
					this.stream.on('close', function() {
						flushVolatile(that.outgoing)
						that.emit('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'))

					// auth
					if (this.options.properties) {
						if (!this.options.properties.authenticationMethod && this.options
							.properties.authenticationData) {
							this.emit('error', new Error(
								'Packet has no Authentication Method'))
							return this
						}
						if (this.options.properties.authenticationMethod && this.options
							.authPacket && typeof this.options.authPacket === 'object') {
							var authPacket = xtend({
								cmd: 'auth',
								reasonCode: 0
							}, this.options.authPacket)
							sendPacket(this, authPacket)
						}
					}

					// 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) {
					var options = this.options

					if (options.protocolVersion === 5 && options.properties && options
						.properties.maximumPacketSize && options.properties
						.maximumPacketSize < packet.length) {
						this.emit('error', new Error('exceeding packets size ' + packet
							.cmd))
						this.end({
							reasonCode: 149,
							properties: {
								reasonString: 'Maximum packet size was exceeded'
							}
						})
						return this
					}

					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
						case 'disconnect':
							this._handleDisconnect(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
				 *    {Function} cbStorePut - function(){} called when message is put into `outgoingStore`
				 * @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
					var options = this.options

					// .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
					}

					if (options.protocolVersion === 5) {
						packet.properties = opts.properties
						if ((!options.properties && packet.properties && packet.properties
								.topicAlias) || ((opts.properties && options.properties) &&
								((opts.properties.topicAlias && options.properties
										.topicAliasMaximum && opts.properties.topicAlias >
										options.properties.topicAliasMaximum) ||
									(!options.properties.topicAliasMaximum && opts
										.properties.topicAlias)))) {
							/*
							if we are don`t setup topic alias or
							topic alias maximum less than topic alias or
							server don`t give topic alias maximum,
							we are removing topic alias from packet
							*/
							delete packet.properties.topicAlias
						}
					}

					switch (opts.qos) {
						case 1:
						case 2:
							// Add to callbacks
							this.outgoing[packet.messageId] = {
								volatile: false,
								cb: callback || nop
							}
							if (this._storeProcessing) {
								this._packetIdsDuringStoreProcessing[packet.messageId] =
									false
								this._storePacket(packet, undefined, opts.cbStorePut)
							} else {
								this._sendPacket(packet, undefined, opts.cbStorePut)
							}
							break
						default:
							if (this._storeProcessing) {
								this._storePacket(packet, callback, opts.cbStorePut)
							} else {
								this._sendPacket(packet, callback, opts.cbStorePut)
							}
							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': {qos: 0}, 'topic2': {qos: 1}}, console.log);
				 * @example client.subscribe('topic', console.log);
				 */
				MqttClient.prototype.subscribe = function() {
					var packet
					var args = new Array(arguments.length)
					for (var i = 0; i < arguments.length; i++) {
						args[i] = arguments[i]
					}
					var subs = []
					var obj = args.shift()
					var resubscribe = obj.resubscribe
					var callback = args.pop() || nop
					var opts = args.pop()
					var invalidTopic
					var that = this
					var version = this.options.protocolVersion

					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
					}
					if (version === 5) {
						defaultOpts.nl = false
						defaultOpts.rap = false
						defaultOpts.rh = 0
					}
					opts = xtend(defaultOpts, opts)

					if (Array.isArray(obj)) {
						obj.forEach(function(topic) {
							if (!that._resubscribeTopics.hasOwnProperty(topic) ||
								that._resubscribeTopics[topic].qos < opts.qos ||
								resubscribe) {
								var currentOpts = {
									topic: topic,
									qos: opts.qos
								}
								if (version === 5) {
									currentOpts.nl = opts.nl
									currentOpts.rap = opts.rap
									currentOpts.rh = opts.rh
									currentOpts.properties = opts.properties
								}
								subs.push(currentOpts)
							}
						})
					} else {
						Object
							.keys(obj)
							.forEach(function(k) {
								if (!that._resubscribeTopics.hasOwnProperty(k) ||
									that._resubscribeTopics[k].qos < obj[k].qos ||
									resubscribe) {
									var currentOpts = {
										topic: k,
										qos: obj[k].qos
									}
									if (version === 5) {
										currentOpts.nl = obj[k].nl
										currentOpts.rap = obj[k].rap
										currentOpts.rh = obj[k].rh
										currentOpts.properties = opts.properties
									}
									subs.push(currentOpts)
								}
							})
					}

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

					if (opts.properties) {
						packet.properties = opts.properties
					}

					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) {
								var topic = {
									qos: sub.qos
								}
								if (version === 5) {
									topic.nl = sub.nl || false
									topic.rap = sub.rap || false
									topic.rh = sub.rh || 0
									topic.properties = sub.properties
								}
								that._resubscribeTopics[sub.topic] = topic
								topics.push(sub.topic)
							}
						})
						that.messageIdToTopic[packet.messageId] = topics
					}

					this.outgoing[packet.messageId] = {
						volatile: true,
						cb: 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 {Object} [opts] - optional subscription options, includes:
				 *    {Object} properties - properties of unsubscribe packet
				 * @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() {
					var packet = {
						cmd: 'unsubscribe',
						qos: 1,
						messageId: this._nextId()
					}
					var that = this
					var args = new Array(arguments.length)
					for (var i = 0; i < arguments.length; i++) {
						args[i] = arguments[i]
					}
					var topic = args.shift()
					var callback = args.pop() || nop
					var opts = args.pop()

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

					if (typeof callback !== 'function') {
						opts = 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]
						})
					}

					if (typeof opts === 'object' && opts.properties) {
						packet.properties = opts.properties
					}

					this.outgoing[packet.messageId] = {
						volatile: true,
						cb: 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() {
					var that = this

					var force = arguments[0]
					var opts = arguments[1]
					var cb = arguments[2]

					if (force == null || typeof force !== 'boolean') {
						cb = opts || nop
						opts = force
						force = false
						if (typeof opts !== 'object') {
							cb = opts
							opts = null
							if (typeof cb !== 'function') {
								cb = nop
							}
						}
					}

					if (typeof opts !== 'object') {
						cb = opts
						opts = null
					}

					cb = cb || nop

					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), opts)
					}

					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] ? this.outgoing[mid].cb : null
					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) {
					var opts = arguments[2]
					if (done) {
						this.stream.on('close', done)
					}

					if (forced) {
						if ((this.options.reconnectPeriod === 0) && this.options.clean) {
							flush(this.outgoing)
						}
						this.stream.destroy()
					} else {
						var packet = xtend({
							cmd: 'disconnect'
						}, opts)
						this._sendPacket(
							packet,
							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
				 * @param {Function} cbStorePut - called when message is put into outgoingStore
				 * @api private
				 */
				MqttClient.prototype._sendPacket = function(packet, cb, cbStorePut) {
					cbStorePut = cbStorePut || nop

					if (!this.connected) {
						this._storePacket(packet, cb, cbStorePut)
						return
					}

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

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

					switch (packet.qos) {
						case 2:
						case 1:
							storeAndSend(this, packet, cb, cbStorePut)
							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
					}
				}

				/**
				 * _storePacket - queue a packet
				 * @param {String} type - packet type (see `protocol`)
				 * @param {Object} packet - packet options
				 * @param {Function} cb - callback when the packet is sent
				 * @param {Function} cbStorePut - called when message is put into outgoingStore
				 * @api private
				 */
				MqttClient.prototype._storePacket = function(packet, cb, cbStorePut) {
					cbStorePut = cbStorePut || nop

					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.outgoing[packet
							.messageId].cb : null
						this.outgoingStore.put(packet, function(err) {
							if (err) {
								return cb && cb(err)
							}
							cbStorePut()
						})
					} else if (cb) {
						cb(new Error('No connection to broker'))
					}
				}

				/**
				 * _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 options = this.options
					var version = options.protocolVersion
					var rc = version === 5 ? packet.reasonCode : packet.returnCode

					clearTimeout(this.connackTimer)

					if (packet.properties) {
						if (packet.properties.topicAliasMaximum) {
							if (!options.properties) {
								options.properties = {}
							}
							options.properties.topicAliasMaximum = packet.properties
								.topicAliasMaximum
						}
						if (packet.properties.serverKeepAlive && options.keepalive) {
							options.keepalive = packet.properties.serverKeepAlive
							this._shiftPingInterval()
						}
						if (packet.properties.maximumPacketSize) {
							if (!options.properties) {
								options.properties = {}
							}
							options.properties.maximumPacketSize = packet.properties
								.maximumPacketSize
						}
					}

					if (rc === 0) {
						this.reconnecting = false
						this._onConnect(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
					var options = this.options
					var validReasonCodes = [0, 16, 128, 131, 135, 144, 145, 151, 153]

					switch (qos) {
						case 2: {
							options.customHandleAcks(topic, message, packet, function(error,
								code) {
								if (!(error instanceof Error)) {
									code = error
									error = null
								}
								if (error) {
									return that.emit('error', error)
								}
								if (validReasonCodes.indexOf(code) === -1) {
									return that.emit('error', new Error(
										'Wrong reason code for pubrec'))
								}
								if (code) {
									that._sendPacket({
										cmd: 'pubrec',
										messageId: mid,
										reasonCode: code
									}, done)
								} else {
									that.incomingStore.put(packet, function() {
										that._sendPacket({
											cmd: 'pubrec',
											messageId: mid
										}, done)
									})
								}
							})
							break
						}
						case 1: {
							// emit the message event
							options.customHandleAcks(topic, message, packet, function(error,
								code) {
								if (!(error instanceof Error)) {
									code = error
									error = null
								}
								if (error) {
									return that.emit('error', error)
								}
								if (validReasonCodes.indexOf(code) === -1) {
									return that.emit('error', new Error(
										'Wrong reason code for puback'))
								}
								if (!code) {
									that.emit('message', topic, message, packet)
								}
								that.handleMessage(packet, function(err) {
									if (err) {
										return done && done(err)
									}
									that._sendPacket({
										cmd: 'puback',
										messageId: mid,
										reasonCode: code
									}, 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] ? this.outgoing[mid].cb : null
					var that = this
					var err

					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':
							var pubackRC = packet.reasonCode
							// Callback - we're done
							if (pubackRC && pubackRC > 0 && pubackRC !== 16) {
								err = new Error('Publish error: ' + errors[pubackRC])
								err.code = pubackRC
								cb(err, packet)
							}
							delete this.outgoing[mid]
							this.outgoingStore.del(packet, cb)
							break
						case 'pubrec':
							response = {
								cmd: 'pubrel',
								qos: 2,
								messageId: mid
							}
							var pubrecRC = packet.reasonCode

							if (pubrecRC && pubrecRC > 0 && pubrecRC !== 16) {
								err = new Error('Publish error: ' + errors[pubrecRC])
								err.code = pubrecRC
								cb(err, packet)
							} else {
								this._sendPacket(response)
							}
							break
						case 'suback':
							delete this.outgoing[mid]
							for (var grantedI = 0; grantedI < packet.granted
								.length; grantedI++) {
								if ((packet.granted[grantedI] & 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) {
							that.emit('message', pub.topic, pub.payload, pub)
							that.handleMessage(pub, function(err) {
								if (err) {
									return callback(err)
								}
								that.incomingStore.del(pub, nop)
								that._sendPacket(comp, callback)
							})
						} else {
							that._sendPacket(comp, callback)
						}
					})
				}

				/**
				 * _handleDisconnect
				 *
				 * @param {Object} packet
				 * @api private
				 */
				MqttClient.prototype._handleDisconnect = function(packet) {
					this.emit('disconnect', packet)
				}

				/**
				 * _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)
				}

				/**
				 * _resubscribe
				 * @api private
				 */
				MqttClient.prototype._resubscribe = function(connack) {
					var _resubscribeTopicsKeys = Object.keys(this._resubscribeTopics)
					if (!this._firstConnection &&
						(this.options.clean || (this.options.protocolVersion === 5 && !
							connack.sessionPresent)) &&
						_resubscribeTopicsKeys.length > 0) {
						if (this.options.resubscribe) {
							if (this.options.protocolVersion === 5) {
								for (var topicI = 0; topicI < _resubscribeTopicsKeys
									.length; topicI++) {
									var resubscribeTopic = {}
									resubscribeTopic[_resubscribeTopicsKeys[topicI]] = this
										._resubscribeTopics[_resubscribeTopicsKeys[topicI]]
									resubscribeTopic.resubscribe = true
									this.subscribe(resubscribeTopic, {
										properties: resubscribeTopic[
												_resubscribeTopicsKeys[topicI]]
											.properties
									})
								}
							} else {
								this._resubscribeTopics.resubscribe = true
								this.subscribe(this._resubscribeTopics)
							}
						} else {
							this._resubscribeTopics = {}
						}
					}

					this._firstConnection = false
				}

				/**
				 * _onConnect
				 *
				 * @api private
				 */
				MqttClient.prototype._onConnect = function(packet) {
					if (this.disconnected) {
						this.emit('connect', packet)
						return
					}

					var that = this

					this._setupPingTimer()
					this._resubscribe(packet)

					this.connected = true

					function startStreamProcess() {
						var outStore = that.outgoingStore.createStream()

						function clearStoreProcessing() {
							that._storeProcessing = false
							that._packetIdsDuringStoreProcessing = {}
						}

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

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

						function storeDeliver() {
							// edge case, we wrapped this twice
							if (!outStore) {
								return
							}
							that._storeProcessing = true

							var packet = outStore.read(1)

							var cb

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

							// Skip already processed store packets
							if (that._packetIdsDuringStoreProcessing[packet.messageId]) {
								storeDeliver()
								return
							}

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

										storeDeliver()
									}
								}
								that._packetIdsDuringStoreProcessing[packet.messageId] =
									true
								that._sendPacket(packet)
							} else if (outStore.destroy) {
								outStore.destroy()
							}
						}

						outStore.on('end', function() {
							var allProcessed = true
							for (var id in that._packetIdsDuringStoreProcessing) {
								if (!that._packetIdsDuringStoreProcessing[id]) {
									allProcessed = false
									break
								}
							}
							if (allProcessed) {
								clearStoreProcessing()
								that.removeListener('close', remove)
								that.emit('connect', packet)
							} else {
								startStreamProcess()
							}
						})
						storeDeliver()
					}
					// start flowing
					startStreamProcess()
				}

				module.exports = MqttClient

			}).call(this, require('_process'), typeof global !== "undefined" ? global :
				typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}
				)
		}, {
			"./store": 7,
			"./validations": 8,
			"_process": 92,
			"events": 13,
			"inherits": 80,
			"mqtt-packet": 84,
			"readable-stream": 108,
			"reinterval": 109,
			"xtend": 121
		}],
		2: [function(require, module, exports) {
			(function(Buffer) {
				'use strict'

				var Transform = require('readable-stream').Transform
				var duplexify = require('duplexify')
				var base64 = require('base64-js')

				/* global FileReader */
				var my
				var proxy
				var stream
				var isInitialized = false

				function buildProxy() {
					var proxy = new Transform()
					proxy._write = function(chunk, encoding, next) {
						my.sendSocketMessage({
							data: chunk.buffer,
							success: function() {
								next()
							},
							fail: function() {
								next(new Error())
							}
						})
					}
					proxy._flush = function socketEnd(done) {
						my.closeSocket({
							success: function() {
								done()
							}
						})
					}

					return proxy
				}

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

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

				function buildUrl(opts, client) {
					var protocol = opts.protocol === 'alis' ? '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 bindEventHandler() {
					if (isInitialized) return

					isInitialized = true

					my.onSocketOpen(function() {
						stream.setReadable(proxy)
						stream.setWritable(proxy)
						stream.emit('connect')
					})

					my.onSocketMessage(function(res) {
						if (typeof res.data === 'string') {
							var array = base64.toByteArray(res.data)
							var buffer = Buffer.from(array)
							proxy.push(buffer)
						} else {
							var reader = new FileReader()
							reader.addEventListener('load', function() {
								var data = reader.result

								if (data instanceof ArrayBuffer) data = Buffer
									.from(data)
								else data = Buffer.from(data, 'utf8')
								proxy.push(data)
							})
							reader.readAsArrayBuffer(res.data)
						}
					})

					my.onSocketClose(function() {
						stream.end()
						stream.destroy()
					})

					my.onSocketError(function(res) {
						stream.destroy(res)
					})
				}

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

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

					var websocketSubProtocol =
						(opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3) ?
						'mqttv3.1' :
						'mqtt'

					setDefaultOpts(opts)

					var url = buildUrl(opts, client)
					my = opts.my
					my.connectSocket({
						url: url,
						protocols: websocketSubProtocol
					})

					proxy = buildProxy()
					stream = duplexify.obj()

					bindEventHandler()

					return stream
				}

				module.exports = buildStream

			}).call(this, require("buffer").Buffer)
		}, {
			"base64-js": 10,
			"buffer": 12,
			"duplexify": 17,
			"readable-stream": 108
		}],
		3: [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
		}],
		4: [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
		}],
		5: [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": 113,
			"websocket-stream": 118
		}],
		6: [function(require, module, exports) {
			(function(process, Buffer) {
				'use strict'

				var Transform = require('readable-stream').Transform
				var duplexify = require('duplexify')

				/* global wx */
				var socketTask
				var proxy
				var stream

				function buildProxy() {
					var proxy = new Transform()
					proxy._write = function(chunk, encoding, next) {
						socketTask.send({
							data: chunk.buffer,
							success: function() {
								next()
							},
							fail: function(errMsg) {
								next(new Error(errMsg))
							}
						})
					}
					proxy._flush = function socketEnd(done) {
						socketTask.close({
							success: function() {
								done()
							}
						})
					}

					return proxy
				}

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

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

				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 bindEventHandler() {
					socketTask.onOpen(function() {
						stream.setReadable(proxy)
						stream.setWritable(proxy)
						stream.emit('connect')
					})

					socketTask.onMessage(function(res) {
						var data = res.data

						if (data instanceof ArrayBuffer) data = Buffer.from(data)
						else data = Buffer.from(data, 'utf8')
						proxy.push(data)
					})

					socketTask.onClose(function() {
						stream.end()
						stream.destroy()
					})

					socketTask.onError(function(res) {
						stream.destroy(new Error(res.errMsg))
					})
				}

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

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

					var websocketSubProtocol =
						(opts.protocolId === 'MQIsdp') && (opts.protocolVersion === 3) ?
						'mqttv3.1' :
						'mqtt'

					setDefaultOpts(opts)

					var url = buildUrl(opts, client)
					socketTask = wx.connectSocket({
						url: url,
						protocols: websocketSubProtocol,
						success() {}
					})

					proxy = buildProxy()
					stream = duplexify.obj()
					stream._destroy = function(err, cb) {
						socketTask.close({
							success: function() {
								cb && cb(err)
							}
						})
					}

					var destroyRef = stream.destroy
					stream.destroy = function() {
						stream.destroy = destroyRef

						var self = this
						process.nextTick(function() {
							socketTask.close({
								fail: function() {
									self._destroy(new Error())
								}
							})
						})
					}.bind(stream)

					bindEventHandler()

					return stream
				}

				module.exports = buildStream

			}).call(this, require('_process'), require("buffer").Buffer)
		}, {
			"_process": 92,
			"buffer": 12,
			"duplexify": 17,
			"readable-stream": 108
		}],
		7: [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": 67,
			"readable-stream": 108,
			"xtend": 121
		}],
		8: [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
			}

		}, {}],
		9: [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.ali = require('./ali')
					protocols.alis = require('./ali')
				}

				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', 'alis'].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
									case 'ali':
										opts.protocol = 'alis'
										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',
							'ali',
							'alis'
						].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": 7,
			"./ali": 2,
			"./tcp": 3,
			"./tls": 4,
			"./ws": 5,
			"./wx": 6,
			"_process": 92,
			"url": 113,
			"xtend": 121
		}],
		10: [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('')
			}

		}, {}],
		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": 10,
			"ieee754": 79
		}],
		13: [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);
				};
			}

		}, {}],
		14: [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
		}],
		15: [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": 39,
			"es5-ext/object/map": 48,
			"es5-ext/object/normalize-options": 49,
			"es5-ext/object/valid-callable": 54,
			"es5-ext/object/valid-value": 55
		}],
		16: [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": 36,
			"es5-ext/object/is-callable": 42,
			"es5-ext/object/normalize-options": 49,
			"es5-ext/string/#/contains": 56
		}],
		17: [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": 18,
			"inherits": 80,
			"readable-stream": 108,
			"stream-shift": 111
		}],
		18: [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
		}],
		19: [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": 55
		}],
		20: [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": 30,
			"../../number/to-pos-integer": 34,
			"../../object/valid-value": 55
		}],
		21: [function(require, module, exports) {
			"use strict";

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

		}, {
			"./is-implemented": 22,
			"./shim": 23
		}],
		22: [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"));
			};

		}, {}],
		23: [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": 24,
			"../../function/is-function": 25,
			"../../number/to-pos-integer": 34,
			"../../object/is-value": 44,
			"../../object/valid-callable": 54,
			"../../object/valid-value": 55,
			"../../string/is-string": 59,
			"es6-symbol": 73
		}],
		24: [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;
			};

		}, {}],
		25: [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": 26
		}],
		26: [function(require, module, exports) {
			"use strict";

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

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

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

		}, {
			"./is-implemented": 28,
			"./shim": 29
		}],
		28: [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);
			};

		}, {}],
		29: [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;
			};

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

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

		}, {
			"./is-implemented": 31,
			"./shim": 32
		}],
		31: [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);
			};

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

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

		}, {}],
		33: [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": 27
		}],
		34: [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": 33
		}],
		35: [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": 54,
			"./valid-value": 55
		}],
		36: [function(require, module, exports) {
			"use strict";

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

		}, {
			"./is-implemented": 37,
			"./shim": 38
		}],
		37: [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";
			};

		}, {}],
		38: [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": 45,
			"../valid-value": 55
		}],
		39: [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": 21,
			"./assign": 36,
			"./valid-value": 55
		}],
		40: [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": 52,
			"./set-prototype-of/shim": 53
		}],
		41: [function(require, module, exports) {
			"use strict";

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

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

			"use strict";

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

		}, {}],
		43: [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": 44
		}],
		44: [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": 26
		}],
		45: [function(require, module, exports) {
			"use strict";

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

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

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

		}, {}],
		47: [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": 44
		}],
		48: [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": 41,
			"./valid-callable": 54
		}],
		49: [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": 44
		}],
		50: [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;
			};

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

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

		}, {
			"./is-implemented": 52,
			"./shim": 53
		}],
		52: [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;
			};

		}, {}],
		53: [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": 40,
			"../is-object": 43,
			"../valid-value": 55
		}],
		54: [function(require, module, exports) {
			"use strict";

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

		}, {}],
		55: [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": 44
		}],
		56: [function(require, module, exports) {
			"use strict";

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

		}, {
			"./is-implemented": 57,
			"./shim": 58
		}],
		57: [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);
			};

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

			var indexOf = String.prototype.indexOf;

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

		}, {}],
		59: [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
				);
			};

		}, {}],
		60: [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"));

		}, {
			"./": 63,
			"d": 16,
			"es5-ext/object/set-prototype-of": 51,
			"es5-ext/string/#/contains": 56,
			"es6-symbol": 73
		}],
		61: [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": 62,
			"es5-ext/function/is-arguments": 24,
			"es5-ext/object/valid-callable": 54,
			"es5-ext/string/is-string": 59
		}],
		62: [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": 60,
			"./string": 65,
			"./valid-iterable": 66,
			"es5-ext/function/is-arguments": 24,
			"es5-ext/string/is-string": 59,
			"es6-symbol": 73
		}],
		63: [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": 16,
			"d/auto-bind": 15,
			"es5-ext/array/#/clear": 19,
			"es5-ext/object/assign": 36,
			"es5-ext/object/valid-callable": 54,
			"es5-ext/object/valid-value": 55,
			"es6-symbol": 73
		}],
		64: [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": 24,
			"es5-ext/object/is-value": 44,
			"es5-ext/string/is-string": 59,
			"es6-symbol": 73
		}],
		65: [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"));

		}, {
			"./": 63,
			"d": 16,
			"es5-ext/object/set-prototype-of": 51,
			"es6-symbol": 73
		}],
		66: [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": 64
		}],
		67: [function(require, module, exports) {
			'use strict';

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

		}, {
			"./is-implemented": 68,
			"./polyfill": 72
		}],
		68: [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;
			};

		}, {}],
		69: [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]');
			}());

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

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

		}, {
			"es5-ext/object/primitive-set": 50
		}],
		71: [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": 70,
			"d": 16,
			"es5-ext/object/set-prototype-of": 51,
			"es6-iterator": 63,
			"es6-symbol": 73
		}],
		72: [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": 69,
			"./lib/iterator": 71,
			"d": 16,
			"es5-ext/array/#/clear": 19,
			"es5-ext/array/#/e-index-of": 20,
			"es5-ext/object/set-prototype-of": 51,
			"es5-ext/object/valid-callable": 54,
			"es5-ext/object/valid-value": 55,
			"es6-iterator/for-of": 61,
			"es6-iterator/valid-iterable": 66,
			"es6-symbol": 73,
			"event-emitter": 78
		}],
		73: [function(require, module, exports) {
			'use strict';

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

		}, {
			"./is-implemented": 74,
			"./polyfill": 76
		}],
		74: [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;
			};

		}, {}],
		75: [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');
			};

		}, {}],
		76: [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": 77,
			"d": 16
		}],
		77: [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": 75
		}],
		78: [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": 16,
			"es5-ext/object/valid-callable": 54
		}],
		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) {
			'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: 'auth'
			}

			/* 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])

			/* Properties */
			protocol.properties = {
				sessionExpiryInterval: 17,
				willDelayInterval: 24,
				receiveMaximum: 33,
				maximumPacketSize: 39,
				topicAliasMaximum: 34,
				requestResponseInformation: 25,
				requestProblemInformation: 23,
				userProperties: 38,
				authenticationMethod: 21,
				authenticationData: 22,
				payloadFormatIndicator: 1,
				messageExpiryInterval: 2,
				contentType: 3,
				responseTopic: 8,
				correlationData: 9,
				maximumQoS: 36,
				retainAvailable: 37,
				assignedClientIdentifier: 18,
				reasonString: 31,
				wildcardSubscriptionAvailable: 40,
				subscriptionIdentifiersAvailable: 41,
				sharedSubscriptionAvailable: 42,
				serverKeepAlive: 19,
				responseInformation: 26,
				serverReference: 28,
				topicAlias: 35,
				subscriptionIdentifier: 11
			}
			protocol.propertiesCodes = {}
			for (var prop in protocol.properties) {
				var id = protocol.properties[prop]
				protocol.propertiesCodes[id] = prop
			}
			protocol.propertiesTypes = {
				sessionExpiryInterval: 'int32',
				willDelayInterval: 'int32',
				receiveMaximum: 'int16',
				maximumPacketSize: 'int32',
				topicAliasMaximum: 'int16',
				requestResponseInformation: 'byte',
				requestProblemInformation: 'byte',
				userProperties: 'pair',
				authenticationMethod: 'string',
				authenticationData: 'binary',
				payloadFormatIndicator: 'byte',
				messageExpiryInterval: 'int32',
				contentType: 'string',
				responseTopic: 'string',
				correlationData: 'binary',
				maximumQoS: 'int8',
				retainAvailable: 'byte',
				assignedClientIdentifier: 'string',
				reasonString: 'string',
				wildcardSubscriptionAvailable: 'byte',
				subscriptionIdentifiersAvailable: 'byte',
				sharedSubscriptionAvailable: 'byte',
				serverKeepAlive: 'int32',
				responseInformation: 'string',
				serverReference: 'string',
				topicAlias: 'int16',
				subscriptionIdentifier: 'var'
			}

			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')
			protocol.SUBSCRIBE_OPTIONS_QOS_MASK = 0x03
			protocol.SUBSCRIBE_OPTIONS_NL_MASK = 0x01
			protocol.SUBSCRIBE_OPTIONS_NL_SHIFT = 2
			protocol.SUBSCRIBE_OPTIONS_RAP_MASK = 0x01
			protocol.SUBSCRIBE_OPTIONS_RAP_SHIFT = 3
			protocol.SUBSCRIBE_OPTIONS_RH_MASK = 0x03
			protocol.SUBSCRIBE_OPTIONS_RH_SHIFT = 4
			protocol.SUBSCRIBE_OPTIONS_RH = [0x00, 0x10, 0x20]
			protocol.SUBSCRIBE_OPTIONS_NL = 0x04
			protocol.SUBSCRIBE_OPTIONS_RAP = 0x08
			protocol.SUBSCRIBE_OPTIONS_QOS = [0x00, 0x01, 0x02]

			/* 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])
			protocol.VERSION5 = Buffer.from([5])

			/* 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": 110
		}],
		83: [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, opts) {
				var stream = new Accumulator()
				writeToStream(packet, stream, opts)
				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": 13,
			"inherits": 80,
			"safe-buffer": 110
		}],
		84: [function(require, module, exports) {
			'use strict'

			exports.parser = require('./parser')
			exports.generate = require('./generate')
			exports.writeToStream = require('./writeToStream')

		}, {
			"./generate": 83,
			"./parser": 88,
			"./writeToStream": 89
		}],
		85: [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": 110,
			"util": 117
		}],
		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)
				}
			}

			/**
			 * calcVariableByteIntLength - calculate the variable byte integer
			 * length field
			 *
			 * @api private
			 */
			function calcVariableByteIntLength(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 genBufVariableByteInt(num) {
				var digit = 0
				var pos = 0
				var length = calcVariableByteIntLength(num)
				var buffer = Buffer.allocUnsafe(length)

				do {
					digit = num % 128 | 0
					num = num / 128 | 0
					if (num > 0) digit = digit | 0x80

					buffer.writeUInt8(digit, pos++)
				} while (num > 0)

				return {
					data: buffer,
					length: length
				}
			}

			function generate4ByteBuffer(num) {
				var buffer = Buffer.allocUnsafe(4)
				buffer.writeUInt32BE(num, 0)
				return buffer
			}

			module.exports = {
				cache: cache,
				generateCache: generateCache,
				generateNumber: generateBuffer,
				genBufVariableByteInt: genBufVariableByteInt,
				generate4ByteBuffer: generate4ByteBuffer
			}

		}, {
			"safe-buffer": 110
		}],
		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(opt) {
				if (!(this instanceof Parser)) return new Parser(opt)

				this.settings = opt || {}

				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 result = this._parseVarByteNum(true)

				if (result) {
					this.packet.length = result.value
					this._list.consume(result.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._parseConfirmation()
							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':
							// These are empty, nothing to do
							break
						case 'disconnect':
							this._parseDisconnect()
							break
						case 'auth':
							this._parseAuth()
							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 && packet
					.protocolVersion !== 5) {
					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 properties
				if (packet.protocolVersion === 5) {
					var properties = this._parseProperties()
					if (Object.getOwnPropertyNames(properties).length) {
						packet.properties = properties
					}
				}
				// Parse clientId
				clientId = this._parseString()
				if (clientId === null) return this._emitError(new Error('Packet too short'))
				packet.clientId = clientId

				if (flags.will) {
					if (packet.protocolVersion === 5) {
						var willProperties = this._parseProperties()
						if (Object.getOwnPropertyNames(willProperties).length) {
							packet.will.properties = willProperties
						}
					}
					// 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
				}
				// need for right parse auth packet and self set up
				this.settings = packet

				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)
				if (this.settings.protocolVersion === 5) {
					packet.reasonCode = this._list.readUInt8(this._pos++)
				} else {
					packet.returnCode = this._list.readUInt8(this._pos++)
				}

				if (packet.returnCode === -1 || packet.reasonCode === -1) return this
					._emitError(new Error('Cannot parse return code'))
				// mqtt 5 properties
				if (this.settings.protocolVersion === 5) {
					var properties = this._parseProperties()
					if (Object.getOwnPropertyNames(properties).length) {
						packet.properties = properties
					}
				}
			}

			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
					}

				// Properties mqtt 5
				if (this.settings.protocolVersion === 5) {
					var properties = this._parseProperties()
					if (Object.getOwnPropertyNames(properties).length) {
						packet.properties = properties
					}
				}

				packet.payload = this._list.slice(this._pos, packet.length)
			}

			Parser.prototype._parseSubscribe = function() {
				var packet = this.packet
				var topic
				var options
				var qos
				var rh
				var rap
				var nl
				var subscription

				if (packet.qos !== 1) {
					return this._emitError(new Error('Wrong subscribe header'))
				}

				packet.subscriptions = []

				if (!this._parseMessageId()) {
					return
				}

				// Properties mqtt 5
				if (this.settings.protocolVersion === 5) {
					var properties = this._parseProperties()
					if (Object.getOwnPropertyNames(properties).length) {
						packet.properties = properties
					}
				}

				while (this._pos < packet.length) {
					// Parse topic
					topic = this._parseString()
					if (topic === null) return this._emitError(new Error('Cannot parse topic'))

					options = this._parseByte()
					qos = options & constants.SUBSCRIBE_OPTIONS_QOS_MASK
					nl = ((options >> constants.SUBSCRIBE_OPTIONS_NL_SHIFT) & constants
						.SUBSCRIBE_OPTIONS_NL_MASK) !== 0
					rap = ((options >> constants.SUBSCRIBE_OPTIONS_RAP_SHIFT) & constants
						.SUBSCRIBE_OPTIONS_RAP_MASK) !== 0
					rh = (options >> constants.SUBSCRIBE_OPTIONS_RH_SHIFT) & constants
						.SUBSCRIBE_OPTIONS_RH_MASK

					subscription = {
						topic: topic,
						qos: qos
					}

					// mqtt 5 options
					if (this.settings.protocolVersion === 5) {
						subscription.nl = nl
						subscription.rap = rap
						subscription.rh = rh
					}

					// Push pair to subscriptions
					packet.subscriptions.push(subscription)
				}
			}

			Parser.prototype._parseSuback = function() {
				var packet = this.packet
				this.packet.granted = []

				if (!this._parseMessageId()) {
					return
				}

				// Properties mqtt 5
				if (this.settings.protocolVersion === 5) {
					var properties = this._parseProperties()
					if (Object.getOwnPropertyNames(properties).length) {
						packet.properties = properties
					}
				}

				// 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
				}

				// Properties mqtt 5
				if (this.settings.protocolVersion === 5) {
					var properties = this._parseProperties()
					if (Object.getOwnPropertyNames(properties).length) {
						packet.properties = properties
					}
				}

				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() {
				var packet = this.packet
				if (!this._parseMessageId()) return this._emitError(new Error(
					'Cannot parse messageId'))
				// Properties mqtt 5
				if (this.settings.protocolVersion === 5) {
					var properties = this._parseProperties()
					if (Object.getOwnPropertyNames(properties).length) {
						packet.properties = properties
					}
					// Parse granted QoSes
					packet.granted = []
					while (this._pos < this.packet.length) {
						this.packet.granted.push(this._list.readUInt8(this._pos++))
					}
				}
			}

			// parse packets like puback, pubrec, pubrel, pubcomp
			Parser.prototype._parseConfirmation = function() {
				var packet = this.packet

				this._parseMessageId()

				if (this.settings.protocolVersion === 5) {
					if (packet.length > 2) {
						// response code
						packet.reasonCode = this._parseByte()
						// properies mqtt 5
						var properties = this._parseProperties()
						if (Object.getOwnPropertyNames(properties).length) {
							packet.properties = properties
						}
					}
				}

				return true
			}

			// parse disconnect packet
			Parser.prototype._parseDisconnect = function() {
				var packet = this.packet

				if (this.settings.protocolVersion === 5) {
					// response code
					packet.reasonCode = this._parseByte()
					// properies mqtt 5
					var properties = this._parseProperties()
					if (Object.getOwnPropertyNames(properties).length) {
						packet.properties = properties
					}
				}

				return true
			}

			// parse auth packet
			Parser.prototype._parseAuth = function() {
				var packet = this.packet

				if (this.settings.protocolVersion !== 5) {
					return this._emitError(new Error(
						'Not supported auth packet for this version MQTT'))
				}

				// response code
				packet.reasonCode = this._parseByte()
				// properies mqtt 5
				var properties = this._parseProperties()
				if (Object.getOwnPropertyNames(properties).length) {
					packet.properties = properties
				}

				return true
			}

			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._parseStringPair = function() {
				return {
					name: this._parseString(),
					value: this._parseString()
				}
			}

			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._parse4ByteNum = function() {
				if (this._list.length - this._pos < 4) return -1

				var result = this._list.readUInt32BE(this._pos)
				this._pos += 4

				return result
			}

			Parser.prototype._parseVarByteNum = function(fullInfoFlag) {
				var bytes = 0
				var mul = 1
				var length = 0
				var result = true
				var current
				var padding = this._pos ? this._pos : 0

				while (bytes < 5) {
					current = this._list.readUInt8(padding + 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 (padding) {
					this._pos += bytes
				}

				result = result ?
					fullInfoFlag ? {
						bytes: bytes,
						value: length
					} : length :
					false

				return result
			}

			Parser.prototype._parseByte = function() {
				var result = this._list.readUInt8(this._pos)
				this._pos++
				return result
			}

			Parser.prototype._parseByType = function(type) {
				switch (type) {
					case 'byte': {
						return this._parseByte() !== 0
					}
					case 'int8': {
						return this._parseByte()
					}
					case 'int16': {
						return this._parseNum()
					}
					case 'int32': {
						return this._parse4ByteNum()
					}
					case 'var': {
						return this._parseVarByteNum()
					}
					case 'string': {
						return this._parseString()
					}
					case 'pair': {
						return this._parseStringPair()
					}
					case 'binary': {
						return this._parseBuffer()
					}
				}
			}

			Parser.prototype._parseProperties = function() {
				var length = this._parseVarByteNum()
				var start = this._pos
				var end = start + length
				var result = {}
				while (this._pos < end) {
					var type = this._parseByte()
					var name = constants.propertiesCodes[type]
					if (!name) {
						this._emitError(new Error('Unknown property'))
						return false
					}
					// user properties process
					if (name === 'userProperties') {
						if (!result[name]) {
							result[name] = {}
						}
						var currentUserProperty = this._parseByType(constants.propertiesTypes[
							name])
						result[name][currentUserProperty.name] = currentUserProperty.value
						continue
					}
					result[name] = this._parseByType(constants.propertiesTypes[name])
				}
				return result
			}

			Parser.prototype._newPacket = function() {
				if (this.packet) {
					this._list.consume(this.packet.length)
					this.emit('packet', this.packet)
				}

				this.packet = new Packet()

				this._pos = 0

				return true
			}

			Parser.prototype._emitError = function(err) {
				this.error = err
				this.emit('error', err)
			}

			module.exports = Parser

		}, {
			"./constants": 82,
			"./packet": 87,
			"bl": 85,
			"events": 13,
			"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 genBufVariableByteInt = numbers.genBufVariableByteInt
			var generate4ByteBuffer = numbers.generate4ByteBuffer
			var writeNumber = writeNumberCached
			var toGenerate = true

			function generate(packet, stream, opts) {
				if (stream.cork) {
					stream.cork()
					nextTick(uncork, stream)
				}

				if (toGenerate) {
					toGenerate = false
					generateCache()
				}

				switch (packet.cmd) {
					case 'connect':
						return connect(packet, stream, opts)
					case 'connack':
						return connack(packet, stream, opts)
					case 'publish':
						return publish(packet, stream, opts)
					case 'puback':
					case 'pubrec':
					case 'pubrel':
					case 'pubcomp':
						return confirmation(packet, stream, opts)
					case 'subscribe':
						return subscribe(packet, stream, opts)
					case 'suback':
						return suback(packet, stream, opts)
					case 'unsubscribe':
						return unsubscribe(packet, stream, opts)
					case 'unsuback':
						return unsuback(packet, stream, opts)
					case 'pingreq':
					case 'pingresp':
						return emptyPacket(packet, stream, opts)
					case 'disconnect':
						return disconnect(packet, stream, opts)
					case 'auth':
						return auth(packet, stream, opts)
					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(packet, stream, opts) {
				var settings = packet || {}
				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
				/* mqtt5 new oprions */
				var properties = settings.properties

				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 or 5
				if (protocolVersion !== 3 && protocolVersion !== 4 && protocolVersion !== 5) {
					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

				// Properties
				if (protocolVersion === 5) {
					var propertiesData = getProperties(stream, properties)
					length += propertiesData.length
				}

				// 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) {
						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
						}

						// will properties
						var willProperties = {}
						if (protocolVersion === 5) {
							willProperties = getProperties(stream, will.properties)
							length += willProperties.length
						}
					}
				}

				// 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
				writeVarByteInt(stream, length)

				// Generate protocol ID
				writeStringOrBuffer(stream, protocolId)
				stream.write(
					protocolVersion === 4 ?
					protocol.VERSION4 :
					protocolVersion === 5 ?
					protocol.VERSION5 :
					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)

				// Properties
				if (protocolVersion === 5) {
					propertiesData.write()
				}

				// Client ID
				writeStringOrBuffer(stream, clientId)

				// Will
				if (will) {
					if (protocolVersion === 5) {
						willProperties.write()
					}
					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(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				var rc = version === 5 ? settings.reasonCode : settings.returnCode
				var properties = settings.properties
				var length = 2 // length of rc and sessionHeader

				// Check return code
				if (typeof rc !== 'number') {
					stream.emit('error', new Error('Invalid return code'))
					return false
				}
				// mqtt5 properties
				var propertiesData = null
				if (version === 5) {
					propertiesData = getProperties(stream, properties)
					length += propertiesData.length
				}

				stream.write(protocol.CONNACK_HEADER)
				// length
				writeVarByteInt(stream, length)
				stream.write(settings.sessionPresent ? protocol.SESSIONPRESENT_HEADER : zeroBuf)

				stream.write(Buffer.from([rc]))
				if (propertiesData != null) {
					propertiesData.write()
				}
				return true
			}

			function publish(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				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 properties = settings.properties

				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

				// mqtt5 properties
				var propertiesData = null
				if (version === 5) {
					propertiesData = getProperties(stream, properties)
					length += propertiesData.length
				}

				// Header
				stream.write(protocol.PUBLISH_HEADER[qos][settings.dup ? 1 : 0][retain ? 1 : 0])

				// Remaining length
				writeVarByteInt(stream, length)

				// Topic
				writeNumber(stream, byteLength(topic))
				stream.write(topic)

				// Message ID
				if (qos > 0) writeNumber(stream, id)

				// Properties
				if (propertiesData != null) {
					propertiesData.write()
				}

				// Payload
				return stream.write(payload)
			}

			/* Puback, pubrec, pubrel and pubcomp */
			function confirmation(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				var type = settings.cmd || 'puback'
				var id = settings.messageId
				var dup = (settings.dup && type === 'pubrel') ? protocol.DUP_MASK : 0
				var qos = 0
				var reasonCode = settings.reasonCode
				var properties = settings.properties
				var length = version === 5 ? 3 : 2

				if (type === 'pubrel') qos = 1

				// Check message ID
				if (typeof id !== 'number') {
					stream.emit('error', new Error('Invalid messageId'))
					return false
				}

				// properies mqtt 5
				var propertiesData = null
				if (version === 5) {
					propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts,
						length)
					if (!propertiesData) {
						return false
					}
					length += propertiesData.length
				}

				// Header
				stream.write(protocol.ACKS[type][qos][dup][0])

				// Length
				writeVarByteInt(stream, length)

				// Message ID
				writeNumber(stream, id)

				// reason code in header
				if (version === 5) {
					stream.write(Buffer.from([reasonCode]))
				}

				// properies mqtt 5
				if (propertiesData !== null) {
					propertiesData.write()
				}
				return true
			}

			function subscribe(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				var dup = settings.dup ? protocol.DUP_MASK : 0
				var id = settings.messageId
				var subs = settings.subscriptions
				var properties = settings.properties

				var length = 0

				// Check message ID
				if (typeof id !== 'number') {
					stream.emit('error', new Error('Invalid messageId'))
					return false
				} else length += 2

				// properies mqtt 5
				var propertiesData = null
				if (version === 5) {
					propertiesData = getProperties(stream, properties)
					length += propertiesData.length
				}

				// 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
						}

						if (version === 5) {
							var nl = subs[i].nl || false
							if (typeof nl !== 'boolean') {
								stream.emit('error', new Error(
									'Invalid subscriptions - invalid No Local'))
								return false
							}
							var rap = subs[i].rap || false
							if (typeof rap !== 'boolean') {
								stream.emit('error', new Error(
									'Invalid subscriptions - invalid Retain as Published'))
								return false
							}
							var rh = subs[i].rh || 0
							if (typeof rh !== 'number' || rh > 2) {
								stream.emit('error', new Error(
									'Invalid subscriptions - invalid Retain Handling'))
								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
				writeVarByteInt(stream, length)

				// Generate message ID
				writeNumber(stream, id)

				// properies mqtt 5
				if (propertiesData !== null) {
					propertiesData.write()
				}

				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
					var jnl = +sub.nl
					var jrap = +sub.rap
					var jrh = sub.rh
					var joptions

					// Write topic string
					writeString(stream, jtopic)

					// options process
					joptions = protocol.SUBSCRIBE_OPTIONS_QOS[jqos]
					if (version === 5) {
						joptions |= jnl ? protocol.SUBSCRIBE_OPTIONS_NL : 0
						joptions |= jrap ? protocol.SUBSCRIBE_OPTIONS_RAP : 0
						joptions |= jrh ? protocol.SUBSCRIBE_OPTIONS_RH[jrh] : 0
					}
					// Write options
					result = stream.write(Buffer.from([joptions]))
				}

				return result
			}

			function suback(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				var id = settings.messageId
				var granted = settings.granted
				var properties = settings.properties
				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
				}

				// properies mqtt 5
				var propertiesData = null
				if (version === 5) {
					propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts,
						length)
					if (!propertiesData) {
						return false
					}
					length += propertiesData.length
				}

				// header
				stream.write(protocol.SUBACK_HEADER)

				// Length
				writeVarByteInt(stream, length)

				// Message ID
				writeNumber(stream, id)

				// properies mqtt 5
				if (propertiesData !== null) {
					propertiesData.write()
				}

				return stream.write(Buffer.from(granted))
			}

			function unsubscribe(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				var id = settings.messageId
				var dup = settings.dup ? protocol.DUP_MASK : 0
				var unsubs = settings.unsubscriptions
				var properties = settings.properties

				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
				}
				// properies mqtt 5
				var propertiesData = null
				if (version === 5) {
					propertiesData = getProperties(stream, properties)
					length += propertiesData.length
				}

				// Header
				stream.write(protocol.UNSUBSCRIBE_HEADER[1][dup ? 1 : 0][0])

				// Length
				writeVarByteInt(stream, length)

				// Message ID
				writeNumber(stream, id)

				// properies mqtt 5
				if (propertiesData !== null) {
					propertiesData.write()
				}

				// Unsubs
				var result = true
				for (var j = 0; j < unsubs.length; j++) {
					result = writeString(stream, unsubs[j])
				}

				return result
			}

			function unsuback(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				var id = settings.messageId
				var dup = settings.dup ? protocol.DUP_MASK : 0
				var granted = settings.granted
				var properties = settings.properties
				var type = settings.cmd
				var qos = 0

				var length = 2

				// Check message ID
				if (typeof id !== 'number') {
					stream.emit('error', new Error('Invalid messageId'))
					return false
				}

				// Check granted
				if (version === 5) {
					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
					}
				}

				// properies mqtt 5
				var propertiesData = null
				if (version === 5) {
					propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts,
						length)
					if (!propertiesData) {
						return false
					}
					length += propertiesData.length
				}

				// Header
				stream.write(protocol.ACKS[type][qos][dup][0])

				// Length
				writeVarByteInt(stream, length)

				// Message ID
				writeNumber(stream, id)

				// properies mqtt 5
				if (propertiesData !== null) {
					propertiesData.write()
				}

				// payload
				if (version === 5) {
					stream.write(Buffer.from(granted))
				}
				return true
			}

			function emptyPacket(packet, stream, opts) {
				return stream.write(protocol.EMPTY[packet.cmd])
			}

			function disconnect(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				var reasonCode = settings.reasonCode
				var properties = settings.properties
				var length = version === 5 ? 1 : 0

				// properies mqtt 5
				var propertiesData = null
				if (version === 5) {
					propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts,
						length)
					if (!propertiesData) {
						return false
					}
					length += propertiesData.length
				}

				// Header
				stream.write(Buffer.from([protocol.codes['disconnect'] << 4]))

				// Length
				writeVarByteInt(stream, length)

				// reason code in header
				if (version === 5) {
					stream.write(Buffer.from([reasonCode]))
				}

				// properies mqtt 5
				if (propertiesData !== null) {
					propertiesData.write()
				}

				return true
			}

			function auth(packet, stream, opts) {
				var version = opts ? opts.protocolVersion : 4
				var settings = packet || {}
				var reasonCode = settings.reasonCode
				var properties = settings.properties
				var length = version === 5 ? 1 : 0

				if (version !== 5) stream.emit('error', new Error(
					'Invalid mqtt version for auth packet'))

				// properies mqtt 5
				var propertiesData = getPropertiesByMaximumPacketSize(stream, properties, opts,
					length)
				if (!propertiesData) {
					return false
				}
				length += propertiesData.length

				// Header
				stream.write(Buffer.from([protocol.codes['auth'] << 4]))

				// Length
				writeVarByteInt(stream, length)

				// reason code in header
				stream.write(Buffer.from([reasonCode]))

				// properies mqtt 5
				if (propertiesData !== null) {
					propertiesData.write()
				}
				return true
			}

			/**
			 * writeVarByteInt - write an MQTT style variable byte integer 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 varByteIntCache = {}

			function writeVarByteInt(stream, num) {
				var buffer = varByteIntCache[num]

				if (!buffer) {
					buffer = genBufVariableByteInt(num).data
					if (num < 16384) varByteIntCache[num] = 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')
			}

			/**
			 * writeStringPair - write a utf8 string pairs to the buffer
			 *
			 * @param <Buffer> buffer - destination
			 * @param <String> name - string name to write
			 * @param <String> value - string value to write
			 * @return <Number> number of bytes written
			 *
			 * @api private
			 */
			function writeStringPair(stream, name, value) {
				writeString(stream, name)
				writeString(stream, value)
			}

			/**
			 * 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))
			}

			function write4ByteNumber(stream, number) {
				return stream.write(generate4ByteBuffer(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 getProperties(stream, properties) {
				/* connect properties */
				if (typeof properties !== 'object' || properties.length != null) {
					return {
						length: 1,
						write: function() {
							writeProperties(stream, {}, 0)
						}
					}
				}
				var propertiesLength = 0

				function getLengthProperty(name) {
					var type = protocol.propertiesTypes[name]
					var value = properties[name]
					var length = 0
					switch (type) {
						case 'byte': {
							if (typeof value !== 'boolean') {
								stream.emit('error', new Error('Invalid ' + name))
								return false
							}
							length += 1 + 1
							break
						}
						case 'int8': {
							if (typeof value !== 'number') {
								stream.emit('error', new Error('Invalid ' + name))
								return false
							}
							length += 1 + 1
							break
						}
						case 'binary': {
							if (value && value === null) {
								stream.emit('error', new Error('Invalid ' + name))
								return false
							}
							length += 1 + Buffer.byteLength(value) + 2
							break
						}
						case 'int16': {
							if (typeof value !== 'number') {
								stream.emit('error', new Error('Invalid ' + name))
								return false
							}
							length += 1 + 2
							break
						}
						case 'int32': {
							if (typeof value !== 'number') {
								stream.emit('error', new Error('Invalid ' + name))
								return false
							}
							length += 1 + 4
							break
						}
						case 'var': {
							if (typeof value !== 'number') {
								stream.emit('error', new Error('Invalid ' + name))
								return false
							}
							length += 1 + genBufVariableByteInt(value).length
							break
						}
						case 'string': {
							if (typeof value !== 'string') {
								stream.emit('error', new Error('Invalid ' + name))
								return false
							}
							length += 1 + 2 + Buffer.byteLength(value.toString())
							break
						}
						case 'pair': {
							if (typeof value !== 'object') {
								stream.emit('error', new Error('Invalid ' + name))
								return false
							}
							length += Object.getOwnPropertyNames(value).reduce(function(result,
								name) {
								result += 1 + 2 + Buffer.byteLength(name.toString()) + 2 +
									Buffer.byteLength(value[name].toString())
								return result
							}, 0)
							break
						}
						default: {
							stream.emit('error', new Error('Invalid property ' + name))
							return false
						}
					}
					return length
				}
				if (properties) {
					for (var propName in properties) {
						var propLength = getLengthProperty(propName)
						if (!propLength) return false
						propertiesLength += propLength
					}
				}
				var propertiesLengthLength = genBufVariableByteInt(propertiesLength).length

				return {
					length: propertiesLengthLength + propertiesLength,
					write: function() {
						writeProperties(stream, properties, propertiesLength)
					}
				}
			}

			function getPropertiesByMaximumPacketSize(stream, properties, opts, length) {
				var mayEmptyProps = ['reasonString', 'userProperties']
				var maximumPacketSize = opts && opts.properties && opts.properties
					.maximumPacketSize ? opts.properties.maximumPacketSize : 0

				var propertiesData = getProperties(stream, properties)
				if (maximumPacketSize) {
					while (length + propertiesData.length > maximumPacketSize) {
						var currentMayEmptyProp = mayEmptyProps.shift()
						if (currentMayEmptyProp && properties[currentMayEmptyProp]) {
							delete properties[currentMayEmptyProp]
							propertiesData = getProperties(stream, properties)
						} else {
							return false
						}
					}
				}
				return propertiesData
			}

			function writeProperties(stream, properties, propertiesLength) {
				/* write properties to stream */
				writeVarByteInt(stream, propertiesLength)
				for (var propName in properties) {
					if (properties.hasOwnProperty(propName) && properties[propName] !== null) {
						var value = properties[propName]
						var type = protocol.propertiesTypes[propName]
						switch (type) {
							case 'byte': {
								stream.write(Buffer.from([protocol.properties[propName]]))
								stream.write(Buffer.from([+value]))
								break
							}
							case 'int8': {
								stream.write(Buffer.from([protocol.properties[propName]]))
								stream.write(Buffer.from([value]))
								break
							}
							case 'binary': {
								stream.write(Buffer.from([protocol.properties[propName]]))
								writeStringOrBuffer(stream, value)
								break
							}
							case 'int16': {
								stream.write(Buffer.from([protocol.properties[propName]]))
								writeNumber(stream, value)
								break
							}
							case 'int32': {
								stream.write(Buffer.from([protocol.properties[propName]]))
								write4ByteNumber(stream, value)
								break
							}
							case 'var': {
								stream.write(Buffer.from([protocol.properties[propName]]))
								writeVarByteInt(stream, value)
								break
							}
							case 'string': {
								stream.write(Buffer.from([protocol.properties[propName]]))
								writeString(stream, value)
								break
							}
							case 'pair': {
								Object.getOwnPropertyNames(value).forEach(function(name) {
									stream.write(Buffer.from([protocol.properties[
										propName]]))
									writeStringPair(stream, name.toString(), value[name]
										.toString())
								})
								break
							}
							default: {
								stream.emit('error', new Error('Invalid property ' + propName))
								return false
							}
						}
					}
				}
			}

			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": 82,
			"./numbers": 86,
			"process-nextick-args": 91,
			"safe-buffer": 110
		}],
		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": 120
		}],
		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": 14,
			"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": 14,
			"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": 14,
			"events": 13,
			"inherits": 80,
			"isarray": 106,
			"process-nextick-args": 91,
			"safe-buffer": 110,
			"string_decoder/": 107,
			"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": 14,
			"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": 14,
			"inherits": 80,
			"process-nextick-args": 91,
			"safe-buffer": 110,
			"timers": 112,
			"util-deprecate": 115
		}],
		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": 110,
			"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": 13
		}],
		106: [function(require, module, exports) {
			var toString = {}.toString;

			module.exports = Array.isArray || function(arr) {
				return toString.call(arr) == '[object Array]';
			};

		}, {}],
		107: [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": 110
		}],
		108: [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
		}],
		109: [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;

		}, {}],
		110: [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
		}],
		111: [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
			}

		}, {}],
		112: [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": 112
		}],
		113: [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": 114,
			"punycode": 93,
			"querystring": 96
		}],
		114: [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;
				}
			};

		}, {}],
		115: [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 : {})
		}, {}],
		116: [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';
			}
		}, {}],
		117: [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": 116,
			"_process": 92,
			"inherits": 80
		}],
		118: [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": 17,
			"readable-stream": 108,
			"safe-buffer": 110,
			"ws": 119
		}],
		119: [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

		}, {}],
		120: [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
				}
			}

		}, {}],
		121: [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
			}

		}, {}]
	}, {}, [9])(9)
};
export default init;
