diff --git a/lib/Client/Client.js b/lib/Client/Client.js index 5d34363e4..e575920c4 100644 --- a/lib/Client/Client.js +++ b/lib/Client/Client.js @@ -630,4 +630,4 @@ var Client = (function (_EventEmitter) { })(_events2["default"]); exports["default"] = Client; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Client/ConnectionState.js b/lib/Client/ConnectionState.js index e876542d8..b17e17a5e 100644 --- a/lib/Client/ConnectionState.js +++ b/lib/Client/ConnectionState.js @@ -8,4 +8,4 @@ exports["default"] = { READY: 3, DISCONNECTED: 4 }; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Client/InternalClient.js b/lib/Client/InternalClient.js index ab70d325a..f993f423f 100644 --- a/lib/Client/InternalClient.js +++ b/lib/Client/InternalClient.js @@ -1415,4 +1415,4 @@ var InternalClient = (function () { })(); exports["default"] = InternalClient; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Client/Resolver/Resolver.js b/lib/Client/Resolver/Resolver.js index c602e4949..b05ac0363 100644 --- a/lib/Client/Resolver/Resolver.js +++ b/lib/Client/Resolver/Resolver.js @@ -245,4 +245,4 @@ var Resolver = (function () { })(); exports["default"] = Resolver; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Constants.js b/lib/Constants.js index 3381d3c5b..13b465ae1 100644 --- a/lib/Constants.js +++ b/lib/Constants.js @@ -127,4 +127,4 @@ var PacketType = { SERVER_BAN_ADD: "GUILD_BAN_ADD", SERVER_BAN_REMOVE: "GUILD_BAN_REMOVE" }; -exports.PacketType = PacketType; \ No newline at end of file +exports.PacketType = PacketType; diff --git a/lib/Structures/Channel.js b/lib/Structures/Channel.js index 887420059..c573a3a10 100644 --- a/lib/Structures/Channel.js +++ b/lib/Structures/Channel.js @@ -42,4 +42,4 @@ var Channel = (function (_Equality) { })(_UtilEquality2["default"]); exports["default"] = Channel; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/ChannelPermissions.js b/lib/Structures/ChannelPermissions.js index 8f2fccab3..81773a75e 100644 --- a/lib/Structures/ChannelPermissions.js +++ b/lib/Structures/ChannelPermissions.js @@ -75,4 +75,4 @@ var ChannelPermissions = (function () { })(); exports["default"] = ChannelPermissions; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/Invite.js b/lib/Structures/Invite.js index 12d349cae..27d470b9c 100644 --- a/lib/Structures/Invite.js +++ b/lib/Structures/Invite.js @@ -29,4 +29,4 @@ var Invite = (function () { })(); exports["default"] = Invite; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/Message.js b/lib/Structures/Message.js index 475815b10..7e0942514 100644 --- a/lib/Structures/Message.js +++ b/lib/Structures/Message.js @@ -98,4 +98,4 @@ var Message = (function (_Equality) { })(_UtilEquality2["default"]); exports["default"] = Message; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/PMChannel.js b/lib/Structures/PMChannel.js index 03bf59251..61a77e465 100644 --- a/lib/Structures/PMChannel.js +++ b/lib/Structures/PMChannel.js @@ -63,4 +63,4 @@ var PMChannel = (function (_Channel) { })(_Channel3["default"]); exports["default"] = PMChannel; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/PermissionOverwrite.js b/lib/Structures/PermissionOverwrite.js index ac539d4d5..6682c168a 100644 --- a/lib/Structures/PermissionOverwrite.js +++ b/lib/Structures/PermissionOverwrite.js @@ -86,4 +86,4 @@ var PermissionOverwrite = (function () { })(); exports["default"] = PermissionOverwrite; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/Role.js b/lib/Structures/Role.js index a9c796639..1aa4ce25b 100644 --- a/lib/Structures/Role.js +++ b/lib/Structures/Role.js @@ -139,4 +139,4 @@ var Role = (function () { })(); exports["default"] = Role; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/Server.js b/lib/Structures/Server.js index e624654dc..57893d23d 100644 --- a/lib/Structures/Server.js +++ b/lib/Structures/Server.js @@ -202,4 +202,4 @@ var Server = (function (_Equality) { })(_UtilEquality2["default"]); exports["default"] = Server; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/ServerChannel.js b/lib/Structures/ServerChannel.js index 333f09f4e..57ad3f21f 100644 --- a/lib/Structures/ServerChannel.js +++ b/lib/Structures/ServerChannel.js @@ -131,4 +131,4 @@ var ServerChannel = (function (_Channel) { })(_Channel3["default"]); exports["default"] = ServerChannel; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/TextChannel.js b/lib/Structures/TextChannel.js index e0b059b3f..92fa7566f 100644 --- a/lib/Structures/TextChannel.js +++ b/lib/Structures/TextChannel.js @@ -66,4 +66,4 @@ var TextChannel = (function (_ServerChannel) { })(_ServerChannel3["default"]); exports["default"] = TextChannel; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/User.js b/lib/Structures/User.js index 6f1c50f61..259da1efc 100644 --- a/lib/Structures/User.js +++ b/lib/Structures/User.js @@ -67,4 +67,4 @@ var User = (function (_Equality) { })(_UtilEquality2["default"]); exports["default"] = User; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Structures/VoiceChannel.js b/lib/Structures/VoiceChannel.js index 7dd54aa5c..f73bbfade 100644 --- a/lib/Structures/VoiceChannel.js +++ b/lib/Structures/VoiceChannel.js @@ -25,4 +25,4 @@ var VoiceChannel = (function (_ServerChannel) { })(_ServerChannel3["default"]); exports["default"] = VoiceChannel; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Util/ArgumentRegulariser.js b/lib/Util/ArgumentRegulariser.js index e51909e5f..cee9d5a57 100644 --- a/lib/Util/ArgumentRegulariser.js +++ b/lib/Util/ArgumentRegulariser.js @@ -5,4 +5,4 @@ exports.reg = reg; function reg(c, a) { return [c].concat(Array.prototype.slice.call(a)); -} \ No newline at end of file +} diff --git a/lib/Util/Cache.js b/lib/Util/Cache.js index f3b22a70f..3932779be 100644 --- a/lib/Util/Cache.js +++ b/lib/Util/Cache.js @@ -106,4 +106,4 @@ var Cache = (function (_Array) { })(Array); exports["default"] = Cache; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Util/Equality.js b/lib/Util/Equality.js index 2963f1d51..aab165350 100644 --- a/lib/Util/Equality.js +++ b/lib/Util/Equality.js @@ -45,4 +45,4 @@ var Equality = (function () { })(); exports["default"] = Equality; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Voice/AudioEncoder.js b/lib/Voice/AudioEncoder.js index 6aecca898..4b8489b9b 100644 --- a/lib/Voice/AudioEncoder.js +++ b/lib/Voice/AudioEncoder.js @@ -132,4 +132,4 @@ var AudioEncoder = (function () { })(); exports["default"] = AudioEncoder; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Voice/StreamIntent.js b/lib/Voice/StreamIntent.js index e3fda0e83..37b981a14 100644 --- a/lib/Voice/StreamIntent.js +++ b/lib/Voice/StreamIntent.js @@ -25,4 +25,4 @@ var StreamIntent = (function (_EventEmitter) { })(_events2["default"]); exports["default"] = StreamIntent; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Voice/VoiceConnection.js b/lib/Voice/VoiceConnection.js index 886f2c1d4..ac43034ea 100644 --- a/lib/Voice/VoiceConnection.js +++ b/lib/Voice/VoiceConnection.js @@ -363,4 +363,4 @@ var VoiceConnection = (function (_EventEmitter) { })(_events2["default"]); exports["default"] = VoiceConnection; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/Voice/VoicePacket.js b/lib/Voice/VoicePacket.js index 71b9fbaaf..445f9d6c4 100644 --- a/lib/Voice/VoicePacket.js +++ b/lib/Voice/VoicePacket.js @@ -26,4 +26,4 @@ var VoicePacket = function VoicePacket(data, sequence, time, ssrc) { }; exports["default"] = VoicePacket; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/lib/index.js b/lib/index.js index 3029911ad..f5ef732bc 100644 --- a/lib/index.js +++ b/lib/index.js @@ -76,4 +76,4 @@ exports["default"] = { VoiceChannel: _StructuresVoiceChannel2["default"], Constants: _Constants2["default"] }; -module.exports = exports["default"]; \ No newline at end of file +module.exports = exports["default"]; diff --git a/web-dist/discord.5.1.0.js b/web-dist/discord.5.1.0.js new file mode 100644 index 000000000..abd36fe78 --- /dev/null +++ b/web-dist/discord.5.1.0.js @@ -0,0 +1,26519 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Discord = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var chan = _ref; + + _this6.channels.remove(chan); + } + // remove server + _this6.servers.remove(server); + }); + }; + + // def login + + InternalClient.prototype.login = function login(email, password) { + var _this7 = this; + + var client = this.client; + if (this.state !== _ConnectionState2["default"].DISCONNECTED && this.state !== _ConnectionState2["default"].IDLE) { + return Promise.reject(new Error("already logging in/logged in/ready!")); + } + + this.state = _ConnectionState2["default"].LOGGING_IN; + + return _superagent2["default"].post(_Constants.Endpoints.LOGIN).send({ + email: email, + password: password + }).end().then(function (res) { + var token = res.body.token; + _this7.state = _ConnectionState2["default"].LOGGED_IN; + _this7.token = token; + _this7.email = email; + _this7.password = password; + + return _this7.getGateway().then(function (url) { + _this7.createWS(url); + return token; + }); + }, function (error) { + _this7.websocket = null; + throw error; + })["catch"](function (error) { + _this7.state = _ConnectionState2["default"].DISCONNECTED; + client.emit("disconnected"); + throw error; + }); + }; + + // def logout + + InternalClient.prototype.logout = function logout() { + var _this8 = this; + + if (this.state === _ConnectionState2["default"].DISCONNECTED || this.state === _ConnectionState2["default"].IDLE) { + return Promise.reject(new Error("Client is not logged in!")); + } + + return _superagent2["default"].post(_Constants.Endpoints.LOGOUT).set("authorization", this.token).end().then(function () { + if (_this8.websocket) { + _this8.websocket.close(); + _this8.websocket = null; + } + _this8.token = null; + _this8.email = null; + _this8.password = null; + _this8.state = _ConnectionState2["default"].DISCONNECTED; + }); + }; + + // def startPM + + InternalClient.prototype.startPM = function startPM(resUser) { + var _this9 = this; + + var user = this.resolver.resolveUser(resUser); + if (!user) { + return Promise.reject(new Error("Unable to resolve resUser to a User")); + } + // start the PM + return _superagent2["default"].post("" + _Constants.Endpoints.USER_CHANNELS(user.id)).set("authorization", this.token).send({ + recipient_id: user.id + }).end().then(function (res) { + return _this9.private_channels.add(new _StructuresPMChannel2["default"](res.body, _this9.client)); + }); + }; + + // def getGateway + + InternalClient.prototype.getGateway = function getGateway() { + return _superagent2["default"].get(_Constants.Endpoints.GATEWAY).set("authorization", this.token).end().then(function (res) { + return res.body.url; + }); + }; + + // def sendMessage + + InternalClient.prototype.sendMessage = function sendMessage(where, _content) { + var _this10 = this; + + var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + return this.resolver.resolveChannel(where).then(function (destination) { + //var destination; + var content = _this10.resolver.resolveString(_content); + var mentions = _this10.resolver.resolveMentions(content); + + return _superagent2["default"].post(_Constants.Endpoints.CHANNEL_MESSAGES(destination.id)).set("authorization", _this10.token).send({ + content: content, + mentions: mentions, + tts: options.tts + }).end().then(function (res) { + return destination.messages.add(new _StructuresMessage2["default"](res.body, destination, _this10.client)); + }); + }); + }; + + // def deleteMessage + + InternalClient.prototype.deleteMessage = function deleteMessage(_message) { + var _this11 = this; + + var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + + var message = this.resolver.resolveMessage(_message); + if (!message) { + return Promise.reject(new Error("Supplied message did not resolve to a message!")); + } + + var chain = options.wait ? delay(options.wait) : Promise.resolve(); + return chain.then(function () { + return _superagent2["default"].del(_Constants.Endpoints.CHANNEL_MESSAGE(message.channel.id, message.id)).set("authorization", _this11.token).end(); + }).then(function () { + return message.channel.messages.remove(message); + }); + }; + + // def updateMessage + + InternalClient.prototype.updateMessage = function updateMessage(msg, _content) { + var _this12 = this; + + var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + var message = this.resolver.resolveMessage(msg); + + if (!message) { + return Promise.reject(new Error("Supplied message did not resolve to a message!")); + } + + var content = this.resolver.resolveString(_content); + var mentions = this.resolver.resolveMentions(content); + + return _superagent2["default"].patch(_Constants.Endpoints.CHANNEL_MESSAGE(message.channel.id, message.id)).set("authorization", this.token).send({ + content: content, + tts: options.tts, + mentions: mentions + }).end().then(function (res) { + return message.channel.messages.update(message, new _StructuresMessage2["default"](res.body, message.channel, _this12.client)); + }); + }; + + // def sendFile + + InternalClient.prototype.sendFile = function sendFile(where, _file) { + var _this13 = this; + + var name = arguments.length <= 2 || arguments[2] === undefined ? "image.png" : arguments[2]; + + return this.resolver.resolveChannel(where).then(function (channel) { + return _superagent2["default"].post(_Constants.Endpoints.CHANNEL_MESSAGES(channel.id)).set("authorization", _this13.token).attach("file", _this13.resolver.resolveFile(_file), name).end().then(function (res) { + return channel.messages.add(new _StructuresMessage2["default"](res.body, channel, _this13.client)); + }); + }); + }; + + // def getChannelLogs + + InternalClient.prototype.getChannelLogs = function getChannelLogs(_channel) { + var _this14 = this; + + var limit = arguments.length <= 1 || arguments[1] === undefined ? 500 : arguments[1]; + var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2]; + + return this.resolver.resolveChannel(_channel).then(function (channel) { + var qsObject = { limit: limit }; + if (options.before) { + var res = _this14.resolver.resolveMessage(options.before); + if (res) { + qsObject.before = res; + } + } + if (options.after) { + var res = _this14.resolver.resolveMessage(options.after); + if (res) { + qsObject.after = res; + } + } + + return _superagent2["default"].get(_Constants.Endpoints.CHANNEL_MESSAGES(channel.id) + "?" + _querystring2["default"].stringify(qsObject)).set("authorization", _this14.token).end().then(function (res) { + return res.body.map(function (msg) { + return channel.messages.add(new _StructuresMessage2["default"](msg, channel, _this14.client)); + }); + }); + }); + }; + + // def getBans + + InternalClient.prototype.getBans = function getBans(server) { + var _this15 = this; + + server = this.resolver.resolveServer(server); + + return _superagent2["default"].get("" + _Constants.Endpoints.SERVER_BANS(server.id)).set("authorization", this.token).end().then(function (res) { + res.body.map(function (ban) { + return _this15.users.add(new _StructuresUser2["default"](ban.user, _this15.client)); + }); + }); + }; + + // def createChannel + + InternalClient.prototype.createChannel = function createChannel(server, name) { + var _this16 = this; + + var type = arguments.length <= 2 || arguments[2] === undefined ? "text" : arguments[2]; + + server = this.resolver.resolveServer(server); + + return _superagent2["default"].post(_Constants.Endpoints.SERVER_CHANNELS(server.id)).set("authorization", this.token).send({ + name: name, + type: type + }).end().then(function (res) { + var channel; + if (res.body.type === "text") { + channel = new _StructuresTextChannel2["default"](res.body, _this16.client, server); + } else { + channel = new _StructuresVoiceChannel2["default"](res.body, _this16.client, server); + } + return server.channels.add(_this16.channels.add(channel)); + }); + }; + + // def deleteChannel + + InternalClient.prototype.deleteChannel = function deleteChannel(_channel) { + var _this17 = this; + + return this.resolver.resolveChannel(_channel).then(function (channel) { + return _superagent2["default"].del(_Constants.Endpoints.CHANNEL(channel.id)).set("authorization", _this17.token).end().then(function () { + channel.server.channels.remove(channel); + _this17.channels.remove(channel); + }); + }, function (error) { + error.message = "Couldn't resolve to channel - " + error.toString(); + throw error; + }); + }; + + // def banMember + + InternalClient.prototype.banMember = function banMember(user, server) { + var length = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2]; + + user = this.resolver.resolveUser(user); + server = this.resolver.resolveServer(server); + + return _superagent2["default"].put(_Constants.Endpoints.SERVER_BANS(server.id) + "/" + user.id + "?delete-message-days=" + length).set("authorization", this.token).end(); //will expose api result, probably not bad tho + }; + + // def unbanMember + + InternalClient.prototype.unbanMember = function unbanMember(user, server) { + + server = this.resolver.resolveServer(server); + user = this.resolver.resolveUser(user); + + return _superagent2["default"].del(_Constants.Endpoints.SERVER_BANS(server.id) + "/" + user.id).set("authorization", this.token).end(); //will expose api result, probably not bad tho + }; + + // def kickMember + + InternalClient.prototype.kickMember = function kickMember(user, server) { + user = this.resolver.resolveUser(user); + server = this.resolver.resolveServer(server); + + return _superagent2["default"].del(_Constants.Endpoints.SERVER_MEMBERS(server.id) + "/" + user.id).set("authorization", this.token).end(); + }; + + // def createRole + + InternalClient.prototype.createRole = function createRole(server, data) { + var _this18 = this; + + server = this.resolver.resolveServer(server); + + return _superagent2["default"].post(_Constants.Endpoints.SERVER_ROLES(server.id)).set("authorization", this.token).end().then(function (res) { + var role = server.roles.add(new _StructuresRole2["default"](res.body, server, _this18.client)); + + if (data) { + return _this18.updateRole(role, data); + } + return role; + }); + }; + + // def updateRole + + InternalClient.prototype.updateRole = function updateRole(role, data) { + var _this19 = this; + + var server = this.resolver.resolveServer(role.server); + + var newData = { + color: data.color || role.color, + hoist: data.hoist || role.hoist, + name: data.name || role.name, + permissions: role.permissions || 0 + }; + + if (data.permissions) { + newData.permissions = 0; + for (var _iterator2 = data.permissions, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var perm = _ref2; + + if (perm instanceof String || typeof perm === "string") { + newData.permissions |= _Constants.Permissions[perm] || 0; + } else { + newData.permissions |= perm; + } + } + } + + return _superagent2["default"].patch(_Constants.Endpoints.SERVER_ROLES(server.id) + "/" + role.id).set("authorization", this.token).send(newData).end().then(function (res) { + return server.roles.update(role, new _StructuresRole2["default"](res.body, server, _this19.client)); + }); + }; + + // def deleteRole + + InternalClient.prototype.deleteRole = function deleteRole(role) { + return _superagent2["default"].del(_Constants.Endpoints.SERVER_ROLES(role.server.id) + "/" + role.id).set("authorization", this.token).end(); + }; + + //def addMemberToRole + + InternalClient.prototype.addMemberToRole = function addMemberToRole(member, role) { + member = this.resolver.resolveUser(member); + + if (!member || !role) { + return Promise.reject(new Error("member/role not in server")); + } + + if (!role.server.memberMap[member.id]) { + return Promise.reject(new Error("member not in server")); + } + + var roleIDS = role.server.memberMap[member.id].roles.map(function (r) { + return r.id; + }).concat(role.id); + + return _superagent2["default"].patch(_Constants.Endpoints.SERVER_MEMBERS(role.server.id) + "/" + member.id).set("authorization", this.token).send({ + roles: roleIDS + }).end(); + }; + + //def removeMemberFromRole + + InternalClient.prototype.removeMemberFromRole = function removeMemberFromRole(member, role) { + member = this.resolver.resolveUser(member); + + if (!member || !role) { + return Promise.reject(new Error("member/role not in server")); + } + + if (!role.server.memberMap[member.id]) { + return Promise.reject(new Error("member not in server")); + } + + var roleIDS = role.server.memberMap[member.id].roles.map(function (r) { + return r.id; + }); + + for (var item in roleIDS) { + if (roleIDS[item] === role.id) { + roleIDS.splice(item, 1); + //missing break? + } + } + + return _superagent2["default"].patch(_Constants.Endpoints.SERVER_MEMBERS(role.server.id) + "/" + member.id).set("authorization", this.token).send({ + roles: roleIDS + }).end(); + }; + + // def createInvite + + InternalClient.prototype.createInvite = function createInvite(chanServ, options) { + var _this20 = this; + + if (chanServ instanceof _StructuresChannel2["default"]) { + // do something + } else if (chanServ instanceof _StructuresServer2["default"]) { + // do something + } else { + chanServ = this.resolver.resolveServer(chanServ) || this.resolver.resolveChannel(chanServ); + } + + if (!chanServ) { + throw new Error("couldn't resolve where"); + } + + if (!options) { + options = { + validate: null + }; + } else { + options.max_age = options.maxAge || 0; + options.max_uses = options.maxUses || 0; + options.temporary = options.temporary || false; + options.xkcdpass = options.xkcd || false; + } + + var epoint; + if (chanServ instanceof _StructuresChannel2["default"]) { + epoint = _Constants.Endpoints.CHANNEL_INVITES(chanServ.id); + } else { + epoint = _Constants.Endpoints.SERVER_INVITES(chanServ.id); + } + + return _superagent2["default"].post(epoint).set("authorization", this.token).send(options).end().then(function (res) { + return new _StructuresInvite2["default"](res.body, _this20.channels.get("id", res.body.channel.id), _this20.client); + }); + }; + + //def deleteInvite + + InternalClient.prototype.deleteInvite = function deleteInvite(invite) { + + invite = this.resolver.resolveInviteID(invite); + if (!invite) { + throw new Error("Not a valid invite"); + } + return _superagent2["default"].del(_Constants.Endpoints.INVITE(invite)).set("authorization", this.token).end(); + }; + + //def overwritePermissions + + InternalClient.prototype.overwritePermissions = function overwritePermissions(channel, role, updated) { + var _this21 = this; + + return this.resolver.resolveChannel(channel).then(function (channel) { + var user; + if (role instanceof _StructuresUser2["default"]) { + user = role; + } + + var data = {}; + data.allow = 0; + data.deny = 0; + + updated.allow = updated.allow || []; + updated.deny = updated.deny || []; + + if (role instanceof _StructuresRole2["default"]) { + data.id = role.id; + data.type = "role"; + } else if (user) { + data.id = user.id; + data.type = "member"; + } else { + throw new Error("role incorrect"); + } + + for (var perm in updated) { + if (updated[perm]) { + if (perm instanceof String || typeof perm === "string") { + data.allow |= _Constants.Permissions[perm] || 0; + } else { + data.allow |= perm; + } + } else { + if (perm instanceof String || typeof perm === "string") { + data.deny |= _Constants.Permissions[perm] || 0; + } else { + data.deny |= perm; + } + } + } + + return _superagent2["default"].put(_Constants.Endpoints.CHANNEL_PERMISSIONS(channel.id) + "/" + data.id).set("authorization", _this21.token).send(data).end(); + }); + }; + + //def setStatus + + InternalClient.prototype.setStatus = function setStatus(idleStatus, gameID) { + + this.idleStatus = idleStatus || this.idleStatus || null; + if (idleStatus) { + if (idleStatus === "online" || idleStatus === "here" || idleStatus === "available") { + this.idleStatus = null; + } + } + this.gameID = this.resolver.resolveGameID(gameID) || this.gameID || null; + + var packet = { + op: 3, + d: { + idle_since: this.idleStatus, + game_id: this.gameID + } + }; + + if (this.idleStatus === "idle" || this.idleStatus === "away") { + packet.d.idle_since = Date.now(); + } + + this.sendWS(packet); + + return Promise.resolve(); //why? + }; + + //def sendTyping + + InternalClient.prototype.sendTyping = function sendTyping(channel) { + var _this22 = this; + + return this.resolver.resolveChannel(channel).then(function (channel) { + return _superagent2["default"].post(_Constants.Endpoints.CHANNEL(channel.id) + "/typing").set("authorization", _this22.token).end(); + }); + }; + + //def startTyping + + InternalClient.prototype.startTyping = function startTyping(channel) { + var _this23 = this; + + return this.resolver.resolveChannel(channel).then(function (channel) { + + if (_this23.typingIntervals[channel.id]) { + // typing interval already exists, leave it alone + throw new Error("Already typing in that channel"); + } + + _this23.typingIntervals[channel.id] = setInterval(function () { + return _this23.sendTyping(channel)["catch"](function (error) { + return _this23.emit("error", error); + }); + }, 4000); + + return _this23.sendTyping(channel); + }); + }; + + //def stopTyping + + InternalClient.prototype.stopTyping = function stopTyping(channel) { + var _this24 = this; + + return this.resolver.resolveChannel(channel).then(function (channel) { + + if (!_this24.typingIntervals[channel.id]) { + // typing interval doesn't exist + throw new Error("Not typing in that channel"); + } + + clearInterval(_this24.typingIntervals[channel.id]); + _this24.typingIntervals[channel.id] = false; + }); + }; + + //def updateDetails + + InternalClient.prototype.updateDetails = function updateDetails(data) { + return _superagent2["default"].patch(_Constants.Endpoints.ME).set("authorization", this.token).send({ + avatar: this.resolver.resolveToBase64(data.avatar) || this.user.avatar, + email: data.email || this.email, + new_password: data.newPassword || null, + password: data.password || this.password, + username: data.username || this.user.username + }).end(); + }; + + //def setAvatar + + InternalClient.prototype.setAvatar = function setAvatar(avatar) { + return this.updateDetails({ avatar: avatar }); + }; + + //def setUsername + + InternalClient.prototype.setUsername = function setUsername(username) { + return this.updateDetails({ username: username }); + }; + + //def setTopic + + InternalClient.prototype.setTopic = function setTopic(chann) { + var _this25 = this; + + var topic = arguments.length <= 1 || arguments[1] === undefined ? "" : arguments[1]; + + return this.resolver.resolveChannel(chann).then(function (channel) { + return _superagent2["default"].patch(_Constants.Endpoints.CHANNEL(channel.id)).set("authorization", _this25.token).send({ + name: channel.name, + position: channel.position, + topic: topic + }).end().then(function (res) { + return channel.topic = res.body.topic; + }); + }); + }; + + //def setChannelName + + InternalClient.prototype.setChannelName = function setChannelName(chann) { + var _this26 = this; + + var name = arguments.length <= 1 || arguments[1] === undefined ? "discordjs_is_the_best" : arguments[1]; + + return this.resolver.resolveChannel(chann).then(function (channel) { + return _superagent2["default"].patch(_Constants.Endpoints.CHANNEL(channel.id)).set("authorization", _this26.token).send({ + name: name, + position: channel.position, + topic: channel.topic + }).end().then(function (res) { + return channel.name = res.body.name; + }); + }); + }; + + //def setChannelNameAndTopic + + InternalClient.prototype.setChannelNameAndTopic = function setChannelNameAndTopic(chann) { + var _this27 = this; + + var name = arguments.length <= 1 || arguments[1] === undefined ? "discordjs_is_the_best" : arguments[1]; + var topic = arguments.length <= 2 || arguments[2] === undefined ? "" : arguments[2]; + + return this.resolver.resolveChannel(chann).then(function (channel) { + return _superagent2["default"].patch(_Constants.Endpoints.CHANNEL(channel.id)).set("authorization", _this27.token).send({ + name: name, + position: channel.position, + topic: topic + }).end().then(function (res) { + channel.name = res.body.name; + channel.topic = res.body.topic; + }); + }); + }; + + //def updateChannel + + InternalClient.prototype.updateChannel = function updateChannel(chann, data) { + return this.setChannelNameAndTopic(chann, data.name, data.topic); + }; + + //def ack + + InternalClient.prototype.ack = function ack(msg) { + msg = this.resolver.resolveMessage(msg); + + if (!msg) { + Promise.reject(new Error("Message does not exist")); + } + + return _superagent2["default"].post(_Constants.Endpoints.CHANNEL_MESSAGE(msg.channel.id, msg.id) + "/ack").set("authorization", this.token).end(); + }; + + InternalClient.prototype.sendWS = function sendWS(object) { + if (this.websocket) { + this.websocket.send(JSON.stringify(object)); + } + }; + + InternalClient.prototype.createWS = function createWS(url) { + var self = this; + var client = self.client; + + if (this.websocket) { + return false; + } + + this.websocket = new _ws2["default"](url); + + this.websocket.onopen = function () { + + self.sendWS({ + op: 2, + d: { + token: self.token, + v: 3, + compress: self.client.options.compress, + properties: { + "$os": "discord.js", + "$browser": "discord.js", + "$device": "discord.js", + "$referrer": "discord.js", + "$referring_domain": "discord.js" + } + } + }); + }; + + this.websocket.onclose = function () { + self.websocket = null; + self.state = _ConnectionState2["default"].DISCONNECTED; + client.emit("disconnected"); + }; + + this.websocket.onerror = function (e) { + client.emit("error", e); + }; + + this.websocket.onmessage = function (e) { + if (e.type === "Binary") { + if (!zlib) zlib = require("zlib"); + e.data = zlib.inflateSync(e.data).toString(); + } + + var packet, data; + try { + packet = JSON.parse(e.data); + data = packet.d; + } catch (e) { + client.emit("error", e); + return; + } + + client.emit("raw", packet); + switch (packet.t) { + + case _Constants.PacketType.READY: + var startTime = Date.now(); + self.user = self.users.add(new _StructuresUser2["default"](data.user, client)); + data.guilds.forEach(function (server) { + self.servers.add(new _StructuresServer2["default"](server, client)); + }); + data.private_channels.forEach(function (pm) { + self.private_channels.add(new _StructuresPMChannel2["default"](pm, client)); + }); + self.state = _ConnectionState2["default"].READY; + + setInterval(function () { + return self.sendWS({ op: 1, d: Date.now() }); + }, data.heartbeat_interval); + + client.emit("ready"); + client.emit("debug", "ready packet took " + (Date.now() - startTime) + "ms to process"); + client.emit("debug", "ready with " + self.servers.length + " servers, " + self.channels.length + " channels and " + self.users.length + " users cached."); + + self.readyTime = Date.now(); + break; + + case _Constants.PacketType.MESSAGE_CREATE: + // format: https://discordapi.readthedocs.org/en/latest/reference/channels/messages.html#message-format + var channel = self.channels.get("id", data.channel_id) || self.private_channels.get("id", data.channel_id); + if (channel) { + var msg = channel.messages.add(new _StructuresMessage2["default"](data, channel, client)); + + if (self.messageAwaits[channel.id + msg.author.id]) { + self.messageAwaits[channel.id + msg.author.id].map(function (fn) { + return fn(msg); + }); + self.messageAwaits[channel.id + msg.author.id] = null; + client.emit("message", msg, true); //2nd param is isAwaitedMessage + } else { + client.emit("message", msg); + } + self.ack(msg); + } else { + client.emit("warn", "message created but channel is not cached"); + } + break; + case _Constants.PacketType.MESSAGE_DELETE: + // format https://discordapi.readthedocs.org/en/latest/reference/channels/messages.html#message-delete + var channel = self.channels.get("id", data.channel_id) || self.private_channels.get("id", data.channel_id); + if (channel) { + // potentially blank + var msg = channel.messages.get("id", data.id); + client.emit("messageDeleted", msg, channel); + if (msg) { + channel.messages.remove(msg); + } + } else { + client.emit("warn", "message was deleted but channel is not cached"); + } + break; + case _Constants.PacketType.MESSAGE_UPDATE: + // format https://discordapi.readthedocs.org/en/latest/reference/channels/messages.html#message-format + var channel = self.channels.get("id", data.channel_id) || self.private_channels.get("id", data.channel_id); + if (channel) { + // potentially blank + var msg = channel.messages.get("id", data.id); + + if (msg) { + // old message exists + data.nonce = data.nonce || msg.nonce; + data.attachments = data.attachments || msg.attachments; + data.tts = data.tts || msg.tts; + data.embeds = data.embeds || msg.embeds; + data.timestamp = data.timestamp || msg.timestamp; + data.mention_everyone = data.mention_everyone || msg.everyoneMentioned; + data.content = data.content || msg.content; + data.mentions = data.mentions || msg.mentions; + data.author = data.author || msg.author; + var nmsg = channel.messages.update(msg, new _StructuresMessage2["default"](data, channel, client)); + client.emit("messageUpdated", nmsg, msg); + } + } else { + client.emit("warn", "message was updated but channel is not cached"); + } + break; + case _Constants.PacketType.SERVER_CREATE: + var server = self.servers.get("id", data.id); + if (!server) { + self.servers.add(new _StructuresServer2["default"](data, client)); + client.emit("serverCreated", server); + } + break; + case _Constants.PacketType.SERVER_DELETE: + var server = self.servers.get("id", data.id); + if (server) { + + for (var _iterator3 = server.channels, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i3 >= _iterator3.length) break; + _ref3 = _iterator3[_i3++]; + } else { + _i3 = _iterator3.next(); + if (_i3.done) break; + _ref3 = _i3.value; + } + + var channel = _ref3; + + self.channels.remove(channel); + } + + self.servers.remove(server); + client.emit("serverDeleted", server); + } else { + client.emit("warn", "server was deleted but it was not in the cache"); + } + break; + case _Constants.PacketType.SERVER_UPDATE: + var server = self.servers.get("id", data.id); + if (server) { + // server exists + data.members = data.members || []; + data.channels = data.channels || []; + var newserver = new _StructuresServer2["default"](data, self); + newserver.members = server.members; + newserver.memberMap = server.memberMap; + newserver.channels = server.channels; + if (newserver.equalsStrict(server)) { + // already the same don't do anything + client.emit("debug", "received server update but server already updated"); + } else { + self.servers.update(server, newserver); + client.emit("serverUpdated", server, newserver); + } + } else if (!server) { + client.emit("warn", "server was updated but it was not in the cache"); + self.servers.add(new _StructuresServer2["default"](data, self)); + client.emit("serverCreated", server); + } + break; + case _Constants.PacketType.CHANNEL_CREATE: + + var channel = self.channels.get("id", data.id); + + if (!channel) { + + var server = self.servers.get("id", data.guild_id); + if (server) { + if (data.is_private) { + client.emit("channelCreated", self.private_channels.add(new _StructuresPMChannel2["default"](data, client))); + } else { + var chan = null; + if (data.type === "text") { + chan = self.channels.add(new _StructuresTextChannel2["default"](data, client, server)); + } else { + chan = self.channels.add(new _StructuresVoiceChannel2["default"](data, client, server)); + } + client.emit("channelCreated", server.channels.add(chan)); + } + } else { + client.emit("warn", "channel created but server does not exist"); + } + } else { + client.emit("warn", "channel created but already in cache"); + } + + break; + case _Constants.PacketType.CHANNEL_DELETE: + var channel = self.channels.get("id", data.id); + if (channel) { + + if (channel.server) // accounts for PMs + channel.server.channels.remove(channel); + + self.channels.remove(channel); + client.emit("channelDeleted", channel); + } else { + client.emit("warn", "channel deleted but already out of cache?"); + } + break; + case _Constants.PacketType.CHANNEL_UPDATE: + var channel = self.channels.get("id", data.id) || self.private_channels.get("id", data.id); + if (channel) { + + if (channel instanceof _StructuresPMChannel2["default"]) { + //PM CHANNEL + client.emit("channelUpdated", channel, self.private_channels.update(channel, new _StructuresPMChannel2["default"](data, client))); + } else { + if (channel.server) { + if (channel.type === "text") { + //TEXT CHANNEL + var chan = new _StructuresTextChannel2["default"](data, client, channel.server); + chan.messages = channel.messages; + channel.server.channels.update(channel, chan); + self.channels.update(channel, chan); + client.emit("channelUpdated", channel, chan); + } else { + //VOICE CHANNEL + var chan = new _StructuresVoiceChannel2["default"](data, client, channel.server); + channel.server.channels.update(channel, chan); + self.channels.update(channel, chan); + client.emit("channelUpdated", channel, chan); + } + } else { + client.emit("warn", "channel updated but server non-existant"); + } + } + } else { + client.emit("warn", "channel updated but not in cache"); + } + break; + case _Constants.PacketType.SERVER_ROLE_CREATE: + var server = self.servers.get("id", data.guild_id); + if (server) { + client.emit("serverRoleCreated", server.roles.add(new _StructuresRole2["default"](data.role, server, client)), server); + } else { + client.emit("warn", "server role made but server not in cache"); + } + break; + case _Constants.PacketType.SERVER_ROLE_DELETE: + var server = self.servers.get("id", data.guild_id); + if (server) { + var role = server.roles.get("id", data.role_id); + if (role) { + server.roles.remove(role); + client.emit("serverRoleDeleted", role); + } else { + client.emit("warn", "server role deleted but role not in cache"); + } + } else { + client.emit("warn", "server role deleted but server not in cache"); + } + break; + case _Constants.PacketType.SERVER_ROLE_UPDATE: + var server = self.servers.get("id", data.guild_id); + if (server) { + var role = server.roles.get("id", data.role.id); + if (role) { + var newRole = new _StructuresRole2["default"](data.role, server, client); + server.roles.update(role, newRole); + client.emit("serverRoleUpdated", role, newRole); + } else { + client.emit("warn", "server role updated but role not in cache"); + } + } else { + client.emit("warn", "server role updated but server not in cache"); + } + break; + case _Constants.PacketType.SERVER_MEMBER_ADD: + var server = self.servers.get("id", data.guild_id); + if (server) { + + server.memberMap[data.user.id] = { + roles: data.roles.map(function (pid) { + return server.roles.get("id", pid); + }), + mute: false, + deaf: false, + joinedAt: Date.parse(data.joined_at) + }; + + client.emit("serverNewMember", server, server.members.add(self.users.add(new _StructuresUser2["default"](data.user, client)))); + } else { + client.emit("warn", "server member added but server doesn't exist in cache"); + } + break; + case _Constants.PacketType.SERVER_MEMBER_REMOVE: + var server = self.servers.get("id", data.guild_id); + if (server) { + var user = self.users.get("id", data.user.id); + if (user) { + server.memberMap[data.user.id] = null; + server.members.remove(user); + client.emit("serverMemberRemoved", server, user); + } else { + client.emit("warn", "server member removed but user doesn't exist in cache"); + } + } else { + client.emit("warn", "server member removed but server doesn't exist in cache"); + } + break; + case _Constants.PacketType.SERVER_MEMBER_UPDATE: + var server = self.servers.get("id", data.guild_id); + if (server) { + var user = self.users.get("id", data.user.id); + if (user) { + server.memberMap[data.user.id].roles = data.roles.map(function (pid) { + return server.roles.get("id", pid); + }); + server.memberMap[data.user.id].mute = data.mute; + server.memberMap[data.user.id].deaf = data.deaf; + client.emit("serverMemberUpdated", server, user); + } else { + client.emit("warn", "server member removed but user doesn't exist in cache"); + } + } else { + client.emit("warn", "server member updated but server doesn't exist in cache"); + } + break; + case _Constants.PacketType.PRESENCE_UPDATE: + + var user = self.users.get("id", data.user.id); + + if (user) { + + data.user.username = data.user.username || user.username; + data.user.id = data.user.id || user.id; + data.user.avatar = data.user.avatar || user.avatar; + data.user.discriminator = data.user.discriminator || user.discriminator; + + var presenceUser = new _StructuresUser2["default"](data.user, client); + + if (presenceUser.equals(user)) { + // a real presence update + client.emit("presence", user, data.status, data.game_id); + user.status = data.status; + user.gameID = data.game_id; + } else { + // a name change or avatar change + client.emit("userUpdated", user, presenceUser); + self.users.update(user, presenceUser); + } + } else { + client.emit("warn", "presence update but user not in cache"); + } + + break; + case _Constants.PacketType.TYPING: + + var user = self.users.get("id", data.user_id); + var channel = self.channels.get("id", data.channel_id) || self.private_channels.get("id", data.channel_id); + + if (user && channel) { + if (user.typing.since) { + user.typing.since = Date.now(); + user.typing.channel = channel; + } else { + user.typing.since = Date.now(); + user.typing.channel = channel; + client.emit("userTypingStarted", user, channel); + } + setTimeout(function () { + if (Date.now() - user.typing.since > 5500) { + // they haven't typed since + user.typing.since = null; + user.typing.channel = null; + client.emit("userTypingStopped", user, channel); + } + }, 6000); + } else { + client.emit("warn", "user typing but user or channel not existant in cache"); + } + break; + case _Constants.PacketType.SERVER_BAN_ADD: + var user = self.users.get("id", data.user.id); + var server = self.servers.get("id", data.guild_id); + + if (user && server) { + client.emit("userBanned", user, server); + } else { + client.emit("warn", "user banned but user/server not in cache."); + } + break; + case _Constants.PacketType.SERVER_BAN_REMOVE: + var user = self.users.get("id", data.user.id); + var server = self.servers.get("id", data.guild_id); + + if (user && server) { + client.emit("userUnbanned", user, server); + } else { + client.emit("warn", "user unbanned but user/server not in cache."); + } + break; + } + }; + }; + + _createClass(InternalClient, [{ + key: "uptime", + get: function get() { + return this.readyTime ? Date.now() - this.readyTime : null; + } + }]); + + return InternalClient; +})(); + +exports["default"] = InternalClient; +module.exports = exports["default"]; + +},{"../Constants":5,"../Structures/Channel":6,"../Structures/Invite":8,"../Structures/Message":9,"../Structures/PMChannel":10,"../Structures/Role":12,"../Structures/Server":13,"../Structures/TextChannel":15,"../Structures/User":16,"../Structures/VoiceChannel":17,"../Util/Cache":19,"../Voice/VoiceConnection":23,"./ConnectionState":2,"./Resolver/Resolver":4,"querystring":71,"superagent":87,"ws":91,"zlib":31}],4:[function(require,module,exports){ +(function (Buffer){ +"use strict"; +/* global Buffer */ + +exports.__esModule = true; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _fs = require("fs"); + +var _fs2 = _interopRequireDefault(_fs); + +var _StructuresUser = require("../../Structures/User"); + +var _StructuresUser2 = _interopRequireDefault(_StructuresUser); + +var _StructuresChannel = require("../../Structures/Channel"); + +var _StructuresChannel2 = _interopRequireDefault(_StructuresChannel); + +var _StructuresTextChannel = require("../../Structures/TextChannel"); + +var _StructuresTextChannel2 = _interopRequireDefault(_StructuresTextChannel); + +var _StructuresVoiceChannel = require("../../Structures/VoiceChannel"); + +var _StructuresVoiceChannel2 = _interopRequireDefault(_StructuresVoiceChannel); + +var _StructuresServerChannel = require("../../Structures/ServerChannel"); + +var _StructuresServerChannel2 = _interopRequireDefault(_StructuresServerChannel); + +var _StructuresPMChannel = require("../../Structures/PMChannel"); + +var _StructuresPMChannel2 = _interopRequireDefault(_StructuresPMChannel); + +var _StructuresServer = require("../../Structures/Server"); + +var _StructuresServer2 = _interopRequireDefault(_StructuresServer); + +var _StructuresMessage = require("../../Structures/Message"); + +var _StructuresMessage2 = _interopRequireDefault(_StructuresMessage); + +var _StructuresInvite = require("../../Structures/Invite"); + +var _StructuresInvite2 = _interopRequireDefault(_StructuresInvite); + +var _refGameMap = require("../../../ref/gameMap"); + +var _refGameMap2 = _interopRequireDefault(_refGameMap); + +var Resolver = (function () { + function Resolver(internal) { + _classCallCheck(this, Resolver); + + this.internal = internal; + } + + Resolver.prototype.resolveGameID = function resolveGameID(resource) { + if (!isNaN(resource) && parseInt(resource) % 1 === 0) { + return resource; + } + if (typeof resource === "string" || resource instanceof String) { + var gameName = resource.toLowerCase(); + var found = _refGameMap2["default"].find(function (game) { + return game.name.toLowerCase() === gameName; + }); + if (found) { + return found.id; + } + } + + return null; + }; + + Resolver.prototype.resolveToBase64 = function resolveToBase64(resource) { + if (resource instanceof Buffer) { + resource = resource.toString("base64"); + resource = "data:image/jpg;base64," + resource; + } + return resource; + }; + + Resolver.prototype.resolveInviteID = function resolveInviteID(resource) { + if (resource instanceof _StructuresInvite2["default"]) { + return resource.id; + } + if (typeof resource === "string" || resource instanceof String) { + if (resource.indexOf("http") === 0) { + var split = resource.split("/"); + return split.pop(); + } + return resource; + } + return null; + }; + + Resolver.prototype.resolveServer = function resolveServer(resource) { + if (resource instanceof _StructuresServer2["default"]) { + return resource; + } + if (resource instanceof _StructuresServerChannel2["default"]) { + return resource.server; + } + if (resource instanceof String || typeof resource === "string") { + return this.internal.servers.get("id", resource); + } + if (resource instanceof _StructuresMessage2["default"]) { + if (resource.channel instanceof _StructuresTextChannel2["default"]) { + return resource.server; + } + } + return null; + }; + + Resolver.prototype.resolveFile = function resolveFile(resource) { + if (typeof resource === "string" || resource instanceof String) { + return _fs2["default"].createReadStream(resource); + } + return resource; + }; + + Resolver.prototype.resolveMentions = function resolveMentions(resource) { + // resource is a string + var _mentions = []; + for (var _iterator = resource.match(/<@[^>]*>/g) || [], _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var mention = _ref; + + _mentions.push(mention.substring(2, mention.length - 1)); + } + return _mentions; + }; + + Resolver.prototype.resolveString = function resolveString(resource) { + + // accepts Array, Channel, Server, User, Message, String and anything + // toString()-able + + var final = resource; + if (resource instanceof Array) { + final = resource.join("\n"); + } + + return final.toString(); + }; + + Resolver.prototype.resolveUser = function resolveUser(resource) { + /* + accepts a Message, Channel, Server, String ID, User, PMChannel + */ + if (resource instanceof _StructuresUser2["default"]) { + return resource; + } + if (resource instanceof _StructuresMessage2["default"]) { + return resource.author; + } + if (resource instanceof _StructuresTextChannel2["default"]) { + var lmsg = resource.lastMessage; + if (lmsg) { + return lmsg.author; + } + } + if (resource instanceof _StructuresServer2["default"]) { + return resource.owner; + } + if (resource instanceof _StructuresPMChannel2["default"]) { + return resource.recipient; + } + if (resource instanceof String || typeof resource === "string") { + return this.client.internal.users.get("id", resource); + } + + return null; + }; + + Resolver.prototype.resolveMessage = function resolveMessage(resource) { + // accepts a Message, PMChannel & TextChannel + + if (resource instanceof _StructuresTextChannel2["default"] || resource instanceof _StructuresPMChannel2["default"]) { + return resource.lastMessage; + } + if (resource instanceof _StructuresMessage2["default"]) { + return resource; + } + + return null; + }; + + Resolver.prototype.resolveVoiceChannel = function resolveVoiceChannel(resource) { + // resolveChannel will also work but this is more apt + if (resource instanceof _StructuresVoiceChannel2["default"]) { + return resource; + } + return null; + }; + + Resolver.prototype.resolveChannel = function resolveChannel(resource) { + /* + accepts a Message, Channel, Server, String ID, User + */ + + if (resource instanceof _StructuresMessage2["default"]) { + return Promise.resolve(resource.channel); + } + if (resource instanceof _StructuresChannel2["default"]) { + return Promise.resolve(resource); + } + if (resource instanceof _StructuresServer2["default"]) { + return Promise.resolve(resource.channels.get("id", resource.id)); + } + if (resource instanceof String || typeof resource === "string") { + return Promise.resolve(this.internal.channels.get("id", resource)); + } + if (resource instanceof _StructuresUser2["default"]) { + // see if a PM exists + var chatFound = this.internal.private_channels.find(function (pmchat) { + return pmchat.recipient.equals(resource); + }); + if (chatFound) { + // a PM already exists! + return Promise.resolve(chatFound); + } + // PM does not exist :\ + return this.internal.startPM(resource); + } + var error = new Error("Could not resolve channel"); + error.resource = resource; + return Promise.reject(error); + }; + + return Resolver; +})(); + +exports["default"] = Resolver; +module.exports = exports["default"]; + +}).call(this,require("buffer").Buffer) +},{"../../../ref/gameMap":92,"../../Structures/Channel":6,"../../Structures/Invite":8,"../../Structures/Message":9,"../../Structures/PMChannel":10,"../../Structures/Server":13,"../../Structures/ServerChannel":14,"../../Structures/TextChannel":15,"../../Structures/User":16,"../../Structures/VoiceChannel":17,"buffer":38,"fs":32}],5:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; +var API = "https://discordapp.com/api"; +exports.API = API; +var Endpoints = { + // general endpoints + LOGIN: API + "/auth/login", + LOGOUT: API + "/auth/logout", + ME: API + "/users/@me", + GATEWAY: API + "/gateway", + USER_CHANNELS: function USER_CHANNELS(userID) { + return API + "/users/" + userID + "/channels"; + }, + AVATAR: function AVATAR(userID, avatar) { + return API + "/users/" + userID + "/avatars/" + avatar + ".jpg"; + }, + INVITE: function INVITE(id) { + return API + "/invite/" + id; + }, + + // servers + SERVERS: API + "/guilds", + SERVER: function SERVER(serverID) { + return Endpoints.SERVERS + "/" + serverID; + }, + SERVER_ICON: function SERVER_ICON(serverID, hash) { + return Endpoints.SERVER(serverID) + "/icons/" + hash + ".jpg"; + }, + SERVER_PRUNE: function SERVER_PRUNE(serverID) { + return Endpoints.SERVER(serverID) + "/prune"; + }, + SERVER_EMBED: function SERVER_EMBED(serverID) { + return Endpoints.SERVER(serverID) + "/embed"; + }, + SERVER_INVITES: function SERVER_INVITES(serverID) { + return Endpoints.SERVER(serverID) + "/invites"; + }, + SERVER_ROLES: function SERVER_ROLES(serverID) { + return Endpoints.SERVER(serverID) + "/roles"; + }, + SERVER_BANS: function SERVER_BANS(serverID) { + return Endpoints.SERVER(serverID) + "/bans"; + }, + SERVER_INTEGRATIONS: function SERVER_INTEGRATIONS(serverID) { + return Endpoints.SERVER(serverID) + "/integrations"; + }, + SERVER_MEMBERS: function SERVER_MEMBERS(serverID) { + return Endpoints.SERVER(serverID) + "/members"; + }, + SERVER_CHANNELS: function SERVER_CHANNELS(serverID) { + return Endpoints.SERVER(serverID) + "/channels"; + }, + + // channels + CHANNELS: API + "/channels", + CHANNEL: function CHANNEL(channelID) { + return Endpoints.CHANNELS + "/" + channelID; + }, + CHANNEL_MESSAGES: function CHANNEL_MESSAGES(channelID) { + return Endpoints.CHANNEL(channelID) + "/messages"; + }, + CHANNEL_INVITES: function CHANNEL_INVITES(channelID) { + return Endpoints.CHANNEL(channelID) + "/invites"; + }, + CHANNEL_TYPING: function CHANNEL_TYPING(channelID) { + return Endpoints.CHANNEL(channelID) + "/typing"; + }, + CHANNEL_PERMISSIONS: function CHANNEL_PERMISSIONS(channelID) { + return Endpoints.CHANNEL(channelID) + "/permissions"; + }, + CHANNEL_MESSAGE: function CHANNEL_MESSAGE(channelID, messageID) { + return Endpoints.CHANNEL_MESSAGES(channelID) + "/" + messageID; + } +}; + +exports.Endpoints = Endpoints; +var Permissions = { + // general + createInstantInvite: 1 << 0, + kickMembers: 1 << 1, + banMembers: 1 << 2, + manageRoles: 1 << 3, + managePermissions: 1 << 3, + manageChannels: 1 << 4, + manageChannel: 1 << 4, + manageServer: 1 << 5, + // text + readMessages: 1 << 10, + sendMessages: 1 << 11, + sendTTSMessages: 1 << 12, + manageMessages: 1 << 13, + embedLinks: 1 << 14, + attachFiles: 1 << 15, + readMessageHistory: 1 << 16, + mentionEveryone: 1 << 17, + // voice + voiceConnect: 1 << 20, + voiceSpeak: 1 << 21, + voiceMuteMembers: 1 << 22, + voiceDeafenMembers: 1 << 23, + voiceMoveMembers: 1 << 24, + voiceUseVAD: 1 << 25 + +}; + +exports.Permissions = Permissions; +var PacketType = { + READY: "READY", + MESSAGE_CREATE: "MESSAGE_CREATE", + MESSAGE_UPDATE: "MESSAGE_UPDATE", + MESSAGE_DELETE: "MESSAGE_DELETE", + SERVER_CREATE: "GUILD_CREATE", + SERVER_DELETE: "GUILD_DELETE", + SERVER_UPDATE: "GUILD_UPDATE", + CHANNEL_CREATE: "CHANNEL_CREATE", + CHANNEL_DELETE: "CHANNEL_DELETE", + CHANNEL_UPDATE: "CHANNEL_UPDATE", + SERVER_ROLE_CREATE: "GUILD_ROLE_CREATE", + SERVER_ROLE_DELETE: "GUILD_ROLE_DELETE", + SERVER_ROLE_UPDATE: "GUILD_ROLE_UPDATE", + SERVER_MEMBER_ADD: "GUILD_MEMBER_ADD", + SERVER_MEMBER_REMOVE: "GUILD_MEMBER_REMOVE", + SERVER_MEMBER_UPDATE: "GUILD_MEMBER_UPDATE", + PRESENCE_UPDATE: "PRESENCE_UPDATE", + TYPING: "TYPING_START", + SERVER_BAN_ADD: "GUILD_BAN_ADD", + SERVER_BAN_REMOVE: "GUILD_BAN_REMOVE" +}; +exports.PacketType = PacketType; + +},{}],6:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _UtilEquality = require("../Util/Equality"); + +var _UtilEquality2 = _interopRequireDefault(_UtilEquality); + +var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser"); + +var Channel = (function (_Equality) { + _inherits(Channel, _Equality); + + function Channel(data, client) { + _classCallCheck(this, Channel); + + _Equality.call(this); + this.id = data.id; + this.client = client; + } + + Channel.prototype["delete"] = function _delete() { + return this.client.deleteChannel.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + _createClass(Channel, [{ + key: "isPrivate", + get: function get() { + return !!this.server; + } + }]); + + return Channel; +})(_UtilEquality2["default"]); + +exports["default"] = Channel; +module.exports = exports["default"]; + +},{"../Util/ArgumentRegulariser":18,"../Util/Equality":20}],7:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _Constants = require("../Constants"); + +var ChannelPermissions = (function () { + function ChannelPermissions(permissions) { + _classCallCheck(this, ChannelPermissions); + + this.permissions = permissions; + } + + ChannelPermissions.prototype.serialise = function serialise(explicit) { + var _this = this; + + var hp = function hp(perm) { + return _this.hasPermission(perm, explicit); + }; + + return { + // general + createInstantInvite: hp(_Constants.Permissions.createInstantInvite), + kickMembers: hp(_Constants.Permissions.kickMembers), + banMembers: hp(_Constants.Permissions.banMembers), + managePermissions: hp(_Constants.Permissions.managePermissions), + manageChannel: hp(_Constants.Permissions.manageChannel), + manageServer: hp(_Constants.Permissions.manageServer), + // text + readMessages: hp(_Constants.Permissions.readMessages), + sendMessages: hp(_Constants.Permissions.sendMessages), + sendTTSMessages: hp(_Constants.Permissions.sendTTSMessages), + manageMessages: hp(_Constants.Permissions.manageMessages), + embedLinks: hp(_Constants.Permissions.embedLinks), + attachFiles: hp(_Constants.Permissions.attachFiles), + readMessageHistory: hp(_Constants.Permissions.readMessageHistory), + mentionEveryone: hp(_Constants.Permissions.mentionEveryone), + // voice + voiceConnect: hp(_Constants.Permissions.voiceConnect), + voiceSpeak: hp(_Constants.Permissions.voiceSpeak), + voiceMuteMembers: hp(_Constants.Permissions.voiceMuteMembers), + voiceDeafenMembers: hp(_Constants.Permissions.voiceDeafenMembers), + voiceMoveMembers: hp(_Constants.Permissions.voiceMoveMembers), + voiceUseVAD: hp(_Constants.Permissions.voiceUseVAD) + }; + }; + + ChannelPermissions.prototype.serialize = function serialize() { + // ;n; + return this.serialise(); + }; + + ChannelPermissions.prototype.hasPermission = function hasPermission(perm) { + var explicit = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1]; + + if (perm instanceof String || typeof perm === "string") { + perm = _Constants.Permissions[perm]; + } + if (!perm) { + return false; + } + if (!explicit) { + // implicit permissions allowed + if (!!(this.permissions & _Constants.Permissions.manageRoles)) { + // manageRoles allowed, they have all permissions + return true; + } + } + return !!(this.permissions & perm); + }; + + return ChannelPermissions; +})(); + +exports["default"] = ChannelPermissions; +module.exports = exports["default"]; + +},{"../Constants":5}],8:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Invite = (function () { + function Invite(data, chan, client) { + _classCallCheck(this, Invite); + + this.maxAge = data.max_age; + this.code = data.code; + this.server = chan.server; + this.channel = chan; + this.revoked = data.revoked; + this.createdAt = Date.parse(data.created_at); + this.temporary = data.temporary; + this.uses = data.uses; + this.maxUses = data.uses; + this.inviter = client.internal.users.get("id", data.inviter.id); + this.xkcd = data.xkcdpass; + } + + Invite.prototype.toString = function toString() { + return "https://discord.gg/" + this.code; + }; + + return Invite; +})(); + +exports["default"] = Invite; +module.exports = exports["default"]; + +},{}],9:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _UtilCache = require("../Util/Cache"); + +var _UtilCache2 = _interopRequireDefault(_UtilCache); + +var _User = require("./User"); + +var _User2 = _interopRequireDefault(_User); + +var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser"); + +var _UtilEquality = require("../Util/Equality"); + +var _UtilEquality2 = _interopRequireDefault(_UtilEquality); + +var Message = (function (_Equality) { + _inherits(Message, _Equality); + + function Message(data, channel, client) { + var _this = this; + + _classCallCheck(this, Message); + + _Equality.call(this); + this.channel = channel; + this.client = client; + this.nonce = data.nonce; + this.attachments = data.attachments; + this.tts = data.tts; + this.embeds = data.embeds; + this.timestamp = Date.parse(data.timestamp); + this.everyoneMentioned = data.mention_everyone; + this.id = data.id; + + if (data.edited_timestamp) this.editedTimestamp = Date.parse(data.edited_timestamp); + + if (data.author instanceof _User2["default"]) this.author = data.author;else this.author = client.internal.users.add(new _User2["default"](data.author, client)); + + this.content = data.content; + this.mentions = new _UtilCache2["default"](); + + data.mentions.forEach(function (mention) { + // this is .add and not .get because it allows the bot to cache + // users from messages from logs who may have left the server and were + // not previously cached. + if (mention instanceof _User2["default"]) _this.mentions.push(mention);else _this.mentions.add(client.internal.users.add(new _User2["default"](mention, client))); + }); + } + + Message.prototype.isMentioned = function isMentioned(user) { + user = this.client.internal.resolver.resolveUser(user); + if (user) { + return this.mentions.has("id", user.id); + } else { + return false; + } + }; + + Message.prototype.toString = function toString() { + return this.content; + }; + + Message.prototype["delete"] = function _delete() { + return this.client.deleteMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + Message.prototype.update = function update() { + return this.client.updateMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + Message.prototype.reply = function reply() { + return this.client.reply.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + Message.prototype.replyTTS = function replyTTS() { + return this.client.replyTTS.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + _createClass(Message, [{ + key: "sender", + get: function get() { + return this.author; + } + }]); + + return Message; +})(_UtilEquality2["default"]); + +exports["default"] = Message; +module.exports = exports["default"]; + +},{"../Util/ArgumentRegulariser":18,"../Util/Cache":19,"../Util/Equality":20,"./User":16}],10:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _Channel2 = require("./Channel"); + +var _Channel3 = _interopRequireDefault(_Channel2); + +var _User = require("./User"); + +var _User2 = _interopRequireDefault(_User); + +var _UtilCache = require("../Util/Cache"); + +var _UtilCache2 = _interopRequireDefault(_UtilCache); + +var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser"); + +var PMChannel = (function (_Channel) { + _inherits(PMChannel, _Channel); + + function PMChannel(data, client) { + _classCallCheck(this, PMChannel); + + _Channel.call(this, data, client); + + this.type = data.type || "text"; + this.lastMessageId = data.last_message_id; + this.messages = new _UtilCache2["default"]("id", 1000); + this.recipient = this.client.internal.users.add(new _User2["default"](data.recipient, this.client)); + } + + /* warning! may return null */ + + PMChannel.prototype.toString = function toString() { + return this.recipient.toString(); + }; + + PMChannel.prototype.sendMessage = function sendMessage() { + return this.client.sendMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + PMChannel.prototype.sendTTSMessage = function sendTTSMessage() { + return this.client.sendTTSMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + _createClass(PMChannel, [{ + key: "lastMessage", + get: function get() { + return this.messages.get("id", this.lastMessageID); + } + }]); + + return PMChannel; +})(_Channel3["default"]); + +exports["default"] = PMChannel; +module.exports = exports["default"]; + +},{"../Util/ArgumentRegulariser":18,"../Util/Cache":19,"./Channel":6,"./User":16}],11:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _Constants = require("../Constants"); + +var PermissionOverwrite = (function () { + function PermissionOverwrite(data) { + _classCallCheck(this, PermissionOverwrite); + + this.id = data.id; + this.type = data.type; // member or role + this.deny = data.deny; + this.allow = data.allow; + } + + // returns an array of allowed permissions + + PermissionOverwrite.prototype.setAllowed = function setAllowed(allowedArray) { + var _this = this; + + allowedArray.forEach(function (permission) { + if (permission instanceof String || typeof permission === "string") { + permission = _Constants.Permissions[permission]; + } + if (permission) { + _this.allow |= 1 << permission; + } + }); + }; + + PermissionOverwrite.prototype.setDenied = function setDenied(deniedArray) { + var _this2 = this; + + deniedArray.forEach(function (permission) { + if (permission instanceof String || typeof permission === "string") { + permission = _Constants.Permissions[permission]; + } + if (permission) { + _this2.deny |= 1 << permission; + } + }); + }; + + _createClass(PermissionOverwrite, [{ + key: "allowed", + get: function get() { + var allowed = []; + for (var permName in _Constants.Permissions) { + if (permName === "manageRoles" || permName === "manageChannels") { + // these permissions do not exist in overwrites. + continue; + } + + if (!!(this.allow & _Constants.Permissions[permName])) { + allowed.push(permName); + } + } + return allowed; + } + + // returns an array of denied permissions + }, { + key: "denied", + get: function get() { + var denied = []; + for (var permName in _Constants.Permissions) { + if (permName === "manageRoles" || permName === "manageChannels") { + // these permissions do not exist in overwrites. + continue; + } + + if (!!(this.deny & _Constants.Permissions[permName])) { + denied.push(permName); + } + } + return denied; + } + }]); + + return PermissionOverwrite; +})(); + +exports["default"] = PermissionOverwrite; +module.exports = exports["default"]; + +},{"../Constants":5}],12:[function(require,module,exports){ +"use strict"; +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _Constants = require("../Constants"); + +/* + +example data + +{ position: -1, + permissions: 36953089, + name: '@everyone', + managed: false, + id: '110007368451915776', + hoist: false, + color: 0 } +*/ + +var DefaultRole = [_Constants.Permissions.createInstantInvite, _Constants.Permissions.readMessages, _Constants.Permissions.readMessageHistory, _Constants.Permissions.sendMessages, _Constants.Permissions.sendTTSMessages, _Constants.Permissions.embedLinks, _Constants.Permissions.attachFiles, _Constants.Permissions.readMessageHistory, _Constants.Permissions.mentionEveryone, _Constants.Permissions.voiceConnect, _Constants.Permissions.voiceSpeak, _Constants.Permissions.voiceUseVAD].reduce(function (previous, current) { + return previous | current; +}, 0); + +var Role = (function () { + function Role(data, server, client) { + _classCallCheck(this, Role); + + this.position = data.position || -1; + this.permissions = data.permissions || (data.name === "@everyone" ? DefaultRole : 0); + this.name = data.name || "@everyone"; + this.managed = data.managed || false; + this.id = data.id; + this.hoist = data.hoist || false; + this.color = data.color || 0; + this.server = server; + this.client = client; + } + + Role.prototype.serialise = function serialise(explicit) { + var _this = this; + + var hp = function hp(perm) { + return _this.hasPermission(perm, explicit); + }; + + return { + // general + createInstantInvite: hp(_Constants.Permissions.createInstantInvite), + kickMembers: hp(_Constants.Permissions.kickMembers), + banMembers: hp(_Constants.Permissions.banMembers), + manageRoles: hp(_Constants.Permissions.manageRoles), + manageChannels: hp(_Constants.Permissions.manageChannels), + manageServer: hp(_Constants.Permissions.manageServer), + // text + readMessages: hp(_Constants.Permissions.readMessages), + sendMessages: hp(_Constants.Permissions.sendMessages), + sendTTSMessages: hp(_Constants.Permissions.sendTTSMessages), + manageMessages: hp(_Constants.Permissions.manageMessages), + embedLinks: hp(_Constants.Permissions.embedLinks), + attachFiles: hp(_Constants.Permissions.attachFiles), + readMessageHistory: hp(_Constants.Permissions.readMessageHistory), + mentionEveryone: hp(_Constants.Permissions.mentionEveryone), + // voice + voiceConnect: hp(_Constants.Permissions.voiceConnect), + voiceSpeak: hp(_Constants.Permissions.voiceSpeak), + voiceMuteMembers: hp(_Constants.Permissions.voiceMuteMembers), + voiceDeafenMembers: hp(_Constants.Permissions.voiceDeafenMembers), + voiceMoveMembers: hp(_Constants.Permissions.voiceMoveMembers), + voiceUseVAD: hp(_Constants.Permissions.voiceUseVAD) + }; + }; + + Role.prototype.serialize = function serialize() { + // ;n; + return this.serialise(); + }; + + Role.prototype.hasPermission = function hasPermission(perm) { + var explicit = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1]; + + if (perm instanceof String || typeof perm === "string") { + perm = _Constants.Permissions[perm]; + } + if (!perm) { + return false; + } + if (!explicit) { + // implicit permissions allowed + if (!!(this.permissions & _Constants.Permissions.manageRoles)) { + // manageRoles allowed, they have all permissions + return true; + } + } + // e.g. + // !!(36953089 & Permissions.manageRoles) = not allowed to manage roles + // !!(36953089 & (1 << 21)) = voice speak allowed + + return !!(this.permissions & perm); + }; + + Role.prototype.setPermission = function setPermission(permission, value) { + if (permission instanceof String || typeof permission === "string") { + permission = _Constants.Permissions[permission]; + } + if (permission) { + // valid permission + if (value) { + this.permissions |= permission; + } else { + this.permissions &= ~permission; + } + } + }; + + Role.prototype.setPermissions = function setPermissions(obj) { + var _this2 = this; + + obj.forEach(function (value, permission) { + if (permission instanceof String || typeof permission === "string") { + permission = _Constants.Permissions[permission]; + } + if (permission) { + // valid permission + _this2.setPermission(permission, value); + } + }); + }; + + Role.prototype.colorAsHex = function colorAsHex() { + var val = this.color.toString(); + while (val.length < 6) { + val = "0" + val; + } + return "#" + val; + }; + + return Role; +})(); + +exports["default"] = Role; +module.exports = exports["default"]; + +},{"../Constants":5}],13:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _UtilEquality = require("../Util/Equality"); + +var _UtilEquality2 = _interopRequireDefault(_UtilEquality); + +var _Constants = require("../Constants"); + +var _UtilCache = require("../Util/Cache"); + +var _UtilCache2 = _interopRequireDefault(_UtilCache); + +var _User = require("./User"); + +var _User2 = _interopRequireDefault(_User); + +var _TextChannel = require("./TextChannel"); + +var _TextChannel2 = _interopRequireDefault(_TextChannel); + +var _VoiceChannel = require("./VoiceChannel"); + +var _VoiceChannel2 = _interopRequireDefault(_VoiceChannel); + +var _Role = require("./Role"); + +var _Role2 = _interopRequireDefault(_Role); + +var strictKeys = ["region", "ownerID", "name", "id", "icon", "afkTimeout", "afkChannelID"]; + +var Server = (function (_Equality) { + _inherits(Server, _Equality); + + function Server(data, client) { + var _this = this; + + _classCallCheck(this, Server); + + _Equality.call(this); + + var self = this; + this.client = client; + + this.region = data.region; + this.ownerID = data.owner_id; + this.name = data.name; + this.id = data.id; + this.members = new _UtilCache2["default"](); + this.channels = new _UtilCache2["default"](); + this.roles = new _UtilCache2["default"](); + this.icon = data.icon; + this.afkTimeout = data.afkTimeout; + this.afkChannelID = data.afk_channel_id; + this.memberMap = {}; + + var self = this; + + data.roles.forEach(function (dataRole) { + _this.roles.add(new _Role2["default"](dataRole, _this, client)); + }); + + data.members.forEach(function (dataUser) { + _this.memberMap[dataUser.user.id] = { + roles: dataUser.roles.map(function (pid) { + return self.roles.get("id", pid); + }), + mute: dataUser.mute, + deaf: dataUser.deaf, + joinedAt: Date.parse(dataUser.joined_at) + }; + var user = client.internal.users.add(new _User2["default"](dataUser.user, client)); + _this.members.add(user); + }); + + data.channels.forEach(function (dataChannel) { + if (dataChannel.type === "text") { + var channel = client.internal.channels.add(new _TextChannel2["default"](dataChannel, client, _this)); + _this.channels.add(channel); + } else { + var channel = client.internal.channels.add(new _VoiceChannel2["default"](dataChannel, client, _this)); + _this.channels.add(channel); + } + }); + + if (data.presences) { + for (var _iterator = data.presences, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var presence = _ref; + + var user = client.internal.users.get("id", presence.user.id); + if (user) { + user.status = presence.status; + user.gameID = presence.game_id; + } + } + } + } + + Server.prototype.details = function details(user) { + user = this.client.internal.resolver.resolveUser(user); + if (user) { + return this.memberMap[user.id]; + } else { + return {}; + } + }; + + Server.prototype.detailsOf = function detailsOf(user) { + return this.details(user); + }; + + Server.prototype.rolesOfUser = function rolesOfUser(user) { + user = this.client.internal.resolver.resolveUser(user); + if (user) { + return this.memberMap[user.id] ? this.memberMap[user.id].roles : []; + } else { + return null; + } + }; + + Server.prototype.rolesOf = function rolesOf(user) { + return this.rolesOfUser(user); + }; + + Server.prototype.toString = function toString() { + return this.name; + }; + + Server.prototype.equalsStrict = function equalsStrict(obj) { + if (obj instanceof Server) { + for (var _iterator2 = strictKeys, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var key = _ref2; + + if (obj[key] !== this[key]) { + return false; + } + } + } else { + return false; + } + return true; + }; + + _createClass(Server, [{ + key: "iconURL", + get: function get() { + if (!this.icon) { + return null; + } else { + return _Constants.Endpoints.SERVER_ICON(this.id, this.icon); + } + } + }, { + key: "afkChannel", + get: function get() { + return this.channels.get("id", this.afkChannelID); + } + }, { + key: "defaultChannel", + get: function get() { + return this.channels.get("id", this.id); + } + }, { + key: "owner", + get: function get() { + return this.members.get("id", this.ownerID); + } + }]); + + return Server; +})(_UtilEquality2["default"]); + +exports["default"] = Server; +module.exports = exports["default"]; + +},{"../Constants":5,"../Util/Cache":19,"../Util/Equality":20,"./Role":12,"./TextChannel":15,"./User":16,"./VoiceChannel":17}],14:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _Channel2 = require("./Channel"); + +var _Channel3 = _interopRequireDefault(_Channel2); + +var _UtilCache = require("../Util/Cache"); + +var _UtilCache2 = _interopRequireDefault(_UtilCache); + +var _PermissionOverwrite = require("./PermissionOverwrite"); + +var _PermissionOverwrite2 = _interopRequireDefault(_PermissionOverwrite); + +var _ChannelPermissions = require("./ChannelPermissions"); + +var _ChannelPermissions2 = _interopRequireDefault(_ChannelPermissions); + +var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser"); + +var ServerChannel = (function (_Channel) { + _inherits(ServerChannel, _Channel); + + function ServerChannel(data, client, server) { + var _this = this; + + _classCallCheck(this, ServerChannel); + + _Channel.call(this, data, client); + this.name = data.name; + this.type = data.type; + this.position = data.position; + this.permissionOverwrites = new _UtilCache2["default"](); + this.server = server; + data.permission_overwrites.forEach(function (permission) { + _this.permissionOverwrites.add(new _PermissionOverwrite2["default"](permission)); + }); + } + + ServerChannel.prototype.permissionsOf = function permissionsOf(user) { + user = this.client.internal.resolver.resolveUser(user); + if (user) { + if (this.server.owner.equals(user)) { + return new _ChannelPermissions2["default"](4294967295); + } + var everyoneRole = this.server.roles.get("name", "@everyone"); + + var userRoles = [everyoneRole].concat(this.server.rolesOf(user) || []); + var userRolesID = userRoles.map(function (v) { + return v.id; + }); + var roleOverwrites = [], + memberOverwrites = []; + + this.permissionOverwrites.forEach(function (overwrite) { + if (overwrite.type === "member" && overwrite.id === user.id) { + memberOverwrites.push(overwrite); + } else if (overwrite.type === "role" && overwrite.id in userRolesID) { + roleOverwrites.push(overwrite); + } + }); + + var permissions = 0; + + for (var _iterator = userRoles, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var serverRole = _ref; + + permissions |= serverRole.permissions; + } + + for (var _iterator2 = roleOverwrites.concat(memberOverwrites), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i2 >= _iterator2.length) break; + _ref2 = _iterator2[_i2++]; + } else { + _i2 = _iterator2.next(); + if (_i2.done) break; + _ref2 = _i2.value; + } + + var overwrite = _ref2; + + permissions = permissions & ~overwrite.deny; + permissions = permissions | overwrite.allow; + } + + return new _ChannelPermissions2["default"](permissions); + } else { + return null; + } + }; + + ServerChannel.prototype.permsOf = function permsOf(user) { + return this.permissionsOf(user); + }; + + ServerChannel.prototype.mention = function mention() { + return "<#" + this.id + ">"; + }; + + ServerChannel.prototype.toString = function toString() { + return this.mention(); + }; + + ServerChannel.prototype.setName = function setName() { + return this.client.setChannelName.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + return ServerChannel; +})(_Channel3["default"]); + +exports["default"] = ServerChannel; +module.exports = exports["default"]; + +},{"../Util/ArgumentRegulariser":18,"../Util/Cache":19,"./Channel":6,"./ChannelPermissions":7,"./PermissionOverwrite":11}],15:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _ServerChannel2 = require("./ServerChannel"); + +var _ServerChannel3 = _interopRequireDefault(_ServerChannel2); + +var _UtilCache = require("../Util/Cache"); + +var _UtilCache2 = _interopRequireDefault(_UtilCache); + +var _UtilArgumentRegulariser = require("../Util/ArgumentRegulariser"); + +var TextChannel = (function (_ServerChannel) { + _inherits(TextChannel, _ServerChannel); + + function TextChannel(data, client, server) { + _classCallCheck(this, TextChannel); + + _ServerChannel.call(this, data, client, server); + + this.topic = data.topic; + this.lastMessageID = data.last_message_id; + this.messages = new _UtilCache2["default"]("id", client.options.maximumMessages); + } + + /* warning! may return null */ + + TextChannel.prototype.setTopic = function setTopic() { + return this.client.setTopic.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + TextChannel.prototype.setNameAndTopic = function setNameAndTopic() { + return this.client.setChannelNameAndTopic.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + TextChannel.prototype.update = function update() { + return this.client.updateChannel.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + TextChannel.prototype.sendMessage = function sendMessage() { + return this.client.sendMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + TextChannel.prototype.sendTTSMessage = function sendTTSMessage() { + return this.client.sendTTSMessage.apply(this.client, _UtilArgumentRegulariser.reg(this, arguments)); + }; + + _createClass(TextChannel, [{ + key: "lastMessage", + get: function get() { + return this.messages.get("id", this.lastMessageID); + } + }]); + + return TextChannel; +})(_ServerChannel3["default"]); + +exports["default"] = TextChannel; +module.exports = exports["default"]; + +},{"../Util/ArgumentRegulariser":18,"../Util/Cache":19,"./ServerChannel":14}],16:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _UtilEquality = require("../Util/Equality"); + +var _UtilEquality2 = _interopRequireDefault(_UtilEquality); + +var _Constants = require("../Constants"); + +var User = (function (_Equality) { + _inherits(User, _Equality); + + function User(data, client) { + _classCallCheck(this, User); + + _Equality.call(this); + this.client = client; + this.username = data.username; + this.discriminator = data.discriminator; + this.id = data.id; + this.avatar = data.avatar; + this.status = data.status || "offline"; + this.gameID = data.game_id || null; + this.typing = { + since: null, + channel: null + }; + } + + User.prototype.mention = function mention() { + return "<@" + this.id + ">"; + }; + + User.prototype.toString = function toString() { + return this.mention(); + }; + + User.prototype.equalsStrict = function equalsStrict(obj) { + if (obj instanceof User) return this.id === obj.id && this.username === obj.username && this.discriminator === obj.discriminator && this.avatar === obj.avatar && this.status === obj.status && this.gameID === obj.gameID;else return false; + }; + + User.prototype.equals = function equals(obj) { + if (obj instanceof User) return this.id === obj.id && this.username === obj.username && this.discriminator === obj.discriminator && this.avatar === obj.avatar;else return false; + }; + + _createClass(User, [{ + key: "avatarURL", + get: function get() { + if (!this.avatar) { + return null; + } else { + return _Constants.Endpoints.AVATAR(this.id, this.avatar); + } + } + }]); + + return User; +})(_UtilEquality2["default"]); + +exports["default"] = User; +module.exports = exports["default"]; + +},{"../Constants":5,"../Util/Equality":20}],17:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _ServerChannel2 = require("./ServerChannel"); + +var _ServerChannel3 = _interopRequireDefault(_ServerChannel2); + +var VoiceChannel = (function (_ServerChannel) { + _inherits(VoiceChannel, _ServerChannel); + + function VoiceChannel(data, client, server) { + _classCallCheck(this, VoiceChannel); + + _ServerChannel.call(this, data, client, server); + } + + return VoiceChannel; +})(_ServerChannel3["default"]); + +exports["default"] = VoiceChannel; +module.exports = exports["default"]; + +},{"./ServerChannel":14}],18:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; +exports.reg = reg; + +function reg(c, a) { + return [c].concat(Array.prototype.slice.call(a)); +} + +},{}],19:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var Cache = (function (_Array) { + _inherits(Cache, _Array); + + function Cache(discrim, limit) { + _classCallCheck(this, Cache); + + _Array.call(this); + this.discrim = discrim || "id"; + } + + Cache.prototype.get = function get(key, value) { + var found = null; + this.forEach(function (val, index, array) { + if (val.hasOwnProperty(key) && val[key] == value) { + found = val; + return; + } + }); + return found; + }; + + Cache.prototype.has = function has(object) { + return !!this.get(this.discrim, object[this.discrim]); + }; + + Cache.prototype.getAll = function getAll(key, value) { + var found = new Cache(this.discrim); + this.forEach(function (val, index, array) { + if (val.hasOwnProperty(key) && val[key] == value) { + found.push(val); + return; + } + }); + return found; + }; + + Cache.prototype.add = function add(data) { + var exit = false; + for (var _iterator = this, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var item = _ref; + + if (item[this.discrim] === data[this.discrim]) { + exit = item; + break; + } + } + if (exit) { + return exit; + } else { + if (this.limit && this.length >= this.limit) { + this.splice(0, 1); + } + this.push(data); + return data; + } + }; + + Cache.prototype.update = function update(old, data) { + var item = this.get(this.discrim, old[this.discrim]); + if (item) { + var index = this.indexOf(item); + this[index] = data; + return this[index]; + } else { + return false; + } + }; + + Cache.prototype.random = function random() { + return this[Math.floor(Math.random() * this.length)]; + }; + + Cache.prototype.remove = function remove(data) { + var index = this.indexOf(data); + if (~index) { + this.splice(index, 1); + } else { + var item = this.get(this.discrim, data[this.discrim]); + if (item) { + this.splice(this.indexOf(item), 1); + } + } + return false; + }; + + return Cache; +})(Array); + +exports["default"] = Cache; +module.exports = exports["default"]; + +},{}],20:[function(require,module,exports){ +/* + The Equality Class is just used to show + that a Class has an ID that can be used to + check for equality. + + Never use == or === when comparing + objects in discord.js, they will be different + instances sometimes. + + Instead, use objectThatExtendsEquality.equals() +*/ +"use strict"; + +exports.__esModule = true; + +var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var Equality = (function () { + function Equality() { + _classCallCheck(this, Equality); + } + + Equality.prototype.equals = function equals(object) { + if (object && object[this.eqDiscriminator] == this[this.eqDiscriminator]) { + return true; + } + return false; + }; + + Equality.prototype.equalsStrict = function equalsStrict(object) { + // override per class type + return; + }; + + _createClass(Equality, [{ + key: "eqDiscriminator", + get: function get() { + return "id"; + } + }]); + + return Equality; +})(); + +exports["default"] = Equality; +module.exports = exports["default"]; + +},{}],21:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var _child_process = require("child_process"); + +var _child_process2 = _interopRequireDefault(_child_process); + +var opus; +try { + opus = require("node-opus"); +} catch (e) { + // no opus! +} + +var AudioEncoder = (function () { + function AudioEncoder() { + _classCallCheck(this, AudioEncoder); + + if (opus) { + this.opus = new opus.OpusEncoder(48000, 1); + } + this.choice = false; + } + + AudioEncoder.prototype.opusBuffer = function opusBuffer(buffer) { + + return this.opus.encode(buffer, 1920); + }; + + AudioEncoder.prototype.getCommand = function getCommand(force) { + + if (this.choice && force) return choice; + + var choices = ["avconv", "ffmpeg"]; + + for (var _iterator = choices, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var choice = _ref; + + var p = _child_process2["default"].spawnSync(choice); + if (!p.error) { + this.choice = choice; + return choice; + } + } + + return "help"; + }; + + AudioEncoder.prototype.encodeStream = function encodeStream(stream) { + var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, buffer) {} : arguments[1]; + + var self = this; + return new Promise(function (resolve, reject) { + var enc = _child_process2["default"].spawn(self.getCommand(), ["-f", "s16le", "-ar", "48000", "-ac", "1", // this can be 2 but there's no point, discord makes it mono on playback, wasted bandwidth. + "-af", "volume=1", "pipe:1", "-i", "-"]); + + stream.pipe(enc.stdin); + + enc.stdout.once("readable", function () { + callback(null, { + proc: enc, + stream: enc.stdout, + instream: stream + }); + resolve({ + proc: enc, + stream: enc.stdout, + instream: stream + }); + }); + + enc.stdout.on("end", function () { + callback("end"); + reject("end"); + }); + + enc.stdout.on("close", function () { + callback("close"); + reject("close"); + }); + }); + }; + + AudioEncoder.prototype.encodeFile = function encodeFile(file) { + var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, buffer) {} : arguments[1]; + + var self = this; + return new Promise(function (resolve, reject) { + var enc = _child_process2["default"].spawn(self.getCommand(), ["-f", "s16le", "-ar", "48000", "-ac", "1", // this can be 2 but there's no point, discord makes it mono on playback, wasted bandwidth. + "-af", "volume=1", "pipe:1", "-i", file]); + + enc.stdout.once("readable", function () { + callback(null, { + proc: enc, + stream: enc.stdout + }); + resolve({ + proc: enc, + stream: enc.stdout + }); + }); + + enc.stdout.on("end", function () { + callback("end"); + reject("end"); + }); + + enc.stdout.on("close", function () { + callback("close"); + reject("close"); + }); + }); + }; + + return AudioEncoder; +})(); + +exports["default"] = AudioEncoder; +module.exports = exports["default"]; + +},{"child_process":32,"node-opus":50}],22:[function(require,module,exports){ +"use strict"; +// represents an intent of streaming music +exports.__esModule = true; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _events = require("events"); + +var _events2 = _interopRequireDefault(_events); + +var StreamIntent = (function (_EventEmitter) { + _inherits(StreamIntent, _EventEmitter); + + function StreamIntent() { + _classCallCheck(this, StreamIntent); + + _EventEmitter.call(this); + } + + return StreamIntent; +})(_events2["default"]); + +exports["default"] = StreamIntent; +module.exports = exports["default"]; + +},{"events":43}],23:[function(require,module,exports){ +(function (Buffer){ +"use strict"; +/* + Major credit to izy521 who is the creator of + https://github.com/izy521/discord.io, + + without his help voice chat in discord.js would not have + been possible! +*/ + +exports.__esModule = true; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } + +var _ws = require("ws"); + +var _ws2 = _interopRequireDefault(_ws); + +var _dns = require("dns"); + +var _dns2 = _interopRequireDefault(_dns); + +var _dgram = require("dgram"); + +var _dgram2 = _interopRequireDefault(_dgram); + +var _AudioEncoder = require("./AudioEncoder"); + +var _AudioEncoder2 = _interopRequireDefault(_AudioEncoder); + +var _VoicePacket = require("./VoicePacket"); + +var _VoicePacket2 = _interopRequireDefault(_VoicePacket); + +var _StreamIntent = require("./StreamIntent"); + +var _StreamIntent2 = _interopRequireDefault(_StreamIntent); + +var _events = require("events"); + +var _events2 = _interopRequireDefault(_events); + +var VoiceConnection = (function (_EventEmitter) { + _inherits(VoiceConnection, _EventEmitter); + + function VoiceConnection(channel, client, session, token, server, endpoint) { + _classCallCheck(this, VoiceConnection); + + _EventEmitter.call(this); + this.id = channel.id; + this.voiceChannel = channel; + this.client = client; + this.session = session; + this.token = token; + this.server = server; + this.endpoint = endpoint.replace(":80", ""); + this.vWS = null; // vWS means voice websocket + this.ready = false; + this.vWSData = {}; + this.encoder = new _AudioEncoder2["default"](); + this.udp = null; + this.playingIntent = null; + this.playing = false; + this.streamTime = 0; + this.streamProc = null; + this.KAI = null; + this.init(); + } + + VoiceConnection.prototype.destroy = function destroy() { + this.stopPlaying(); + if (this.KAI) clearInterval(this.KAI); + this.vWS.close(); + this.udp.close(); + this.client.internal.sendWS({ + op: 4, + d: { + guild_id: null, + channel_id: null, + self_mute: true, + self_deaf: false + } + }); + }; + + VoiceConnection.prototype.stopPlaying = function stopPlaying() { + this.playing = false; + this.playingIntent = null; + if (this.instream) { + //not all streams implement these... + //and even file stream don't seem to implement them properly... + if (this.instream.end) { + this.instream.end(); + } + if (this.instream.destroy) { + this.instream.destroy(); + } + this.instream = null; + } + }; + + VoiceConnection.prototype.playStream = function playStream(stream) { + + var self = this; + + var startTime = Date.now(); + var sequence = 0; + var time = 0; + var count = 0; + + var length = 20; + + if (self.playingIntent) { + self.stopPlaying(); + } + self.playing = true; + var retStream = new _StreamIntent2["default"](); + var onWarning = false; + self.playingIntent = retStream; + + function send() { + + if (!self.playingIntent || !self.playing) { + self.setSpeaking(false); + retStream.emit("end"); + self; + return; + } + try { + + var buffer = stream.read(1920); + + if (!buffer) { + if (onWarning) { + retStream.emit("end"); + self.setSpeaking(false); + return; + } else { + onWarning = true; + setTimeout(send, length * 10); // give chance for some data in 200ms to appear + return; + } + } + + if (buffer.length !== 1920) { + var newBuffer = new Buffer(1920).fill(0); + buffer.copy(newBuffer); + buffer = newBuffer; + } + + count++; + sequence + 10 < 65535 ? sequence += 1 : sequence = 0; + time + 9600 < 4294967295 ? time += 960 : time = 0; + + self.sendBuffer(buffer, sequence, time, function (e) {}); + + var nextTime = startTime + count * length; + + self.streamTime = count * length; + + setTimeout(send, length + (nextTime - Date.now())); + + if (!self.playing) self.setSpeaking(true); + + retStream.emit("time", self.streamTime); + } catch (e) { + retStream.emit("error", e); + } + } + self.setSpeaking(true); + send(); + + return retStream; + }; + + VoiceConnection.prototype.setSpeaking = function setSpeaking(value) { + this.playing = value; + if (this.vWS.readyState === _ws2["default"].OPEN) this.vWS.send(JSON.stringify({ + op: 5, + d: { + speaking: value, + delay: 0 + } + })); + }; + + VoiceConnection.prototype.sendPacket = function sendPacket(packet) { + var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1]; + + var self = this; + self.playing = true; + try { + if (self.vWS.readyState === _ws2["default"].OPEN) self.udp.send(packet, 0, packet.length, self.vWSData.port, self.endpoint, callback); + } catch (e) { + self.playing = false; + callback(e); + return false; + } + }; + + VoiceConnection.prototype.sendBuffer = function sendBuffer(rawbuffer, sequence, timestamp, callback) { + var self = this; + self.playing = true; + try { + if (!self.encoder.opus) { + self.playing = false; + self.emit("error", "No Opus!"); + self.client.emit("debug", "Tried to use node-opus, but opus not available - install it!"); + return; + } + var buffer = self.encoder.opusBuffer(rawbuffer); + var packet = new _VoicePacket2["default"](buffer, sequence, timestamp, self.vWSData.ssrc); + return self.sendPacket(packet, callback); + } catch (e) { + self.playing = false; + self.emit("error", e); + return false; + } + }; + + VoiceConnection.prototype.test = function test() { + this.playFile("C:/users/amish/desktop/audio.mp3").then(function (stream) { + stream.on("time", function (time) { + console.log("Time", time); + }); + }); + }; + + VoiceConnection.prototype.playFile = function playFile(stream) { + var _this = this; + + var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, str) {} : arguments[1]; + + var self = this; + return new Promise(function (resolve, reject) { + _this.encoder.encodeFile(stream)["catch"](error).then(function (data) { + self.streamProc = data.proc; + var intent = self.playStream(data.stream); + resolve(intent); + callback(null, intent); + }); + function error() { + var e = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0]; + + reject(e); + callback(e); + } + }); + }; + + VoiceConnection.prototype.playRawStream = function playRawStream(stream) { + var _this2 = this; + + var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, str) {} : arguments[1]; + + var self = this; + return new Promise(function (resolve, reject) { + _this2.encoder.encodeStream(stream)["catch"](error).then(function (data) { + self.streamProc = data.proc; + self.instream = data.instream; + var intent = self.playStream(data.stream); + resolve(intent); + callback(null, intent); + }); + function error() { + var e = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0]; + + reject(e); + callback(e); + } + }); + }; + + VoiceConnection.prototype.init = function init() { + var _this3 = this; + + var self = this; + _dns2["default"].lookup(this.endpoint, function (err, address, family) { + self.endpoint = address; + var vWS = self.vWS = new _ws2["default"]("wss://" + _this3.endpoint, null, { rejectUnauthorized: false }); + var udpClient = self.udp = _dgram2["default"].createSocket("udp4"); + + var firstPacket = true; + + var discordIP = "", + discordPort = ""; + + udpClient.bind({ exclusive: true }); + udpClient.on('message', function (msg, rinfo) { + var buffArr = JSON.parse(JSON.stringify(msg)).data; + if (firstPacket === true) { + for (var i = 4; i < buffArr.indexOf(0, i); i++) { + discordIP += String.fromCharCode(buffArr[i]); + } + discordPort = msg.readUIntLE(msg.length - 2, 2).toString(10); + + var wsDiscPayload = { + "op": 1, + "d": { + "protocol": "udp", + "data": { + "address": discordIP, + "port": Number(discordPort), + "mode": self.vWSData.modes[0] //Plain + } + } + }; + vWS.send(JSON.stringify(wsDiscPayload)); + firstPacket = false; + } + }); + + vWS.on("open", function () { + vWS.send(JSON.stringify({ + op: 0, + d: { + server_id: self.server.id, + user_id: self.client.internal.user.id, + session_id: self.session, + token: self.token + } + })); + }); + + var KAI; + + vWS.on("message", function (msg) { + var data = JSON.parse(msg); + switch (data.op) { + case 2: + self.vWSData = data.d; + + KAI = setInterval(function () { + if (vWS && vWS.readyState === _ws2["default"].OPEN) vWS.send(JSON.stringify({ + op: 3, + d: null + })); + }, data.d.heartbeat_interval); + self.KAI = KAI; + + var udpPacket = new Buffer(70); + udpPacket.writeUIntBE(data.d.ssrc, 0, 4); + udpClient.send(udpPacket, 0, udpPacket.length, data.d.port, self.endpoint, function (err) { + if (err) self.emit("error", err); + }); + break; + case 4: + + self.ready = true; + self.mode = data.d.mode; + self.emit("ready", self); + + break; + } + }); + }); + }; + + return VoiceConnection; +})(_events2["default"]); + +exports["default"] = VoiceConnection; +module.exports = exports["default"]; + +}).call(this,require("buffer").Buffer) +},{"./AudioEncoder":21,"./StreamIntent":22,"./VoicePacket":24,"buffer":38,"dgram":32,"dns":32,"events":43,"ws":91}],24:[function(require,module,exports){ +(function (Buffer){ +"use strict"; + +exports.__esModule = true; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var VoicePacket = function VoicePacket(data, sequence, time, ssrc) { + _classCallCheck(this, VoicePacket); + + var audioBuffer = data, + returnBuffer = new Buffer(audioBuffer.length + 12); + + returnBuffer.fill(0); + returnBuffer[0] = 0x80; + returnBuffer[1] = 0x78; + + returnBuffer.writeUIntBE(sequence, 2, 2); + returnBuffer.writeUIntBE(time, 4, 4); + returnBuffer.writeUIntBE(ssrc, 8, 4); + + for (var i = 0; i < audioBuffer.length; i++) { + returnBuffer[i + 12] = audioBuffer[i]; + } + + return returnBuffer; +}; + +exports["default"] = VoicePacket; +module.exports = exports["default"]; + +}).call(this,require("buffer").Buffer) +},{"buffer":38}],25:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +var _ClientClient = require("./Client/Client"); + +var _ClientClient2 = _interopRequireDefault(_ClientClient); + +var _StructuresChannel = require("./Structures/Channel"); + +var _StructuresChannel2 = _interopRequireDefault(_StructuresChannel); + +var _StructuresChannelPermissions = require("./Structures/ChannelPermissions"); + +var _StructuresChannelPermissions2 = _interopRequireDefault(_StructuresChannelPermissions); + +var _StructuresInvite = require("./Structures/Invite"); + +var _StructuresInvite2 = _interopRequireDefault(_StructuresInvite); + +var _StructuresMessage = require("./Structures/Message"); + +var _StructuresMessage2 = _interopRequireDefault(_StructuresMessage); + +var _StructuresPermissionOverwrite = require("./Structures/PermissionOverwrite"); + +var _StructuresPermissionOverwrite2 = _interopRequireDefault(_StructuresPermissionOverwrite); + +var _StructuresPMChannel = require("./Structures/PMChannel"); + +var _StructuresPMChannel2 = _interopRequireDefault(_StructuresPMChannel); + +var _StructuresRole = require("./Structures/Role"); + +var _StructuresRole2 = _interopRequireDefault(_StructuresRole); + +var _StructuresServer = require("./Structures/Server"); + +var _StructuresServer2 = _interopRequireDefault(_StructuresServer); + +var _StructuresServerChannel = require("./Structures/ServerChannel"); + +var _StructuresServerChannel2 = _interopRequireDefault(_StructuresServerChannel); + +var _StructuresTextChannel = require("./Structures/TextChannel"); + +var _StructuresTextChannel2 = _interopRequireDefault(_StructuresTextChannel); + +var _StructuresUser = require("./Structures/User"); + +var _StructuresUser2 = _interopRequireDefault(_StructuresUser); + +var _StructuresVoiceChannel = require("./Structures/VoiceChannel"); + +var _StructuresVoiceChannel2 = _interopRequireDefault(_StructuresVoiceChannel); + +var _Constants = require("./Constants"); + +var _Constants2 = _interopRequireDefault(_Constants); + +exports["default"] = { + Client: _ClientClient2["default"], + Channel: _StructuresChannel2["default"], + ChannelPermissions: _StructuresChannelPermissions2["default"], + Invite: _StructuresInvite2["default"], + Message: _StructuresMessage2["default"], + PermissionOverwrite: _StructuresPermissionOverwrite2["default"], + PMChannel: _StructuresPMChannel2["default"], + Role: _StructuresRole2["default"], + Server: _StructuresServer2["default"], + ServerChannel: _StructuresServerChannel2["default"], + TextChannel: _StructuresTextChannel2["default"], + User: _StructuresUser2["default"], + VoiceChannel: _StructuresVoiceChannel2["default"], + Constants: _Constants2["default"] +}; +module.exports = exports["default"]; + +},{"./Client/Client":1,"./Constants":5,"./Structures/Channel":6,"./Structures/ChannelPermissions":7,"./Structures/Invite":8,"./Structures/Message":9,"./Structures/PMChannel":10,"./Structures/PermissionOverwrite":11,"./Structures/Role":12,"./Structures/Server":13,"./Structures/ServerChannel":14,"./Structures/TextChannel":15,"./Structures/User":16,"./Structures/VoiceChannel":17}],26:[function(require,module,exports){ +// http://wiki.commonjs.org/wiki/Unit_Testing/1.0 +// +// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! +// +// Originally from narwhal.js (http://narwhaljs.org) +// Copyright (c) 2009 Thomas Robinson <280north.com> +// +// 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 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. + +// when used in node, this will actually load the util module we depend on +// versus loading the builtin util module as happens otherwise +// this is a bug in node module loading as far as I am concerned +var util = require('util/'); + +var pSlice = Array.prototype.slice; +var hasOwn = Object.prototype.hasOwnProperty; + +// 1. The assert module provides functions that throw +// AssertionError's when particular conditions are not met. The +// assert module must conform to the following interface. + +var assert = module.exports = ok; + +// 2. The AssertionError is defined in assert. +// new assert.AssertionError({ message: message, +// actual: actual, +// expected: expected }) + +assert.AssertionError = function AssertionError(options) { + this.name = 'AssertionError'; + this.actual = options.actual; + this.expected = options.expected; + this.operator = options.operator; + if (options.message) { + this.message = options.message; + this.generatedMessage = false; + } else { + this.message = getMessage(this); + this.generatedMessage = true; + } + var stackStartFunction = options.stackStartFunction || fail; + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, stackStartFunction); + } + else { + // non v8 browsers so we can have a stacktrace + var err = new Error(); + if (err.stack) { + var out = err.stack; + + // try to strip useless frames + var fn_name = stackStartFunction.name; + var idx = out.indexOf('\n' + fn_name); + if (idx >= 0) { + // once we have located the function frame + // we need to strip out everything before it (and its line) + var next_line = out.indexOf('\n', idx + 1); + out = out.substring(next_line + 1); + } + + this.stack = out; + } + } +}; + +// assert.AssertionError instanceof Error +util.inherits(assert.AssertionError, Error); + +function replacer(key, value) { + if (util.isUndefined(value)) { + return '' + value; + } + if (util.isNumber(value) && !isFinite(value)) { + return value.toString(); + } + if (util.isFunction(value) || util.isRegExp(value)) { + return value.toString(); + } + return value; +} + +function truncate(s, n) { + if (util.isString(s)) { + return s.length < n ? s : s.slice(0, n); + } else { + return s; + } +} + +function getMessage(self) { + return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' + + self.operator + ' ' + + truncate(JSON.stringify(self.expected, replacer), 128); +} + +// At present only the three keys mentioned above are used and +// understood by the spec. Implementations or sub modules can pass +// other keys to the AssertionError's constructor - they will be +// ignored. + +// 3. All of the following functions must throw an AssertionError +// when a corresponding condition is not met, with a message that +// may be undefined if not provided. All assertion methods provide +// both the actual and expected values to the assertion error for +// display purposes. + +function fail(actual, expected, message, operator, stackStartFunction) { + throw new assert.AssertionError({ + message: message, + actual: actual, + expected: expected, + operator: operator, + stackStartFunction: stackStartFunction + }); +} + +// EXTENSION! allows for well behaved errors defined elsewhere. +assert.fail = fail; + +// 4. Pure assertion tests whether a value is truthy, as determined +// by !!guard. +// assert.ok(guard, message_opt); +// This statement is equivalent to assert.equal(true, !!guard, +// message_opt);. To test strictly for the value true, use +// assert.strictEqual(true, guard, message_opt);. + +function ok(value, message) { + if (!value) fail(value, true, message, '==', assert.ok); +} +assert.ok = ok; + +// 5. The equality assertion tests shallow, coercive equality with +// ==. +// assert.equal(actual, expected, message_opt); + +assert.equal = function equal(actual, expected, message) { + if (actual != expected) fail(actual, expected, message, '==', assert.equal); +}; + +// 6. The non-equality assertion tests for whether two objects are not equal +// with != assert.notEqual(actual, expected, message_opt); + +assert.notEqual = function notEqual(actual, expected, message) { + if (actual == expected) { + fail(actual, expected, message, '!=', assert.notEqual); + } +}; + +// 7. The equivalence assertion tests a deep equality relation. +// assert.deepEqual(actual, expected, message_opt); + +assert.deepEqual = function deepEqual(actual, expected, message) { + if (!_deepEqual(actual, expected)) { + fail(actual, expected, message, 'deepEqual', assert.deepEqual); + } +}; + +function _deepEqual(actual, expected) { + // 7.1. All identical values are equivalent, as determined by ===. + if (actual === expected) { + return true; + + } else if (util.isBuffer(actual) && util.isBuffer(expected)) { + if (actual.length != expected.length) return false; + + for (var i = 0; i < actual.length; i++) { + if (actual[i] !== expected[i]) return false; + } + + return true; + + // 7.2. If the expected value is a Date object, the actual value is + // equivalent if it is also a Date object that refers to the same time. + } else if (util.isDate(actual) && util.isDate(expected)) { + return actual.getTime() === expected.getTime(); + + // 7.3 If the expected value is a RegExp object, the actual value is + // equivalent if it is also a RegExp object with the same source and + // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`). + } else if (util.isRegExp(actual) && util.isRegExp(expected)) { + return actual.source === expected.source && + actual.global === expected.global && + actual.multiline === expected.multiline && + actual.lastIndex === expected.lastIndex && + actual.ignoreCase === expected.ignoreCase; + + // 7.4. Other pairs that do not both pass typeof value == 'object', + // equivalence is determined by ==. + } else if (!util.isObject(actual) && !util.isObject(expected)) { + return actual == expected; + + // 7.5 For all other Object pairs, including Array objects, equivalence is + // determined by having the same number of owned properties (as verified + // with Object.prototype.hasOwnProperty.call), the same set of keys + // (although not necessarily the same order), equivalent values for every + // corresponding key, and an identical 'prototype' property. Note: this + // accounts for both named and indexed properties on Arrays. + } else { + return objEquiv(actual, expected); + } +} + +function isArguments(object) { + return Object.prototype.toString.call(object) == '[object Arguments]'; +} + +function objEquiv(a, b) { + if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b)) + return false; + // an identical 'prototype' property. + if (a.prototype !== b.prototype) return false; + // if one is a primitive, the other must be same + if (util.isPrimitive(a) || util.isPrimitive(b)) { + return a === b; + } + var aIsArgs = isArguments(a), + bIsArgs = isArguments(b); + if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) + return false; + if (aIsArgs) { + a = pSlice.call(a); + b = pSlice.call(b); + return _deepEqual(a, b); + } + var ka = objectKeys(a), + kb = objectKeys(b), + key, i; + // having the same number of owned properties (keys incorporates + // hasOwnProperty) + if (ka.length != kb.length) + return false; + //the same set of keys (although not necessarily the same order), + ka.sort(); + kb.sort(); + //~~~cheap key test + for (i = ka.length - 1; i >= 0; i--) { + if (ka[i] != kb[i]) + return false; + } + //equivalent values for every corresponding key, and + //~~~possibly expensive deep test + for (i = ka.length - 1; i >= 0; i--) { + key = ka[i]; + if (!_deepEqual(a[key], b[key])) return false; + } + return true; +} + +// 8. The non-equivalence assertion tests for any deep inequality. +// assert.notDeepEqual(actual, expected, message_opt); + +assert.notDeepEqual = function notDeepEqual(actual, expected, message) { + if (_deepEqual(actual, expected)) { + fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); + } +}; + +// 9. The strict equality assertion tests strict equality, as determined by ===. +// assert.strictEqual(actual, expected, message_opt); + +assert.strictEqual = function strictEqual(actual, expected, message) { + if (actual !== expected) { + fail(actual, expected, message, '===', assert.strictEqual); + } +}; + +// 10. The strict non-equality assertion tests for strict inequality, as +// determined by !==. assert.notStrictEqual(actual, expected, message_opt); + +assert.notStrictEqual = function notStrictEqual(actual, expected, message) { + if (actual === expected) { + fail(actual, expected, message, '!==', assert.notStrictEqual); + } +}; + +function expectedException(actual, expected) { + if (!actual || !expected) { + return false; + } + + if (Object.prototype.toString.call(expected) == '[object RegExp]') { + return expected.test(actual); + } else if (actual instanceof expected) { + return true; + } else if (expected.call({}, actual) === true) { + return true; + } + + return false; +} + +function _throws(shouldThrow, block, expected, message) { + var actual; + + if (util.isString(expected)) { + message = expected; + expected = null; + } + + try { + block(); + } catch (e) { + actual = e; + } + + message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + + (message ? ' ' + message : '.'); + + if (shouldThrow && !actual) { + fail(actual, expected, 'Missing expected exception' + message); + } + + if (!shouldThrow && expectedException(actual, expected)) { + fail(actual, expected, 'Got unwanted exception' + message); + } + + if ((shouldThrow && actual && expected && + !expectedException(actual, expected)) || (!shouldThrow && actual)) { + throw actual; + } +} + +// 11. Expected to throw an error: +// assert.throws(block, Error_opt, message_opt); + +assert.throws = function(block, /*optional*/error, /*optional*/message) { + _throws.apply(this, [true].concat(pSlice.call(arguments))); +}; + +// EXTENSION! This is annoying to write outside this module. +assert.doesNotThrow = function(block, /*optional*/message) { + _throws.apply(this, [false].concat(pSlice.call(arguments))); +}; + +assert.ifError = function(err) { if (err) {throw err;}}; + +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + if (hasOwn.call(obj, key)) keys.push(key); + } + return keys; +}; + +},{"util/":90}],27:[function(require,module,exports){ +var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + +;(function (exports) { + 'use strict'; + + var Arr = (typeof Uint8Array !== 'undefined') + ? Uint8Array + : Array + + var PLUS = '+'.charCodeAt(0) + var SLASH = '/'.charCodeAt(0) + var NUMBER = '0'.charCodeAt(0) + var LOWER = 'a'.charCodeAt(0) + var UPPER = 'A'.charCodeAt(0) + var PLUS_URL_SAFE = '-'.charCodeAt(0) + var SLASH_URL_SAFE = '_'.charCodeAt(0) + + function decode (elt) { + var code = elt.charCodeAt(0) + if (code === PLUS || + code === PLUS_URL_SAFE) + return 62 // '+' + if (code === SLASH || + code === SLASH_URL_SAFE) + return 63 // '/' + if (code < NUMBER) + return -1 //no match + if (code < NUMBER + 10) + return code - NUMBER + 26 + 26 + if (code < UPPER + 26) + return code - UPPER + if (code < LOWER + 26) + return code - LOWER + 26 + } + + function b64ToByteArray (b64) { + var i, j, l, tmp, placeHolders, arr + + if (b64.length % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // the number of equal signs (place holders) + // if there are two placeholders, than the two characters before it + // represent one byte + // if there is only one, then the three characters before it represent 2 bytes + // this is just a cheap hack to not do indexOf twice + var len = b64.length + placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0 + + // base64 is 4/3 + up to two characters of the original data + arr = new Arr(b64.length * 3 / 4 - placeHolders) + + // if there are placeholders, only get up to the last complete 4 chars + l = placeHolders > 0 ? b64.length - 4 : b64.length + + var L = 0 + + function push (v) { + arr[L++] = v + } + + for (i = 0, j = 0; i < l; i += 4, j += 3) { + tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)) + push((tmp & 0xFF0000) >> 16) + push((tmp & 0xFF00) >> 8) + push(tmp & 0xFF) + } + + if (placeHolders === 2) { + tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4) + push(tmp & 0xFF) + } else if (placeHolders === 1) { + tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2) + push((tmp >> 8) & 0xFF) + push(tmp & 0xFF) + } + + return arr + } + + function uint8ToBase64 (uint8) { + var i, + extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes + output = "", + temp, length + + function encode (num) { + return lookup.charAt(num) + } + + function tripletToBase64 (num) { + return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F) + } + + // go through the array every three bytes, we'll deal with trailing stuff later + for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) { + temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) + output += tripletToBase64(temp) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + switch (extraBytes) { + case 1: + temp = uint8[uint8.length - 1] + output += encode(temp >> 2) + output += encode((temp << 4) & 0x3F) + output += '==' + break + case 2: + temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]) + output += encode(temp >> 10) + output += encode((temp >> 4) & 0x3F) + output += encode((temp << 2) & 0x3F) + output += '=' + break + } + + return output + } + + exports.toByteArray = b64ToByteArray + exports.fromByteArray = uint8ToBase64 +}(typeof exports === 'undefined' ? (this.base64js = {}) : exports)) + +},{}],28:[function(require,module,exports){ +(function (process,__filename){ + +/** + * Module dependencies. + */ + +var fs = require('fs') + , path = require('path') + , join = path.join + , dirname = path.dirname + , exists = fs.existsSync || path.existsSync + , defaults = { + arrow: process.env.NODE_BINDINGS_ARROW || ' → ' + , compiled: process.env.NODE_BINDINGS_COMPILED_DIR || 'compiled' + , platform: process.platform + , arch: process.arch + , version: process.versions.node + , bindings: 'bindings.node' + , try: [ + // node-gyp's linked version in the "build" dir + [ 'module_root', 'build', 'bindings' ] + // node-waf and gyp_addon (a.k.a node-gyp) + , [ 'module_root', 'build', 'Debug', 'bindings' ] + , [ 'module_root', 'build', 'Release', 'bindings' ] + // Debug files, for development (legacy behavior, remove for node v0.9) + , [ 'module_root', 'out', 'Debug', 'bindings' ] + , [ 'module_root', 'Debug', 'bindings' ] + // Release files, but manually compiled (legacy behavior, remove for node v0.9) + , [ 'module_root', 'out', 'Release', 'bindings' ] + , [ 'module_root', 'Release', 'bindings' ] + // Legacy from node-waf, node <= 0.4.x + , [ 'module_root', 'build', 'default', 'bindings' ] + // Production "Release" buildtype binary (meh...) + , [ 'module_root', 'compiled', 'version', 'platform', 'arch', 'bindings' ] + ] + } + +/** + * The main `bindings()` function loads the compiled bindings for a given module. + * It uses V8's Error API to determine the parent filename that this function is + * being invoked from, which is then used to find the root directory. + */ + +function bindings (opts) { + + // Argument surgery + if (typeof opts == 'string') { + opts = { bindings: opts } + } else if (!opts) { + opts = {} + } + opts.__proto__ = defaults + + // Get the module root + if (!opts.module_root) { + opts.module_root = exports.getRoot(exports.getFileName()) + } + + // Ensure the given bindings name ends with .node + if (path.extname(opts.bindings) != '.node') { + opts.bindings += '.node' + } + + var tries = [] + , i = 0 + , l = opts.try.length + , n + , b + , err + + for (; i exports.UNZIP) + throw new TypeError("Bad argument"); + + this.mode = mode; + this.init_done = false; + this.write_in_progress = false; + this.pending_close = false; + this.windowBits = 0; + this.level = 0; + this.memLevel = 0; + this.strategy = 0; + this.dictionary = null; +} + +Zlib.prototype.init = function(windowBits, level, memLevel, strategy, dictionary) { + this.windowBits = windowBits; + this.level = level; + this.memLevel = memLevel; + this.strategy = strategy; + // dictionary not supported. + + if (this.mode === exports.GZIP || this.mode === exports.GUNZIP) + this.windowBits += 16; + + if (this.mode === exports.UNZIP) + this.windowBits += 32; + + if (this.mode === exports.DEFLATERAW || this.mode === exports.INFLATERAW) + this.windowBits = -this.windowBits; + + this.strm = new zstream(); + + switch (this.mode) { + case exports.DEFLATE: + case exports.GZIP: + case exports.DEFLATERAW: + var status = zlib_deflate.deflateInit2( + this.strm, + this.level, + exports.Z_DEFLATED, + this.windowBits, + this.memLevel, + this.strategy + ); + break; + case exports.INFLATE: + case exports.GUNZIP: + case exports.INFLATERAW: + case exports.UNZIP: + var status = zlib_inflate.inflateInit2( + this.strm, + this.windowBits + ); + break; + default: + throw new Error("Unknown mode " + this.mode); + } + + if (status !== exports.Z_OK) { + this._error(status); + return; + } + + this.write_in_progress = false; + this.init_done = true; +}; + +Zlib.prototype.params = function() { + throw new Error("deflateParams Not supported"); +}; + +Zlib.prototype._writeCheck = function() { + if (!this.init_done) + throw new Error("write before init"); + + if (this.mode === exports.NONE) + throw new Error("already finalized"); + + if (this.write_in_progress) + throw new Error("write already in progress"); + + if (this.pending_close) + throw new Error("close is pending"); +}; + +Zlib.prototype.write = function(flush, input, in_off, in_len, out, out_off, out_len) { + this._writeCheck(); + this.write_in_progress = true; + + var self = this; + process.nextTick(function() { + self.write_in_progress = false; + var res = self._write(flush, input, in_off, in_len, out, out_off, out_len); + self.callback(res[0], res[1]); + + if (self.pending_close) + self.close(); + }); + + return this; +}; + +// set method for Node buffers, used by pako +function bufferSet(data, offset) { + for (var i = 0; i < data.length; i++) { + this[offset + i] = data[i]; + } +} + +Zlib.prototype.writeSync = function(flush, input, in_off, in_len, out, out_off, out_len) { + this._writeCheck(); + return this._write(flush, input, in_off, in_len, out, out_off, out_len); +}; + +Zlib.prototype._write = function(flush, input, in_off, in_len, out, out_off, out_len) { + this.write_in_progress = true; + + if (flush !== exports.Z_NO_FLUSH && + flush !== exports.Z_PARTIAL_FLUSH && + flush !== exports.Z_SYNC_FLUSH && + flush !== exports.Z_FULL_FLUSH && + flush !== exports.Z_FINISH && + flush !== exports.Z_BLOCK) { + throw new Error("Invalid flush value"); + } + + if (input == null) { + input = new Buffer(0); + in_len = 0; + in_off = 0; + } + + if (out._set) + out.set = out._set; + else + out.set = bufferSet; + + var strm = this.strm; + strm.avail_in = in_len; + strm.input = input; + strm.next_in = in_off; + strm.avail_out = out_len; + strm.output = out; + strm.next_out = out_off; + + switch (this.mode) { + case exports.DEFLATE: + case exports.GZIP: + case exports.DEFLATERAW: + var status = zlib_deflate.deflate(strm, flush); + break; + case exports.UNZIP: + case exports.INFLATE: + case exports.GUNZIP: + case exports.INFLATERAW: + var status = zlib_inflate.inflate(strm, flush); + break; + default: + throw new Error("Unknown mode " + this.mode); + } + + if (status !== exports.Z_STREAM_END && status !== exports.Z_OK) { + this._error(status); + } + + this.write_in_progress = false; + return [strm.avail_in, strm.avail_out]; +}; + +Zlib.prototype.close = function() { + if (this.write_in_progress) { + this.pending_close = true; + return; + } + + this.pending_close = false; + + if (this.mode === exports.DEFLATE || this.mode === exports.GZIP || this.mode === exports.DEFLATERAW) { + zlib_deflate.deflateEnd(this.strm); + } else { + zlib_inflate.inflateEnd(this.strm); + } + + this.mode = exports.NONE; +}; + +Zlib.prototype.reset = function() { + switch (this.mode) { + case exports.DEFLATE: + case exports.DEFLATERAW: + var status = zlib_deflate.deflateReset(this.strm); + break; + case exports.INFLATE: + case exports.INFLATERAW: + var status = zlib_inflate.inflateReset(this.strm); + break; + } + + if (status !== exports.Z_OK) { + this._error(status); + } +}; + +Zlib.prototype._error = function(status) { + this.onerror(msg[status] + ': ' + this.strm.msg, status); + + this.write_in_progress = false; + if (this.pending_close) + this.close(); +}; + +exports.Zlib = Zlib; + +}).call(this,require('_process'),require("buffer").Buffer) +},{"_process":68,"buffer":38,"pako/lib/zlib/constants":57,"pako/lib/zlib/deflate.js":59,"pako/lib/zlib/inflate.js":61,"pako/lib/zlib/messages":63,"pako/lib/zlib/zstream":65}],31:[function(require,module,exports){ +(function (process,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. + +var Transform = require('_stream_transform'); + +var binding = require('./binding'); +var util = require('util'); +var assert = require('assert').ok; + +// zlib doesn't provide these, so kludge them in following the same +// const naming scheme zlib uses. +binding.Z_MIN_WINDOWBITS = 8; +binding.Z_MAX_WINDOWBITS = 15; +binding.Z_DEFAULT_WINDOWBITS = 15; + +// fewer than 64 bytes per chunk is stupid. +// technically it could work with as few as 8, but even 64 bytes +// is absurdly low. Usually a MB or more is best. +binding.Z_MIN_CHUNK = 64; +binding.Z_MAX_CHUNK = Infinity; +binding.Z_DEFAULT_CHUNK = (16 * 1024); + +binding.Z_MIN_MEMLEVEL = 1; +binding.Z_MAX_MEMLEVEL = 9; +binding.Z_DEFAULT_MEMLEVEL = 8; + +binding.Z_MIN_LEVEL = -1; +binding.Z_MAX_LEVEL = 9; +binding.Z_DEFAULT_LEVEL = binding.Z_DEFAULT_COMPRESSION; + +// expose all the zlib constants +Object.keys(binding).forEach(function(k) { + if (k.match(/^Z/)) exports[k] = binding[k]; +}); + +// translation table for return codes. +exports.codes = { + Z_OK: binding.Z_OK, + Z_STREAM_END: binding.Z_STREAM_END, + Z_NEED_DICT: binding.Z_NEED_DICT, + Z_ERRNO: binding.Z_ERRNO, + Z_STREAM_ERROR: binding.Z_STREAM_ERROR, + Z_DATA_ERROR: binding.Z_DATA_ERROR, + Z_MEM_ERROR: binding.Z_MEM_ERROR, + Z_BUF_ERROR: binding.Z_BUF_ERROR, + Z_VERSION_ERROR: binding.Z_VERSION_ERROR +}; + +Object.keys(exports.codes).forEach(function(k) { + exports.codes[exports.codes[k]] = k; +}); + +exports.Deflate = Deflate; +exports.Inflate = Inflate; +exports.Gzip = Gzip; +exports.Gunzip = Gunzip; +exports.DeflateRaw = DeflateRaw; +exports.InflateRaw = InflateRaw; +exports.Unzip = Unzip; + +exports.createDeflate = function(o) { + return new Deflate(o); +}; + +exports.createInflate = function(o) { + return new Inflate(o); +}; + +exports.createDeflateRaw = function(o) { + return new DeflateRaw(o); +}; + +exports.createInflateRaw = function(o) { + return new InflateRaw(o); +}; + +exports.createGzip = function(o) { + return new Gzip(o); +}; + +exports.createGunzip = function(o) { + return new Gunzip(o); +}; + +exports.createUnzip = function(o) { + return new Unzip(o); +}; + + +// Convenience methods. +// compress/decompress a string or buffer in one step. +exports.deflate = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Deflate(opts), buffer, callback); +}; + +exports.deflateSync = function(buffer, opts) { + return zlibBufferSync(new Deflate(opts), buffer); +}; + +exports.gzip = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Gzip(opts), buffer, callback); +}; + +exports.gzipSync = function(buffer, opts) { + return zlibBufferSync(new Gzip(opts), buffer); +}; + +exports.deflateRaw = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new DeflateRaw(opts), buffer, callback); +}; + +exports.deflateRawSync = function(buffer, opts) { + return zlibBufferSync(new DeflateRaw(opts), buffer); +}; + +exports.unzip = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Unzip(opts), buffer, callback); +}; + +exports.unzipSync = function(buffer, opts) { + return zlibBufferSync(new Unzip(opts), buffer); +}; + +exports.inflate = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Inflate(opts), buffer, callback); +}; + +exports.inflateSync = function(buffer, opts) { + return zlibBufferSync(new Inflate(opts), buffer); +}; + +exports.gunzip = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Gunzip(opts), buffer, callback); +}; + +exports.gunzipSync = function(buffer, opts) { + return zlibBufferSync(new Gunzip(opts), buffer); +}; + +exports.inflateRaw = function(buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new InflateRaw(opts), buffer, callback); +}; + +exports.inflateRawSync = function(buffer, opts) { + return zlibBufferSync(new InflateRaw(opts), buffer); +}; + +function zlibBuffer(engine, buffer, callback) { + var buffers = []; + var nread = 0; + + engine.on('error', onError); + engine.on('end', onEnd); + + engine.end(buffer); + flow(); + + function flow() { + var chunk; + while (null !== (chunk = engine.read())) { + buffers.push(chunk); + nread += chunk.length; + } + engine.once('readable', flow); + } + + function onError(err) { + engine.removeListener('end', onEnd); + engine.removeListener('readable', flow); + callback(err); + } + + function onEnd() { + var buf = Buffer.concat(buffers, nread); + buffers = []; + callback(null, buf); + engine.close(); + } +} + +function zlibBufferSync(engine, buffer) { + if (typeof buffer === 'string') + buffer = new Buffer(buffer); + if (!Buffer.isBuffer(buffer)) + throw new TypeError('Not a string or buffer'); + + var flushFlag = binding.Z_FINISH; + + return engine._processChunk(buffer, flushFlag); +} + +// generic zlib +// minimal 2-byte header +function Deflate(opts) { + if (!(this instanceof Deflate)) return new Deflate(opts); + Zlib.call(this, opts, binding.DEFLATE); +} + +function Inflate(opts) { + if (!(this instanceof Inflate)) return new Inflate(opts); + Zlib.call(this, opts, binding.INFLATE); +} + + + +// gzip - bigger header, same deflate compression +function Gzip(opts) { + if (!(this instanceof Gzip)) return new Gzip(opts); + Zlib.call(this, opts, binding.GZIP); +} + +function Gunzip(opts) { + if (!(this instanceof Gunzip)) return new Gunzip(opts); + Zlib.call(this, opts, binding.GUNZIP); +} + + + +// raw - no header +function DeflateRaw(opts) { + if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts); + Zlib.call(this, opts, binding.DEFLATERAW); +} + +function InflateRaw(opts) { + if (!(this instanceof InflateRaw)) return new InflateRaw(opts); + Zlib.call(this, opts, binding.INFLATERAW); +} + + +// auto-detect header. +function Unzip(opts) { + if (!(this instanceof Unzip)) return new Unzip(opts); + Zlib.call(this, opts, binding.UNZIP); +} + + +// the Zlib class they all inherit from +// This thing manages the queue of requests, and returns +// true or false if there is anything in the queue when +// you call the .write() method. + +function Zlib(opts, mode) { + this._opts = opts = opts || {}; + this._chunkSize = opts.chunkSize || exports.Z_DEFAULT_CHUNK; + + Transform.call(this, opts); + + if (opts.flush) { + if (opts.flush !== binding.Z_NO_FLUSH && + opts.flush !== binding.Z_PARTIAL_FLUSH && + opts.flush !== binding.Z_SYNC_FLUSH && + opts.flush !== binding.Z_FULL_FLUSH && + opts.flush !== binding.Z_FINISH && + opts.flush !== binding.Z_BLOCK) { + throw new Error('Invalid flush flag: ' + opts.flush); + } + } + this._flushFlag = opts.flush || binding.Z_NO_FLUSH; + + if (opts.chunkSize) { + if (opts.chunkSize < exports.Z_MIN_CHUNK || + opts.chunkSize > exports.Z_MAX_CHUNK) { + throw new Error('Invalid chunk size: ' + opts.chunkSize); + } + } + + if (opts.windowBits) { + if (opts.windowBits < exports.Z_MIN_WINDOWBITS || + opts.windowBits > exports.Z_MAX_WINDOWBITS) { + throw new Error('Invalid windowBits: ' + opts.windowBits); + } + } + + if (opts.level) { + if (opts.level < exports.Z_MIN_LEVEL || + opts.level > exports.Z_MAX_LEVEL) { + throw new Error('Invalid compression level: ' + opts.level); + } + } + + if (opts.memLevel) { + if (opts.memLevel < exports.Z_MIN_MEMLEVEL || + opts.memLevel > exports.Z_MAX_MEMLEVEL) { + throw new Error('Invalid memLevel: ' + opts.memLevel); + } + } + + if (opts.strategy) { + if (opts.strategy != exports.Z_FILTERED && + opts.strategy != exports.Z_HUFFMAN_ONLY && + opts.strategy != exports.Z_RLE && + opts.strategy != exports.Z_FIXED && + opts.strategy != exports.Z_DEFAULT_STRATEGY) { + throw new Error('Invalid strategy: ' + opts.strategy); + } + } + + if (opts.dictionary) { + if (!Buffer.isBuffer(opts.dictionary)) { + throw new Error('Invalid dictionary: it should be a Buffer instance'); + } + } + + this._binding = new binding.Zlib(mode); + + var self = this; + this._hadError = false; + this._binding.onerror = function(message, errno) { + // there is no way to cleanly recover. + // continuing only obscures problems. + self._binding = null; + self._hadError = true; + + var error = new Error(message); + error.errno = errno; + error.code = exports.codes[errno]; + self.emit('error', error); + }; + + var level = exports.Z_DEFAULT_COMPRESSION; + if (typeof opts.level === 'number') level = opts.level; + + var strategy = exports.Z_DEFAULT_STRATEGY; + if (typeof opts.strategy === 'number') strategy = opts.strategy; + + this._binding.init(opts.windowBits || exports.Z_DEFAULT_WINDOWBITS, + level, + opts.memLevel || exports.Z_DEFAULT_MEMLEVEL, + strategy, + opts.dictionary); + + this._buffer = new Buffer(this._chunkSize); + this._offset = 0; + this._closed = false; + this._level = level; + this._strategy = strategy; + + this.once('end', this.close); +} + +util.inherits(Zlib, Transform); + +Zlib.prototype.params = function(level, strategy, callback) { + if (level < exports.Z_MIN_LEVEL || + level > exports.Z_MAX_LEVEL) { + throw new RangeError('Invalid compression level: ' + level); + } + if (strategy != exports.Z_FILTERED && + strategy != exports.Z_HUFFMAN_ONLY && + strategy != exports.Z_RLE && + strategy != exports.Z_FIXED && + strategy != exports.Z_DEFAULT_STRATEGY) { + throw new TypeError('Invalid strategy: ' + strategy); + } + + if (this._level !== level || this._strategy !== strategy) { + var self = this; + this.flush(binding.Z_SYNC_FLUSH, function() { + self._binding.params(level, strategy); + if (!self._hadError) { + self._level = level; + self._strategy = strategy; + if (callback) callback(); + } + }); + } else { + process.nextTick(callback); + } +}; + +Zlib.prototype.reset = function() { + return this._binding.reset(); +}; + +// This is the _flush function called by the transform class, +// internally, when the last chunk has been written. +Zlib.prototype._flush = function(callback) { + this._transform(new Buffer(0), '', callback); +}; + +Zlib.prototype.flush = function(kind, callback) { + var ws = this._writableState; + + if (typeof kind === 'function' || (kind === void 0 && !callback)) { + callback = kind; + kind = binding.Z_FULL_FLUSH; + } + + if (ws.ended) { + if (callback) + process.nextTick(callback); + } else if (ws.ending) { + if (callback) + this.once('end', callback); + } else if (ws.needDrain) { + var self = this; + this.once('drain', function() { + self.flush(callback); + }); + } else { + this._flushFlag = kind; + this.write(new Buffer(0), '', callback); + } +}; + +Zlib.prototype.close = function(callback) { + if (callback) + process.nextTick(callback); + + if (this._closed) + return; + + this._closed = true; + + this._binding.close(); + + var self = this; + process.nextTick(function() { + self.emit('close'); + }); +}; + +Zlib.prototype._transform = function(chunk, encoding, cb) { + var flushFlag; + var ws = this._writableState; + var ending = ws.ending || ws.ended; + var last = ending && (!chunk || ws.length === chunk.length); + + if (!chunk === null && !Buffer.isBuffer(chunk)) + return cb(new Error('invalid input')); + + // If it's the last chunk, or a final flush, we use the Z_FINISH flush flag. + // If it's explicitly flushing at some other time, then we use + // Z_FULL_FLUSH. Otherwise, use Z_NO_FLUSH for maximum compression + // goodness. + if (last) + flushFlag = binding.Z_FINISH; + else { + flushFlag = this._flushFlag; + // once we've flushed the last of the queue, stop flushing and + // go back to the normal behavior. + if (chunk.length >= ws.length) { + this._flushFlag = this._opts.flush || binding.Z_NO_FLUSH; + } + } + + var self = this; + this._processChunk(chunk, flushFlag, cb); +}; + +Zlib.prototype._processChunk = function(chunk, flushFlag, cb) { + var availInBefore = chunk && chunk.length; + var availOutBefore = this._chunkSize - this._offset; + var inOff = 0; + + var self = this; + + var async = typeof cb === 'function'; + + if (!async) { + var buffers = []; + var nread = 0; + + var error; + this.on('error', function(er) { + error = er; + }); + + do { + var res = this._binding.writeSync(flushFlag, + chunk, // in + inOff, // in_off + availInBefore, // in_len + this._buffer, // out + this._offset, //out_off + availOutBefore); // out_len + } while (!this._hadError && callback(res[0], res[1])); + + if (this._hadError) { + throw error; + } + + var buf = Buffer.concat(buffers, nread); + this.close(); + + return buf; + } + + var req = this._binding.write(flushFlag, + chunk, // in + inOff, // in_off + availInBefore, // in_len + this._buffer, // out + this._offset, //out_off + availOutBefore); // out_len + + req.buffer = chunk; + req.callback = callback; + + function callback(availInAfter, availOutAfter) { + if (self._hadError) + return; + + var have = availOutBefore - availOutAfter; + assert(have >= 0, 'have should not go down'); + + if (have > 0) { + var out = self._buffer.slice(self._offset, self._offset + have); + self._offset += have; + // serve some output to the consumer. + if (async) { + self.push(out); + } else { + buffers.push(out); + nread += out.length; + } + } + + // exhausted the output buffer, or used all the input create a new one. + if (availOutAfter === 0 || self._offset >= self._chunkSize) { + availOutBefore = self._chunkSize; + self._offset = 0; + self._buffer = new Buffer(self._chunkSize); + } + + if (availOutAfter === 0) { + // Not actually done. Need to reprocess. + // Also, update the availInBefore to the availInAfter value, + // so that if we have to hit it a third (fourth, etc.) time, + // it'll have the correct byte counts. + inOff += (availInBefore - availInAfter); + availInBefore = availInAfter; + + if (!async) + return true; + + var newReq = self._binding.write(flushFlag, + chunk, + inOff, + availInBefore, + self._buffer, + self._offset, + self._chunkSize); + newReq.callback = callback; // this same function + newReq.buffer = chunk; + return; + } + + if (!async) + return false; + + // finished with the chunk. + cb(); + } +}; + +util.inherits(Deflate, Zlib); +util.inherits(Inflate, Zlib); +util.inherits(Gzip, Zlib); +util.inherits(Gunzip, Zlib); +util.inherits(DeflateRaw, Zlib); +util.inherits(InflateRaw, Zlib); +util.inherits(Unzip, Zlib); + +}).call(this,require('_process'),require("buffer").Buffer) +},{"./binding":30,"_process":68,"_stream_transform":37,"assert":26,"buffer":38,"util":90}],32:[function(require,module,exports){ +arguments[4][29][0].apply(exports,arguments) +},{"dup":29}],33:[function(require,module,exports){ +// 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'; + +/**/ +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) keys.push(key); + return keys; +} +/**/ + + +module.exports = Duplex; + +/**/ +var processNextTick = require('process-nextick-args'); +/**/ + + + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +var Readable = require('./_stream_readable'); +var Writable = require('./_stream_writable'); + +util.inherits(Duplex, Readable); + +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); +} + +// 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. + processNextTick(onEndNT, this); +} + +function onEndNT(self) { + self.end(); +} + +function forEach (xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} + +},{"./_stream_readable":34,"./_stream_writable":36,"core-util-is":40,"inherits":45,"process-nextick-args":67}],34:[function(require,module,exports){ +(function (process){ +'use strict'; + +module.exports = Readable; + +/**/ +var processNextTick = require('process-nextick-args'); +/**/ + + +/**/ +var isArray = require('isarray'); +/**/ + + +/**/ +var Buffer = require('buffer').Buffer; +/**/ + +Readable.ReadableState = ReadableState; + +var EE = require('events'); + +/**/ +var EElistenerCount = function(emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + + + +/**/ +var Stream; +(function (){try{ + Stream = require('st' + 'ream'); +}catch(_){}finally{ + if (!Stream) + Stream = require('events').EventEmitter; +}}()) +/**/ + +var Buffer = require('buffer').Buffer; + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + + + +/**/ +var debugUtil = require('util'); +var debug; +if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); +} else { + debug = function () {}; +} +/**/ + +var StringDecoder; + +util.inherits(Readable, Stream); + +function ReadableState(options, stream) { + var Duplex = require('./_stream_duplex'); + + options = options || {}; + + // 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 (stream instanceof Duplex) + 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 defaultHwm = this.objectMode ? 16 : 16 * 1024; + this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = ~~this.highWaterMark; + + this.buffer = []; + 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 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; + + // 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; + + // 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'; + + // when piping, we only care about 'readable' events that happen + // after read()ing all the bytes and not getting any pushback. + this.ranOut = false; + + // 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) { + var Duplex = require('./_stream_duplex'); + + if (!(this instanceof Readable)) + return new Readable(options); + + this._readableState = new ReadableState(options, this); + + // legacy + this.readable = true; + + if (options && typeof options.read === 'function') + this._read = options.read; + + Stream.call(this); +} + +// 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; + + if (!state.objectMode && typeof chunk === 'string') { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = new Buffer(chunk, encoding); + encoding = ''; + } + } + + return readableAddChunk(this, state, chunk, encoding, false); +}; + +// Unshift should *always* be something directly out of read() +Readable.prototype.unshift = function(chunk) { + var state = this._readableState; + return readableAddChunk(this, state, chunk, '', true); +}; + +Readable.prototype.isPaused = function() { + return this._readableState.flowing === false; +}; + +function readableAddChunk(stream, state, chunk, encoding, addToFront) { + var er = chunkInvalid(state, chunk); + if (er) { + stream.emit('error', er); + } else if (chunk === null) { + state.reading = false; + onEofChunk(stream, state); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (state.ended && !addToFront) { + var e = new Error('stream.push() after EOF'); + stream.emit('error', e); + } else if (state.endEmitted && addToFront) { + var e = new Error('stream.unshift() after end event'); + stream.emit('error', e); + } else { + if (state.decoder && !addToFront && !encoding) + chunk = state.decoder.write(chunk); + + if (!addToFront) + state.reading = false; + + // if we want the data now, just emit it. + 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); + } + } else if (!addToFront) { + state.reading = false; + } + + return needMoreData(state); +} + + +// 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); +} + +// 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 + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; +} + +function howMuchToRead(n, state) { + if (state.length === 0 && state.ended) + return 0; + + if (state.objectMode) + return n === 0 ? 0 : 1; + + if (n === null || isNaN(n)) { + // only flow one buffer at a time + if (state.flowing && state.buffer.length) + return state.buffer[0].length; + else + return state.length; + } + + if (n <= 0) + return 0; + + // If we're asking for more than the target buffer level, + // then raise the water mark. Bump up to the next highest + // power of 2, to prevent increasing it excessively in tiny + // amounts. + if (n > state.highWaterMark) + state.highWaterMark = computeNewHighWaterMark(n); + + // don't have that much. return null, unless we've ended. + if (n > state.length) { + if (!state.ended) { + state.needReadable = true; + return 0; + } else { + return state.length; + } + } + + return n; +} + +// you can override either this method, or the async _read(n) below. +Readable.prototype.read = function(n) { + debug('read', n); + var state = this._readableState; + var nOrig = n; + + if (typeof n !== 'number' || 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); + } + + 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 (doRead && !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; + } + + state.length -= n; + + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (state.length === 0 && !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 && state.length === 0) + endReadable(this); + + if (ret !== null) + this.emit('data', ret); + + return ret; +}; + +function chunkInvalid(state, chunk) { + var er = null; + if (!(Buffer.isBuffer(chunk)) && + typeof chunk !== 'string' && + chunk !== null && + chunk !== undefined && + !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + return er; +} + + +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) + processNextTick(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; + processNextTick(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('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 : cleanup; + if (state.endEmitted) + processNextTick(endFn); + else + src.once('end', endFn); + + dest.on('unpipe', onunpipe); + function onunpipe(readable) { + debug('onunpipe'); + if (readable === src) { + 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', cleanup); + 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(); + } + + src.on('data', ondata); + function ondata(chunk) { + debug('ondata'); + var ret = dest.write(chunk); + if (false === ret) { + // If the user unpiped during `dest.write()`, it is possible + // to get stuck in a permanently paused state if that write + // also returned false. + if (state.pipesCount === 1 && + state.pipes[0] === dest && + src.listenerCount('data') === 1 && + !cleanedUp) { + debug('false write response, pause', src._readableState.awaitDrain); + src._readableState.awaitDrain++; + } + 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); + } + // This is a brutally ugly hack to make sure that our error handler + // is attached before any userland ones. NEVER DO THIS. + if (!dest._events || !dest._events.error) + dest.on('error', onerror); + else if (isArray(dest._events.error)) + dest._events.error.unshift(onerror); + else + dest._events.error = [onerror, dest._events.error]; + + + // 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; + + // 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); + 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); + return this; + } + + // try to find the right one. + var i = indexOf(state.pipes, dest); + if (i === -1) + return this; + + state.pipes.splice(i, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) + state.pipes = state.pipes[0]; + + dest.emit('unpipe', this); + + 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 listening to data, and it has not explicitly been paused, + // then call resume to start the flow of data on the next tick. + if (ev === 'data' && false !== this._readableState.flowing) { + this.resume(); + } + + if (ev === 'readable' && this.readable) { + var state = this._readableState; + if (!state.readableListening) { + state.readableListening = true; + state.emittedReadable = false; + state.needReadable = true; + if (!state.reading) { + processNextTick(nReadingNextTick, this); + } else if (state.length) { + emitReadable(this, state); + } + } + } + + 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; + processNextTick(resume_, stream, state); + } +} + +function resume_(stream, state) { + if (!state.reading) { + debug('resume read 0'); + stream.read(0); + } + + state.resumeScheduled = false; + 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); + if (state.flowing) { + do { + var chunk = stream.read(); + } while (null !== chunk && state.flowing); + } +} + +// 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 state = this._readableState; + var paused = false; + + var self = this; + stream.on('end', function() { + debug('wrapped end'); + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) + self.push(chunk); + } + + self.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 = self.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. + var events = ['error', 'close', 'destroy', 'pause', 'resume']; + forEach(events, function(ev) { + stream.on(ev, self.emit.bind(self, ev)); + }); + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + self._read = function(n) { + debug('wrapped _read', n); + if (paused) { + paused = false; + stream.resume(); + } + }; + + return self; +}; + + +// 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. +function fromList(n, state) { + var list = state.buffer; + var length = state.length; + var stringMode = !!state.decoder; + var objectMode = !!state.objectMode; + var ret; + + // nothing in the list, definitely empty. + if (list.length === 0) + return null; + + if (length === 0) + ret = null; + else if (objectMode) + ret = list.shift(); + else if (!n || n >= length) { + // read it all, truncate the array. + if (stringMode) + ret = list.join(''); + else if (list.length === 1) + ret = list[0]; + else + ret = Buffer.concat(list, length); + list.length = 0; + } else { + // read just some of it. + if (n < list[0].length) { + // just take a part of the first list item. + // slice is the same for buffers and strings. + var buf = list[0]; + ret = buf.slice(0, n); + list[0] = buf.slice(n); + } else if (n === list[0].length) { + // first list is a perfect match + ret = list.shift(); + } else { + // complex case. + // we have enough to cover it, but it spans past the first buffer. + if (stringMode) + ret = ''; + else + ret = new Buffer(n); + + var c = 0; + for (var i = 0, l = list.length; i < l && c < n; i++) { + var buf = list[0]; + var cpy = Math.min(n - c, buf.length); + + if (stringMode) + ret += buf.slice(0, cpy); + else + buf.copy(ret, c, 0, cpy); + + if (cpy < buf.length) + list[0] = buf.slice(cpy); + else + list.shift(); + + c += cpy; + } + } + } + + 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; + processNextTick(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 forEach (xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } +} + +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')) +},{"./_stream_duplex":33,"_process":68,"buffer":38,"core-util-is":40,"events":43,"inherits":45,"isarray":48,"process-nextick-args":67,"string_decoder/":86,"util":29}],35:[function(require,module,exports){ +// 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'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +util.inherits(Transform, Duplex); + + +function TransformState(stream) { + this.afterTransform = function(er, data) { + return afterTransform(stream, er, data); + }; + + this.needTransform = false; + this.transforming = false; + this.writecb = null; + this.writechunk = null; +} + +function afterTransform(stream, er, data) { + var ts = stream._transformState; + ts.transforming = false; + + var cb = ts.writecb; + + if (!cb) + return stream.emit('error', new Error('no writecb in Transform class')); + + ts.writechunk = null; + ts.writecb = null; + + if (data !== null && data !== undefined) + stream.push(data); + + if (cb) + cb(er); + + var rs = stream._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + stream._read(rs.highWaterMark); + } +} + + +function Transform(options) { + if (!(this instanceof Transform)) + return new Transform(options); + + Duplex.call(this, options); + + this._transformState = new TransformState(this); + + // when the writable side finishes, then flush out anything remaining. + var stream = this; + + // 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; + } + + this.once('prefinish', function() { + if (typeof this._flush === 'function') + this._flush(function(er) { + done(stream, er); + }); + else + done(stream); + }); +} + +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('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; + } +}; + + +function done(stream, er) { + if (er) + return stream.emit('error', er); + + // if there's nothing in the write buffer, then that means + // that nothing more will ever be provided + var ws = stream._writableState; + var ts = stream._transformState; + + if (ws.length) + throw new Error('calling transform done when ws.length != 0'); + + if (ts.transforming) + throw new Error('calling transform done when still transforming'); + + return stream.push(null); +} + +},{"./_stream_duplex":33,"core-util-is":40,"inherits":45}],36:[function(require,module,exports){ +// 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'; + +module.exports = Writable; + +/**/ +var processNextTick = require('process-nextick-args'); +/**/ + + +/**/ +var Buffer = require('buffer').Buffer; +/**/ + +Writable.WritableState = WritableState; + + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + + +/**/ +var internalUtil = { + deprecate: require('util-deprecate') +}; +/**/ + + + +/**/ +var Stream; +(function (){try{ + Stream = require('st' + 'ream'); +}catch(_){}finally{ + if (!Stream) + Stream = require('events').EventEmitter; +}}()) +/**/ + +var Buffer = require('buffer').Buffer; + +util.inherits(Writable, Stream); + +function nop() {} + +function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; + this.next = null; +} + +function WritableState(options, stream) { + var Duplex = require('./_stream_duplex'); + + options = options || {}; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + + if (stream instanceof Duplex) + 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 defaultHwm = this.objectMode ? 16 : 16 * 1024; + this.highWaterMark = (hwm || hwm === 0) ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = ~~this.highWaterMark; + + 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; + + // 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; +} + +WritableState.prototype.getBuffer = function writableStateGetBuffer() { + 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.') +}); +}catch(_){}}()); + + +function Writable(options) { + var Duplex = require('./_stream_duplex'); + + // Writable ctor is applied to Duplexes, though they're not + // instanceof Writable, they're instanceof Readable. + if (!(this instanceof Writable) && !(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; + } + + 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); + processNextTick(cb, er); +} + +// If we get something that is not a buffer, string, null, or undefined, +// and we're not in objectMode, then that's an error. +// Otherwise stream chunks are all considered to be of length=1, and the +// watermarks determine how many objects to keep in the buffer, rather than +// how many bytes or characters. +function validChunk(stream, state, chunk, cb) { + var valid = true; + + if (!(Buffer.isBuffer(chunk)) && + typeof chunk !== 'string' && + chunk !== null && + chunk !== undefined && + !state.objectMode) { + var er = new TypeError('Invalid non-string/buffer chunk'); + stream.emit('error', er); + processNextTick(cb, er); + valid = false; + } + return valid; +} + +Writable.prototype.write = function(chunk, encoding, cb) { + var state = this._writableState; + var ret = false; + + if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (Buffer.isBuffer(chunk)) + encoding = 'buffer'; + else if (!encoding) + encoding = state.defaultEncoding; + + if (typeof cb !== 'function') + cb = nop; + + if (state.ended) + writeAfterEnd(this, cb); + else if (validChunk(this, state, chunk, cb)) { + state.pendingcb++; + ret = writeOrBuffer(this, state, 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; +}; + +function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && + state.decodeStrings !== false && + typeof chunk === 'string') { + chunk = new Buffer(chunk, encoding); + } + return chunk; +} + +// 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, chunk, encoding, cb) { + chunk = decodeChunk(state, chunk, encoding); + + if (Buffer.isBuffer(chunk)) + encoding = 'buffer'; + 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 = new WriteReq(chunk, encoding, cb); + if (last) { + last.next = state.lastBufferedRequest; + } else { + state.bufferedRequest = state.lastBufferedRequest; + } + } 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) + processNextTick(cb, er); + else + cb(er); + + stream._writableState.errorEmitted = true; + stream.emit('error', er); +} + +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) { + processNextTick(afterWrite, stream, state, finished, cb); + } 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 buffer = []; + var cbs = []; + while (entry) { + cbs.push(entry.callback); + buffer.push(entry); + entry = entry.next; + } + + // count the one we are adding, as well. + // TODO(isaacs) clean this up + state.pendingcb++; + state.lastBufferedRequest = null; + doWrite(stream, state, true, state.length, buffer, '', function(err) { + for (var i = 0; i < cbs.length; i++) { + state.pendingcb--; + cbs[i](err); + } + }); + + // Clear buffer + } 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; + // 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('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 prefinish(stream, state) { + if (!state.prefinished) { + state.prefinished = true; + stream.emit('prefinish'); + } +} + +function finishMaybe(stream, state) { + var need = needFinish(state); + if (need) { + if (state.pendingcb === 0) { + prefinish(stream, state); + state.finished = true; + stream.emit('finish'); + } else { + prefinish(stream, state); + } + } + return need; +} + +function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) + processNextTick(cb); + else + stream.once('finish', cb); + } + state.ended = true; +} + +},{"./_stream_duplex":33,"buffer":38,"core-util-is":40,"events":43,"inherits":45,"process-nextick-args":67,"util-deprecate":88}],37:[function(require,module,exports){ +module.exports = require("./lib/_stream_transform.js") + +},{"./lib/_stream_transform.js":35}],38:[function(require,module,exports){ +(function (global){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +/* eslint-disable no-proto */ + +var base64 = require('base64-js') +var ieee754 = require('ieee754') +var isArray = require('is-array') + +exports.Buffer = Buffer +exports.SlowBuffer = SlowBuffer +exports.INSPECT_MAX_BYTES = 50 +Buffer.poolSize = 8192 // not used by this implementation + +var rootParent = {} + +/** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Use 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+. + * + * Due to various browser bugs, sometimes the Object implementation will be used even + * when the browser supports typed arrays. + * + * Note: + * + * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, + * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. + * + * - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property + * on objects. + * + * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. + * + * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of + * incorrect length in some situations. + + * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they + * get the Object implementation, which is slower but behaves correctly. + */ +Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined + ? global.TYPED_ARRAY_SUPPORT + : typedArraySupport() + +function typedArraySupport () { + function Bar () {} + try { + var arr = new Uint8Array(1) + arr.foo = function () { return 42 } + arr.constructor = Bar + return arr.foo() === 42 && // typed array instances can be augmented + arr.constructor === Bar && // constructor can be set + typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` + arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` + } catch (e) { + return false + } +} + +function kMaxLength () { + return Buffer.TYPED_ARRAY_SUPPORT + ? 0x7fffffff + : 0x3fffffff +} + +/** + * Class: Buffer + * ============= + * + * The Buffer constructor returns instances of `Uint8Array` that are augmented + * with function properties for all the node `Buffer` API functions. We use + * `Uint8Array` so that square bracket notation works as expected -- it returns + * a single octet. + * + * By augmenting the instances, we can avoid modifying the `Uint8Array` + * prototype. + */ +function Buffer (arg) { + if (!(this instanceof Buffer)) { + // Avoid going through an ArgumentsAdaptorTrampoline in the common case. + if (arguments.length > 1) return new Buffer(arg, arguments[1]) + return new Buffer(arg) + } + + this.length = 0 + this.parent = undefined + + // Common case. + if (typeof arg === 'number') { + return fromNumber(this, arg) + } + + // Slightly less common case. + if (typeof arg === 'string') { + return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8') + } + + // Unusual. + return fromObject(this, arg) +} + +function fromNumber (that, length) { + that = allocate(that, length < 0 ? 0 : checked(length) | 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < length; i++) { + that[i] = 0 + } + } + return that +} + +function fromString (that, string, encoding) { + if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8' + + // Assumption: byteLength() return value is always < kMaxLength. + var length = byteLength(string, encoding) | 0 + that = allocate(that, length) + + that.write(string, encoding) + return that +} + +function fromObject (that, object) { + if (Buffer.isBuffer(object)) return fromBuffer(that, object) + + if (isArray(object)) return fromArray(that, object) + + if (object == null) { + throw new TypeError('must start with number, buffer, array or string') + } + + if (typeof ArrayBuffer !== 'undefined') { + if (object.buffer instanceof ArrayBuffer) { + return fromTypedArray(that, object) + } + if (object instanceof ArrayBuffer) { + return fromArrayBuffer(that, object) + } + } + + if (object.length) return fromArrayLike(that, object) + + return fromJsonObject(that, object) +} + +function fromBuffer (that, buffer) { + var length = checked(buffer.length) | 0 + that = allocate(that, length) + buffer.copy(that, 0, 0, length) + return that +} + +function fromArray (that, array) { + var length = checked(array.length) | 0 + that = allocate(that, length) + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +// Duplicate of fromArray() to keep fromArray() monomorphic. +function fromTypedArray (that, array) { + var length = checked(array.length) | 0 + that = allocate(that, length) + // Truncating the elements is probably not what people expect from typed + // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior + // of the old Buffer constructor. + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +function fromArrayBuffer (that, array) { + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + array.byteLength + that = Buffer._augment(new Uint8Array(array)) + } else { + // Fallback: Return an object instance of the Buffer class + that = fromTypedArray(that, new Uint8Array(array)) + } + return that +} + +function fromArrayLike (that, array) { + var length = checked(array.length) | 0 + that = allocate(that, length) + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object. +// Returns a zero-length buffer for inputs that don't conform to the spec. +function fromJsonObject (that, object) { + var array + var length = 0 + + if (object.type === 'Buffer' && isArray(object.data)) { + array = object.data + length = checked(array.length) | 0 + } + that = allocate(that, length) + + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that +} + +if (Buffer.TYPED_ARRAY_SUPPORT) { + Buffer.prototype.__proto__ = Uint8Array.prototype + Buffer.__proto__ = Uint8Array +} + +function allocate (that, length) { + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = Buffer._augment(new Uint8Array(length)) + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + that.length = length + that._isBuffer = true + } + + var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1 + if (fromPool) that.parent = rootParent + + return that +} + +function checked (length) { + // Note: cannot use `length < kMaxLength` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= kMaxLength()) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + kMaxLength().toString(16) + ' bytes') + } + return length | 0 +} + +function SlowBuffer (subject, encoding) { + if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding) + + var buf = new Buffer(subject, encoding) + delete buf.parent + return buf +} + +Buffer.isBuffer = function isBuffer (b) { + return !!(b != null && b._isBuffer) +} + +Buffer.compare = function compare (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError('Arguments must be Buffers') + } + + if (a === b) return 0 + + var x = a.length + var y = b.length + + var i = 0 + var len = Math.min(x, y) + while (i < len) { + if (a[i] !== b[i]) break + + ++i + } + + if (i !== len) { + x = a[i] + y = b[i] + } + + 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 'binary': + case 'base64': + case 'raw': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return true + default: + return false + } +} + +Buffer.concat = function concat (list, length) { + if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.') + + if (list.length === 0) { + return new Buffer(0) + } + + var i + if (length === undefined) { + length = 0 + for (i = 0; i < list.length; i++) { + length += list[i].length + } + } + + var buf = new Buffer(length) + var pos = 0 + for (i = 0; i < list.length; i++) { + var item = list[i] + item.copy(buf, pos) + pos += item.length + } + return buf +} + +function byteLength (string, encoding) { + if (typeof string !== 'string') string = '' + string + + var len = string.length + if (len === 0) return 0 + + // Use a for loop to avoid recursion + var loweredCase = false + for (;;) { + switch (encoding) { + case 'ascii': + case 'binary': + // Deprecated + case 'raw': + case 'raws': + 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 utf8ToBytes(string).length // assume utf8 + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } +} +Buffer.byteLength = byteLength + +// pre-set for values that may exist in the future +Buffer.prototype.length = undefined +Buffer.prototype.parent = undefined + +function slowToString (encoding, start, end) { + var loweredCase = false + + start = start | 0 + end = end === undefined || end === Infinity ? this.length : end | 0 + + if (!encoding) encoding = 'utf8' + if (start < 0) start = 0 + if (end > this.length) end = this.length + if (end <= start) return '' + + 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 'binary': + return binarySlice(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 + } + } +} + +Buffer.prototype.toString = function toString () { + var length = this.length | 0 + if (length === 0) return '' + if (arguments.length === 0) return utf8Slice(this, 0, length) + return slowToString.apply(this, arguments) +} + +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 + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) str += ' ... ' + } + return '' +} + +Buffer.prototype.compare = function compare (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return 0 + return Buffer.compare(this, b) +} + +Buffer.prototype.indexOf = function indexOf (val, byteOffset) { + if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff + else if (byteOffset < -0x80000000) byteOffset = -0x80000000 + byteOffset >>= 0 + + if (this.length === 0) return -1 + if (byteOffset >= this.length) return -1 + + // Negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0) + + if (typeof val === 'string') { + if (val.length === 0) return -1 // special case: looking for empty string always fails + return String.prototype.indexOf.call(this, val, byteOffset) + } + if (Buffer.isBuffer(val)) { + return arrayIndexOf(this, val, byteOffset) + } + if (typeof val === 'number') { + if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') { + return Uint8Array.prototype.indexOf.call(this, val, byteOffset) + } + return arrayIndexOf(this, [ val ], byteOffset) + } + + function arrayIndexOf (arr, val, byteOffset) { + var foundIndex = -1 + for (var i = 0; byteOffset + i < arr.length; i++) { + if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) { + if (foundIndex === -1) foundIndex = i + if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex + } else { + foundIndex = -1 + } + } + return -1 + } + + throw new TypeError('val must be string, number or Buffer') +} + +// `get` is deprecated +Buffer.prototype.get = function get (offset) { + console.log('.get() is deprecated. Access using array indexes instead.') + return this.readUInt8(offset) +} + +// `set` is deprecated +Buffer.prototype.set = function set (v, offset) { + console.log('.set() is deprecated. Access using array indexes instead.') + return this.writeUInt8(v, offset) +} + +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 + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new Error('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; i++) { + var parsed = parseInt(string.substr(i * 2, 2), 16) + if (isNaN(parsed)) throw new Error('Invalid hex string') + 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 binaryWrite (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 + } + // legacy write(string, encoding, offset, length) - remove in v0.13 + } else { + var swap = encoding + encoding = offset + offset = length | 0 + length = swap + } + + 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 'binary': + return binaryWrite(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 binarySlice (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 + if (Buffer.TYPED_ARRAY_SUPPORT) { + newBuf = Buffer._augment(this.subarray(start, end)) + } else { + var sliceLen = end - start + newBuf = new Buffer(sliceLen, undefined) + for (var i = 0; i < sliceLen; i++) { + newBuf[i] = this[i + start] + } + } + + if (newBuf.length) newBuf.parent = this.parent || this + + 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) { + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] +} + +Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) +} + +Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] +} + +Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + 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) { + 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) { + 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) { + 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) { + 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) { + 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) { + 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) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) +} + +Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) +} + +Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) +} + +Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + 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 must be a Buffer instance') + if (value > max || value < min) throw new RangeError('value 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) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 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) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 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) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + this[offset] = (value & 0xff) + return offset + 1 +} + +function objectWriteUInt16 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) { + buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> + (littleEndian ? i : 1 - i) * 8 + } +} + +Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 +} + +function objectWriteUInt32 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffffffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) { + buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff + } +} + +Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, true) + } + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + 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 = value < 0 ? 1 : 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + 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 = value < 0 ? 1 : 0 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + 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 (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + } else { + objectWriteUInt32(this, value, offset, true) + } + 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 + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 +} + +function checkIEEE754 (buf, value, offset, ext, max, min) { + if (value > max || value < min) throw new RangeError('value is out of bounds') + 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) { + 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) { + 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 (!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('sourceStart out of bounds') + 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 + var i + + if (this === target && start < targetStart && targetStart < end) { + // descending copy from end + for (i = len - 1; i >= 0; i--) { + target[i + targetStart] = this[i + start] + } + } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { + // ascending copy from start + for (i = 0; i < len; i++) { + target[i + targetStart] = this[i + start] + } + } else { + target._set(this.subarray(start, start + len), targetStart) + } + + return len +} + +// fill(value, start=0, end=buffer.length) +Buffer.prototype.fill = function fill (value, start, end) { + if (!value) value = 0 + if (!start) start = 0 + if (!end) end = this.length + + if (end < start) throw new RangeError('end < start') + + // Fill 0 bytes; we're done + if (end === start) return + if (this.length === 0) return + + if (start < 0 || start >= this.length) throw new RangeError('start out of bounds') + if (end < 0 || end > this.length) throw new RangeError('end out of bounds') + + var i + if (typeof value === 'number') { + for (i = start; i < end; i++) { + this[i] = value + } + } else { + var bytes = utf8ToBytes(value.toString()) + var len = bytes.length + for (i = start; i < end; i++) { + this[i] = bytes[i % len] + } + } + + return this +} + +/** + * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance. + * Added in Node 0.12. Only available in browsers that support ArrayBuffer. + */ +Buffer.prototype.toArrayBuffer = function toArrayBuffer () { + if (typeof Uint8Array !== 'undefined') { + if (Buffer.TYPED_ARRAY_SUPPORT) { + return (new Buffer(this)).buffer + } else { + var buf = new Uint8Array(this.length) + for (var i = 0, len = buf.length; i < len; i += 1) { + buf[i] = this[i] + } + return buf.buffer + } + } else { + throw new TypeError('Buffer.toArrayBuffer not supported in this browser') + } +} + +// HELPER FUNCTIONS +// ================ + +var BP = Buffer.prototype + +/** + * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods + */ +Buffer._augment = function _augment (arr) { + arr.constructor = Buffer + arr._isBuffer = true + + // save reference to original Uint8Array set method before overwriting + arr._set = arr.set + + // deprecated + arr.get = BP.get + arr.set = BP.set + + arr.write = BP.write + arr.toString = BP.toString + arr.toLocaleString = BP.toString + arr.toJSON = BP.toJSON + arr.equals = BP.equals + arr.compare = BP.compare + arr.indexOf = BP.indexOf + arr.copy = BP.copy + arr.slice = BP.slice + arr.readUIntLE = BP.readUIntLE + arr.readUIntBE = BP.readUIntBE + arr.readUInt8 = BP.readUInt8 + arr.readUInt16LE = BP.readUInt16LE + arr.readUInt16BE = BP.readUInt16BE + arr.readUInt32LE = BP.readUInt32LE + arr.readUInt32BE = BP.readUInt32BE + arr.readIntLE = BP.readIntLE + arr.readIntBE = BP.readIntBE + arr.readInt8 = BP.readInt8 + arr.readInt16LE = BP.readInt16LE + arr.readInt16BE = BP.readInt16BE + arr.readInt32LE = BP.readInt32LE + arr.readInt32BE = BP.readInt32BE + arr.readFloatLE = BP.readFloatLE + arr.readFloatBE = BP.readFloatBE + arr.readDoubleLE = BP.readDoubleLE + arr.readDoubleBE = BP.readDoubleBE + arr.writeUInt8 = BP.writeUInt8 + arr.writeUIntLE = BP.writeUIntLE + arr.writeUIntBE = BP.writeUIntBE + arr.writeUInt16LE = BP.writeUInt16LE + arr.writeUInt16BE = BP.writeUInt16BE + arr.writeUInt32LE = BP.writeUInt32LE + arr.writeUInt32BE = BP.writeUInt32BE + arr.writeIntLE = BP.writeIntLE + arr.writeIntBE = BP.writeIntBE + arr.writeInt8 = BP.writeInt8 + arr.writeInt16LE = BP.writeInt16LE + arr.writeInt16BE = BP.writeInt16BE + arr.writeInt32LE = BP.writeInt32LE + arr.writeInt32BE = BP.writeInt32BE + arr.writeFloatLE = BP.writeFloatLE + arr.writeFloatBE = BP.writeFloatBE + arr.writeDoubleLE = BP.writeDoubleLE + arr.writeDoubleBE = BP.writeDoubleBE + arr.fill = BP.fill + arr.inspect = BP.inspect + arr.toArrayBuffer = BP.toArrayBuffer + + return arr +} + +var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g + +function base64clean (str) { + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = stringtrim(str).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 stringtrim (str) { + if (str.trim) return str.trim() + return str.replace(/^\s+|\s+$/g, '') +} + +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 +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"base64-js":27,"ieee754":44,"is-array":46}],39:[function(require,module,exports){ + +/** + * Expose `Emitter`. + */ + +module.exports = Emitter; + +/** + * Initialize a new `Emitter`. + * + * @api public + */ + +function Emitter(obj) { + if (obj) return mixin(obj); +}; + +/** + * Mixin the emitter properties. + * + * @param {Object} obj + * @return {Object} + * @api private + */ + +function mixin(obj) { + for (var key in Emitter.prototype) { + obj[key] = Emitter.prototype[key]; + } + return obj; +} + +/** + * Listen on the given `event` with `fn`. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + +Emitter.prototype.on = +Emitter.prototype.addEventListener = function(event, fn){ + this._callbacks = this._callbacks || {}; + (this._callbacks[event] = this._callbacks[event] || []) + .push(fn); + return this; +}; + +/** + * Adds an `event` listener that will be invoked a single + * time then automatically removed. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + +Emitter.prototype.once = function(event, fn){ + var self = this; + this._callbacks = this._callbacks || {}; + + function on() { + self.off(event, on); + fn.apply(this, arguments); + } + + on.fn = fn; + this.on(event, on); + return this; +}; + +/** + * Remove the given callback for `event` or all + * registered callbacks. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + +Emitter.prototype.off = +Emitter.prototype.removeListener = +Emitter.prototype.removeAllListeners = +Emitter.prototype.removeEventListener = function(event, fn){ + this._callbacks = this._callbacks || {}; + + // all + if (0 == arguments.length) { + this._callbacks = {}; + return this; + } + + // specific event + var callbacks = this._callbacks[event]; + if (!callbacks) return this; + + // remove all handlers + if (1 == arguments.length) { + delete this._callbacks[event]; + return this; + } + + // remove specific handler + var cb; + for (var i = 0; i < callbacks.length; i++) { + cb = callbacks[i]; + if (cb === fn || cb.fn === fn) { + callbacks.splice(i, 1); + break; + } + } + return this; +}; + +/** + * Emit `event` with the given args. + * + * @param {String} event + * @param {Mixed} ... + * @return {Emitter} + */ + +Emitter.prototype.emit = function(event){ + this._callbacks = this._callbacks || {}; + var args = [].slice.call(arguments, 1) + , callbacks = this._callbacks[event]; + + if (callbacks) { + callbacks = callbacks.slice(0); + for (var i = 0, len = callbacks.length; i < len; ++i) { + callbacks[i].apply(this, args); + } + } + + return this; +}; + +/** + * Return array of callbacks for `event`. + * + * @param {String} event + * @return {Array} + * @api public + */ + +Emitter.prototype.listeners = function(event){ + this._callbacks = this._callbacks || {}; + return this._callbacks[event] || []; +}; + +/** + * Check if this emitter has `event` handlers. + * + * @param {String} event + * @return {Boolean} + * @api public + */ + +Emitter.prototype.hasListeners = function(event){ + return !! this.listeners(event).length; +}; + +},{}],40:[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":47}],41:[function(require,module,exports){ + +/** + * This is the web browser implementation of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = require('./debug'); +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; +exports.storage = 'undefined' != typeof chrome + && 'undefined' != typeof chrome.storage + ? chrome.storage.local + : localstorage(); + +/** + * Colors. + */ + +exports.colors = [ + 'lightseagreen', + 'forestgreen', + 'goldenrod', + 'dodgerblue', + 'darkorchid', + 'crimson' +]; + +/** + * Currently only WebKit-based Web Inspectors, Firefox >= v31, + * and the Firebug extension (any Firefox version) are known + * to support "%c" CSS customizations. + * + * TODO: add a `localStorage` variable to explicitly enable/disable colors + */ + +function useColors() { + // is webkit? http://stackoverflow.com/a/16459606/376773 + return ('WebkitAppearance' in document.documentElement.style) || + // is firebug? http://stackoverflow.com/a/398120/376773 + (window.console && (console.firebug || (console.exception && console.table))) || + // is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + (navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31); +} + +/** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ + +exports.formatters.j = function(v) { + return JSON.stringify(v); +}; + + +/** + * Colorize log arguments if enabled. + * + * @api public + */ + +function formatArgs() { + var args = arguments; + var useColors = this.useColors; + + args[0] = (useColors ? '%c' : '') + + this.namespace + + (useColors ? ' %c' : ' ') + + args[0] + + (useColors ? '%c ' : ' ') + + '+' + exports.humanize(this.diff); + + if (!useColors) return args; + + var c = 'color: ' + this.color; + args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1)); + + // the final "%c" is somewhat tricky, because there could be other + // arguments passed either before or after the %c, so we need to + // figure out the correct index to insert the CSS into + var index = 0; + var lastC = 0; + args[0].replace(/%[a-z%]/g, function(match) { + if ('%%' === match) return; + index++; + if ('%c' === match) { + // we only are interested in the *last* %c + // (the user may have provided their own) + lastC = index; + } + }); + + args.splice(lastC, 0, c); + return args; +} + +/** + * Invokes `console.log()` when available. + * No-op when `console.log` is not a "function". + * + * @api public + */ + +function log() { + // this hackery is required for IE8/9, where + // the `console.log` function doesn't have 'apply' + return 'object' === typeof console + && console.log + && Function.prototype.apply.call(console.log, console, arguments); +} + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ + +function save(namespaces) { + try { + if (null == namespaces) { + exports.storage.removeItem('debug'); + } else { + exports.storage.debug = namespaces; + } + } catch(e) {} +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + +function load() { + var r; + try { + r = exports.storage.debug; + } catch(e) {} + return r; +} + +/** + * Enable namespaces listed in `localStorage.debug` initially. + */ + +exports.enable(load()); + +/** + * Localstorage attempts to return the localstorage. + * + * This is necessary because safari throws + * when a user disables cookies/localstorage + * and you attempt to access it. + * + * @return {LocalStorage} + * @api private + */ + +function localstorage(){ + try { + return window.localStorage; + } catch (e) {} +} + +},{"./debug":42}],42:[function(require,module,exports){ + +/** + * This is the common logic for both the Node.js and web browser + * implementations of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = debug; +exports.coerce = coerce; +exports.disable = disable; +exports.enable = enable; +exports.enabled = enabled; +exports.humanize = require('ms'); + +/** + * The currently active debug mode names, and names to skip. + */ + +exports.names = []; +exports.skips = []; + +/** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lowercased letter, i.e. "n". + */ + +exports.formatters = {}; + +/** + * Previously assigned color. + */ + +var prevColor = 0; + +/** + * Previous log timestamp. + */ + +var prevTime; + +/** + * Select a color. + * + * @return {Number} + * @api private + */ + +function selectColor() { + return exports.colors[prevColor++ % exports.colors.length]; +} + +/** + * Create a debugger with the given `namespace`. + * + * @param {String} namespace + * @return {Function} + * @api public + */ + +function debug(namespace) { + + // define the `disabled` version + function disabled() { + } + disabled.enabled = false; + + // define the `enabled` version + function enabled() { + + var self = enabled; + + // set `diff` timestamp + var curr = +new Date(); + var ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + + // add the `color` if not set + if (null == self.useColors) self.useColors = exports.useColors(); + if (null == self.color && self.useColors) self.color = selectColor(); + + var args = Array.prototype.slice.call(arguments); + + args[0] = exports.coerce(args[0]); + + if ('string' !== typeof args[0]) { + // anything else let's inspect with %o + args = ['%o'].concat(args); + } + + // apply any `formatters` transformations + var index = 0; + args[0] = args[0].replace(/%([a-z%])/g, function(match, format) { + // if we encounter an escaped % then don't increase the array index + if (match === '%%') return match; + index++; + var formatter = exports.formatters[format]; + if ('function' === typeof formatter) { + var val = args[index]; + match = formatter.call(self, val); + + // now we need to remove `args[index]` since it's inlined in the `format` + args.splice(index, 1); + index--; + } + return match; + }); + + if ('function' === typeof exports.formatArgs) { + args = exports.formatArgs.apply(self, args); + } + var logFn = enabled.log || exports.log || console.log.bind(console); + logFn.apply(self, args); + } + enabled.enabled = true; + + var fn = exports.enabled(namespace) ? enabled : disabled; + + fn.namespace = namespace; + + return fn; +} + +/** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + * + * @param {String} namespaces + * @api public + */ + +function enable(namespaces) { + exports.save(namespaces); + + var split = (namespaces || '').split(/[\s,]+/); + var len = split.length; + + for (var i = 0; i < len; i++) { + if (!split[i]) continue; // ignore empty strings + namespaces = split[i].replace(/\*/g, '.*?'); + if (namespaces[0] === '-') { + exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); + } else { + exports.names.push(new RegExp('^' + namespaces + '$')); + } + } +} + +/** + * Disable debug output. + * + * @api public + */ + +function disable() { + exports.enable(''); +} + +/** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + +function enabled(name) { + var i, len; + for (i = 0, len = exports.skips.length; i < len; i++) { + if (exports.skips[i].test(name)) { + return false; + } + } + for (i = 0, len = exports.names.length; i < len; i++) { + if (exports.names[i].test(name)) { + return true; + } + } + return false; +} + +/** + * Coerce `val`. + * + * @param {Mixed} val + * @return {Mixed} + * @api private + */ + +function coerce(val) { + if (val instanceof Error) return val.stack || val.message; + return val; +} + +},{"ms":49}],43:[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. + +function EventEmitter() { + this._events = this._events || {}; + 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. +EventEmitter.defaultMaxListeners = 10; + +// 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(n) { + if (!isNumber(n) || n < 0 || isNaN(n)) + throw TypeError('n must be a positive number'); + this._maxListeners = n; + return this; +}; + +EventEmitter.prototype.emit = function(type) { + var er, handler, len, args, i, listeners; + + if (!this._events) + this._events = {}; + + // If there is no 'error' event listener then throw. + if (type === 'error') { + if (!this._events.error || + (isObject(this._events.error) && !this._events.error.length)) { + er = arguments[1]; + if (er instanceof Error) { + throw er; // Unhandled 'error' event + } + throw TypeError('Uncaught, unspecified "error" event.'); + } + } + + handler = this._events[type]; + + if (isUndefined(handler)) + return false; + + if (isFunction(handler)) { + switch (arguments.length) { + // fast cases + case 1: + handler.call(this); + break; + case 2: + handler.call(this, arguments[1]); + break; + case 3: + handler.call(this, arguments[1], arguments[2]); + break; + // slower + default: + len = arguments.length; + args = new Array(len - 1); + for (i = 1; i < len; i++) + args[i - 1] = arguments[i]; + handler.apply(this, args); + } + } else if (isObject(handler)) { + len = arguments.length; + args = new Array(len - 1); + for (i = 1; i < len; i++) + args[i - 1] = arguments[i]; + + listeners = handler.slice(); + len = listeners.length; + for (i = 0; i < len; i++) + listeners[i].apply(this, args); + } + + return true; +}; + +EventEmitter.prototype.addListener = function(type, listener) { + var m; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events) + this._events = {}; + + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (this._events.newListener) + this.emit('newListener', type, + isFunction(listener.listener) ? + listener.listener : listener); + + if (!this._events[type]) + // Optimize the case of one listener. Don't need the extra array object. + this._events[type] = listener; + else if (isObject(this._events[type])) + // If we've already got an array, just append. + this._events[type].push(listener); + else + // Adding the second element, need to change to array. + this._events[type] = [this._events[type], listener]; + + // Check for listener leak + if (isObject(this._events[type]) && !this._events[type].warned) { + var m; + if (!isUndefined(this._maxListeners)) { + m = this._maxListeners; + } else { + m = EventEmitter.defaultMaxListeners; + } + + if (m && m > 0 && this._events[type].length > m) { + this._events[type].warned = true; + console.error('(node) warning: possible EventEmitter memory ' + + 'leak detected. %d listeners added. ' + + 'Use emitter.setMaxListeners() to increase limit.', + this._events[type].length); + if (typeof console.trace === 'function') { + // not supported in IE 10 + console.trace(); + } + } + } + + return this; +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.once = function(type, listener) { + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + var fired = false; + + function g() { + this.removeListener(type, g); + + if (!fired) { + fired = true; + listener.apply(this, arguments); + } + } + + g.listener = listener; + this.on(type, g); + + return this; +}; + +// emits a 'removeListener' event iff the listener was removed +EventEmitter.prototype.removeListener = function(type, listener) { + var list, position, length, i; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events || !this._events[type]) + return this; + + list = this._events[type]; + length = list.length; + position = -1; + + if (list === listener || + (isFunction(list.listener) && list.listener === listener)) { + delete this._events[type]; + if (this._events.removeListener) + this.emit('removeListener', type, listener); + + } else if (isObject(list)) { + for (i = length; i-- > 0;) { + if (list[i] === listener || + (list[i].listener && list[i].listener === listener)) { + position = i; + break; + } + } + + if (position < 0) + return this; + + if (list.length === 1) { + list.length = 0; + delete this._events[type]; + } else { + list.splice(position, 1); + } + + if (this._events.removeListener) + this.emit('removeListener', type, listener); + } + + return this; +}; + +EventEmitter.prototype.removeAllListeners = function(type) { + var key, listeners; + + if (!this._events) + return this; + + // not listening for removeListener, no need to emit + if (!this._events.removeListener) { + if (arguments.length === 0) + this._events = {}; + else if (this._events[type]) + delete this._events[type]; + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (key in this._events) { + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = {}; + return this; + } + + listeners = this._events[type]; + + if (isFunction(listeners)) { + this.removeListener(type, listeners); + } else { + // LIFO order + while (listeners.length) + this.removeListener(type, listeners[listeners.length - 1]); + } + delete this._events[type]; + + return this; +}; + +EventEmitter.prototype.listeners = function(type) { + var ret; + if (!this._events || !this._events[type]) + ret = []; + else if (isFunction(this._events[type])) + ret = [this._events[type]]; + else + ret = this._events[type].slice(); + return ret; +}; + +EventEmitter.listenerCount = function(emitter, type) { + var ret; + if (!emitter._events || !emitter._events[type]) + ret = 0; + else if (isFunction(emitter._events[type])) + ret = 1; + else + ret = emitter._events[type].length; + return ret; +}; + +function isFunction(arg) { + return typeof arg === 'function'; +} + +function isNumber(arg) { + return typeof arg === 'number'; +} + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} + +function isUndefined(arg) { + return arg === void 0; +} + +},{}],44:[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 +} + +},{}],45:[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 + } +} + +},{}],46:[function(require,module,exports){ + +/** + * isArray + */ + +var isArray = Array.isArray; + +/** + * toString + */ + +var str = Object.prototype.toString; + +/** + * Whether or not the given `val` + * is an array. + * + * example: + * + * isArray([]); + * // > true + * isArray(arguments); + * // > false + * isArray(''); + * // > false + * + * @param {mixed} val + * @return {bool} + */ + +module.exports = isArray || function (val) { + return !! val && '[object Array]' == str.call(val); +}; + +},{}],47:[function(require,module,exports){ +/** + * Determine if an object is Buffer + * + * Author: Feross Aboukhadijeh + * License: MIT + * + * `npm install is-buffer` + */ + +module.exports = function (obj) { + return !!(obj != null && + (obj._isBuffer || // For Safari 5-7 (missing Object.prototype.constructor) + (obj.constructor && + typeof obj.constructor.isBuffer === 'function' && + obj.constructor.isBuffer(obj)) + )) +} + +},{}],48:[function(require,module,exports){ +module.exports = Array.isArray || function (arr) { + return Object.prototype.toString.call(arr) == '[object Array]'; +}; + +},{}],49:[function(require,module,exports){ +/** + * Helpers. + */ + +var s = 1000; +var m = s * 60; +var h = m * 60; +var d = h * 24; +var y = d * 365.25; + +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} options + * @return {String|Number} + * @api public + */ + +module.exports = function(val, options){ + options = options || {}; + if ('string' == typeof val) return parse(val); + return options.long + ? long(val) + : short(val); +}; + +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + +function parse(str) { + str = '' + str; + if (str.length > 10000) return; + var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str); + if (!match) return; + var n = parseFloat(match[1]); + var type = (match[2] || 'ms').toLowerCase(); + switch (type) { + case 'years': + case 'year': + case 'yrs': + case 'yr': + case 'y': + return n * y; + case 'days': + case 'day': + case 'd': + return n * d; + case 'hours': + case 'hour': + case 'hrs': + case 'hr': + case 'h': + return n * h; + case 'minutes': + case 'minute': + case 'mins': + case 'min': + case 'm': + return n * m; + case 'seconds': + case 'second': + case 'secs': + case 'sec': + case 's': + return n * s; + case 'milliseconds': + case 'millisecond': + case 'msecs': + case 'msec': + case 'ms': + return n; + } +} + +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function short(ms) { + if (ms >= d) return Math.round(ms / d) + 'd'; + if (ms >= h) return Math.round(ms / h) + 'h'; + if (ms >= m) return Math.round(ms / m) + 'm'; + if (ms >= s) return Math.round(ms / s) + 's'; + return ms + 'ms'; +} + +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function long(ms) { + return plural(ms, d, 'day') + || plural(ms, h, 'hour') + || plural(ms, m, 'minute') + || plural(ms, s, 'second') + || ms + ' ms'; +} + +/** + * Pluralization helper. + */ + +function plural(ms, n, name) { + if (ms < n) return; + if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name; + return Math.ceil(ms / n) + ' ' + name + 's'; +} + +},{}],50:[function(require,module,exports){ + +"use strict"; + +var OpusEncoder = require( './lib/OpusEncoder' ); +var Encoder = require( './lib/Encoder' ); +var Decoder = require( './lib/Decoder' ); + +exports.OpusEncoder = OpusEncoder; +exports.Encoder = Encoder; +exports.Decoder = Decoder; + + +},{"./lib/Decoder":51,"./lib/Encoder":52,"./lib/OpusEncoder":53}],51:[function(require,module,exports){ + +var util = require( 'util' ); +var Transform = require( 'stream' ).Transform; +var ogg_packet = require( 'ogg-packet' ); + +var OpusEncoder = require( './OpusEncoder' ); + +var Decoder = function( rate, channels, frameSize ) { + Transform.call( this, { readableObjectMode: true } ); + + this.rate = rate || 48000; + this.channels = channels || 1; + this.frameSize = frameSize || this.rate * 0.04; + + this.encoder = null; + + this.header = {}; + this.tags = null; + this.pos = 0; + this.samplesWritten = 0; + + this.packetBuffer = []; +}; +util.inherits( Decoder, Transform ); + +/** + * Transform stream callback + */ +Decoder.prototype._transform = function( packet, encoding, done ) { + + // Write the header if it hasn't been written yet + if( !this.encoder ) { + this._parseHeader( packet ); + } else if( !this.tags ) { + // TODO: Not implemented + // this._parseTags( packet ); + this.tags = {}; + } else { + this._processInput( packet ); + } + + done(); +}; + +Decoder.prototype._parseHeader = function( packet ) { + + var header = packet.packet; + + var signature = header.slice( 0, 8 ); + if( signature.toString( 'ascii' ) !== 'OpusHead' ) { + return this.emit( 'error', 'Bad header' ); + } + + this.header.version = header.readUInt8( 8 ); + this.header.channels = header.readUInt8( 9 ); + this.header.preSkip = header.readUInt16LE( 10 ); + this.header.rate = header.readUInt32LE( 12 ); + this.header.gain = header.readUInt16LE( 16 ); + this.header.channelMap = header.readUInt8( 18 ); + + this.emit( 'format', { + channels: this.header.channels, + sampleRate: this.header.rate, + bitDepth: 16, + float: false, + signed: true, + + gain: this.header.gain, + preSkip: this.header.preSkip, + version: this.header.version + }); + + this.encoder = new OpusEncoder( this.header.rate, this.header.channels ); +}; + +Decoder.prototype._processInput = function( packet ) { + + var frame = packet.packet; + + var pcm = this.encoder.decode( frame ); + this.push( pcm ); +}; + +module.exports = Decoder; + + + +},{"./OpusEncoder":53,"ogg-packet":54,"stream":75,"util":90}],52:[function(require,module,exports){ +(function (Buffer){ + +var util = require( 'util' ); +var Transform = require( 'stream' ).Transform; +var ogg_packet = require( 'ogg-packet' ); +var OpusEncoder = require( './OpusEncoder' ); + +var Encoder = function( rate, channels, frameSize ) { + Transform.call( this, { readableObjectMode: true } ); + + this.rate = rate || 48000; + this.channels = channels || 1; + this.frameSize = frameSize || this.rate * 0.04; + + this.encoder = new OpusEncoder( this.rate, this.channels ); + this.frameOverflow = new Buffer(0); + + this.headerWritten = false; + this.pos = 0; + this.samplesWritten = 0; +}; +util.inherits( Encoder, Transform ); + +/** + * Transform stream callback + */ +Encoder.prototype._transform = function( buf, encoding, done ) { + + // Write the header if it hasn't been written yet + if( !this.headerWritten ) { + this._writeHeader(); + } + + // Transform the buffer + this._processOutput( buf ); + + done(); +}; + +Encoder.prototype._writeHeader = function() { + + // OpusHead packet + var magicSignature = new Buffer( 'OpusHead', 'ascii' ); + var data = new Buffer([ + 0x01, // version + this.channels, + 0x00, 0x00, // Preskip (TODO: how do we get this?) + ( ( this.rate & 0x000000ff ) >> 0 ), + ( ( this.rate & 0x0000ff00 ) >> 8 ), + ( ( this.rate & 0x00ff0000 ) >> 16 ), + ( ( this.rate & 0xff000000 ) >> 24 ), + 0x00, 0x00, // gain + 0x00, // Channel mappign (RTP, mono/stereo) + ]); + + var header = Buffer.concat([ magicSignature, data ]); + + + var packet = new ogg_packet(); + packet.packet = header; + packet.bytes = header.length; + packet.b_o_s = 1; + packet.e_o_s = 0; + packet.granulepos = 0; + packet.packetno = this.pos++; + //packet.flush = true; + + this.push( packet ); + + // OpusTags packet + magicSignature = new Buffer( 'OpusTags', 'ascii' ); + var vendor = new Buffer( 'node-opus', 'ascii' ); + var vendorLength = new Buffer( 4 ); + vendorLength.writeUInt32LE( vendor.length, 0 ); + var commentLength = new Buffer( 4 ); + commentLength.writeUInt32LE( 0, 0 ); + + header = new Buffer.concat([ + magicSignature, vendorLength, vendor, commentLength, new Buffer([ 0xff ]) + ]); + + packet = new ogg_packet(); + packet.packet = header; + packet.bytes = header.length; + packet.b_o_s = 0; + packet.e_o_s = 0; + packet.granulepos = 0; + packet.packetno = this.pos++; + packet.flush = true; + + this.push( packet ); + + this.headerWritten = true; +}; + +Encoder.prototype._processOutput = function( buf ) { + + // Calculate the total data available and data required for each frame. + var totalData = buf.length + this.frameOverflow.length; + var requiredData = this.frameSize * 2 * this.channels; + + // Process output while we got enough for a frame. + while( totalData >= requiredData ) { + + // If we got overflow, use it up first. + var buffer; + if( this.frameOverflow ) { + + buffer = Buffer.concat([ + this.frameOverflow, + buf.slice( 0, requiredData - this.frameOverflow.length ) + ]); + + // Cut the already used part off the buf. + buf = buf.slice( requiredData - this.frameOverflow.length ); + + // Remove overflow. We'll set it later so it'll never be null + // outside of this function. + this.frameOverflow = null; + + } else { + + // We got no overflow. + // Just cut the required bits from the buffer + buffer = buf.slice( 0, requiredData ); + buf = buf.slice( requiredData ); + } + + // Flush frame and remove bits from the total data counter before + // repeating loop. + this._flushFrame( buffer ); + totalData -= requiredData; + } + + // Store the remainign buffer in the overflow. + this.frameOverflow = buf; +}; + +Encoder.prototype._flushFrame = function( frame, end ) { + + var encoded = this.encoder.encode( frame ); + + var packet = new ogg_packet(); + packet.packet = encoded; + packet.bytes = encoded.length, + packet.b_o_s = 0; + packet.e_o_s = 0; + packet.granulepos = this.samplesWritten; + packet.packetno = this.pos++; + packet.flush = true; + + this.samplesWritten += this.frameSize; + + this.push( packet ); +}; + +Encoder.prototype._flush = function( done ) { + + var packet = new ogg_packet(); + packet.packet = new Buffer(0); + packet.bytes = 0; + packet.b_o_s = 0; + packet.e_o_s = 1; + packet.granulepos = this.pos; + packet.packetno = this.pos++; + packet.flush = true; + + this.push( packet ); + + done(); +}; + +module.exports = Encoder; + +}).call(this,require("buffer").Buffer) +},{"./OpusEncoder":53,"buffer":38,"ogg-packet":54,"stream":75,"util":90}],53:[function(require,module,exports){ + +"use strict"; + +var binding = require('bindings')('node-opus'); +module.exports = binding.OpusEncoder; + +},{"bindings":28}],54:[function(require,module,exports){ + +/** + * Module dependencies. + */ + +var Struct = require('ref-struct'); + +/** + * `ogg_packet` is used to encapsulate the data and metadata belonging + * to a single raw Ogg/Vorbis packet. + * + * typedef struct { + * unsigned char *packet; + * long bytes; + * long b_o_s; + * long e_o_s; + * + * ogg_int64_t granulepos; + * + * ogg_int64_t packetno; sequence number for decode; the framing + * knows where there's a hole in the data, + * but we need coupling so that the codec + * (which is in a separate abstraction + * layer) also knows about the gap + * } ogg_packet; + */ + +module.exports = Struct({ + packet: 'uchar *', + bytes: 'long', + b_o_s: 'long', + e_o_s: 'long', + granulepos: 'int64', + packetno: 'int64' +}); + +},{"ref-struct":73}],55:[function(require,module,exports){ +'use strict'; + + +var TYPED_OK = (typeof Uint8Array !== 'undefined') && + (typeof Uint16Array !== 'undefined') && + (typeof Int32Array !== 'undefined'); + + +exports.assign = function (obj /*from1, from2, from3, ...*/) { + var sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + var source = sources.shift(); + if (!source) { continue; } + + if (typeof source !== 'object') { + throw new TypeError(source + 'must be non-object'); + } + + for (var p in source) { + if (source.hasOwnProperty(p)) { + obj[p] = source[p]; + } + } + } + + return obj; +}; + + +// reduce buffer size, avoiding mem copy +exports.shrinkBuf = function (buf, size) { + if (buf.length === size) { return buf; } + if (buf.subarray) { return buf.subarray(0, size); } + buf.length = size; + return buf; +}; + + +var fnTyped = { + arraySet: function (dest, src, src_offs, len, dest_offs) { + if (src.subarray && dest.subarray) { + dest.set(src.subarray(src_offs, src_offs+len), dest_offs); + return; + } + // Fallback to ordinary array + for (var i=0; i>> 16) & 0xffff) |0, + n = 0; + + while (len !== 0) { + // Set limit ~ twice less than 5552, to keep + // s2 in 31-bits, because we force signed ints. + // in other case %= will fail. + n = len > 2000 ? 2000 : len; + len -= n; + + do { + s1 = (s1 + buf[pos++]) |0; + s2 = (s2 + s1) |0; + } while (--n); + + s1 %= 65521; + s2 %= 65521; + } + + return (s1 | (s2 << 16)) |0; +} + + +module.exports = adler32; + +},{}],57:[function(require,module,exports){ +module.exports = { + + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + + /* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + //Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + //Z_VERSION_ERROR: -6, + + /* compression levels */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + + + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + + /* Possible values of the data_type field (though see inflate()) */ + Z_BINARY: 0, + Z_TEXT: 1, + //Z_ASCII: 1, // = Z_TEXT (deprecated) + Z_UNKNOWN: 2, + + /* The deflate compression method */ + Z_DEFLATED: 8 + //Z_NULL: null // Use -1 or null inline, depending on var type +}; + +},{}],58:[function(require,module,exports){ +'use strict'; + +// Note: we can't get significant speed boost here. +// So write code to minimize size - no pregenerated tables +// and array tools dependencies. + + +// Use ordinary array, since untyped makes no boost here +function makeTable() { + var c, table = []; + + for (var n =0; n < 256; n++) { + c = n; + for (var k =0; k < 8; k++) { + c = ((c&1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1)); + } + table[n] = c; + } + + return table; +} + +// Create table on load. Just 255 signed longs. Not a problem. +var crcTable = makeTable(); + + +function crc32(crc, buf, len, pos) { + var t = crcTable, + end = pos + len; + + crc = crc ^ (-1); + + for (var i = pos; i < end; i++) { + crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF]; + } + + return (crc ^ (-1)); // >>> 0; +} + + +module.exports = crc32; + +},{}],59:[function(require,module,exports){ +'use strict'; + +var utils = require('../utils/common'); +var trees = require('./trees'); +var adler32 = require('./adler32'); +var crc32 = require('./crc32'); +var msg = require('./messages'); + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +/* Allowed flush values; see deflate() and inflate() below for details */ +var Z_NO_FLUSH = 0; +var Z_PARTIAL_FLUSH = 1; +//var Z_SYNC_FLUSH = 2; +var Z_FULL_FLUSH = 3; +var Z_FINISH = 4; +var Z_BLOCK = 5; +//var Z_TREES = 6; + + +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ +var Z_OK = 0; +var Z_STREAM_END = 1; +//var Z_NEED_DICT = 2; +//var Z_ERRNO = -1; +var Z_STREAM_ERROR = -2; +var Z_DATA_ERROR = -3; +//var Z_MEM_ERROR = -4; +var Z_BUF_ERROR = -5; +//var Z_VERSION_ERROR = -6; + + +/* compression levels */ +//var Z_NO_COMPRESSION = 0; +//var Z_BEST_SPEED = 1; +//var Z_BEST_COMPRESSION = 9; +var Z_DEFAULT_COMPRESSION = -1; + + +var Z_FILTERED = 1; +var Z_HUFFMAN_ONLY = 2; +var Z_RLE = 3; +var Z_FIXED = 4; +var Z_DEFAULT_STRATEGY = 0; + +/* Possible values of the data_type field (though see inflate()) */ +//var Z_BINARY = 0; +//var Z_TEXT = 1; +//var Z_ASCII = 1; // = Z_TEXT +var Z_UNKNOWN = 2; + + +/* The deflate compression method */ +var Z_DEFLATED = 8; + +/*============================================================================*/ + + +var MAX_MEM_LEVEL = 9; +/* Maximum value for memLevel in deflateInit2 */ +var MAX_WBITS = 15; +/* 32K LZ77 window */ +var DEF_MEM_LEVEL = 8; + + +var LENGTH_CODES = 29; +/* number of length codes, not counting the special END_BLOCK code */ +var LITERALS = 256; +/* number of literal bytes 0..255 */ +var L_CODES = LITERALS + 1 + LENGTH_CODES; +/* number of Literal or Length codes, including the END_BLOCK code */ +var D_CODES = 30; +/* number of distance codes */ +var BL_CODES = 19; +/* number of codes used to transfer the bit lengths */ +var HEAP_SIZE = 2*L_CODES + 1; +/* maximum heap size */ +var MAX_BITS = 15; +/* All codes must not exceed MAX_BITS bits */ + +var MIN_MATCH = 3; +var MAX_MATCH = 258; +var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1); + +var PRESET_DICT = 0x20; + +var INIT_STATE = 42; +var EXTRA_STATE = 69; +var NAME_STATE = 73; +var COMMENT_STATE = 91; +var HCRC_STATE = 103; +var BUSY_STATE = 113; +var FINISH_STATE = 666; + +var BS_NEED_MORE = 1; /* block not completed, need more input or more output */ +var BS_BLOCK_DONE = 2; /* block flush performed */ +var BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */ +var BS_FINISH_DONE = 4; /* finish done, accept no more input or output */ + +var OS_CODE = 0x03; // Unix :) . Don't detect, use this default. + +function err(strm, errorCode) { + strm.msg = msg[errorCode]; + return errorCode; +} + +function rank(f) { + return ((f) << 1) - ((f) > 4 ? 9 : 0); +} + +function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } + + +/* ========================================================================= + * Flush as much pending output as possible. All deflate() output goes + * through this function so some applications may wish to modify it + * to avoid allocating a large strm->output buffer and copying into it. + * (See also read_buf()). + */ +function flush_pending(strm) { + var s = strm.state; + + //_tr_flush_bits(s); + var len = s.pending; + if (len > strm.avail_out) { + len = strm.avail_out; + } + if (len === 0) { return; } + + utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out); + strm.next_out += len; + s.pending_out += len; + strm.total_out += len; + strm.avail_out -= len; + s.pending -= len; + if (s.pending === 0) { + s.pending_out = 0; + } +} + + +function flush_block_only (s, last) { + trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last); + s.block_start = s.strstart; + flush_pending(s.strm); +} + + +function put_byte(s, b) { + s.pending_buf[s.pending++] = b; +} + + +/* ========================================================================= + * Put a short in the pending buffer. The 16-bit value is put in MSB order. + * IN assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +function putShortMSB(s, b) { +// put_byte(s, (Byte)(b >> 8)); +// put_byte(s, (Byte)(b & 0xff)); + s.pending_buf[s.pending++] = (b >>> 8) & 0xff; + s.pending_buf[s.pending++] = b & 0xff; +} + + +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->input buffer and copying from it. + * (See also flush_pending()). + */ +function read_buf(strm, buf, start, size) { + var len = strm.avail_in; + + if (len > size) { len = size; } + if (len === 0) { return 0; } + + strm.avail_in -= len; + + utils.arraySet(buf, strm.input, strm.next_in, len, start); + if (strm.state.wrap === 1) { + strm.adler = adler32(strm.adler, buf, len, start); + } + + else if (strm.state.wrap === 2) { + strm.adler = crc32(strm.adler, buf, len, start); + } + + strm.next_in += len; + strm.total_in += len; + + return len; +} + + +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + * OUT assertion: the match length is not greater than s->lookahead. + */ +function longest_match(s, cur_match) { + var chain_length = s.max_chain_length; /* max hash chain length */ + var scan = s.strstart; /* current string */ + var match; /* matched string */ + var len; /* length of current match */ + var best_len = s.prev_length; /* best match length so far */ + var nice_match = s.nice_match; /* stop if match long enough */ + var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ? + s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/; + + var _win = s.window; // shortcut + + var wmask = s.w_mask; + var prev = s.prev; + + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + + var strend = s.strstart + MAX_MATCH; + var scan_end1 = _win[scan + best_len - 1]; + var scan_end = _win[scan + best_len]; + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ + if (nice_match > s.lookahead) { nice_match = s.lookahead; } + + // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + do { + // Assert(cur_match < s->strstart, "no future"); + match = cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2. Note that the checks below + * for insufficient lookahead only occur occasionally for performance + * reasons. Therefore uninitialized memory will be accessed, and + * conditional jumps will be made that depend on those values. + * However the length of the match is limited to the lookahead, so + * the output of deflate is not affected by the uninitialized values. + */ + + if (_win[match + best_len] !== scan_end || + _win[match + best_len - 1] !== scan_end1 || + _win[match] !== _win[scan] || + _win[++match] !== _win[scan + 1]) { + continue; + } + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2; + match++; + // Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + /*jshint noempty:false*/ + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + scan < strend); + + // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + + if (len > best_len) { + s.match_start = cur_match; + best_len = len; + if (len >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; + } + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; +} + + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +function fill_window(s) { + var _w_size = s.w_size; + var p, n, m, more, str; + + //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); + + do { + more = s.window_size - s.lookahead - s.strstart; + + // JS ints have 32 bit, block below not needed + /* Deal with !@#$% 64K limit: */ + //if (sizeof(int) <= 2) { + // if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + // more = wsize; + // + // } else if (more == (unsigned)(-1)) { + // /* Very unlikely, but possible on 16 bit machine if + // * strstart == 0 && lookahead == 1 (input done a byte at time) + // */ + // more--; + // } + //} + + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { + + utils.arraySet(s.window, s.window, _w_size, _w_size, 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + /* we now have strstart >= MAX_DIST */ + s.block_start -= _w_size; + + /* Slide the hash table (could be avoided with 32 bit values + at the expense of memory usage). We slide even when level == 0 + to keep the hash table consistent if we switch back to level > 0 + later. (Using level 0 permanently is not an optimal usage of + zlib, so we don't care about this pathological case.) + */ + + n = s.hash_size; + p = n; + do { + m = s.head[--p]; + s.head[p] = (m >= _w_size ? m - _w_size : 0); + } while (--n); + + n = _w_size; + p = n; + do { + m = s.prev[--p]; + s.prev[p] = (m >= _w_size ? m - _w_size : 0); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } while (--n); + + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + * more == window_size - lookahead - strstart + * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + * => more >= window_size - 2*WSIZE + 2 + * In the BIG_MEM or MMAP case (not yet supported), + * window_size == input_size + MIN_LOOKAHEAD && + * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + * Otherwise, window_size == 2*WSIZE so more >= 2. + * If there was sliding, more >= WSIZE. So in all cases, more >= 2. + */ + //Assert(more >= 2, "more < 2"); + n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s.lookahead + s.insert >= MIN_MATCH) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + + /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask; +//#if MIN_MATCH != 3 +// Call update_hash() MIN_MATCH-3 more times +//#endif + while (s.insert) { + /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH-1]) & s.hash_mask; + + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH) { + break; + } + } + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. + */ + + } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); + + /* If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by + * the longest match routines. Update the high water mark for the next + * time through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ +// if (s.high_water < s.window_size) { +// var curr = s.strstart + s.lookahead; +// var init = 0; +// +// if (s.high_water < curr) { +// /* Previous high water mark below current data -- zero WIN_INIT +// * bytes or up to end of window, whichever is less. +// */ +// init = s.window_size - curr; +// if (init > WIN_INIT) +// init = WIN_INIT; +// zmemzero(s->window + curr, (unsigned)init); +// s->high_water = curr + init; +// } +// else if (s->high_water < (ulg)curr + WIN_INIT) { +// /* High water mark at or above current data, but below current data +// * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up +// * to end of window, whichever is less. +// */ +// init = (ulg)curr + WIN_INIT - s->high_water; +// if (init > s->window_size - s->high_water) +// init = s->window_size - s->high_water; +// zmemzero(s->window + s->high_water, (unsigned)init); +// s->high_water += init; +// } +// } +// +// Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, +// "not enough room for search"); +} + +/* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. + * This function does not insert new strings in the dictionary since + * uncompressible data is probably not useful. This function is used + * only for the level=0 compression option. + * NOTE: this function should be optimized to avoid extra copying from + * window to pending_buf. + */ +function deflate_stored(s, flush) { + /* Stored blocks are limited to 0xffff bytes, pending_buf is limited + * to pending_buf_size, and each stored block has a 5 byte header: + */ + var max_block_size = 0xffff; + + if (max_block_size > s.pending_buf_size - 5) { + max_block_size = s.pending_buf_size - 5; + } + + /* Copy as much as possible from input to output: */ + for (;;) { + /* Fill the window as much as possible: */ + if (s.lookahead <= 1) { + + //Assert(s->strstart < s->w_size+MAX_DIST(s) || + // s->block_start >= (long)s->w_size, "slide too late"); +// if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) || +// s.block_start >= s.w_size)) { +// throw new Error("slide too late"); +// } + + fill_window(s); + if (s.lookahead === 0 && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + + if (s.lookahead === 0) { + break; + } + /* flush the current block */ + } + //Assert(s->block_start >= 0L, "block gone"); +// if (s.block_start < 0) throw new Error("block gone"); + + s.strstart += s.lookahead; + s.lookahead = 0; + + /* Emit a stored block if pending_buf will be full: */ + var max_start = s.block_start + max_block_size; + + if (s.strstart === 0 || s.strstart >= max_start) { + /* strstart == 0 is possible when wraparound on 16-bit machine */ + s.lookahead = s.strstart - max_start; + s.strstart = max_start; + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + + + } + /* Flush if we may have to slide, otherwise block_start may become + * negative and the data will be gone: + */ + if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + + s.insert = 0; + + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + + if (s.strstart > s.block_start) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + return BS_NEED_MORE; +} + +/* =========================================================================== + * Compress as much as possible from the input stream, return the current + * block state. + * This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +function deflate_fast(s, flush) { + var hash_head; /* head of the hash chain */ + var bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; /* flush the current block */ + } + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = 0/*NIL*/; + if (s.lookahead >= MIN_MATCH) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s.match_length = longest_match(s, hash_head); + /* longest_match() sets match_start */ + } + if (s.match_length >= MIN_MATCH) { + // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only + + /*** _tr_tally_dist(s, s.strstart - s.match_start, + s.match_length - MIN_MATCH, bflush); ***/ + bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); + + s.lookahead -= s.match_length; + + /* Insert new strings in the hash table only if the match length + * is not too large. This saves time but degrades compression. + */ + if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) { + s.match_length--; /* string at strstart already in table */ + do { + s.strstart++; + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. + */ + } while (--s.match_length !== 0); + s.strstart++; + } else + { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask; + +//#if MIN_MATCH != 3 +// Call UPDATE_HASH() MIN_MATCH-3 more times +//#endif + /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not + * matter since it will be recomputed at next deflate call. + */ + } + } else { + /* No match, output a literal byte */ + //Tracevv((stderr,"%c", s.window[s.strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + + s.lookahead--; + s.strstart++; + } + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = ((s.strstart < (MIN_MATCH-1)) ? s.strstart : MIN_MATCH-1); + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +function deflate_slow(s, flush) { + var hash_head; /* head of hash chain */ + var bflush; /* set if current block must be flushed */ + + var max_insert; + + /* Process the input block. */ + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { break; } /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = 0/*NIL*/; + if (s.lookahead >= MIN_MATCH) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + + /* Find the longest match, discarding those <= prev_length. + */ + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH-1; + + if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match && + s.strstart - hash_head <= (s.w_size-MIN_LOOKAHEAD)/*MAX_DIST(s)*/) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s.match_length = longest_match(s, hash_head); + /* longest_match() sets match_start */ + + if (s.match_length <= 5 && + (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) { + + /* If prev_match is also MIN_MATCH, match_start is garbage + * but we will ignore the current match anyway. + */ + s.match_length = MIN_MATCH-1; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH; + /* Do not insert strings in hash table beyond this. */ + + //check_match(s, s.strstart-1, s.prev_match, s.prev_length); + + /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match, + s.prev_length - MIN_MATCH, bflush);***/ + bflush = trees._tr_tally(s, s.strstart - 1- s.prev_match, s.prev_length - MIN_MATCH); + /* Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not + * enough lookahead, the last two strings are not inserted in + * the hash table. + */ + s.lookahead -= s.prev_length-1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH-1; + s.strstart++; + + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + } else if (s.match_available) { + /* If there was no match at the previous position, output a + * single literal. If there was a match but the current match + * is longer, truncate the previous match to a single literal. + */ + //Tracevv((stderr,"%c", s->window[s->strstart-1])); + /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]); + + if (bflush) { + /*** FLUSH_BLOCK_ONLY(s, 0) ***/ + flush_block_only(s, false); + /***/ + } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + s.match_available = 1; + s.strstart++; + s.lookahead--; + } + } + //Assert (flush != Z_NO_FLUSH, "no flush?"); + if (s.match_available) { + //Tracevv((stderr,"%c", s->window[s->strstart-1])); + /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart-1]); + + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH-1 ? s.strstart : MIN_MATCH-1; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + return BS_BLOCK_DONE; +} + + +/* =========================================================================== + * For Z_RLE, simply look for runs of bytes, generate matches only of distance + * one. Do not maintain a hash table. (It will be regenerated if this run of + * deflate switches away from Z_RLE.) + */ +function deflate_rle(s, flush) { + var bflush; /* set if current block must be flushed */ + var prev; /* byte at distance one to match */ + var scan, strend; /* scan goes up to strend for length of run */ + + var _win = s.window; + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the longest run, plus one for the unrolled loop. + */ + if (s.lookahead <= MAX_MATCH) { + fill_window(s); + if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { break; } /* flush the current block */ + } + + /* See how many times the previous byte repeats */ + s.match_length = 0; + if (s.lookahead >= MIN_MATCH && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH; + do { + /*jshint noempty:false*/ + } while (prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + scan < strend); + s.match_length = MAX_MATCH - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } + } + //Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + } + + /* Emit match if have run of MIN_MATCH or longer, else emit literal */ + if (s.match_length >= MIN_MATCH) { + //check_match(s, s.strstart, s.strstart - 1, s.match_length); + + /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/ + bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH); + + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + /* No match, output a literal byte */ + //Tracevv((stderr,"%c", s->window[s->strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + + s.lookahead--; + s.strstart++; + } + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = 0; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* =========================================================================== + * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. + * (It will be regenerated if this run of deflate switches away from Huffman.) + */ +function deflate_huff(s, flush) { + var bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we have a literal to write. */ + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + break; /* flush the current block */ + } + } + + /* Output a literal byte */ + s.match_length = 0; + //Tracevv((stderr,"%c", s->window[s->strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = 0; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ +var Config = function (good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; +}; + +var configuration_table; + +configuration_table = [ + /* good lazy nice chain */ + new Config(0, 0, 0, 0, deflate_stored), /* 0 store only */ + new Config(4, 4, 8, 4, deflate_fast), /* 1 max speed, no lazy matches */ + new Config(4, 5, 16, 8, deflate_fast), /* 2 */ + new Config(4, 6, 32, 32, deflate_fast), /* 3 */ + + new Config(4, 4, 16, 16, deflate_slow), /* 4 lazy matches */ + new Config(8, 16, 32, 32, deflate_slow), /* 5 */ + new Config(8, 16, 128, 128, deflate_slow), /* 6 */ + new Config(8, 32, 128, 256, deflate_slow), /* 7 */ + new Config(32, 128, 258, 1024, deflate_slow), /* 8 */ + new Config(32, 258, 258, 4096, deflate_slow) /* 9 max compression */ +]; + + +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +function lm_init(s) { + s.window_size = 2 * s.w_size; + + /*** CLEAR_HASH(s); ***/ + zero(s.head); // Fill with NIL (= 0); + + /* Set the default configuration parameters: + */ + s.max_lazy_match = configuration_table[s.level].max_lazy; + s.good_match = configuration_table[s.level].good_length; + s.nice_match = configuration_table[s.level].nice_length; + s.max_chain_length = configuration_table[s.level].max_chain; + + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + s.ins_h = 0; +} + + +function DeflateState() { + this.strm = null; /* pointer back to this zlib stream */ + this.status = 0; /* as the name implies */ + this.pending_buf = null; /* output still pending */ + this.pending_buf_size = 0; /* size of pending_buf */ + this.pending_out = 0; /* next pending byte to output to the stream */ + this.pending = 0; /* nb of bytes in the pending buffer */ + this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ + this.gzhead = null; /* gzip header information to write */ + this.gzindex = 0; /* where in extra, name, or comment */ + this.method = Z_DEFLATED; /* can only be DEFLATED */ + this.last_flush = -1; /* value of flush param for previous deflate call */ + + this.w_size = 0; /* LZ77 window size (32K by default) */ + this.w_bits = 0; /* log2(w_size) (8..16) */ + this.w_mask = 0; /* w_size - 1 */ + + this.window = null; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. + */ + + this.window_size = 0; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + this.prev = null; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + this.head = null; /* Heads of the hash chains or NIL. */ + + this.ins_h = 0; /* hash index of string to be inserted */ + this.hash_size = 0; /* number of elements in hash table */ + this.hash_bits = 0; /* log2(hash_size) */ + this.hash_mask = 0; /* hash_size-1 */ + + this.hash_shift = 0; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + this.block_start = 0; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + this.match_length = 0; /* length of best match */ + this.prev_match = 0; /* previous match */ + this.match_available = 0; /* set if previous match exists */ + this.strstart = 0; /* start of string to insert */ + this.match_start = 0; /* start of matching string */ + this.lookahead = 0; /* number of valid bytes ahead in window */ + + this.prev_length = 0; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + this.max_chain_length = 0; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + this.max_lazy_match = 0; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ + // That's alias to max_lazy_match, don't use directly + //this.max_insert_length = 0; + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + this.level = 0; /* compression level (1..9) */ + this.strategy = 0; /* favor or force Huffman coding*/ + + this.good_match = 0; + /* Use a faster search when the previous match is longer than this */ + + this.nice_match = 0; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + + /* Didn't use ct_data typedef below to suppress compiler warning */ + + // struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + // struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + // Use flat array of DOUBLE size, with interleaved fata, + // because JS does not support effective + this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2); + this.dyn_dtree = new utils.Buf16((2*D_CODES+1) * 2); + this.bl_tree = new utils.Buf16((2*BL_CODES+1) * 2); + zero(this.dyn_ltree); + zero(this.dyn_dtree); + zero(this.bl_tree); + + this.l_desc = null; /* desc. for literal tree */ + this.d_desc = null; /* desc. for distance tree */ + this.bl_desc = null; /* desc. for bit length tree */ + + //ush bl_count[MAX_BITS+1]; + this.bl_count = new utils.Buf16(MAX_BITS+1); + /* number of codes at each bit length for an optimal tree */ + + //int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + this.heap = new utils.Buf16(2*L_CODES+1); /* heap used to build the Huffman trees */ + zero(this.heap); + + this.heap_len = 0; /* number of elements in the heap */ + this.heap_max = 0; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + this.depth = new utils.Buf16(2*L_CODES+1); //uch depth[2*L_CODES+1]; + zero(this.depth); + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + this.l_buf = 0; /* buffer index for literals or lengths */ + + this.lit_bufsize = 0; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + this.last_lit = 0; /* running index in l_buf */ + + this.d_buf = 0; + /* Buffer index for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + this.opt_len = 0; /* bit length of current block with optimal trees */ + this.static_len = 0; /* bit length of current block with static trees */ + this.matches = 0; /* number of string matches in current block */ + this.insert = 0; /* bytes at end of window left to insert */ + + + this.bi_buf = 0; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + this.bi_valid = 0; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + + // Used for window memory init. We safely ignore it for JS. That makes + // sense only for pointers and memory check tools. + //this.high_water = 0; + /* High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when + * longest match routines access bytes past the input. This is then + * updated to the new high water mark. + */ +} + + +function deflateResetKeep(strm) { + var s; + + if (!strm || !strm.state) { + return err(strm, Z_STREAM_ERROR); + } + + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN; + + s = strm.state; + s.pending = 0; + s.pending_out = 0; + + if (s.wrap < 0) { + s.wrap = -s.wrap; + /* was made negative by deflate(..., Z_FINISH); */ + } + s.status = (s.wrap ? INIT_STATE : BUSY_STATE); + strm.adler = (s.wrap === 2) ? + 0 // crc32(0, Z_NULL, 0) + : + 1; // adler32(0, Z_NULL, 0) + s.last_flush = Z_NO_FLUSH; + trees._tr_init(s); + return Z_OK; +} + + +function deflateReset(strm) { + var ret = deflateResetKeep(strm); + if (ret === Z_OK) { + lm_init(strm.state); + } + return ret; +} + + +function deflateSetHeader(strm, head) { + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; } + strm.state.gzhead = head; + return Z_OK; +} + + +function deflateInit2(strm, level, method, windowBits, memLevel, strategy) { + if (!strm) { // === Z_NULL + return Z_STREAM_ERROR; + } + var wrap = 1; + + if (level === Z_DEFAULT_COMPRESSION) { + level = 6; + } + + if (windowBits < 0) { /* suppress zlib wrapper */ + wrap = 0; + windowBits = -windowBits; + } + + else if (windowBits > 15) { + wrap = 2; /* write gzip wrapper instead */ + windowBits -= 16; + } + + + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_FIXED) { + return err(strm, Z_STREAM_ERROR); + } + + + if (windowBits === 8) { + windowBits = 9; + } + /* until 256-byte window bug fixed */ + + var s = new DeflateState(); + + strm.state = s; + s.strm = strm; + + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); + + s.window = new utils.Buf8(s.w_size * 2); + s.head = new utils.Buf16(s.hash_size); + s.prev = new utils.Buf16(s.w_size); + + // Don't need mem init magic for JS. + //s.high_water = 0; /* nothing written to s->window yet */ + + s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ + + s.pending_buf_size = s.lit_bufsize * 4; + s.pending_buf = new utils.Buf8(s.pending_buf_size); + + s.d_buf = s.lit_bufsize >> 1; + s.l_buf = (1 + 2) * s.lit_bufsize; + + s.level = level; + s.strategy = strategy; + s.method = method; + + return deflateReset(strm); +} + +function deflateInit(strm, level) { + return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); +} + + +function deflate(strm, flush) { + var old_flush, s; + var beg, val; // for gzip header write only + + if (!strm || !strm.state || + flush > Z_BLOCK || flush < 0) { + return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR; + } + + s = strm.state; + + if (!strm.output || + (!strm.input && strm.avail_in !== 0) || + (s.status === FINISH_STATE && flush !== Z_FINISH)) { + return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR); + } + + s.strm = strm; /* just in case */ + old_flush = s.last_flush; + s.last_flush = flush; + + /* Write the header */ + if (s.status === INIT_STATE) { + + if (s.wrap === 2) { // GZIP header + strm.adler = 0; //crc32(0L, Z_NULL, 0); + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (!s.gzhead) { // s->gzhead == Z_NULL + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s.level === 9 ? 2 : + (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? + 4 : 0)); + put_byte(s, OS_CODE); + s.status = BUSY_STATE; + } + else { + put_byte(s, (s.gzhead.text ? 1 : 0) + + (s.gzhead.hcrc ? 2 : 0) + + (!s.gzhead.extra ? 0 : 4) + + (!s.gzhead.name ? 0 : 8) + + (!s.gzhead.comment ? 0 : 16) + ); + put_byte(s, s.gzhead.time & 0xff); + put_byte(s, (s.gzhead.time >> 8) & 0xff); + put_byte(s, (s.gzhead.time >> 16) & 0xff); + put_byte(s, (s.gzhead.time >> 24) & 0xff); + put_byte(s, s.level === 9 ? 2 : + (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? + 4 : 0)); + put_byte(s, s.gzhead.os & 0xff); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte(s, s.gzhead.extra.length & 0xff); + put_byte(s, (s.gzhead.extra.length >> 8) & 0xff); + } + if (s.gzhead.hcrc) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE; + } + } + else // DEFLATE header + { + var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8; + var level_flags = -1; + + if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= (level_flags << 6); + if (s.strstart !== 0) { header |= PRESET_DICT; } + header += 31 - (header % 31); + + s.status = BUSY_STATE; + putShortMSB(s, header); + + /* Save the adler32 of the preset dictionary: */ + if (s.strstart !== 0) { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 0xffff); + } + strm.adler = 1; // adler32(0L, Z_NULL, 0); + } + } + +//#ifdef GZIP + if (s.status === EXTRA_STATE) { + if (s.gzhead.extra/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + + while (s.gzindex < (s.gzhead.extra.length & 0xffff)) { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + break; + } + } + put_byte(s, s.gzhead.extra[s.gzindex] & 0xff); + s.gzindex++; + } + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (s.gzindex === s.gzhead.extra.length) { + s.gzindex = 0; + s.status = NAME_STATE; + } + } + else { + s.status = NAME_STATE; + } + } + if (s.status === NAME_STATE) { + if (s.gzhead.name/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + //int val; + + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + // JS specific: little magic to add zero terminator to end of string + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.gzindex = 0; + s.status = COMMENT_STATE; + } + } + else { + s.status = COMMENT_STATE; + } + } + if (s.status === COMMENT_STATE) { + if (s.gzhead.comment/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + //int val; + + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + // JS specific: little magic to add zero terminator to end of string + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.status = HCRC_STATE; + } + } + else { + s.status = HCRC_STATE; + } + } + if (s.status === HCRC_STATE) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending(strm); + } + if (s.pending + 2 <= s.pending_buf_size) { + put_byte(s, strm.adler & 0xff); + put_byte(s, (strm.adler >> 8) & 0xff); + strm.adler = 0; //crc32(0L, Z_NULL, 0); + s.status = BUSY_STATE; + } + } + else { + s.status = BUSY_STATE; + } + } +//#endif + + /* Flush as much pending output as possible */ + if (s.pending !== 0) { + flush_pending(strm); + if (strm.avail_out === 0) { + /* Since avail_out is 0, deflate will be called again with + * more output space, but possibly with both pending and + * avail_in equal to zero. There won't be anything to do, + * but this is not an error situation so make sure we + * return OK instead of BUF_ERROR at next call of deflate: + */ + s.last_flush = -1; + return Z_OK; + } + + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUF_ERROR. + */ + } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && + flush !== Z_FINISH) { + return err(strm, Z_BUF_ERROR); + } + + /* User must not provide more input after the first FINISH: */ + if (s.status === FINISH_STATE && strm.avail_in !== 0) { + return err(strm, Z_BUF_ERROR); + } + + /* Start a new block or continue the current one. + */ + if (strm.avail_in !== 0 || s.lookahead !== 0 || + (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) { + var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) : + (s.strategy === Z_RLE ? deflate_rle(s, flush) : + configuration_table[s.level].func(s, flush)); + + if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { + s.status = FINISH_STATE; + } + if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { + if (strm.avail_out === 0) { + s.last_flush = -1; + /* avoid BUF_ERROR next call, see above */ + } + return Z_OK; + /* If flush != Z_NO_FLUSH && avail_out == 0, the next call + * of deflate should use the same flush parameter to make sure + * that the flush is complete. So we don't have to output an + * empty block here, this will be done at next call. This also + * ensures that for a very small output buffer, we emit at most + * one empty block. + */ + } + if (bstate === BS_BLOCK_DONE) { + if (flush === Z_PARTIAL_FLUSH) { + trees._tr_align(s); + } + else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ + + trees._tr_stored_block(s, 0, 0, false); + /* For a full flush, this empty block will be recognized + * as a special marker by inflate_sync(). + */ + if (flush === Z_FULL_FLUSH) { + /*** CLEAR_HASH(s); ***/ /* forget history */ + zero(s.head); // Fill with NIL (= 0); + + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; + } + } + } + //Assert(strm->avail_out > 0, "bug2"); + //if (strm.avail_out <= 0) { throw new Error("bug2");} + + if (flush !== Z_FINISH) { return Z_OK; } + if (s.wrap <= 0) { return Z_STREAM_END; } + + /* Write the trailer */ + if (s.wrap === 2) { + put_byte(s, strm.adler & 0xff); + put_byte(s, (strm.adler >> 8) & 0xff); + put_byte(s, (strm.adler >> 16) & 0xff); + put_byte(s, (strm.adler >> 24) & 0xff); + put_byte(s, strm.total_in & 0xff); + put_byte(s, (strm.total_in >> 8) & 0xff); + put_byte(s, (strm.total_in >> 16) & 0xff); + put_byte(s, (strm.total_in >> 24) & 0xff); + } + else + { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 0xffff); + } + + flush_pending(strm); + /* If avail_out is zero, the application will call deflate again + * to flush the rest. + */ + if (s.wrap > 0) { s.wrap = -s.wrap; } + /* write the trailer only once! */ + return s.pending !== 0 ? Z_OK : Z_STREAM_END; +} + +function deflateEnd(strm) { + var status; + + if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) { + return Z_STREAM_ERROR; + } + + status = strm.state.status; + if (status !== INIT_STATE && + status !== EXTRA_STATE && + status !== NAME_STATE && + status !== COMMENT_STATE && + status !== HCRC_STATE && + status !== BUSY_STATE && + status !== FINISH_STATE + ) { + return err(strm, Z_STREAM_ERROR); + } + + strm.state = null; + + return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK; +} + +/* ========================================================================= + * Copy the source state to the destination state + */ +//function deflateCopy(dest, source) { +// +//} + +exports.deflateInit = deflateInit; +exports.deflateInit2 = deflateInit2; +exports.deflateReset = deflateReset; +exports.deflateResetKeep = deflateResetKeep; +exports.deflateSetHeader = deflateSetHeader; +exports.deflate = deflate; +exports.deflateEnd = deflateEnd; +exports.deflateInfo = 'pako deflate (from Nodeca project)'; + +/* Not implemented +exports.deflateBound = deflateBound; +exports.deflateCopy = deflateCopy; +exports.deflateSetDictionary = deflateSetDictionary; +exports.deflateParams = deflateParams; +exports.deflatePending = deflatePending; +exports.deflatePrime = deflatePrime; +exports.deflateTune = deflateTune; +*/ + +},{"../utils/common":55,"./adler32":56,"./crc32":58,"./messages":63,"./trees":64}],60:[function(require,module,exports){ +'use strict'; + +// See state defs from inflate.js +var BAD = 30; /* got a data error -- remain here until reset */ +var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ + +/* + Decode literal, length, and distance codes and write out the resulting + literal and match bytes until either not enough input or output is + available, an end-of-block is encountered, or a data error is encountered. + When large enough input and output buffers are supplied to inflate(), for + example, a 16K input buffer and a 64K output buffer, more than 95% of the + inflate execution time is spent in this routine. + + Entry assumptions: + + state.mode === LEN + strm.avail_in >= 6 + strm.avail_out >= 258 + start >= strm.avail_out + state.bits < 8 + + On return, state.mode is one of: + + LEN -- ran out of enough output space or enough available input + TYPE -- reached end of block code, inflate() to interpret next block + BAD -- error in block data + + Notes: + + - The maximum input bits used by a length/distance pair is 15 bits for the + length code, 5 bits for the length extra, 15 bits for the distance code, + and 13 bits for the distance extra. This totals 48 bits, or six bytes. + Therefore if strm.avail_in >= 6, then there is enough input to avoid + checking for available input while decoding. + + - The maximum bytes that a single length/distance pair can output is 258 + bytes, which is the maximum length that can be coded. inflate_fast() + requires strm.avail_out >= 258 for each loop to avoid checking for + output space. + */ +module.exports = function inflate_fast(strm, start) { + var state; + var _in; /* local strm.input */ + var last; /* have enough input while in < last */ + var _out; /* local strm.output */ + var beg; /* inflate()'s initial strm.output */ + var end; /* while out < end, enough space available */ +//#ifdef INFLATE_STRICT + var dmax; /* maximum distance from zlib header */ +//#endif + var wsize; /* window size or zero if not using window */ + var whave; /* valid bytes in the window */ + var wnext; /* window write index */ + // Use `s_window` instead `window`, avoid conflict with instrumentation tools + var s_window; /* allocated sliding window, if wsize != 0 */ + var hold; /* local strm.hold */ + var bits; /* local strm.bits */ + var lcode; /* local strm.lencode */ + var dcode; /* local strm.distcode */ + var lmask; /* mask for first level of length codes */ + var dmask; /* mask for first level of distance codes */ + var here; /* retrieved table entry */ + var op; /* code bits, operation, extra bits, or */ + /* window position, window bytes to copy */ + var len; /* match length, unused bytes */ + var dist; /* match distance */ + var from; /* where to copy match from */ + var from_source; + + + var input, output; // JS specific, because we have no pointers + + /* copy state to local variables */ + state = strm.state; + //here = state.here; + _in = strm.next_in; + input = strm.input; + last = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); +//#ifdef INFLATE_STRICT + dmax = state.dmax; +//#endif + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + + + /* decode literals and length/distances until end-of-block or not enough + input data or output space */ + + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + + here = lcode[hold & lmask]; + + dolen: + for (;;) { // Goto emulation + op = here >>> 24/*here.bits*/; + hold >>>= op; + bits -= op; + op = (here >>> 16) & 0xff/*here.op*/; + if (op === 0) { /* literal */ + //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + // "inflate: literal '%c'\n" : + // "inflate: literal 0x%02x\n", here.val)); + output[_out++] = here & 0xffff/*here.val*/; + } + else if (op & 16) { /* length base */ + len = here & 0xffff/*here.val*/; + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len += hold & ((1 << op) - 1); + hold >>>= op; + bits -= op; + } + //Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + + dodist: + for (;;) { // goto emulation + op = here >>> 24/*here.bits*/; + hold >>>= op; + bits -= op; + op = (here >>> 16) & 0xff/*here.op*/; + + if (op & 16) { /* distance base */ + dist = here & 0xffff/*here.val*/; + op &= 15; /* number of extra bits */ + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & ((1 << op) - 1); +//#ifdef INFLATE_STRICT + if (dist > dmax) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break top; + } +//#endif + hold >>>= op; + bits -= op; + //Tracevv((stderr, "inflate: distance %u\n", dist)); + op = _out - beg; /* max distance in output */ + if (dist > op) { /* see if copy from window */ + op = dist - op; /* distance back in window */ + if (op > whave) { + if (state.sane) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break top; + } + +// (!) This block is disabled in zlib defailts, +// don't enable it for binary compatibility +//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +// if (len <= op - whave) { +// do { +// output[_out++] = 0; +// } while (--len); +// continue top; +// } +// len -= op - whave; +// do { +// output[_out++] = 0; +// } while (--op > whave); +// if (op === 0) { +// from = _out - dist; +// do { +// output[_out++] = output[from++]; +// } while (--len); +// continue top; +// } +//#endif + } + from = 0; // window index + from_source = s_window; + if (wnext === 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + else if (wnext < op) { /* wrap around window */ + from += wsize + wnext - op; + op -= wnext; + if (op < len) { /* some from end of window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len) { /* some from start of window */ + op = wnext; + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + } + else { /* contiguous in window */ + from += wnext - op; + if (op < len) { /* some from window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + while (len > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len -= 3; + } + if (len) { + output[_out++] = from_source[from++]; + if (len > 1) { + output[_out++] = from_source[from++]; + } + } + } + else { + from = _out - dist; /* copy direct from output */ + do { /* minimum length is three */ + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len -= 3; + } while (len > 2); + if (len) { + output[_out++] = output[from++]; + if (len > 1) { + output[_out++] = output[from++]; + } + } + } + } + else if ((op & 64) === 0) { /* 2nd level distance code */ + here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))]; + continue dodist; + } + else { + strm.msg = 'invalid distance code'; + state.mode = BAD; + break top; + } + + break; // need to emulate goto via "continue" + } + } + else if ((op & 64) === 0) { /* 2nd level length code */ + here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))]; + continue dolen; + } + else if (op & 32) { /* end-of-block */ + //Tracevv((stderr, "inflate: end of block\n")); + state.mode = TYPE; + break top; + } + else { + strm.msg = 'invalid literal/length code'; + state.mode = BAD; + break top; + } + + break; // need to emulate goto via "continue" + } + } while (_in < last && _out < end); + + /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ + len = bits >> 3; + _in -= len; + bits -= len << 3; + hold &= (1 << bits) - 1; + + /* update state and return */ + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last)); + strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end)); + state.hold = hold; + state.bits = bits; + return; +}; + +},{}],61:[function(require,module,exports){ +'use strict'; + + +var utils = require('../utils/common'); +var adler32 = require('./adler32'); +var crc32 = require('./crc32'); +var inflate_fast = require('./inffast'); +var inflate_table = require('./inftrees'); + +var CODES = 0; +var LENS = 1; +var DISTS = 2; + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +/* Allowed flush values; see deflate() and inflate() below for details */ +//var Z_NO_FLUSH = 0; +//var Z_PARTIAL_FLUSH = 1; +//var Z_SYNC_FLUSH = 2; +//var Z_FULL_FLUSH = 3; +var Z_FINISH = 4; +var Z_BLOCK = 5; +var Z_TREES = 6; + + +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ +var Z_OK = 0; +var Z_STREAM_END = 1; +var Z_NEED_DICT = 2; +//var Z_ERRNO = -1; +var Z_STREAM_ERROR = -2; +var Z_DATA_ERROR = -3; +var Z_MEM_ERROR = -4; +var Z_BUF_ERROR = -5; +//var Z_VERSION_ERROR = -6; + +/* The deflate compression method */ +var Z_DEFLATED = 8; + + +/* STATES ====================================================================*/ +/* ===========================================================================*/ + + +var HEAD = 1; /* i: waiting for magic header */ +var FLAGS = 2; /* i: waiting for method and flags (gzip) */ +var TIME = 3; /* i: waiting for modification time (gzip) */ +var OS = 4; /* i: waiting for extra flags and operating system (gzip) */ +var EXLEN = 5; /* i: waiting for extra length (gzip) */ +var EXTRA = 6; /* i: waiting for extra bytes (gzip) */ +var NAME = 7; /* i: waiting for end of file name (gzip) */ +var COMMENT = 8; /* i: waiting for end of comment (gzip) */ +var HCRC = 9; /* i: waiting for header crc (gzip) */ +var DICTID = 10; /* i: waiting for dictionary check value */ +var DICT = 11; /* waiting for inflateSetDictionary() call */ +var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ +var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */ +var STORED = 14; /* i: waiting for stored size (length and complement) */ +var COPY_ = 15; /* i/o: same as COPY below, but only first time in */ +var COPY = 16; /* i/o: waiting for input or output to copy stored block */ +var TABLE = 17; /* i: waiting for dynamic block table lengths */ +var LENLENS = 18; /* i: waiting for code length code lengths */ +var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */ +var LEN_ = 20; /* i: same as LEN below, but only first time in */ +var LEN = 21; /* i: waiting for length/lit/eob code */ +var LENEXT = 22; /* i: waiting for length extra bits */ +var DIST = 23; /* i: waiting for distance code */ +var DISTEXT = 24; /* i: waiting for distance extra bits */ +var MATCH = 25; /* o: waiting for output space to copy string */ +var LIT = 26; /* o: waiting for output space to write literal */ +var CHECK = 27; /* i: waiting for 32-bit check value */ +var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */ +var DONE = 29; /* finished check, done -- remain here until reset */ +var BAD = 30; /* got a data error -- remain here until reset */ +var MEM = 31; /* got an inflate() memory error -- remain here until reset */ +var SYNC = 32; /* looking for synchronization bytes to restart inflate() */ + +/* ===========================================================================*/ + + + +var ENOUGH_LENS = 852; +var ENOUGH_DISTS = 592; +//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); + +var MAX_WBITS = 15; +/* 32K LZ77 window */ +var DEF_WBITS = MAX_WBITS; + + +function ZSWAP32(q) { + return (((q >>> 24) & 0xff) + + ((q >>> 8) & 0xff00) + + ((q & 0xff00) << 8) + + ((q & 0xff) << 24)); +} + + +function InflateState() { + this.mode = 0; /* current inflate mode */ + this.last = false; /* true if processing last block */ + this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ + this.havedict = false; /* true if dictionary provided */ + this.flags = 0; /* gzip header method and flags (0 if zlib) */ + this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */ + this.check = 0; /* protected copy of check value */ + this.total = 0; /* protected copy of output count */ + // TODO: may be {} + this.head = null; /* where to save gzip header information */ + + /* sliding window */ + this.wbits = 0; /* log base 2 of requested window size */ + this.wsize = 0; /* window size or zero if not using window */ + this.whave = 0; /* valid bytes in the window */ + this.wnext = 0; /* window write index */ + this.window = null; /* allocated sliding window, if needed */ + + /* bit accumulator */ + this.hold = 0; /* input bit accumulator */ + this.bits = 0; /* number of bits in "in" */ + + /* for string and stored block copying */ + this.length = 0; /* literal or length of data to copy */ + this.offset = 0; /* distance back to copy string from */ + + /* for table and code decoding */ + this.extra = 0; /* extra bits needed */ + + /* fixed and dynamic code tables */ + this.lencode = null; /* starting table for length/literal codes */ + this.distcode = null; /* starting table for distance codes */ + this.lenbits = 0; /* index bits for lencode */ + this.distbits = 0; /* index bits for distcode */ + + /* dynamic table building */ + this.ncode = 0; /* number of code length code lengths */ + this.nlen = 0; /* number of length code lengths */ + this.ndist = 0; /* number of distance code lengths */ + this.have = 0; /* number of code lengths in lens[] */ + this.next = null; /* next available space in codes[] */ + + this.lens = new utils.Buf16(320); /* temporary storage for code lengths */ + this.work = new utils.Buf16(288); /* work area for code table building */ + + /* + because we don't have pointers in js, we use lencode and distcode directly + as buffers so we don't need codes + */ + //this.codes = new utils.Buf32(ENOUGH); /* space for code tables */ + this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */ + this.distdyn = null; /* dynamic table for distance codes (JS specific) */ + this.sane = 0; /* if false, allow invalid distance too far */ + this.back = 0; /* bits back of last unprocessed length/lit */ + this.was = 0; /* initial length of match */ +} + +function inflateResetKeep(strm) { + var state; + + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ''; /*Z_NULL*/ + if (state.wrap) { /* to support ill-conceived Java test suite */ + strm.adler = state.wrap & 1; + } + state.mode = HEAD; + state.last = 0; + state.havedict = 0; + state.dmax = 32768; + state.head = null/*Z_NULL*/; + state.hold = 0; + state.bits = 0; + //state.lencode = state.distcode = state.next = state.codes; + state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS); + state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS); + + state.sane = 1; + state.back = -1; + //Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + +function inflateReset(strm) { + var state; + + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep(strm); + +} + +function inflateReset2(strm, windowBits) { + var wrap; + var state; + + /* get the state */ + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + + /* extract wrap request from windowBits parameter */ + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } + else { + wrap = (windowBits >> 4) + 1; + if (windowBits < 48) { + windowBits &= 15; + } + } + + /* set number of window bits, free window if different */ + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + + /* update state and reset the rest of it */ + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset(strm); +} + +function inflateInit2(strm, windowBits) { + var ret; + var state; + + if (!strm) { return Z_STREAM_ERROR; } + //strm.msg = Z_NULL; /* in case we return an error */ + + state = new InflateState(); + + //if (state === Z_NULL) return Z_MEM_ERROR; + //Tracev((stderr, "inflate: allocated\n")); + strm.state = state; + state.window = null/*Z_NULL*/; + ret = inflateReset2(strm, windowBits); + if (ret !== Z_OK) { + strm.state = null/*Z_NULL*/; + } + return ret; +} + +function inflateInit(strm) { + return inflateInit2(strm, DEF_WBITS); +} + + +/* + Return state with length and distance decoding tables and index sizes set to + fixed code decoding. Normally this returns fixed tables from inffixed.h. + If BUILDFIXED is defined, then instead this routine builds the tables the + first time it's called, and returns those tables the first time and + thereafter. This reduces the size of the code by about 2K bytes, in + exchange for a little execution time. However, BUILDFIXED should not be + used for threaded applications, since the rewriting of the tables and virgin + may not be thread-safe. + */ +var virgin = true; + +var lenfix, distfix; // We have no pointers in JS, so keep tables separate + +function fixedtables(state) { + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + var sym; + + lenfix = new utils.Buf32(512); + distfix = new utils.Buf32(32); + + /* literal/length table */ + sym = 0; + while (sym < 144) { state.lens[sym++] = 8; } + while (sym < 256) { state.lens[sym++] = 9; } + while (sym < 280) { state.lens[sym++] = 7; } + while (sym < 288) { state.lens[sym++] = 8; } + + inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, {bits: 9}); + + /* distance table */ + sym = 0; + while (sym < 32) { state.lens[sym++] = 5; } + + inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, {bits: 5}); + + /* do this just once */ + virgin = false; + } + + state.lencode = lenfix; + state.lenbits = 9; + state.distcode = distfix; + state.distbits = 5; +} + + +/* + Update the window with the last wsize (normally 32K) bytes written before + returning. If window does not exist yet, create it. This is only called + when a window is already in use, or when output has been written during this + inflate call, but the end of the deflate stream has not been reached yet. + It is also called to create a window for dictionary data when a dictionary + is loaded. + + Providing output buffers larger than 32K to inflate() should provide a speed + advantage, since only the last 32K of output is copied to the sliding window + upon return from inflate(), and since all distances after the first 32K of + output will fall in the output data, making match copies simpler and faster. + The advantage may be dependent on the size of the processor's data caches. + */ +function updatewindow(strm, src, end, copy) { + var dist; + var state = strm.state; + + /* if it hasn't been done already, allocate space for the window */ + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + + state.window = new utils.Buf8(state.wsize); + } + + /* copy state->wsize or less output bytes into the circular window */ + if (copy >= state.wsize) { + utils.arraySet(state.window,src, end - state.wsize, state.wsize, 0); + state.wnext = 0; + state.whave = state.wsize; + } + else { + dist = state.wsize - state.wnext; + if (dist > copy) { + dist = copy; + } + //zmemcpy(state->window + state->wnext, end - copy, dist); + utils.arraySet(state.window,src, end - copy, dist, state.wnext); + copy -= dist; + if (copy) { + //zmemcpy(state->window, end - copy, copy); + utils.arraySet(state.window,src, end - copy, copy, 0); + state.wnext = copy; + state.whave = state.wsize; + } + else { + state.wnext += dist; + if (state.wnext === state.wsize) { state.wnext = 0; } + if (state.whave < state.wsize) { state.whave += dist; } + } + } + return 0; +} + +function inflate(strm, flush) { + var state; + var input, output; // input/output buffers + var next; /* next input INDEX */ + var put; /* next output INDEX */ + var have, left; /* available input and output */ + var hold; /* bit buffer */ + var bits; /* bits in bit buffer */ + var _in, _out; /* save starting available input and output */ + var copy; /* number of stored or match bytes to copy */ + var from; /* where to copy match bytes from */ + var from_source; + var here = 0; /* current decoding table entry */ + var here_bits, here_op, here_val; // paked "here" denormalized (JS specific) + //var last; /* parent table entry */ + var last_bits, last_op, last_val; // paked "last" denormalized (JS specific) + var len; /* length to copy for repeats, bits to drop */ + var ret; /* return code */ + var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */ + var opts; + + var n; // temporary var for NEED_BITS + + var order = /* permutation of code lengths */ + [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; + + + if (!strm || !strm.state || !strm.output || + (!strm.input && strm.avail_in !== 0)) { + return Z_STREAM_ERROR; + } + + state = strm.state; + if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */ + + + //--- LOAD() --- + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + //--- + + _in = have; + _out = left; + ret = Z_OK; + + inf_leave: // goto emulation + for (;;) { + switch (state.mode) { + case HEAD: + if (state.wrap === 0) { + state.mode = TYPEDO; + break; + } + //=== NEEDBITS(16); + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */ + state.check = 0/*crc32(0L, Z_NULL, 0)*/; + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = FLAGS; + break; + } + state.flags = 0; /* expect zlib header */ + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || /* check if zlib header allowed */ + (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) { + strm.msg = 'incorrect header check'; + state.mode = BAD; + break; + } + if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) { + strm.msg = 'unknown compression method'; + state.mode = BAD; + break; + } + //--- DROPBITS(4) ---// + hold >>>= 4; + bits -= 4; + //---// + len = (hold & 0x0f)/*BITS(4)*/ + 8; + if (state.wbits === 0) { + state.wbits = len; + } + else if (len > state.wbits) { + strm.msg = 'invalid window size'; + state.mode = BAD; + break; + } + state.dmax = 1 << len; + //Tracev((stderr, "inflate: zlib header ok\n")); + strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/; + state.mode = hold & 0x200 ? DICTID : TYPE; + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + break; + case FLAGS: + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.flags = hold; + if ((state.flags & 0xff) !== Z_DEFLATED) { + strm.msg = 'unknown compression method'; + state.mode = BAD; + break; + } + if (state.flags & 0xe000) { + strm.msg = 'unknown header flags set'; + state.mode = BAD; + break; + } + if (state.head) { + state.head.text = ((hold >> 8) & 1); + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = TIME; + /* falls through */ + case TIME: + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (state.head) { + state.head.time = hold; + } + if (state.flags & 0x0200) { + //=== CRC4(state.check, hold) + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + hbuf[2] = (hold >>> 16) & 0xff; + hbuf[3] = (hold >>> 24) & 0xff; + state.check = crc32(state.check, hbuf, 4, 0); + //=== + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = OS; + /* falls through */ + case OS: + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (state.head) { + state.head.xflags = (hold & 0xff); + state.head.os = (hold >> 8); + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = EXLEN; + /* falls through */ + case EXLEN: + if (state.flags & 0x0400) { + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + } + else if (state.head) { + state.head.extra = null/*Z_NULL*/; + } + state.mode = EXTRA; + /* falls through */ + case EXTRA: + if (state.flags & 0x0400) { + copy = state.length; + if (copy > have) { copy = have; } + if (copy) { + if (state.head) { + len = state.head.extra_len - state.length; + if (!state.head.extra) { + // Use untyped array for more conveniend processing later + state.head.extra = new Array(state.head.extra_len); + } + utils.arraySet( + state.head.extra, + input, + next, + // extra field is limited to 65536 bytes + // - no need for additional size check + copy, + /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ + len + ); + //zmemcpy(state.head.extra + len, next, + // len + copy > state.head.extra_max ? + // state.head.extra_max - len : copy); + } + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + state.length -= copy; + } + if (state.length) { break inf_leave; } + } + state.length = 0; + state.mode = NAME; + /* falls through */ + case NAME: + if (state.flags & 0x0800) { + if (have === 0) { break inf_leave; } + copy = 0; + do { + // TODO: 2 or 1 bytes? + len = input[next + copy++]; + /* use constant limit because in js we should not preallocate memory */ + if (state.head && len && + (state.length < 65536 /*state.head.name_max*/)) { + state.head.name += String.fromCharCode(len); + } + } while (len && copy < have); + + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { break inf_leave; } + } + else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + /* falls through */ + case COMMENT: + if (state.flags & 0x1000) { + if (have === 0) { break inf_leave; } + copy = 0; + do { + len = input[next + copy++]; + /* use constant limit because in js we should not preallocate memory */ + if (state.head && len && + (state.length < 65536 /*state.head.comm_max*/)) { + state.head.comment += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { break inf_leave; } + } + else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + /* falls through */ + case HCRC: + if (state.flags & 0x0200) { + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (hold !== (state.check & 0xffff)) { + strm.msg = 'header crc mismatch'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + } + if (state.head) { + state.head.hcrc = ((state.flags >> 9) & 1); + state.head.done = true; + } + strm.adler = state.check = 0 /*crc32(0L, Z_NULL, 0)*/; + state.mode = TYPE; + break; + case DICTID: + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + strm.adler = state.check = ZSWAP32(hold); + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = DICT; + /* falls through */ + case DICT: + if (state.havedict === 0) { + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + return Z_NEED_DICT; + } + strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/; + state.mode = TYPE; + /* falls through */ + case TYPE: + if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; } + /* falls through */ + case TYPEDO: + if (state.last) { + //--- BYTEBITS() ---// + hold >>>= bits & 7; + bits -= bits & 7; + //---// + state.mode = CHECK; + break; + } + //=== NEEDBITS(3); */ + while (bits < 3) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.last = (hold & 0x01)/*BITS(1)*/; + //--- DROPBITS(1) ---// + hold >>>= 1; + bits -= 1; + //---// + + switch ((hold & 0x03)/*BITS(2)*/) { + case 0: /* stored block */ + //Tracev((stderr, "inflate: stored block%s\n", + // state.last ? " (last)" : "")); + state.mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + //Tracev((stderr, "inflate: fixed codes block%s\n", + // state.last ? " (last)" : "")); + state.mode = LEN_; /* decode codes */ + if (flush === Z_TREES) { + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + break inf_leave; + } + break; + case 2: /* dynamic block */ + //Tracev((stderr, "inflate: dynamic codes block%s\n", + // state.last ? " (last)" : "")); + state.mode = TABLE; + break; + case 3: + strm.msg = 'invalid block type'; + state.mode = BAD; + } + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + break; + case STORED: + //--- BYTEBITS() ---// /* go to byte boundary */ + hold >>>= bits & 7; + bits -= bits & 7; + //---// + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) { + strm.msg = 'invalid stored block lengths'; + state.mode = BAD; + break; + } + state.length = hold & 0xffff; + //Tracev((stderr, "inflate: stored length %u\n", + // state.length)); + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = COPY_; + if (flush === Z_TREES) { break inf_leave; } + /* falls through */ + case COPY_: + state.mode = COPY; + /* falls through */ + case COPY: + copy = state.length; + if (copy) { + if (copy > have) { copy = have; } + if (copy > left) { copy = left; } + if (copy === 0) { break inf_leave; } + //--- zmemcpy(put, next, copy); --- + utils.arraySet(output, input, next, copy, put); + //---// + have -= copy; + next += copy; + left -= copy; + put += copy; + state.length -= copy; + break; + } + //Tracev((stderr, "inflate: stored end\n")); + state.mode = TYPE; + break; + case TABLE: + //=== NEEDBITS(14); */ + while (bits < 14) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257; + //--- DROPBITS(5) ---// + hold >>>= 5; + bits -= 5; + //---// + state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1; + //--- DROPBITS(5) ---// + hold >>>= 5; + bits -= 5; + //---// + state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4; + //--- DROPBITS(4) ---// + hold >>>= 4; + bits -= 4; + //---// +//#ifndef PKZIP_BUG_WORKAROUND + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = 'too many length or distance symbols'; + state.mode = BAD; + break; + } +//#endif + //Tracev((stderr, "inflate: table sizes ok\n")); + state.have = 0; + state.mode = LENLENS; + /* falls through */ + case LENLENS: + while (state.have < state.ncode) { + //=== NEEDBITS(3); + while (bits < 3) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.lens[order[state.have++]] = (hold & 0x07);//BITS(3); + //--- DROPBITS(3) ---// + hold >>>= 3; + bits -= 3; + //---// + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + // We have separate tables & no pointers. 2 commented lines below not needed. + //state.next = state.codes; + //state.lencode = state.next; + // Switch to use dynamic table + state.lencode = state.lendyn; + state.lenbits = 7; + + opts = {bits: state.lenbits}; + ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + + if (ret) { + strm.msg = 'invalid code lengths set'; + state.mode = BAD; + break; + } + //Tracev((stderr, "inflate: code lengths ok\n")); + state.have = 0; + state.mode = CODELENS; + /* falls through */ + case CODELENS: + while (state.have < state.nlen + state.ndist) { + for (;;) { + here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if (here_val < 16) { + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.lens[state.have++] = here_val; + } + else { + if (here_val === 16) { + //=== NEEDBITS(here.bits + 2); + n = here_bits + 2; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + if (state.have === 0) { + strm.msg = 'invalid bit length repeat'; + state.mode = BAD; + break; + } + len = state.lens[state.have - 1]; + copy = 3 + (hold & 0x03);//BITS(2); + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + } + else if (here_val === 17) { + //=== NEEDBITS(here.bits + 3); + n = here_bits + 3; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + len = 0; + copy = 3 + (hold & 0x07);//BITS(3); + //--- DROPBITS(3) ---// + hold >>>= 3; + bits -= 3; + //---// + } + else { + //=== NEEDBITS(here.bits + 7); + n = here_bits + 7; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + len = 0; + copy = 11 + (hold & 0x7f);//BITS(7); + //--- DROPBITS(7) ---// + hold >>>= 7; + bits -= 7; + //---// + } + if (state.have + copy > state.nlen + state.ndist) { + strm.msg = 'invalid bit length repeat'; + state.mode = BAD; + break; + } + while (copy--) { + state.lens[state.have++] = len; + } + } + } + + /* handle error breaks in while */ + if (state.mode === BAD) { break; } + + /* check for end-of-block code (better have one) */ + if (state.lens[256] === 0) { + strm.msg = 'invalid code -- missing end-of-block'; + state.mode = BAD; + break; + } + + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state.lenbits = 9; + + opts = {bits: state.lenbits}; + ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + // We have separate tables & no pointers. 2 commented lines below not needed. + // state.next_index = opts.table_index; + state.lenbits = opts.bits; + // state.lencode = state.next; + + if (ret) { + strm.msg = 'invalid literal/lengths set'; + state.mode = BAD; + break; + } + + state.distbits = 6; + //state.distcode.copy(state.codes); + // Switch to use dynamic table + state.distcode = state.distdyn; + opts = {bits: state.distbits}; + ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + // We have separate tables & no pointers. 2 commented lines below not needed. + // state.next_index = opts.table_index; + state.distbits = opts.bits; + // state.distcode = state.next; + + if (ret) { + strm.msg = 'invalid distances set'; + state.mode = BAD; + break; + } + //Tracev((stderr, 'inflate: codes ok\n')); + state.mode = LEN_; + if (flush === Z_TREES) { break inf_leave; } + /* falls through */ + case LEN_: + state.mode = LEN; + /* falls through */ + case LEN: + if (have >= 6 && left >= 258) { + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + inflate_fast(strm, _out); + //--- LOAD() --- + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + //--- + + if (state.mode === TYPE) { + state.back = -1; + } + break; + } + state.back = 0; + for (;;) { + here = state.lencode[hold & ((1 << state.lenbits) -1)]; /*BITS(state.lenbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if (here_bits <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if (here_op && (here_op & 0xf0) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (;;) { + here = state.lencode[last_val + + ((hold & ((1 << (last_bits + last_op)) -1))/*BITS(last.bits + last.op)*/ >> last_bits)]; + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((last_bits + here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + //--- DROPBITS(last.bits) ---// + hold >>>= last_bits; + bits -= last_bits; + //---// + state.back += last_bits; + } + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + // "inflate: literal '%c'\n" : + // "inflate: literal 0x%02x\n", here.val)); + state.mode = LIT; + break; + } + if (here_op & 32) { + //Tracevv((stderr, "inflate: end of block\n")); + state.back = -1; + state.mode = TYPE; + break; + } + if (here_op & 64) { + strm.msg = 'invalid literal/length code'; + state.mode = BAD; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT; + /* falls through */ + case LENEXT: + if (state.extra) { + //=== NEEDBITS(state.extra); + n = state.extra; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.length += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/; + //--- DROPBITS(state.extra) ---// + hold >>>= state.extra; + bits -= state.extra; + //---// + state.back += state.extra; + } + //Tracevv((stderr, "inflate: length %u\n", state.length)); + state.was = state.length; + state.mode = DIST; + /* falls through */ + case DIST: + for (;;) { + here = state.distcode[hold & ((1 << state.distbits) -1)];/*BITS(state.distbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if ((here_op & 0xf0) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (;;) { + here = state.distcode[last_val + + ((hold & ((1 << (last_bits + last_op)) -1))/*BITS(last.bits + last.op)*/ >> last_bits)]; + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((last_bits + here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + //--- DROPBITS(last.bits) ---// + hold >>>= last_bits; + bits -= last_bits; + //---// + state.back += last_bits; + } + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.back += here_bits; + if (here_op & 64) { + strm.msg = 'invalid distance code'; + state.mode = BAD; + break; + } + state.offset = here_val; + state.extra = (here_op) & 15; + state.mode = DISTEXT; + /* falls through */ + case DISTEXT: + if (state.extra) { + //=== NEEDBITS(state.extra); + n = state.extra; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.offset += hold & ((1 << state.extra) -1)/*BITS(state.extra)*/; + //--- DROPBITS(state.extra) ---// + hold >>>= state.extra; + bits -= state.extra; + //---// + state.back += state.extra; + } +//#ifdef INFLATE_STRICT + if (state.offset > state.dmax) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break; + } +//#endif + //Tracevv((stderr, "inflate: distance %u\n", state.offset)); + state.mode = MATCH; + /* falls through */ + case MATCH: + if (left === 0) { break inf_leave; } + copy = _out - left; + if (state.offset > copy) { /* copy from window */ + copy = state.offset - copy; + if (copy > state.whave) { + if (state.sane) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break; + } +// (!) This block is disabled in zlib defailts, +// don't enable it for binary compatibility +//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +// Trace((stderr, "inflate.c too far\n")); +// copy -= state.whave; +// if (copy > state.length) { copy = state.length; } +// if (copy > left) { copy = left; } +// left -= copy; +// state.length -= copy; +// do { +// output[put++] = 0; +// } while (--copy); +// if (state.length === 0) { state.mode = LEN; } +// break; +//#endif + } + if (copy > state.wnext) { + copy -= state.wnext; + from = state.wsize - copy; + } + else { + from = state.wnext - copy; + } + if (copy > state.length) { copy = state.length; } + from_source = state.window; + } + else { /* copy from output */ + from_source = output; + from = put - state.offset; + copy = state.length; + } + if (copy > left) { copy = left; } + left -= copy; + state.length -= copy; + do { + output[put++] = from_source[from++]; + } while (--copy); + if (state.length === 0) { state.mode = LEN; } + break; + case LIT: + if (left === 0) { break inf_leave; } + output[put++] = state.length; + left--; + state.mode = LEN; + break; + case CHECK: + if (state.wrap) { + //=== NEEDBITS(32); + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + // Use '|' insdead of '+' to make sure that result is signed + hold |= input[next++] << bits; + bits += 8; + } + //===// + _out -= left; + strm.total_out += _out; + state.total += _out; + if (_out) { + strm.adler = state.check = + /*UPDATE(state.check, put - _out, _out);*/ + (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out)); + + } + _out = left; + // NB: crc32 stored as signed 32-bit int, ZSWAP32 returns signed too + if ((state.flags ? hold : ZSWAP32(hold)) !== state.check) { + strm.msg = 'incorrect data check'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + //Tracev((stderr, "inflate: check matches trailer\n")); + } + state.mode = LENGTH; + /* falls through */ + case LENGTH: + if (state.wrap && state.flags) { + //=== NEEDBITS(32); + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (hold !== (state.total & 0xffffffff)) { + strm.msg = 'incorrect length check'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + //Tracev((stderr, "inflate: length matches trailer\n")); + } + state.mode = DONE; + /* falls through */ + case DONE: + ret = Z_STREAM_END; + break inf_leave; + case BAD: + ret = Z_DATA_ERROR; + break inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + /* falls through */ + default: + return Z_STREAM_ERROR; + } + } + + // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave" + + /* + Return from inflate(), updating the total counts and the check value. + If there was no progress during the inflate() call, return a buffer + error. Call updatewindow() to create and/or update the window state. + Note: a memory error from inflate() is non-recoverable. + */ + + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + + if (state.wsize || (_out !== strm.avail_out && state.mode < BAD && + (state.mode < CHECK || flush !== Z_FINISH))) { + if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) { + state.mode = MEM; + return Z_MEM_ERROR; + } + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap && _out) { + strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/ + (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out)); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + + (state.mode === TYPE ? 128 : 0) + + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); + if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) { + ret = Z_BUF_ERROR; + } + return ret; +} + +function inflateEnd(strm) { + + if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) { + return Z_STREAM_ERROR; + } + + var state = strm.state; + if (state.window) { + state.window = null; + } + strm.state = null; + return Z_OK; +} + +function inflateGetHeader(strm, head) { + var state; + + /* check state */ + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; } + + /* save header structure */ + state.head = head; + head.done = false; + return Z_OK; +} + + +exports.inflateReset = inflateReset; +exports.inflateReset2 = inflateReset2; +exports.inflateResetKeep = inflateResetKeep; +exports.inflateInit = inflateInit; +exports.inflateInit2 = inflateInit2; +exports.inflate = inflate; +exports.inflateEnd = inflateEnd; +exports.inflateGetHeader = inflateGetHeader; +exports.inflateInfo = 'pako inflate (from Nodeca project)'; + +/* Not implemented +exports.inflateCopy = inflateCopy; +exports.inflateGetDictionary = inflateGetDictionary; +exports.inflateMark = inflateMark; +exports.inflatePrime = inflatePrime; +exports.inflateSetDictionary = inflateSetDictionary; +exports.inflateSync = inflateSync; +exports.inflateSyncPoint = inflateSyncPoint; +exports.inflateUndermine = inflateUndermine; +*/ + +},{"../utils/common":55,"./adler32":56,"./crc32":58,"./inffast":60,"./inftrees":62}],62:[function(require,module,exports){ +'use strict'; + + +var utils = require('../utils/common'); + +var MAXBITS = 15; +var ENOUGH_LENS = 852; +var ENOUGH_DISTS = 592; +//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); + +var CODES = 0; +var LENS = 1; +var DISTS = 2; + +var lbase = [ /* Length codes 257..285 base */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 +]; + +var lext = [ /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78 +]; + +var dbase = [ /* Distance codes 0..29 base */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577, 0, 0 +]; + +var dext = [ /* Distance codes 0..29 extra */ + 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, + 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 64, 64 +]; + +module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) +{ + var bits = opts.bits; + //here = opts.here; /* table entry for duplication */ + + var len = 0; /* a code's length in bits */ + var sym = 0; /* index of code symbols */ + var min = 0, max = 0; /* minimum and maximum code lengths */ + var root = 0; /* number of index bits for root table */ + var curr = 0; /* number of index bits for current table */ + var drop = 0; /* code bits to drop for sub-table */ + var left = 0; /* number of prefix codes available */ + var used = 0; /* code entries in table used */ + var huff = 0; /* Huffman code */ + var incr; /* for incrementing code, index */ + var fill; /* index for replicating entries */ + var low; /* low bits for current root entry */ + var mask; /* mask for low root bits */ + var next; /* next available space in table */ + var base = null; /* base value table to use */ + var base_index = 0; +// var shoextra; /* extra bits table to use */ + var end; /* use base and extra for symbol > end */ + var count = new utils.Buf16(MAXBITS+1); //[MAXBITS+1]; /* number of codes of each length */ + var offs = new utils.Buf16(MAXBITS+1); //[MAXBITS+1]; /* offsets in table for each length */ + var extra = null; + var extra_index = 0; + + var here_bits, here_op, here_val; + + /* + Process a set of code lengths to create a canonical Huffman code. The + code lengths are lens[0..codes-1]. Each length corresponds to the + symbols 0..codes-1. The Huffman code is generated by first sorting the + symbols by length from short to long, and retaining the symbol order + for codes with equal lengths. Then the code starts with all zero bits + for the first code of the shortest length, and the codes are integer + increments for the same length, and zeros are appended as the length + increases. For the deflate format, these bits are stored backwards + from their more natural integer increment ordering, and so when the + decoding tables are built in the large loop below, the integer codes + are incremented backwards. + + This routine assumes, but does not check, that all of the entries in + lens[] are in the range 0..MAXBITS. The caller must assure this. + 1..MAXBITS is interpreted as that code length. zero means that that + symbol does not occur in this code. + + The codes are sorted by computing a count of codes for each length, + creating from that a table of starting indices for each length in the + sorted table, and then entering the symbols in order in the sorted + table. The sorted table is work[], with that space being provided by + the caller. + + The length counts are used for other purposes as well, i.e. finding + the minimum and maximum length codes, determining if there are any + codes at all, checking for a valid set of lengths, and looking ahead + at length counts to determine sub-table sizes when building the + decoding tables. + */ + + /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ + for (len = 0; len <= MAXBITS; len++) { + count[len] = 0; + } + for (sym = 0; sym < codes; sym++) { + count[lens[lens_index + sym]]++; + } + + /* bound code lengths, force root to be within code lengths */ + root = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count[max] !== 0) { break; } + } + if (root > max) { + root = max; + } + if (max === 0) { /* no symbols to code at all */ + //table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */ + //table.bits[opts.table_index] = 1; //here.bits = (var char)1; + //table.val[opts.table_index++] = 0; //here.val = (var short)0; + table[table_index++] = (1 << 24) | (64 << 16) | 0; + + + //table.op[opts.table_index] = 64; + //table.bits[opts.table_index] = 1; + //table.val[opts.table_index++] = 0; + table[table_index++] = (1 << 24) | (64 << 16) | 0; + + opts.bits = 1; + return 0; /* no symbols, but wait for decoding to report error */ + } + for (min = 1; min < max; min++) { + if (count[min] !== 0) { break; } + } + if (root < min) { + root = min; + } + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) { + return -1; + } /* over-subscribed */ + } + if (left > 0 && (type === CODES || max !== 1)) { + return -1; /* incomplete set */ + } + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) { + offs[len + 1] = offs[len] + count[len]; + } + + /* sort symbols by length, by symbol order within each length */ + for (sym = 0; sym < codes; sym++) { + if (lens[lens_index + sym] !== 0) { + work[offs[lens[lens_index + sym]]++] = sym; + } + } + + /* + Create and fill in decoding tables. In this loop, the table being + filled is at next and has curr index bits. The code being used is huff + with length len. That code is converted to an index by dropping drop + bits off of the bottom. For codes where len is less than drop + curr, + those top drop + curr - len bits are incremented through all values to + fill the table with replicated entries. + + root is the number of index bits for the root table. When len exceeds + root, sub-tables are created pointed to by the root entry with an index + of the low root bits of huff. This is saved in low to check for when a + new sub-table should be started. drop is zero when the root table is + being filled, and drop is root when sub-tables are being filled. + + When a new sub-table is needed, it is necessary to look ahead in the + code lengths to determine what size sub-table is needed. The length + counts are used for this, and so count[] is decremented as codes are + entered in the tables. + + used keeps track of how many table entries have been allocated from the + provided *table space. It is checked for LENS and DIST tables against + the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in + the initial root table size constants. See the comments in inftrees.h + for more information. + + sym increments through all symbols, and the loop terminates when + all codes of length max, i.e. all codes, have been processed. This + routine permits incomplete codes, so another loop after this one fills + in the rest of the decoding tables with invalid code markers. + */ + + /* set up for code type */ + // poor man optimization - use if-else instead of switch, + // to avoid deopts in old v8 + if (type === CODES) { + base = extra = work; /* dummy value--not used */ + end = 19; + + } else if (type === LENS) { + base = lbase; + base_index -= 257; + extra = lext; + extra_index -= 257; + end = 256; + + } else { /* DISTS */ + base = dbase; + extra = dext; + end = -1; + } + + /* initialize opts for loop */ + huff = 0; /* starting code */ + sym = 0; /* starting code symbol */ + len = min; /* starting code length */ + next = table_index; /* current table to fill in */ + curr = root; /* current table index bits */ + drop = 0; /* current bits to drop from code for index */ + low = -1; /* trigger new sub-table when len > root */ + used = 1 << root; /* use root table entries */ + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ + if ((type === LENS && used > ENOUGH_LENS) || + (type === DISTS && used > ENOUGH_DISTS)) { + return 1; + } + + var i=0; + /* process all codes and make table entries */ + for (;;) { + i++; + /* create table entry */ + here_bits = len - drop; + if (work[sym] < end) { + here_op = 0; + here_val = work[sym]; + } + else if (work[sym] > end) { + here_op = extra[extra_index + work[sym]]; + here_val = base[base_index + work[sym]]; + } + else { + here_op = 32 + 64; /* end of block */ + here_val = 0; + } + + /* replicate for those indices with low len bits equal to huff */ + incr = 1 << (len - drop); + fill = 1 << curr; + min = fill; /* save offset to next table */ + do { + fill -= incr; + table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0; + } while (fill !== 0); + + /* backwards increment the len-bit code huff */ + incr = 1 << (len - 1); + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + + /* go to next symbol, update count, len */ + sym++; + if (--count[len] === 0) { + if (len === max) { break; } + len = lens[lens_index + work[sym]]; + } + + /* create new sub-table if needed */ + if (len > root && (huff & mask) !== low) { + /* if first time, transition to sub-tables */ + if (drop === 0) { + drop = root; + } + + /* increment past last table */ + next += min; /* here min is 1 << curr */ + + /* determine length of next table */ + curr = len - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) { break; } + curr++; + left <<= 1; + } + + /* check for enough space */ + used += 1 << curr; + if ((type === LENS && used > ENOUGH_LENS) || + (type === DISTS && used > ENOUGH_DISTS)) { + return 1; + } + + /* point entry in root table to sub-table */ + low = huff & mask; + /*table.op[low] = curr; + table.bits[low] = root; + table.val[low] = next - opts.table_index;*/ + table[low] = (root << 24) | (curr << 16) | (next - table_index) |0; + } + } + + /* fill in remaining table entry if code is incomplete (guaranteed to have + at most one remaining entry, since if the code is incomplete, the + maximum code length that was allowed to get this far is one bit) */ + if (huff !== 0) { + //table.op[next + huff] = 64; /* invalid code marker */ + //table.bits[next + huff] = len - drop; + //table.val[next + huff] = 0; + table[next + huff] = ((len - drop) << 24) | (64 << 16) |0; + } + + /* set return parameters */ + //opts.table_index += used; + opts.bits = root; + return 0; +}; + +},{"../utils/common":55}],63:[function(require,module,exports){ +'use strict'; + +module.exports = { + '2': 'need dictionary', /* Z_NEED_DICT 2 */ + '1': 'stream end', /* Z_STREAM_END 1 */ + '0': '', /* Z_OK 0 */ + '-1': 'file error', /* Z_ERRNO (-1) */ + '-2': 'stream error', /* Z_STREAM_ERROR (-2) */ + '-3': 'data error', /* Z_DATA_ERROR (-3) */ + '-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */ + '-5': 'buffer error', /* Z_BUF_ERROR (-5) */ + '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */ +}; + +},{}],64:[function(require,module,exports){ +'use strict'; + + +var utils = require('../utils/common'); + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +//var Z_FILTERED = 1; +//var Z_HUFFMAN_ONLY = 2; +//var Z_RLE = 3; +var Z_FIXED = 4; +//var Z_DEFAULT_STRATEGY = 0; + +/* Possible values of the data_type field (though see inflate()) */ +var Z_BINARY = 0; +var Z_TEXT = 1; +//var Z_ASCII = 1; // = Z_TEXT +var Z_UNKNOWN = 2; + +/*============================================================================*/ + + +function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } + +// From zutil.h + +var STORED_BLOCK = 0; +var STATIC_TREES = 1; +var DYN_TREES = 2; +/* The three kinds of block type */ + +var MIN_MATCH = 3; +var MAX_MATCH = 258; +/* The minimum and maximum match lengths */ + +// From deflate.h +/* =========================================================================== + * Internal compression state. + */ + +var LENGTH_CODES = 29; +/* number of length codes, not counting the special END_BLOCK code */ + +var LITERALS = 256; +/* number of literal bytes 0..255 */ + +var L_CODES = LITERALS + 1 + LENGTH_CODES; +/* number of Literal or Length codes, including the END_BLOCK code */ + +var D_CODES = 30; +/* number of distance codes */ + +var BL_CODES = 19; +/* number of codes used to transfer the bit lengths */ + +var HEAP_SIZE = 2*L_CODES + 1; +/* maximum heap size */ + +var MAX_BITS = 15; +/* All codes must not exceed MAX_BITS bits */ + +var Buf_size = 16; +/* size of bit buffer in bi_buf */ + + +/* =========================================================================== + * Constants + */ + +var MAX_BL_BITS = 7; +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +var END_BLOCK = 256; +/* end of block literal code */ + +var REP_3_6 = 16; +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +var REPZ_3_10 = 17; +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +var REPZ_11_138 = 18; +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +var extra_lbits = /* extra bits for each length code */ + [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0]; + +var extra_dbits = /* extra bits for each distance code */ + [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13]; + +var extra_blbits = /* extra bits for each bit length code */ + [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]; + +var bl_order = + [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]; +/* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +/* =========================================================================== + * Local data. These are initialized only once. + */ + +// We pre-fill arrays with 0 to avoid uninitialized gaps + +var DIST_CODE_LEN = 512; /* see definition of array dist_code below */ + +// !!!! Use flat array insdead of structure, Freq = i*2, Len = i*2+1 +var static_ltree = new Array((L_CODES+2) * 2); +zero(static_ltree); +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see _tr_init + * below). + */ + +var static_dtree = new Array(D_CODES * 2); +zero(static_dtree); +/* The static distance tree. (Actually a trivial tree since all codes use + * 5 bits.) + */ + +var _dist_code = new Array(DIST_CODE_LEN); +zero(_dist_code); +/* Distance codes. The first 256 values correspond to the distances + * 3 .. 258, the last 256 values correspond to the top 8 bits of + * the 15 bit distances. + */ + +var _length_code = new Array(MAX_MATCH-MIN_MATCH+1); +zero(_length_code); +/* length code for each normalized match length (0 == MIN_MATCH) */ + +var base_length = new Array(LENGTH_CODES); +zero(base_length); +/* First normalized length for each code (0 = MIN_MATCH) */ + +var base_dist = new Array(D_CODES); +zero(base_dist); +/* First normalized distance for each code (0 = distance of 1) */ + + +var StaticTreeDesc = function (static_tree, extra_bits, extra_base, elems, max_length) { + + this.static_tree = static_tree; /* static tree or NULL */ + this.extra_bits = extra_bits; /* extra bits for each code or NULL */ + this.extra_base = extra_base; /* base index for extra_bits */ + this.elems = elems; /* max number of elements in the tree */ + this.max_length = max_length; /* max bit length for the codes */ + + // show if `static_tree` has data or dummy - needed for monomorphic objects + this.has_stree = static_tree && static_tree.length; +}; + + +var static_l_desc; +var static_d_desc; +var static_bl_desc; + + +var TreeDesc = function(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; /* the dynamic tree */ + this.max_code = 0; /* largest code with non zero frequency */ + this.stat_desc = stat_desc; /* the corresponding static tree */ +}; + + + +function d_code(dist) { + return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; +} + + +/* =========================================================================== + * Output a short LSB first on the stream. + * IN assertion: there is enough room in pendingBuf. + */ +function put_short (s, w) { +// put_byte(s, (uch)((w) & 0xff)); +// put_byte(s, (uch)((ush)(w) >> 8)); + s.pending_buf[s.pending++] = (w) & 0xff; + s.pending_buf[s.pending++] = (w >>> 8) & 0xff; +} + + +/* =========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +function send_bits(s, value, length) { + if (s.bi_valid > (Buf_size - length)) { + s.bi_buf |= (value << s.bi_valid) & 0xffff; + put_short(s, s.bi_buf); + s.bi_buf = value >> (Buf_size - s.bi_valid); + s.bi_valid += length - Buf_size; + } else { + s.bi_buf |= (value << s.bi_valid) & 0xffff; + s.bi_valid += length; + } +} + + +function send_code(s, c, tree) { + send_bits(s, tree[c*2]/*.Code*/, tree[c*2 + 1]/*.Len*/); +} + + +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +function bi_reverse(code, len) { + var res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len > 0); + return res >>> 1; +} + + +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +function bi_flush(s) { + if (s.bi_valid === 16) { + put_short(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 0xff; + s.bi_buf >>= 8; + s.bi_valid -= 8; + } +} + + +/* =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +function gen_bitlen(s, desc) +// deflate_state *s; +// tree_desc *desc; /* the tree descriptor */ +{ + var tree = desc.dyn_tree; + var max_code = desc.max_code; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var extra = desc.stat_desc.extra_bits; + var base = desc.stat_desc.extra_base; + var max_length = desc.stat_desc.max_length; + var h; /* heap index */ + var n, m; /* iterate over the tree elements */ + var bits; /* bit length */ + var xbits; /* extra bits */ + var f; /* frequency */ + var overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) { + s.bl_count[bits] = 0; + } + + /* In a first pass, compute the optimal bit lengths (which may + * overflow in the case of the bit length tree). + */ + tree[s.heap[s.heap_max]*2 + 1]/*.Len*/ = 0; /* root of the heap */ + + for (h = s.heap_max+1; h < HEAP_SIZE; h++) { + n = s.heap[h]; + bits = tree[tree[n*2 +1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n*2 + 1]/*.Len*/ = bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) { continue; } /* not a leaf node */ + + s.bl_count[bits]++; + xbits = 0; + if (n >= base) { + xbits = extra[n-base]; + } + f = tree[n * 2]/*.Freq*/; + s.opt_len += f * (bits + xbits); + if (has_stree) { + s.static_len += f * (stree[n*2 + 1]/*.Len*/ + xbits); + } + } + if (overflow === 0) { return; } + + // Trace((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length-1; + while (s.bl_count[bits] === 0) { bits--; } + s.bl_count[bits]--; /* move one leaf down the tree */ + s.bl_count[bits+1] += 2; /* move one overflow item as its brother */ + s.bl_count[max_length]--; + /* The brother of the overflow item also moves one step up, + * but this does not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* Now recompute all bit lengths, scanning in increasing frequency. + * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all + * lengths instead of fixing only the wrong ones. This idea is taken + * from 'ar' written by Haruhiko Okumura.) + */ + for (bits = max_length; bits !== 0; bits--) { + n = s.bl_count[bits]; + while (n !== 0) { + m = s.heap[--h]; + if (m > max_code) { continue; } + if (tree[m*2 + 1]/*.Len*/ !== bits) { + // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + s.opt_len += (bits - tree[m*2 + 1]/*.Len*/)*tree[m*2]/*.Freq*/; + tree[m*2 + 1]/*.Len*/ = bits; + } + n--; + } + } +} + + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +function gen_codes(tree, max_code, bl_count) +// ct_data *tree; /* the tree to decorate */ +// int max_code; /* largest code with non zero frequency */ +// ushf *bl_count; /* number of codes at each bit length */ +{ + var next_code = new Array(MAX_BITS+1); /* next code value for each bit length */ + var code = 0; /* running code value */ + var bits; /* bit index */ + var n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits-1]) << 1; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + //Assert (code + bl_count[MAX_BITS]-1 == (1< length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES-1; code++) { + base_length[code] = length; + for (n = 0; n < (1< dist code (0..29) */ + dist = 0; + for (code = 0 ; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ + for (; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { + _dist_code[256 + dist++] = code; + } + } + //Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) { + bl_count[bits] = 0; + } + + n = 0; + while (n <= 143) { + static_ltree[n*2 + 1]/*.Len*/ = 8; + n++; + bl_count[8]++; + } + while (n <= 255) { + static_ltree[n*2 + 1]/*.Len*/ = 9; + n++; + bl_count[9]++; + } + while (n <= 279) { + static_ltree[n*2 + 1]/*.Len*/ = 7; + n++; + bl_count[7]++; + } + while (n <= 287) { + static_ltree[n*2 + 1]/*.Len*/ = 8; + n++; + bl_count[8]++; + } + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + gen_codes(static_ltree, L_CODES+1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n*2 + 1]/*.Len*/ = 5; + static_dtree[n*2]/*.Code*/ = bi_reverse(n, 5); + } + + // Now data ready and we can init static trees + static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS); + static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS); + static_bl_desc =new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS); + + //static_init_done = true; +} + + +/* =========================================================================== + * Initialize a new block. + */ +function init_block(s) { + var n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n*2]/*.Freq*/ = 0; } + for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n*2]/*.Freq*/ = 0; } + for (n = 0; n < BL_CODES; n++) { s.bl_tree[n*2]/*.Freq*/ = 0; } + + s.dyn_ltree[END_BLOCK*2]/*.Freq*/ = 1; + s.opt_len = s.static_len = 0; + s.last_lit = s.matches = 0; +} + + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +function bi_windup(s) +{ + if (s.bi_valid > 8) { + put_short(s, s.bi_buf); + } else if (s.bi_valid > 0) { + //put_byte(s, (Byte)s->bi_buf); + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; +} + +/* =========================================================================== + * Copy a stored block, storing first the length and its + * one's complement if requested. + */ +function copy_block(s, buf, len, header) +//DeflateState *s; +//charf *buf; /* the input data */ +//unsigned len; /* its length */ +//int header; /* true if block header must be written */ +{ + bi_windup(s); /* align on byte boundary */ + + if (header) { + put_short(s, len); + put_short(s, ~len); + } +// while (len--) { +// put_byte(s, *buf++); +// } + utils.arraySet(s.pending_buf, s.window, buf, len, s.pending); + s.pending += len; +} + +/* =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +function smaller(tree, n, m, depth) { + var _n2 = n*2; + var _m2 = m*2; + return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ || + (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m])); +} + +/* =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its + * two sons). + */ +function pqdownheap(s, tree, k) +// deflate_state *s; +// ct_data *tree; /* the tree to restore */ +// int k; /* node to move down */ +{ + var v = s.heap[k]; + var j = k << 1; /* left son of k */ + while (j <= s.heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < s.heap_len && + smaller(tree, s.heap[j+1], s.heap[j], s.depth)) { + j++; + } + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, s.heap[j], s.depth)) { break; } + + /* Exchange v with the smallest son */ + s.heap[k] = s.heap[j]; + k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + s.heap[k] = v; +} + + +// inlined manually +// var SMALLEST = 1; + +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +function compress_block(s, ltree, dtree) +// deflate_state *s; +// const ct_data *ltree; /* literal tree */ +// const ct_data *dtree; /* distance tree */ +{ + var dist; /* distance of matched string */ + var lc; /* match length or unmatched char (if dist == 0) */ + var lx = 0; /* running index in l_buf */ + var code; /* the code to send */ + var extra; /* number of extra bits to send */ + + if (s.last_lit !== 0) { + do { + dist = (s.pending_buf[s.d_buf + lx*2] << 8) | (s.pending_buf[s.d_buf + lx*2 + 1]); + lc = s.pending_buf[s.l_buf + lx]; + lx++; + + if (dist === 0) { + send_code(s, lc, ltree); /* send a literal byte */ + //Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code+LITERALS+1, ltree); /* send the length code */ + extra = extra_lbits[code]; + if (extra !== 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + //Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra !== 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, + // "pendingBuf overflow"); + + } while (lx < s.last_lit); + } + + send_code(s, END_BLOCK, ltree); +} + + +/* =========================================================================== + * Construct one Huffman tree and assigns the code bit strings and lengths. + * Update the total bit length for the current block. + * IN assertion: the field freq is set for all tree elements. + * OUT assertions: the fields len and code are set to the optimal bit length + * and corresponding code. The length opt_len is updated; static_len is + * also updated if stree is not null. The field max_code is set. + */ +function build_tree(s, desc) +// deflate_state *s; +// tree_desc *desc; /* the tree descriptor */ +{ + var tree = desc.dyn_tree; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var elems = desc.stat_desc.elems; + var n, m; /* iterate over heap elements */ + var max_code = -1; /* largest code with non zero frequency */ + var node; /* new node being created */ + + /* Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + s.heap_len = 0; + s.heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n * 2]/*.Freq*/ !== 0) { + s.heap[++s.heap_len] = max_code = n; + s.depth[n] = 0; + + } else { + tree[n*2 + 1]/*.Len*/ = 0; + } + } + + /* The pkzip format requires that at least one distance code exists, + * and that at least one bit should be sent even if there is only one + * possible code. So to avoid special checks later on we force at least + * two codes of non zero frequency. + */ + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0); + tree[node * 2]/*.Freq*/ = 1; + s.depth[node] = 0; + s.opt_len--; + + if (has_stree) { + s.static_len -= stree[node*2 + 1]/*.Len*/; + } + /* node is 0 or 1 so it does not have extra bits */ + } + desc.max_code = max_code; + + /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); } + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + node = elems; /* next internal node of the tree */ + do { + //pqremove(s, tree, n); /* n = node of least frequency */ + /*** pqremove ***/ + n = s.heap[1/*SMALLEST*/]; + s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--]; + pqdownheap(s, tree, 1/*SMALLEST*/); + /***/ + + m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */ + + s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */ + s.heap[--s.heap_max] = m; + + /* Create a new node father of n and m */ + tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/; + s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1; + tree[n*2 + 1]/*.Dad*/ = tree[m*2 + 1]/*.Dad*/ = node; + + /* and insert the new node in the heap */ + s.heap[1/*SMALLEST*/] = node++; + pqdownheap(s, tree, 1/*SMALLEST*/); + + } while (s.heap_len >= 2); + + s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + gen_bitlen(s, desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes(tree, max_code, s.bl_count); +} + + +/* =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. + */ +function scan_tree(s, tree, max_code) +// deflate_state *s; +// ct_data *tree; /* the tree to be scanned */ +// int max_code; /* and its largest code of non zero frequency */ +{ + var n; /* iterates over all tree elements */ + var prevlen = -1; /* last emitted length */ + var curlen; /* length of current code */ + + var nextlen = tree[0*2 + 1]/*.Len*/; /* length of next code */ + + var count = 0; /* repeat count of the current code */ + var max_count = 7; /* max repeat count */ + var min_count = 4; /* min repeat count */ + + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code+1)*2 + 1]/*.Len*/ = 0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n+1)*2 + 1]/*.Len*/; + + if (++count < max_count && curlen === nextlen) { + continue; + + } else if (count < min_count) { + s.bl_tree[curlen * 2]/*.Freq*/ += count; + + } else if (curlen !== 0) { + + if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; } + s.bl_tree[REP_3_6*2]/*.Freq*/++; + + } else if (count <= 10) { + s.bl_tree[REPZ_3_10*2]/*.Freq*/++; + + } else { + s.bl_tree[REPZ_11_138*2]/*.Freq*/++; + } + + count = 0; + prevlen = curlen; + + if (nextlen === 0) { + max_count = 138; + min_count = 3; + + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + + } else { + max_count = 7; + min_count = 4; + } + } +} + + +/* =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +function send_tree(s, tree, max_code) +// deflate_state *s; +// ct_data *tree; /* the tree to be scanned */ +// int max_code; /* and its largest code of non zero frequency */ +{ + var n; /* iterates over all tree elements */ + var prevlen = -1; /* last emitted length */ + var curlen; /* length of current code */ + + var nextlen = tree[0*2 + 1]/*.Len*/; /* length of next code */ + + var count = 0; /* repeat count of the current code */ + var max_count = 7; /* max repeat count */ + var min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n+1)*2 + 1]/*.Len*/; + + if (++count < max_count && curlen === nextlen) { + continue; + + } else if (count < min_count) { + do { send_code(s, curlen, s.bl_tree); } while (--count !== 0); + + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code(s, curlen, s.bl_tree); + count--; + } + //Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s.bl_tree); + send_bits(s, count-3, 2); + + } else if (count <= 10) { + send_code(s, REPZ_3_10, s.bl_tree); + send_bits(s, count-3, 3); + + } else { + send_code(s, REPZ_11_138, s.bl_tree); + send_bits(s, count-11, 7); + } + + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + + } else { + max_count = 7; + min_count = 4; + } + } +} + + +/* =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +function build_bl_tree(s) { + var max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees */ + scan_tree(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree(s, s.dyn_dtree, s.d_desc.max_code); + + /* Build the bit length tree: */ + build_tree(s, s.bl_desc); + /* opt_len now includes the length of the tree representations, except + * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order[max_blindex]*2 + 1]/*.Len*/ !== 0) { + break; + } + } + /* Update opt_len to include the bit length tree and counts */ + s.opt_len += 3*(max_blindex+1) + 5+5+4; + //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + // s->opt_len, s->static_len)); + + return max_blindex; +} + + +/* =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. + * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +function send_all_trees(s, lcodes, dcodes, blcodes) +// deflate_state *s; +// int lcodes, dcodes, blcodes; /* number of codes for each tree */ +{ + var rank; /* index in bl_order */ + + //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); + //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + // "too many codes"); + //Tracev((stderr, "\nbl counts: ")); + send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes-1, 5); + send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + //Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(s, s.bl_tree[bl_order[rank]*2 + 1]/*.Len*/, 3); + } + //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); + + send_tree(s, s.dyn_ltree, lcodes-1); /* literal tree */ + //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); + + send_tree(s, s.dyn_dtree, dcodes-1); /* distance tree */ + //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +} + + +/* =========================================================================== + * Check if the data type is TEXT or BINARY, using the following algorithm: + * - TEXT if the two conditions below are satisfied: + * a) There are no non-portable control characters belonging to the + * "black list" (0..6, 14..25, 28..31). + * b) There is at least one printable character belonging to the + * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). + * - BINARY otherwise. + * - The following partially-portable control characters form a + * "gray list" that is ignored in this detection algorithm: + * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). + * IN assertion: the fields Freq of dyn_ltree are set. + */ +function detect_data_type(s) { + /* black_mask is the bit mask of black-listed bytes + * set bits 0..6, 14..25, and 28..31 + * 0xf3ffc07f = binary 11110011111111111100000001111111 + */ + var black_mask = 0xf3ffc07f; + var n; + + /* Check for non-textual ("black-listed") bytes. */ + for (n = 0; n <= 31; n++, black_mask >>>= 1) { + if ((black_mask & 1) && (s.dyn_ltree[n*2]/*.Freq*/ !== 0)) { + return Z_BINARY; + } + } + + /* Check for textual ("white-listed") bytes. */ + if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 || + s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) { + return Z_TEXT; + } + for (n = 32; n < LITERALS; n++) { + if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) { + return Z_TEXT; + } + } + + /* There are no "black-listed" or "white-listed" bytes: + * this stream either is empty or has tolerated ("gray-listed") bytes only. + */ + return Z_BINARY; +} + + +var static_init_done = false; + +/* =========================================================================== + * Initialize the tree data structures for a new zlib stream. + */ +function _tr_init(s) +{ + + if (!static_init_done) { + tr_static_init(); + static_init_done = true; + } + + s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); + s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); + s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); + + s.bi_buf = 0; + s.bi_valid = 0; + + /* Initialize the first block of the first file: */ + init_block(s); +} + + +/* =========================================================================== + * Send a stored block + */ +function _tr_stored_block(s, buf, stored_len, last) +//DeflateState *s; +//charf *buf; /* input block */ +//ulg stored_len; /* length of input block */ +//int last; /* one if this is the last block for a file */ +{ + send_bits(s, (STORED_BLOCK<<1)+(last ? 1 : 0), 3); /* send block type */ + copy_block(s, buf, stored_len, true); /* with header */ +} + + +/* =========================================================================== + * Send one empty static block to give enough lookahead for inflate. + * This takes 10 bits, of which 7 may remain in the bit buffer. + */ +function _tr_align(s) { + send_bits(s, STATIC_TREES<<1, 3); + send_code(s, END_BLOCK, static_ltree); + bi_flush(s); +} + + +/* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +function _tr_flush_block(s, buf, stored_len, last) +//DeflateState *s; +//charf *buf; /* input block, or NULL if too old */ +//ulg stored_len; /* length of input block */ +//int last; /* one if this is the last block for a file */ +{ + var opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + var max_blindex = 0; /* index of last bit length code of non zero freq */ + + /* Build the Huffman trees unless a stored block is forced */ + if (s.level > 0) { + + /* Check if the file is binary or text */ + if (s.strm.data_type === Z_UNKNOWN) { + s.strm.data_type = detect_data_type(s); + } + + /* Construct the literal and distance trees */ + build_tree(s, s.l_desc); + // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, + // s->static_len)); + + build_tree(s, s.d_desc); + // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, + // s->static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* Build the bit length tree for the above two trees, and get the index + * in bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(s); + + /* Determine the best encoding. Compute the block lengths in bytes. */ + opt_lenb = (s.opt_len+3+7) >>> 3; + static_lenb = (s.static_len+3+7) >>> 3; + + // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + // opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, + // s->last_lit)); + + if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; } + + } else { + // Assert(buf != (char*)0, "lost buf"); + opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ + } + + if ((stored_len+4 <= opt_lenb) && (buf !== -1)) { + /* 4: two words for the lengths */ + + /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + * Otherwise we can't have processed more than WSIZE input bytes since + * the last block flush, because compression would have been + * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to + * transform a block into a stored block. + */ + _tr_stored_block(s, buf, stored_len, last); + + } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { + + send_bits(s, (STATIC_TREES<<1) + (last ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + + } else { + send_bits(s, (DYN_TREES<<1) + (last ? 1 : 0), 3); + send_all_trees(s, s.l_desc.max_code+1, s.d_desc.max_code+1, max_blindex+1); + compress_block(s, s.dyn_ltree, s.dyn_dtree); + } + // Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* The above check is made mod 2^32, for files larger than 512 MB + * and uLong implemented on 32 bits. + */ + init_block(s); + + if (last) { + bi_windup(s); + } + // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, + // s->compressed_len-7*last)); +} + +/* =========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +function _tr_tally(s, dist, lc) +// deflate_state *s; +// unsigned dist; /* distance of matched string */ +// unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + //var out_length, in_length, dcode; + + s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff; + s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff; + + s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff; + s.last_lit++; + + if (dist === 0) { + /* lc is the unmatched char */ + s.dyn_ltree[lc*2]/*.Freq*/++; + } else { + s.matches++; + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + //Assert((ush)dist < (ush)MAX_DIST(s) && + // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + // (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); + + s.dyn_ltree[(_length_code[lc]+LITERALS+1) * 2]/*.Freq*/++; + s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++; + } + +// (!) This block is disabled in zlib defailts, +// don't enable it for binary compatibility + +//#ifdef TRUNCATE_BLOCK +// /* Try to guess if it is profitable to stop the current block here */ +// if ((s.last_lit & 0x1fff) === 0 && s.level > 2) { +// /* Compute an upper bound for the compressed length */ +// out_length = s.last_lit*8; +// in_length = s.strstart - s.block_start; +// +// for (dcode = 0; dcode < D_CODES; dcode++) { +// out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]); +// } +// out_length >>>= 3; +// //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", +// // s->last_lit, in_length, out_length, +// // 100L - out_length*100L/in_length)); +// if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) { +// return true; +// } +// } +//#endif + + return (s.last_lit === s.lit_bufsize-1); + /* We avoid equality with lit_bufsize because of wraparound at 64K + * on 16 bit machines and because stored blocks are restricted to + * 64K-1 bytes. + */ +} + +exports._tr_init = _tr_init; +exports._tr_stored_block = _tr_stored_block; +exports._tr_flush_block = _tr_flush_block; +exports._tr_tally = _tr_tally; +exports._tr_align = _tr_align; + +},{"../utils/common":55}],65:[function(require,module,exports){ +'use strict'; + + +function ZStream() { + /* next input byte */ + this.input = null; // JS specific, because we have no pointers + this.next_in = 0; + /* number of bytes available at input */ + this.avail_in = 0; + /* total number of input bytes read so far */ + this.total_in = 0; + /* next output byte should be put there */ + this.output = null; // JS specific, because we have no pointers + this.next_out = 0; + /* remaining free space at output */ + this.avail_out = 0; + /* total number of bytes output so far */ + this.total_out = 0; + /* last error message, NULL if no error */ + this.msg = ''/*Z_NULL*/; + /* not visible by applications */ + this.state = null; + /* best guess about the data type: binary or text */ + this.data_type = 2/*Z_UNKNOWN*/; + /* adler32 value of the uncompressed data */ + this.adler = 0; +} + +module.exports = ZStream; + +},{}],66:[function(require,module,exports){ +(function (process){ +// 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. + +// resolves . and .. elements in a path array with directory names there +// must be no slashes, empty elements, or device names (c:\) in the array +// (so also no leading and trailing slashes - it does not distinguish +// relative and absolute paths) +function normalizeArray(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up--; up) { + parts.unshift('..'); + } + } + + return parts; +} + +// Split a filename into [root, dir, basename, ext], unix version +// 'root' is just a slash, or nothing. +var splitPathRe = + /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; +var splitPath = function(filename) { + return splitPathRe.exec(filename).slice(1); +}; + +// path.resolve([from ...], to) +// posix version +exports.resolve = function() { + var resolvedPath = '', + resolvedAbsolute = false; + + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) ? arguments[i] : process.cwd(); + + // Skip empty and invalid entries + if (typeof path !== 'string') { + throw new TypeError('Arguments to path.resolve must be strings'); + } else if (!path) { + continue; + } + + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; + } + + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + + // Normalize the path + resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; +}; + +// path.normalize(path) +// posix version +exports.normalize = function(path) { + var isAbsolute = exports.isAbsolute(path), + trailingSlash = substr(path, -1) === '/'; + + // Normalize the path + path = normalizeArray(filter(path.split('/'), function(p) { + return !!p; + }), !isAbsolute).join('/'); + + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + + return (isAbsolute ? '/' : '') + path; +}; + +// posix version +exports.isAbsolute = function(path) { + return path.charAt(0) === '/'; +}; + +// posix version +exports.join = function() { + var paths = Array.prototype.slice.call(arguments, 0); + return exports.normalize(filter(paths, function(p, index) { + if (typeof p !== 'string') { + throw new TypeError('Arguments to path.join must be strings'); + } + return p; + }).join('/')); +}; + + +// path.relative(from, to) +// posix version +exports.relative = function(from, to) { + from = exports.resolve(from).substr(1); + to = exports.resolve(to).substr(1); + + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== '') break; + } + + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== '') break; + } + + if (start > end) return []; + return arr.slice(start, end - start + 1); + } + + var fromParts = trim(from.split('/')); + var toParts = trim(to.split('/')); + + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break; + } + } + + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push('..'); + } + + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + + return outputParts.join('/'); +}; + +exports.sep = '/'; +exports.delimiter = ':'; + +exports.dirname = function(path) { + var result = splitPath(path), + root = result[0], + dir = result[1]; + + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + + return root + dir; +}; + + +exports.basename = function(path, ext) { + var f = splitPath(path)[2]; + // TODO: make this comparison case-insensitive on windows? + if (ext && f.substr(-1 * ext.length) === ext) { + f = f.substr(0, f.length - ext.length); + } + return f; +}; + + +exports.extname = function(path) { + return splitPath(path)[3]; +}; + +function filter (xs, f) { + if (xs.filter) return xs.filter(f); + var res = []; + for (var i = 0; i < xs.length; i++) { + if (f(xs[i], i, xs)) res.push(xs[i]); + } + return res; +} + +// String.prototype.substr - negative index don't work in IE8 +var substr = 'ab'.substr(-1) === 'b' + ? function (str, start, len) { return str.substr(start, len) } + : function (str, start, len) { + if (start < 0) start = str.length + start; + return str.substr(start, len); + } +; + +}).call(this,require('_process')) +},{"_process":68}],67:[function(require,module,exports){ +(function (process){ +'use strict'; +module.exports = nextTick; + +function nextTick(fn) { + var args = new Array(arguments.length - 1); + var i = 0; + while (i < args.length) { + args[i++] = arguments[i]; + } + process.nextTick(function afterTick() { + fn.apply(null, args); + }); +} + +}).call(this,require('_process')) +},{"_process":68}],68:[function(require,module,exports){ +// shim for using process in browser + +var process = module.exports = {}; +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = setTimeout(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; + clearTimeout(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) { + setTimeout(drainQueue, 0); + } +}; + +// 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.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; }; + +},{}],69:[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]'; +}; + +},{}],70:[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; +}; + +},{}],71:[function(require,module,exports){ +'use strict'; + +exports.decode = exports.parse = require('./decode'); +exports.encode = exports.stringify = require('./encode'); + +},{"./decode":69,"./encode":70}],72:[function(require,module,exports){ + +/** + * Reduce `arr` with `fn`. + * + * @param {Array} arr + * @param {Function} fn + * @param {Mixed} initial + * + * TODO: combatible error handling? + */ + +module.exports = function(arr, fn, initial){ + var idx = 0; + var len = arr.length; + var curr = arguments.length == 3 + ? initial + : arr[idx++]; + + while (idx < len) { + curr = fn.call(null, curr, arr[idx], ++idx, arr); + } + + return curr; +}; +},{}],73:[function(require,module,exports){ +(function (Buffer){ + +/** + * An interface for modeling and instantiating C-style data structures. This is + * not a constructor per-say, but a constructor generator. It takes an array of + * tuples, the left side being the type, and the right side being a field name. + * The order should be the same order it would appear in the C-style struct + * definition. It returns a function that can be used to construct an object that + * reads and writes to the data structure using properties specified by the + * initial field list. + * + * The only verboten field names are "ref", which is used used on struct + * instances as a function to retrieve the backing Buffer instance of the + * struct, and "ref.buffer" which contains the backing Buffer instance. + * + * + * Example: + * + * ``` javascript + * var ref = require('ref') + * var Struct = require('ref-struct') + * + * // create the `char *` type + * var charPtr = ref.refType(ref.types.char) + * var int = ref.types.int + * + * // create the struct "type" / constructor + * var PasswordEntry = Struct({ + * 'username': 'string' + * , 'password': 'string' + * , 'salt': int + * }) + * + * // create an instance of the struct, backed a Buffer instance + * var pwd = new PasswordEntry() + * pwd.username = 'ricky' + * pwd.password = 'rbransonlovesnode.js' + * pwd.salt = (Math.random() * 1000000) | 0 + * + * pwd.username // → 'ricky' + * pwd.password // → 'rbransonlovesnode.js' + * pwd.salt // → 820088 + * ``` + */ + +/** + * Module dependencies. + */ + +var ref = require('ref') +var util = require('util') +var assert = require('assert') +var debug = require('debug')('ref:struct') + +/** + * Module exports. + */ + +module.exports = Struct + +/** + * The Struct "type" meta-constructor. + */ + +function Struct () { + debug('defining new struct "type"') + + /** + * This is the "constructor" of the Struct type that gets returned. + * + * Invoke it with `new` to create a new Buffer instance backing the struct. + * Pass it an existing Buffer instance to use that as the backing buffer. + * Pass in an Object containing the struct fields to auto-populate the + * struct with the data. + */ + + function StructType (arg, data) { + if (!(this instanceof StructType)) { + return new StructType(arg, data) + } + debug('creating new struct instance') + var store + if (Buffer.isBuffer(arg)) { + debug('using passed-in Buffer instance to back the struct', arg) + assert(arg.length >= StructType.size, 'Buffer instance must be at least ' + + StructType.size + ' bytes to back this struct type') + store = arg + arg = data + } else { + debug('creating new Buffer instance to back the struct (size: %d)', StructType.size) + store = new Buffer(StructType.size) + } + + // set the backing Buffer store + store.type = StructType + this['ref.buffer'] = store + + if (arg) { + for (var key in arg) { + // hopefully hit the struct setters + this[key] = arg[key] + } + } + StructType._instanceCreated = true + } + + // make instances inherit from the `proto` + StructType.prototype = Object.create(proto, { + constructor: { + value: StructType + , enumerable: false + , writable: true + , configurable: true + } + }) + + StructType.defineProperty = defineProperty + StructType.toString = toString + StructType.fields = {} + + // Setup the ref "type" interface. The constructor doubles as the "type" object + StructType.size = 0 + StructType.alignment = 0 + StructType.indirection = 1 + StructType.get = get + StructType.set = set + + // Read the fields list and apply all the fields to the struct + // TODO: Better arg handling... (maybe look at ES6 binary data API?) + var arg = arguments[0] + if (Array.isArray(arg)) { + // legacy API + arg.forEach(function (a) { + var type = a[0] + var name = a[1] + StructType.defineProperty(name, type) + }) + } else if (typeof arg === 'object') { + Object.keys(arg).forEach(function (name) { + var type = arg[name] + StructType.defineProperty(name, type) + }) + } + + return StructType +} + +/** + * The "get" function of the Struct "type" interface + */ + +function get (buffer, offset) { + debug('Struct "type" getter for buffer at offset', buffer, offset) + if (offset > 0) { + buffer = buffer.slice(offset) + } + return new this(buffer) +} + +/** + * The "set" function of the Struct "type" interface + */ + +function set (buffer, offset, value) { + debug('Struct "type" setter for buffer at offset', buffer, offset, value) + var isStruct = value instanceof this + if (isStruct) { + // optimization: copy the buffer contents directly rather + // than going through the ref-struct constructor + value['ref.buffer'].copy(buffer, offset, 0, this.size); + } else { + if (offset > 0) { + buffer = buffer.slice(offset) + } + new this(buffer, value) + } +} + +/** + * Custom `toString()` override for struct type instances. + */ + +function toString () { + return '[StructType]' +} + +/** + * Adds a new field to the struct instance with the given name and type. + * Note that this function will throw an Error if any instances of the struct + * type have already been created, therefore this function must be called at the + * beginning, before any instances are created. + */ + +function defineProperty (name, type) { + debug('defining new struct type field', name) + + // allow string types for convenience + type = ref.coerceType(type) + + assert(!this._instanceCreated, 'an instance of this Struct type has already ' + + 'been created, cannot add new "fields" anymore') + assert.equal('string', typeof name, 'expected a "string" field name') + assert(type && /object|function/i.test(typeof type) && 'size' in type && + 'indirection' in type + , 'expected a "type" object describing the field type: "' + type + '"') + assert(type.indirection > 1 || type.size > 0, + '"type" object must have a size greater than 0') + assert(!(name in this.prototype), 'the field "' + name + + '" already exists in this Struct type') + + var field = { + type: type + } + this.fields[name] = field + + // define the getter/setter property + var desc = { enumerable: true , configurable: true } + desc.get = function () { + debug('getting "%s" struct field (offset: %d)', name, field.offset) + return ref.get(this['ref.buffer'], field.offset, type) + } + desc.set = function (value) { + debug('setting "%s" struct field (offset: %d)', name, field.offset, value) + return ref.set(this['ref.buffer'], field.offset, value, type) + } + + // calculate the new size and field offsets + recalc(this) + + Object.defineProperty(this.prototype, name, desc); +} + +function recalc (struct) { + + // reset size and alignment + struct.size = 0 + struct.alignment = 0 + + var fieldNames = Object.keys(struct.fields) + + // first loop through is to determine the `alignment` of this struct + fieldNames.forEach(function (name) { + var field = struct.fields[name] + var type = field.type + var alignment = type.alignment || ref.alignof.pointer + if (type.indirection > 1) { + alignment = ref.alignof.pointer + } + struct.alignment = Math.max(struct.alignment, alignment) + }) + + // second loop through sets the `offset` property on each "field" + // object, and sets the `struct.size` as we go along + fieldNames.forEach(function (name) { + var field = struct.fields[name] + var type = field.type + + if (null != type.fixedLength) { + // "ref-array" types set the "fixedLength" prop. don't treat arrays like one + // contiguous entity. instead, treat them like individual elements in the + // struct. doing this makes the padding end up being calculated correctly. + field.offset = addType(type.type) + for (var i = 1; i < type.fixedLength; i++) { + addType(type.type) + } + } else { + field.offset = addType(type) + } + }) + + function addType (type) { + var offset = struct.size + var align = type.indirection === 1 ? type.alignment : ref.alignof.pointer + var padding = (align - (offset % align)) % align + var size = type.indirection === 1 ? type.size : ref.sizeof.pointer + + offset += padding + + assert.equal(offset % align, 0, "offset should align") + + // adjust the "size" of the struct type + struct.size = offset + size + + // return the calulated offset + return offset + } + + // any final padding? + var left = struct.size % struct.alignment + if (left > 0) { + debug('additional padding to the end of struct:', struct.alignment - left) + struct.size += struct.alignment - left + } +} + +/** + * this is the custom prototype of Struct type instances. + */ + +var proto = {} + +/** + * set a placeholder variable on the prototype so that defineProperty() will + * throw an error if you try to define a struct field with the name "buffer". + */ + +proto['ref.buffer'] = ref.NULL + +/** + * Flattens the Struct instance into a regular JavaScript Object. This function + * "gets" all the defined properties. + * + * @api public + */ + +proto.toObject = function toObject () { + var obj = {} + Object.keys(this.constructor.fields).forEach(function (k) { + obj[k] = this[k] + }, this) + return obj +} + +/** + * Basic `JSON.stringify(struct)` support. + */ + +proto.toJSON = function toJSON () { + return this.toObject() +} + +/** + * `.inspect()` override. For the REPL. + * + * @api public + */ + +proto.inspect = function inspect () { + var obj = this.toObject() + // add instance's "own properties" + Object.keys(this).forEach(function (k) { + obj[k] = this[k] + }, this) + return util.inspect(obj) +} + +/** + * returns a Buffer pointing to this struct data structure. + */ + +proto.ref = function ref () { + return this['ref.buffer'] +} + +}).call(this,require("buffer").Buffer) +},{"assert":26,"buffer":38,"debug":41,"ref":74,"util":90}],74:[function(require,module,exports){ +(function (Buffer){ + +var assert = require('assert') +var debug = require('debug')('ref') + +exports = module.exports = require('bindings')('binding') + +/** + * A `Buffer` that references the C NULL pointer. That is, its memory address + * points to 0. Its `length` is 0 because accessing any data from this buffer + * would cause a _segmentation fault_. + * + * ``` + * console.log(ref.NULL); + * + * ``` + * + * @name NULL + * @type Buffer + */ + +/** + * A string that represents the native endianness of the machine's processor. + * The possible values are either `"LE"` or `"BE"`. + * + * ``` + * console.log(ref.endianness); + * 'LE' + * ``` + * + * @name endianness + * @type String + */ + +/** + * Accepts a `Buffer` instance and returns the memory address of the buffer + * instance. + * + * ``` + * console.log(ref.address(new Buffer(1))); + * 4320233616 + * + * console.log(ref.address(ref.NULL))); + * 0 + * ``` + * + * @param {Buffer} buffer The buffer to get the memory address of. + * @return {Number} The memory address the buffer instance. + * @name address + * @type method + */ + +/** + * Accepts a `Buffer` instance and returns _true_ if the buffer represents the + * NULL pointer, _false_ otherwise. + * + * ``` + * console.log(ref.isNull(new Buffer(1))); + * false + * + * console.log(ref.isNull(ref.NULL)); + * true + * ``` + * + * @param {Buffer} buffer The buffer to check for NULL. + * @return {Boolean} true or false. + * @name isNull + * @type method + */ + +/** + * Reads a JavaScript Object that has previously been written to the given + * _buffer_ at the given _offset_. + * + * ``` + * var obj = { foo: 'bar' }; + * var buf = ref.alloc('Object', obj); + * + * var obj2 = ref.readObject(buf, 0); + * console.log(obj === obj2); + * true + * ``` + * + * @param {Buffer} buffer The buffer to read an Object from. + * @param {Number} offset The offset to begin reading from. + * @return {Object} The Object that was read from _buffer_. + * @name readObject + * @type method + */ + +/** + * Reads a Buffer instance from the given _buffer_ at the given _offset_. + * The _size_ parameter specifies the `length` of the returned Buffer instance, + * which defaults to __0__. + * + * ``` + * var buf = new Buffer('hello world'); + * var pointer = ref.alloc('pointer'); + * + * var buf2 = ref.readPointer(pointer, 0, buf.length); + * console.log(buf.toString()); + * 'hello world' + * ``` + * + * @param {Buffer} buffer The buffer to read a Buffer from. + * @param {Number} offset The offset to begin reading from. + * @param {Number} length (optional) The length of the returned Buffer. Defaults to 0. + * @return {Buffer} The Buffer instance that was read from _buffer_. + * @name readPointer + * @type method + */ + +/** + * Returns a JavaScript String read from _buffer_ at the given _offset_. The + * C String is read until the first NULL byte, which indicates the end of the + * String. + * + * This function can read beyond the `length` of a Buffer. + * + * ``` + * var buf = new Buffer('hello\0world\0'); + * + * var str = ref.readCString(buf, 0); + * console.log(str); + * 'hello' + * ``` + * + * @param {Buffer} buffer The buffer to read a Buffer from. + * @param {Number} offset The offset to begin reading from. + * @return {String} The String that was read from _buffer_. + * @name readCString + * @type method + */ + +/** + * Returns a big-endian signed 64-bit int read from _buffer_ at the given + * _offset_. + * + * If the returned value will fit inside a JavaScript Number without losing + * precision, then a Number is returned, otherwise a String is returned. + * + * ``` + * var buf = ref.alloc('int64'); + * ref.writeInt64BE(buf, 0, '9223372036854775807'); + * + * var val = ref.readInt64BE(buf, 0) + * console.log(val) + * '9223372036854775807' + * ``` + * + * @param {Buffer} buffer The buffer to read a Buffer from. + * @param {Number} offset The offset to begin reading from. + * @return {Number|String} The Number or String that was read from _buffer_. + * @name readInt64BE + * @type method + */ + +/** + * Returns a little-endian signed 64-bit int read from _buffer_ at the given + * _offset_. + * + * If the returned value will fit inside a JavaScript Number without losing + * precision, then a Number is returned, otherwise a String is returned. + * + * ``` + * var buf = ref.alloc('int64'); + * ref.writeInt64LE(buf, 0, '9223372036854775807'); + * + * var val = ref.readInt64LE(buf, 0) + * console.log(val) + * '9223372036854775807' + * ``` + * + * @param {Buffer} buffer The buffer to read a Buffer from. + * @param {Number} offset The offset to begin reading from. + * @return {Number|String} The Number or String that was read from _buffer_. + * @name readInt64LE + * @type method + */ + +/** + * Returns a big-endian unsigned 64-bit int read from _buffer_ at the given + * _offset_. + * + * If the returned value will fit inside a JavaScript Number without losing + * precision, then a Number is returned, otherwise a String is returned. + * + * ``` + * var buf = ref.alloc('uint64'); + * ref.writeUInt64BE(buf, 0, '18446744073709551615'); + * + * var val = ref.readUInt64BE(buf, 0) + * console.log(val) + * '18446744073709551615' + * ``` + * + * @param {Buffer} buffer The buffer to read a Buffer from. + * @param {Number} offset The offset to begin reading from. + * @return {Number|String} The Number or String that was read from _buffer_. + * @name readUInt64BE + * @type method + */ + +/** + * Returns a little-endian unsigned 64-bit int read from _buffer_ at the given + * _offset_. + * + * If the returned value will fit inside a JavaScript Number without losing + * precision, then a Number is returned, otherwise a String is returned. + * + * ``` + * var buf = ref.alloc('uint64'); + * ref.writeUInt64LE(buf, 0, '18446744073709551615'); + * + * var val = ref.readUInt64LE(buf, 0) + * console.log(val) + * '18446744073709551615' + * ``` + * + * @param {Buffer} buffer The buffer to read a Buffer from. + * @param {Number} offset The offset to begin reading from. + * @return {Number|String} The Number or String that was read from _buffer_. + * @name readUInt64LE + * @type method + */ + +/** + * Writes the _input_ Number or String as a big-endian signed 64-bit int into + * _buffer_ at the given _offset_. + * + * ``` + * var buf = ref.alloc('int64'); + * ref.writeInt64BE(buf, 0, '9223372036854775807'); + * ``` + * + * @param {Buffer} buffer The buffer to write to. + * @param {Number} offset The offset to begin writing from. + * @param {Number|String} input This String or Number which gets written. + * @name writeInt64BE + * @type method + */ + +/** + * Writes the _input_ Number or String as a little-endian signed 64-bit int into + * _buffer_ at the given _offset_. + * + * ``` + * var buf = ref.alloc('int64'); + * ref.writeInt64LE(buf, 0, '9223372036854775807'); + * ``` + * + * @param {Buffer} buffer The buffer to write to. + * @param {Number} offset The offset to begin writing from. + * @param {Number|String} input This String or Number which gets written. + * @name writeInt64LE + * @type method + */ + +/** + * Writes the _input_ Number or String as a big-endian unsigned 64-bit int into + * _buffer_ at the given _offset_. + * + * ``` + * var buf = ref.alloc('uint64'); + * ref.writeUInt64BE(buf, 0, '18446744073709551615'); + * ``` + * + * @param {Buffer} buffer The buffer to write to. + * @param {Number} offset The offset to begin writing from. + * @param {Number|String} input This String or Number which gets written. + * @name writeUInt64BE + * @type method + */ + +/** + * Writes the _input_ Number or String as a little-endian unsigned 64-bit int + * into _buffer_ at the given _offset_. + * + * ``` + * var buf = ref.alloc('uint64'); + * ref.writeUInt64LE(buf, 0, '18446744073709551615'); + * ``` + * + * @param {Buffer} buffer The buffer to write to. + * @param {Number} offset The offset to begin writing from. + * @param {Number|String} input This String or Number which gets written. + * @name writeUInt64LE + * @type method + */ + +/** + * Returns a new clone of the given "type" object, with its + * `indirection` level incremented by **1**. + * + * Say you wanted to create a type representing a `void *`: + * + * ``` + * var voidPtrType = ref.refType(ref.types.void); + * ``` + * + * @param {Object|String} type The "type" object to create a reference type from. Strings get coerced first. + * @return {Object} The new "type" object with its `indirection` incremented by 1. + */ + +exports.refType = function refType (type) { + var _type = exports.coerceType(type) + var rtn = Object.create(_type) + rtn.indirection++ + if (_type.name) { + rtn.name = _type.name + '*' + } + return rtn +} + +/** + * Returns a new clone of the given "type" object, with its + * `indirection` level decremented by 1. + * + * @param {Object|String} type The "type" object to create a dereference type from. Strings get coerced first. + * @return {Object} The new "type" object with its `indirection` decremented by 1. + */ + +exports.derefType = function derefType (type) { + var _type = exports.coerceType(type) + if (_type.indirection === 1) { + throw new Error('Cannot create deref\'d type for type with indirection 1') + } + var rtn = Object.getPrototypeOf(_type) + if (rtn.indirection !== _type.indirection - 1) { + // slow case + rtn = Object.create(_type) + rtn.indirection-- + } + return rtn +} + +/** + * Coerces a "type" object from a String or an actual "type" object. String values + * are looked up from the `ref.types` Object. So: + * + * * `"int"` gets coerced into `ref.types.int`. + * * `"int *"` gets translated into `ref.refType(ref.types.int)` + * * `ref.types.int` gets translated into `ref.types.int` (returns itself) + * + * Throws an Error if no valid "type" object could be determined. Most `ref` + * functions use this function under the hood, so anywhere a "type" object is + * expected, a String may be passed as well, including simply setting the + * `buffer.type` property. + * + * ``` + * var type = ref.coerceType('int **'); + * + * console.log(type.indirection); + * 3 + * ``` + * + * @param {Object|String} type The "type" Object or String to coerce. + * @return {Object} A "type" object + */ + +exports.coerceType = function coerceType (type) { + var rtn = type + if (typeof rtn === 'string') { + rtn = exports.types[type] + if (rtn) return rtn + + // strip whitespace + rtn = type.replace(/\s+/g, '').toLowerCase() + if (rtn === 'pointer') { + // legacy "pointer" being used :( + rtn = exports.refType(exports.types.void) // void * + } else if (rtn === 'string') { + rtn = exports.types.CString // special char * type + } else { + var refCount = 0 + rtn = rtn.replace(/\*/g, function () { + refCount++ + return '' + }) + // allow string names to be passed in + rtn = exports.types[rtn] + if (refCount > 0) { + if (!(rtn && 'size' in rtn && 'indirection' in rtn)) { + throw new TypeError('could not determine a proper "type" from: ' + JSON.stringify(type)) + } + for (var i = 0; i < refCount; i++) { + rtn = exports.refType(rtn) + } + } + } + } + if (!(rtn && 'size' in rtn && 'indirection' in rtn)) { + throw new TypeError('could not determine a proper "type" from: ' + JSON.stringify(type)) + } + return rtn +} + +/** + * Returns the "type" property of the given Buffer. + * Creates a default type for the buffer when none exists. + * + * @param {Buffer} buffer The Buffer instance to get the "type" object from. + * @return {Object} The "type" object from the given Buffer. + */ + +exports.getType = function getType (buffer) { + if (!buffer.type) { + debug('WARN: no "type" found on buffer, setting default "type"', buffer) + buffer.type = {} + buffer.type.size = buffer.length + buffer.type.indirection = 1 + buffer.type.get = function get () { + throw new Error('unknown "type"; cannot get()') + } + buffer.type.set = function set () { + throw new Error('unknown "type"; cannot set()') + } + } + return exports.coerceType(buffer.type) +} + +/** + * Calls the `get()` function of the Buffer's current "type" (or the + * passed in _type_ if present) at the given _offset_. + * + * This function handles checking the "indirection" level and returning a + * proper "dereferenced" Bufffer instance when necessary. + * + * @param {Buffer} buffer The Buffer instance to read from. + * @param {Number} offset (optional) The offset on the Buffer to start reading from. Defaults to 0. + * @param {Object|String} type (optional) The "type" object to use when reading. Defaults to calling `getType()` on the buffer. + * @return {?} Whatever value the "type" used when reading returns. + */ + +exports.get = function get (buffer, offset, type) { + if (!offset) { + offset = 0 + } + if (type) { + type = exports.coerceType(type) + } else { + type = exports.getType(buffer) + } + debug('get(): (offset: %d)', offset, buffer) + assert(type.indirection > 0, '"indirection" level must be at least 1') + if (type.indirection === 1) { + // need to check "type" + return type.get(buffer, offset) + } else { + // need to create a deref'd Buffer + var size = type.indirection === 2 ? type.size : exports.sizeof.pointer + var reference = exports.readPointer(buffer, offset, size) + reference.type = exports.derefType(type) + return reference + } +} + +/** + * Calls the `set()` function of the Buffer's current "type" (or the + * passed in _type_ if present) at the given _offset_. + * + * This function handles checking the "indirection" level writing a pointer rather + * than calling the `set()` function if the indirection is greater than 1. + * + * @param {Buffer} buffer The Buffer instance to write to. + * @param {Number} offset The offset on the Buffer to start writing to. + * @param {?} value The value to write to the Buffer instance. + * @param {Object|String} type (optional) The "type" object to use when reading. Defaults to calling `getType()` on the buffer. + */ + +exports.set = function set (buffer, offset, value, type) { + if (!offset) { + offset = 0 + } + if (type) { + type = exports.coerceType(type) + } else { + type = exports.getType(buffer) + } + debug('set(): (offset: %d)', offset, buffer, value) + assert(type.indirection >= 1, '"indirection" level must be at least 1') + if (type.indirection === 1) { + type.set(buffer, offset, value) + } else { + exports.writePointer(buffer, offset, value) + } +} + + +/** + * Returns a new Buffer instance big enough to hold `type`, + * with the given `value` written to it. + * + * ``` js + * var intBuf = ref.alloc(ref.types.int) + * var int_with_4 = ref.alloc(ref.types.int, 4) + * ``` + * + * @param {Object|String} type The "type" object to allocate. Strings get coerced first. + * @param {?} value (optional) The initial value set on the returned Buffer, using _type_'s `set()` function. + * @return {Buffer} A new Buffer instance with it's `type` set to "type", and (optionally) "value" written to it. + */ + +exports.alloc = function alloc (_type, value) { + var type = exports.coerceType(_type) + debug('allocating Buffer for type with "size"', type.size) + var size + if (type.indirection === 1) { + size = type.size + } else { + size = exports.sizeof.pointer + } + var buffer = new Buffer(size) + buffer.type = type + if (arguments.length >= 2) { + debug('setting value on allocated buffer', value) + exports.set(buffer, 0, value, type) + } + return buffer +} + +/** + * Returns a new `Buffer` instance with the given String written to it with the + * given encoding (defaults to __'utf8'__). The buffer is 1 byte longer than the + * string itself, and is NUL terminated. + * + * ``` + * var buf = ref.allocCString('hello world'); + * + * console.log(buf.toString()); + * 'hello world\u0000' + * ``` + * + * @param {String} string The JavaScript string to be converted to a C string. + * @param {String} encoding (optional) The encoding to use for the C string. Defaults to __'utf8'__. + * @return {Buffer} The new `Buffer` instance with the specified String wrtten to it, and a trailing NUL byte. + */ + +exports.allocCString = function allocCString (string, encoding) { + if (null == string || (Buffer.isBuffer(string) && exports.isNull(string))) { + return exports.NULL + } + var size = Buffer.byteLength(string, encoding) + 1 + var buffer = new Buffer(size) + exports.writeCString(buffer, 0, string, encoding) + buffer.type = charPtrType + return buffer +} + +/** + * Writes the given string as a C String (NULL terminated) to the given buffer + * at the given offset. "encoding" is optional and defaults to __'utf8'__. + * + * Unlike `readCString()`, this function requires the buffer to actually have the + * proper length. + * + * @param {Buffer} buffer The Buffer instance to write to. + * @param {Number} offset The offset of the buffer to begin writing at. + * @param {String} string The JavaScript String to write that will be written to the buffer. + * @param {String} encoding (optional) The encoding to read the C string as. Defaults to __'utf8'__. + */ + +exports.writeCString = function writeCString (buffer, offset, string, encoding) { + assert(Buffer.isBuffer(buffer), 'expected a Buffer as the first argument') + assert.equal('string', typeof string, 'expected a "string" as the third argument') + if (!offset) { + offset = 0 + } + if (!encoding) { + encoding = 'utf8' + } + var size = buffer.length - offset + var len = buffer.write(string, offset, size, encoding) + buffer.writeUInt8(0, offset + len) // NUL terminate +} + +exports['readInt64' + exports.endianness] = exports.readInt64 +exports['readUInt64' + exports.endianness] = exports.readUInt64 +exports['writeInt64' + exports.endianness] = exports.writeInt64 +exports['writeUInt64' + exports.endianness] = exports.writeUInt64 + +var opposite = exports.endianness == 'LE' ? 'BE' : 'LE' +var int64temp = new Buffer(exports.sizeof.int64) +var uint64temp = new Buffer(exports.sizeof.uint64) + +exports['readInt64' + opposite] = function (buffer, offset) { + for (var i = 0; i < exports.sizeof.int64; i++) { + int64temp[i] = buffer[offset + exports.sizeof.int64 - i - 1] + } + return exports.readInt64(int64temp, 0) +} +exports['readUInt64' + opposite] = function (buffer, offset) { + for (var i = 0; i < exports.sizeof.uint64; i++) { + uint64temp[i] = buffer[offset + exports.sizeof.uint64 - i - 1] + } + return exports.readUInt64(uint64temp, 0) +} +exports['writeInt64' + opposite] = function (buffer, offset, value) { + exports.writeInt64(int64temp, 0, value) + for (var i = 0; i < exports.sizeof.int64; i++) { + buffer[offset + i] = int64temp[exports.sizeof.int64 - i - 1] + } +} +exports['writeUInt64' + opposite] = function (buffer, offset, value) { + exports.writeUInt64(uint64temp, 0, value) + for (var i = 0; i < exports.sizeof.uint64; i++) { + buffer[offset + i] = uint64temp[exports.sizeof.uint64 - i - 1] + } +} + +/** + * `ref()` accepts a Buffer instance and returns a new Buffer + * instance that is "pointer" sized and has its data pointing to the given + * Buffer instance. Essentially the created Buffer is a "reference" to the + * original pointer, equivalent to the following C code: + * + * ``` c + * char *buf = buffer; + * char **ref = &buf; + * ``` + * + * @param {Buffer} buffer A Buffer instance to create a reference to. + * @return {Buffer} A new Buffer instance pointing to _buffer_. + */ + +exports.ref = function ref (buffer) { + debug('creating a reference to buffer', buffer) + var type = exports.refType(exports.getType(buffer)) + return exports.alloc(type, buffer) +} + +/** + * Accepts a Buffer instance and attempts to "dereference" it. + * That is, first it checks the `indirection` count of _buffer_'s "type", and if + * it's greater than __1__ then it merely returns another Buffer, but with one + * level less `indirection`. + * + * When _buffer_'s indirection is at __1__, then it checks for `buffer.type` + * which should be an Object with its own `get()` function. + * + * ``` + * var buf = ref.alloc('int', 6); + * + * var val = ref.deref(buf); + * console.log(val); + * 6 + * ``` + * + * + * @param {Buffer} buffer A Buffer instance to dereference. + * @return {?} The returned value after dereferencing _buffer_. + */ + +exports.deref = function deref (buffer) { + debug('dereferencing buffer', buffer) + return exports.get(buffer) +} + +/** + * Attaches _object_ to _buffer_ such that it prevents _object_ from being garbage + * collected until _buffer_ does. + * + * @param {Buffer} buffer A Buffer instance to attach _object_ to. + * @param {Object|Buffer} object An Object or Buffer to prevent from being garbage collected until _buffer_ does. + * @api private + */ + +exports._attach = function _attach (buf, obj) { + if (!buf._refs) { + buf._refs = [] + } + buf._refs.push(obj) +} + +/** + * Same as `ref.writeObject()`, except that this version does not _attach_ the + * Object to the Buffer, which is potentially unsafe if the garbage collector + * runs. + * + * @param {Buffer} buffer A Buffer instance to write _object_ to. + * @param {Number} offset The offset on the Buffer to start writing at. + * @param {Object} object The Object to be written into _buffer_. + * @api private + */ + +exports._writeObject = exports.writeObject + +/** + * Writes a pointer to _object_ into _buffer_ at the specified _offset. + * + * This function "attaches" _object_ to _buffer_ to prevent it from being garbage + * collected. + * + * ``` + * var buf = ref.alloc('Object'); + * ref.writeObject(buf, 0, { foo: 'bar' }); + * + * ``` + * + * @param {Buffer} buffer A Buffer instance to write _object_ to. + * @param {Number} offset The offset on the Buffer to start writing at. + * @param {Object} object The Object to be written into _buffer_. + */ + +exports.writeObject = function writeObject (buf, offset, obj, persistent) { + debug('writing Object to buffer', buf, offset, obj, persistent) + exports._writeObject(buf, offset, obj, persistent) + exports._attach(buf, obj) +} + +/** + * Same as `ref.writePointer()`, except that this version does not attach + * _pointer_ to _buffer_, which is potentially unsafe if the garbage collector + * runs. + * + * @param {Buffer} buffer A Buffer instance to write _pointer to. + * @param {Number} offset The offset on the Buffer to start writing at. + * @param {Buffer} pointer The Buffer instance whose memory address will be written to _buffer_. + * @api private + */ + +exports._writePointer = exports.writePointer + +/** + * Writes the memory address of _pointer_ to _buffer_ at the specified _offset_. + * + * This function "attaches" _object_ to _buffer_ to prevent it from being garbage + * collected. + * + * ``` + * var someBuffer = new Buffer('whatever'); + * var buf = ref.alloc('pointer'); + * ref.writePointer(buf, 0, someBuffer); + * ``` + * + * @param {Buffer} buffer A Buffer instance to write _pointer to. + * @param {Number} offset The offset on the Buffer to start writing at. + * @param {Buffer} pointer The Buffer instance whose memory address will be written to _buffer_. + */ + +exports.writePointer = function writePointer (buf, offset, ptr) { + debug('writing pointer to buffer', buf, offset, ptr) + exports._writePointer(buf, offset, ptr) + exports._attach(buf, ptr) +} + +/** + * Same as `ref.reinterpret()`, except that this version does not attach + * _buffer_ to the returned Buffer, which is potentially unsafe if the + * garbage collector runs. + * + * @param {Buffer} buffer A Buffer instance to base the returned Buffer off of. + * @param {Number} size The `length` property of the returned Buffer. + * @param {Number} offset The offset of the Buffer to begin from. + * @return {Buffer} A new Buffer instance with the same memory address as _buffer_, and the requested _size_. + * @api private + */ + +exports._reinterpret = exports.reinterpret + +/** + * Returns a new Buffer instance with the specified _size_, with the same memory + * address as _buffer_. + * + * This function "attaches" _buffer_ to the returned Buffer to prevent it from + * being garbage collected. + * + * @param {Buffer} buffer A Buffer instance to base the returned Buffer off of. + * @param {Number} size The `length` property of the returned Buffer. + * @param {Number} offset The offset of the Buffer to begin from. + * @return {Buffer} A new Buffer instance with the same memory address as _buffer_, and the requested _size_. + */ + +exports.reinterpret = function reinterpret (buffer, size, offset) { + debug('reinterpreting buffer to "%d" bytes', size) + var rtn = exports._reinterpret(buffer, size, offset || 0) + exports._attach(rtn, buffer) + return rtn +} + +/** + * Same as `ref.reinterpretUntilZeros()`, except that this version does not + * attach _buffer_ to the returned Buffer, which is potentially unsafe if the + * garbage collector runs. + * + * @param {Buffer} buffer A Buffer instance to base the returned Buffer off of. + * @param {Number} size The number of sequential, aligned `NULL` bytes that are required to terminate the buffer. + * @param {Number} offset The offset of the Buffer to begin from. + * @return {Buffer} A new Buffer instance with the same memory address as _buffer_, and a variable `length` that is terminated by _size_ NUL bytes. + * @api private + */ + +exports._reinterpretUntilZeros = exports.reinterpretUntilZeros + +/** + * Accepts a `Buffer` instance and a number of `NULL` bytes to read from the + * pointer. This function will scan past the boundary of the Buffer's `length` + * until it finds `size` number of aligned `NULL` bytes. + * + * This is useful for finding the end of NUL-termintated array or C string. For + * example, the `readCString()` function _could_ be implemented like: + * + * ``` + * function readCString (buf) { + * return ref.reinterpretUntilZeros(buf, 1).toString('utf8') + * } + * ``` + * + * This function "attaches" _buffer_ to the returned Buffer to prevent it from + * being garbage collected. + * + * @param {Buffer} buffer A Buffer instance to base the returned Buffer off of. + * @param {Number} size The number of sequential, aligned `NULL` bytes are required to terminate the buffer. + * @param {Number} offset The offset of the Buffer to begin from. + * @return {Buffer} A new Buffer instance with the same memory address as _buffer_, and a variable `length` that is terminated by _size_ NUL bytes. + */ + +exports.reinterpretUntilZeros = function reinterpretUntilZeros (buffer, size, offset) { + debug('reinterpreting buffer to until "%d" NULL (0) bytes are found', size) + var rtn = exports._reinterpretUntilZeros(buffer, size, offset || 0) + exports._attach(rtn, buffer) + return rtn +} + + +// the built-in "types" +var types = exports.types = {} + +/** + * The `void` type. + * + * @section types + */ + +types.void = { + size: 0 + , indirection: 1 + , get: function get (buf, offset) { + debug('getting `void` type (returns `null`)') + return null + } + , set: function set (buf, offset, val) { + debug('setting `void` type (no-op)') + } +} + +/** + * The `int8` type. + */ + +types.int8 = { + size: exports.sizeof.int8 + , indirection: 1 + , get: function get (buf, offset) { + return buf.readInt8(offset || 0) + } + , set: function set (buf, offset, val) { + if (typeof val === 'string') { + val = val.charCodeAt(0) + } + return buf.writeInt8(val, offset || 0) + } +} + +/** + * The `uint8` type. + */ + +types.uint8 = { + size: exports.sizeof.uint8 + , indirection: 1 + , get: function get (buf, offset) { + return buf.readUInt8(offset || 0) + } + , set: function set (buf, offset, val) { + if (typeof val === 'string') { + val = val.charCodeAt(0) + } + return buf.writeUInt8(val, offset || 0) + } +} + +/** + * The `int16` type. + */ + +types.int16 = { + size: exports.sizeof.int16 + , indirection: 1 + , get: function get (buf, offset) { + return buf['readInt16' + exports.endianness](offset || 0) + } + , set: function set (buf, offset, val) { + return buf['writeInt16' + exports.endianness](val, offset || 0) + } +} + +/** + * The `uint16` type. + */ + +types.uint16 = { + size: exports.sizeof.uint16 + , indirection: 1 + , get: function get (buf, offset) { + return buf['readUInt16' + exports.endianness](offset || 0) + } + , set: function set (buf, offset, val) { + return buf['writeUInt16' + exports.endianness](val, offset || 0) + } +} + +/** + * The `int32` type. + */ + +types.int32 = { + size: exports.sizeof.int32 + , indirection: 1 + , get: function get (buf, offset) { + return buf['readInt32' + exports.endianness](offset || 0) + } + , set: function set (buf, offset, val) { + return buf['writeInt32' + exports.endianness](val, offset || 0) + } +} + +/** + * The `uint32` type. + */ + +types.uint32 = { + size: exports.sizeof.uint32 + , indirection: 1 + , get: function get (buf, offset) { + return buf['readUInt32' + exports.endianness](offset || 0) + } + , set: function set (buf, offset, val) { + return buf['writeUInt32' + exports.endianness](val, offset || 0) + } +} + +/** + * The `int64` type. + */ + +types.int64 = { + size: exports.sizeof.int64 + , indirection: 1 + , get: function get (buf, offset) { + return buf['readInt64' + exports.endianness](offset || 0) + } + , set: function set (buf, offset, val) { + return buf['writeInt64' + exports.endianness](val, offset || 0) + } +} + +/** + * The `uint64` type. + */ + +types.uint64 = { + size: exports.sizeof.uint64 + , indirection: 1 + , get: function get (buf, offset) { + return buf['readUInt64' + exports.endianness](offset || 0) + } + , set: function set (buf, offset, val) { + return buf['writeUInt64' + exports.endianness](val, offset || 0) + } +} + +/** + * The `float` type. + */ + +types.float = { + size: exports.sizeof.float + , indirection: 1 + , get: function get (buf, offset) { + return buf['readFloat' + exports.endianness](offset || 0) + } + , set: function set (buf, offset, val) { + return buf['writeFloat' + exports.endianness](val, offset || 0) + } +} + +/** + * The `double` type. + */ + +types.double = { + size: exports.sizeof.double + , indirection: 1 + , get: function get (buf, offset) { + return buf['readDouble' + exports.endianness](offset || 0) + } + , set: function set (buf, offset, val) { + return buf['writeDouble' + exports.endianness](val, offset || 0) + } +} + +/** + * The `Object` type. This can be used to read/write regular JS Objects + * into raw memory. + */ + +types.Object = { + size: exports.sizeof.Object + , indirection: 1 + , get: function get (buf, offset) { + return buf.readObject(offset || 0) + } + , set: function set (buf, offset, val) { + return buf.writeObject(val, offset || 0) + } +} + +/** + * The `CString` (a.k.a `"string"`) type. + * + * CStrings are a kind of weird thing. We say it's `sizeof(char *)`, and + * `indirection` level of 1, which means that we have to return a Buffer that + * is pointer sized, and points to a some utf8 string data, so we have to create + * a 2nd "in-between" buffer. + */ + +types.CString = { + size: exports.sizeof.pointer + , alignment: exports.alignof.pointer + , indirection: 1 + , get: function get (buf, offset) { + var _buf = exports.readPointer(buf, offset) + if (exports.isNull(_buf)) { + return null + } + return exports.readCString(_buf, 0) + } + , set: function set (buf, offset, val) { + var _buf + if (Buffer.isBuffer(val)) { + _buf = val + } else { + // assume string + _buf = exports.allocCString(val) + } + return exports.writePointer(buf, offset, _buf) + } +} + +// alias Utf8String +var utfstringwarned = false +Object.defineProperty(types, 'Utf8String', { + enumerable: false + , configurable: true + , get: function () { + if (!utfstringwarned) { + utfstringwarned = true + console.error('"Utf8String" type is deprecated, use "CString" instead') + } + return types.CString + } +}) + +/** + * The `bool` type. + * + * Wrapper type around `types.uint8` that accepts/returns `true` or + * `false` Boolean JavaScript values. + * + * @name bool + * + */ + +/** + * The `byte` type. + * + * @name byte + */ + +/** + * The `char` type. + * + * @name char + */ + +/** + * The `uchar` type. + * + * @name uchar + */ + +/** + * The `short` type. + * + * @name short + */ + +/** + * The `ushort` type. + * + * @name ushort + */ + +/** + * The `int` type. + * + * @name int + */ + +/** + * The `uint` type. + * + * @name uint + */ + +/** + * The `long` type. + * + * @name long + */ + +/** + * The `ulong` type. + * + * @name ulong + */ + +/** + * The `longlong` type. + * + * @name longlong + */ + +/** + * The `ulonglong` type. + * + * @name ulonglong + */ + +/** + * The `size_t` type. + * + * @name size_t + */ + +// "typedef"s for the variable-sized types +;[ 'bool', 'byte', 'char', 'uchar', 'short', 'ushort', 'int', 'uint', 'long' +, 'ulong', 'longlong', 'ulonglong', 'size_t' ].forEach(function (name) { + var unsigned = name === 'bool' + || name === 'byte' + || name === 'size_t' + || name[0] === 'u' + var size = exports.sizeof[name] + assert(size >= 1 && size <= 8) + var typeName = 'int' + (size * 8) + if (unsigned) { + typeName = 'u' + typeName + } + var type = exports.types[typeName] + assert(type) + exports.types[name] = Object.create(type) +}) + +// set the "alignment" property on the built-in types +Object.keys(exports.alignof).forEach(function (name) { + if (name === 'pointer') return + exports.types[name].alignment = exports.alignof[name] + assert(exports.types[name].alignment > 0) +}) + +// make the `bool` type work with JS true/false values +exports.types.bool.get = (function (_get) { + return function get (buf, offset) { + return _get(buf, offset) ? true : false + } +})(exports.types.bool.get) +exports.types.bool.set = (function (_set) { + return function set (buf, offset, val) { + if (typeof val !== 'number') { + val = val ? 1 : 0 + } + return _set(buf, offset, val) + } +})(exports.types.bool.set) + +/*! + * Set the `name` property of the types. Used for debugging... + */ + +Object.keys(exports.types).forEach(function (name) { + exports.types[name].name = name +}) + +/*! + * This `char *` type is used by "allocCString()" above. + */ + +var charPtrType = exports.refType(exports.types.char) + +/*! + * Set the `type` property of the `NULL` pointer Buffer object. + */ + +exports.NULL.type = exports.types.void + +/** + * `NULL_POINTER` is a pointer-sized `Buffer` instance pointing to `NULL`. + * Conceptually, it's equivalent to the following C code: + * + * ``` c + * char *null_pointer; + * null_pointer = NULL; + * ``` + * + * @type Buffer + */ + +exports.NULL_POINTER = exports.ref(exports.NULL) + +/** + * All these '...' comment blocks below are for the documentation generator. + * + * @section buffer + */ + +Buffer.prototype.address = function address () { + return exports.address(this, 0) +} + +/** + * ... + */ + +Buffer.prototype.hexAddress = function hexAddress () { + return exports.hexAddress(this, 0) +} + +/** + * ... + */ + +Buffer.prototype.isNull = function isNull () { + return exports.isNull(this, 0) +} + +/** + * ... + */ + +Buffer.prototype.ref = function ref () { + return exports.ref(this) +} + +/** + * ... + */ + +Buffer.prototype.deref = function deref () { + return exports.deref(this) +} + +/** + * ... + */ + +Buffer.prototype.readObject = function readObject (offset) { + return exports.readObject(this, offset) +} + +/** + * ... + */ + +Buffer.prototype.writeObject = function writeObject (obj, offset) { + return exports.writeObject(this, offset, obj) +} + +/** + * ... + */ + +Buffer.prototype.readPointer = function readPointer (offset, size) { + return exports.readPointer(this, offset, size) +} + +/** + * ... + */ + +Buffer.prototype.writePointer = function writePointer (ptr, offset) { + return exports.writePointer(this, offset, ptr) +} + +/** + * ... + */ + +Buffer.prototype.readCString = function readCString (offset) { + return exports.readCString(this, offset) +} + +/** + * ... + */ + +Buffer.prototype.writeCString = function writeCString (string, offset, encoding) { + return exports.writeCString(this, offset, string, encoding) +} + +/** + * ... + */ + +Buffer.prototype.readInt64BE = function readInt64BE (offset) { + return exports.readInt64BE(this, offset) +} + +/** + * ... + */ + +Buffer.prototype.writeInt64BE = function writeInt64BE (val, offset) { + return exports.writeInt64BE(this, offset, val) +} + +/** + * ... + */ + +Buffer.prototype.readUInt64BE = function readUInt64BE (offset) { + return exports.readUInt64BE(this, offset) +} + +/** + * ... + */ + +Buffer.prototype.writeUInt64BE = function writeUInt64BE (val, offset) { + return exports.writeUInt64BE(this, offset, val) +} + +/** + * ... + */ + +Buffer.prototype.readInt64LE = function readInt64LE (offset) { + return exports.readInt64LE(this, offset) +} + +/** + * ... + */ + +Buffer.prototype.writeInt64LE = function writeInt64LE (val, offset) { + return exports.writeInt64LE(this, offset, val) +} + +/** + * ... + */ + +Buffer.prototype.readUInt64LE = function readUInt64LE (offset) { + return exports.readUInt64LE(this, offset) +} + +/** + * ... + */ + +Buffer.prototype.writeUInt64LE = function writeUInt64LE (val, offset) { + return exports.writeUInt64LE(this, offset, val) +} + +/** + * ... + */ + +Buffer.prototype.reinterpret = function reinterpret (size, offset) { + return exports.reinterpret(this, size, offset) +} + +/** + * ... + */ + +Buffer.prototype.reinterpretUntilZeros = function reinterpretUntilZeros (size, offset) { + return exports.reinterpretUntilZeros(this, size, offset) +} + +/** + * `ref` overwrites the default `Buffer#inspect()` function to include the + * hex-encoded memory address of the Buffer instance when invoked. + * + * This is simply a nice-to-have. + * + * **Before**: + * + * ``` js + * console.log(new Buffer('ref')); + * + * ``` + * + * **After**: + * + * ``` js + * console.log(new Buffer('ref')); + * + * ``` + */ + +Buffer.prototype.inspect = overwriteInspect(Buffer.prototype.inspect) + +// does SlowBuffer inherit from Buffer? (node >= v0.7.9) +if (!(exports.NULL instanceof Buffer)) { + debug('extending SlowBuffer\'s prototype since it doesn\'t inherit from Buffer.prototype') + + /*! + * SlowBuffer convenience methods. + */ + + var SlowBuffer = require('buffer').SlowBuffer + + SlowBuffer.prototype.address = Buffer.prototype.address + SlowBuffer.prototype.hexAddress = Buffer.prototype.hexAddress + SlowBuffer.prototype.isNull = Buffer.prototype.isNull + SlowBuffer.prototype.ref = Buffer.prototype.ref + SlowBuffer.prototype.deref = Buffer.prototype.deref + SlowBuffer.prototype.readObject = Buffer.prototype.readObject + SlowBuffer.prototype.writeObject = Buffer.prototype.writeObject + SlowBuffer.prototype.readPointer = Buffer.prototype.readPointer + SlowBuffer.prototype.writePointer = Buffer.prototype.writePointer + SlowBuffer.prototype.readCString = Buffer.prototype.readCString + SlowBuffer.prototype.writeCString = Buffer.prototype.writeCString + SlowBuffer.prototype.reinterpret = Buffer.prototype.reinterpret + SlowBuffer.prototype.reinterpretUntilZeros = Buffer.prototype.reinterpretUntilZeros + SlowBuffer.prototype.readInt64BE = Buffer.prototype.readInt64BE + SlowBuffer.prototype.writeInt64BE = Buffer.prototype.writeInt64BE + SlowBuffer.prototype.readUInt64BE = Buffer.prototype.readUInt64BE + SlowBuffer.prototype.writeUInt64BE = Buffer.prototype.writeUInt64BE + SlowBuffer.prototype.readInt64LE = Buffer.prototype.readInt64LE + SlowBuffer.prototype.writeInt64LE = Buffer.prototype.writeInt64LE + SlowBuffer.prototype.readUInt64LE = Buffer.prototype.readUInt64LE + SlowBuffer.prototype.writeUInt64LE = Buffer.prototype.writeUInt64LE + SlowBuffer.prototype.inspect = overwriteInspect(SlowBuffer.prototype.inspect) +} + +function overwriteInspect (inspect) { + if (inspect.name === 'refinspect') { + return inspect + } else { + return function refinspect () { + var v = inspect.apply(this, arguments) + return v.replace('Buffer', 'Buffer@0x' + this.hexAddress()) + } + } +} + +}).call(this,require("buffer").Buffer) +},{"assert":26,"bindings":28,"buffer":38,"debug":41}],75:[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. + +module.exports = Stream; + +var EE = require('events').EventEmitter; +var inherits = require('inherits'); + +inherits(Stream, EE); +Stream.Readable = require('readable-stream/readable.js'); +Stream.Writable = require('readable-stream/writable.js'); +Stream.Duplex = require('readable-stream/duplex.js'); +Stream.Transform = require('readable-stream/transform.js'); +Stream.PassThrough = require('readable-stream/passthrough.js'); + +// Backwards-compat with node 0.4.x +Stream.Stream = Stream; + + + +// old-style streams. Note that the pipe method (the only relevant +// part of this class) is overridden in the Readable class. + +function Stream() { + EE.call(this); +} + +Stream.prototype.pipe = function(dest, options) { + var source = this; + + function ondata(chunk) { + if (dest.writable) { + if (false === dest.write(chunk) && source.pause) { + source.pause(); + } + } + } + + source.on('data', ondata); + + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } + + dest.on('drain', ondrain); + + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } + + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + + dest.end(); + } + + + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + + if (typeof dest.destroy === 'function') dest.destroy(); + } + + // don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, 'error') === 0) { + throw er; // Unhandled stream error in pipe. + } + } + + source.on('error', onerror); + dest.on('error', onerror); + + // remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); + + source.removeListener('end', onend); + source.removeListener('close', onclose); + + source.removeListener('error', onerror); + dest.removeListener('error', onerror); + + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); + + dest.removeListener('close', cleanup); + } + + source.on('end', cleanup); + source.on('close', cleanup); + + dest.on('close', cleanup); + + dest.emit('pipe', source); + + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; +}; + +},{"events":43,"inherits":45,"readable-stream/duplex.js":76,"readable-stream/passthrough.js":82,"readable-stream/readable.js":83,"readable-stream/transform.js":84,"readable-stream/writable.js":85}],76:[function(require,module,exports){ +module.exports = require("./lib/_stream_duplex.js") + +},{"./lib/_stream_duplex.js":77}],77:[function(require,module,exports){ +arguments[4][33][0].apply(exports,arguments) +},{"./_stream_readable":79,"./_stream_writable":81,"core-util-is":40,"dup":33,"inherits":45,"process-nextick-args":67}],78:[function(require,module,exports){ +// 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'); + +/**/ +var util = require('core-util-is'); +util.inherits = require('inherits'); +/**/ + +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":80,"core-util-is":40,"inherits":45}],79:[function(require,module,exports){ +arguments[4][34][0].apply(exports,arguments) +},{"./_stream_duplex":77,"_process":68,"buffer":38,"core-util-is":40,"dup":34,"events":43,"inherits":45,"isarray":48,"process-nextick-args":67,"string_decoder/":86,"util":29}],80:[function(require,module,exports){ +arguments[4][35][0].apply(exports,arguments) +},{"./_stream_duplex":77,"core-util-is":40,"dup":35,"inherits":45}],81:[function(require,module,exports){ +arguments[4][36][0].apply(exports,arguments) +},{"./_stream_duplex":77,"buffer":38,"core-util-is":40,"dup":36,"events":43,"inherits":45,"process-nextick-args":67,"util-deprecate":88}],82:[function(require,module,exports){ +module.exports = require("./lib/_stream_passthrough.js") + +},{"./lib/_stream_passthrough.js":78}],83:[function(require,module,exports){ +var Stream = (function (){ + try { + return require('st' + 'ream'); // hack to fix a circular dependency issue when used with browserify + } catch(_){} +}()); +exports = module.exports = require('./lib/_stream_readable.js'); +exports.Stream = 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":77,"./lib/_stream_passthrough.js":78,"./lib/_stream_readable.js":79,"./lib/_stream_transform.js":80,"./lib/_stream_writable.js":81}],84:[function(require,module,exports){ +arguments[4][37][0].apply(exports,arguments) +},{"./lib/_stream_transform.js":80,"dup":37}],85:[function(require,module,exports){ +module.exports = require("./lib/_stream_writable.js") + +},{"./lib/_stream_writable.js":81}],86:[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 Buffer = require('buffer').Buffer; + +var isBufferEncoding = Buffer.isEncoding + || function(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 assertEncoding(encoding) { + if (encoding && !isBufferEncoding(encoding)) { + throw new Error('Unknown encoding: ' + encoding); + } +} + +// StringDecoder provides an interface for efficiently splitting a series of +// buffers into a series of JS strings without breaking apart multi-byte +// characters. CESU-8 is handled as part of the UTF-8 encoding. +// +// @TODO Handling all encodings inside a single object makes it very difficult +// to reason about this code, so it should be split up in the future. +// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code +// points as used by CESU-8. +var StringDecoder = exports.StringDecoder = function(encoding) { + this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); + assertEncoding(encoding); + switch (this.encoding) { + case 'utf8': + // CESU-8 represents each of Surrogate Pair by 3-bytes + this.surrogateSize = 3; + break; + case 'ucs2': + case 'utf16le': + // UTF-16 represents each of Surrogate Pair by 2-bytes + this.surrogateSize = 2; + this.detectIncompleteChar = utf16DetectIncompleteChar; + break; + case 'base64': + // Base-64 stores 3 bytes in 4 chars, and pads the remainder. + this.surrogateSize = 3; + this.detectIncompleteChar = base64DetectIncompleteChar; + break; + default: + this.write = passThroughWrite; + return; + } + + // Enough space to store all bytes of a single character. UTF-8 needs 4 + // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). + this.charBuffer = new Buffer(6); + // Number of bytes received for the current incomplete multi-byte character. + this.charReceived = 0; + // Number of bytes expected for the current incomplete multi-byte character. + this.charLength = 0; +}; + + +// write decodes the given buffer and returns it as JS string that is +// guaranteed to not contain any partial multi-byte characters. Any partial +// character found at the end of the buffer is buffered up, and will be +// returned when calling write again with the remaining bytes. +// +// Note: Converting a Buffer containing an orphan surrogate to a String +// currently works, but converting a String to a Buffer (via `new Buffer`, or +// Buffer#write) will replace incomplete surrogates with the unicode +// replacement character. See https://codereview.chromium.org/121173009/ . +StringDecoder.prototype.write = function(buffer) { + var charStr = ''; + // if our last write ended with an incomplete multibyte character + while (this.charLength) { + // determine how many remaining bytes this buffer has to offer for this char + var available = (buffer.length >= this.charLength - this.charReceived) ? + this.charLength - this.charReceived : + buffer.length; + + // add the new bytes to the char buffer + buffer.copy(this.charBuffer, this.charReceived, 0, available); + this.charReceived += available; + + if (this.charReceived < this.charLength) { + // still not enough chars in this buffer? wait for more ... + return ''; + } + + // remove bytes belonging to the current character from the buffer + buffer = buffer.slice(available, buffer.length); + + // get the character that was split + charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); + + // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character + var charCode = charStr.charCodeAt(charStr.length - 1); + if (charCode >= 0xD800 && charCode <= 0xDBFF) { + this.charLength += this.surrogateSize; + charStr = ''; + continue; + } + this.charReceived = this.charLength = 0; + + // if there are no more bytes in this buffer, just emit our char + if (buffer.length === 0) { + return charStr; + } + break; + } + + // determine and set charLength / charReceived + this.detectIncompleteChar(buffer); + + var end = buffer.length; + if (this.charLength) { + // buffer the incomplete character bytes we got + buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); + end -= this.charReceived; + } + + charStr += buffer.toString(this.encoding, 0, end); + + var end = charStr.length - 1; + var charCode = charStr.charCodeAt(end); + // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character + if (charCode >= 0xD800 && charCode <= 0xDBFF) { + var size = this.surrogateSize; + this.charLength += size; + this.charReceived += size; + this.charBuffer.copy(this.charBuffer, size, 0, size); + buffer.copy(this.charBuffer, 0, 0, size); + return charStr.substring(0, end); + } + + // or just emit the charStr + return charStr; +}; + +// detectIncompleteChar determines if there is an incomplete UTF-8 character at +// the end of the given buffer. If so, it sets this.charLength to the byte +// length that character, and sets this.charReceived to the number of bytes +// that are available for this character. +StringDecoder.prototype.detectIncompleteChar = function(buffer) { + // determine how many bytes we have to check at the end of this buffer + var i = (buffer.length >= 3) ? 3 : buffer.length; + + // Figure out if one of the last i bytes of our buffer announces an + // incomplete char. + for (; i > 0; i--) { + var c = buffer[buffer.length - i]; + + // See http://en.wikipedia.org/wiki/UTF-8#Description + + // 110XXXXX + if (i == 1 && c >> 5 == 0x06) { + this.charLength = 2; + break; + } + + // 1110XXXX + if (i <= 2 && c >> 4 == 0x0E) { + this.charLength = 3; + break; + } + + // 11110XXX + if (i <= 3 && c >> 3 == 0x1E) { + this.charLength = 4; + break; + } + } + this.charReceived = i; +}; + +StringDecoder.prototype.end = function(buffer) { + var res = ''; + if (buffer && buffer.length) + res = this.write(buffer); + + if (this.charReceived) { + var cr = this.charReceived; + var buf = this.charBuffer; + var enc = this.encoding; + res += buf.slice(0, cr).toString(enc); + } + + return res; +}; + +function passThroughWrite(buffer) { + return buffer.toString(this.encoding); +} + +function utf16DetectIncompleteChar(buffer) { + this.charReceived = buffer.length % 2; + this.charLength = this.charReceived ? 2 : 0; +} + +function base64DetectIncompleteChar(buffer) { + this.charReceived = buffer.length % 3; + this.charLength = this.charReceived ? 3 : 0; +} + +},{"buffer":38}],87:[function(require,module,exports){ +/** + * Module dependencies. + */ + +var Emitter = require('emitter'); +var reduce = require('reduce'); + +/** + * Root reference for iframes. + */ + +var root; +if (typeof window !== 'undefined') { // Browser window + root = window; +} else if (typeof self !== 'undefined') { // Web Worker + root = self; +} else { // Other environments + root = this; +} + +/** + * Noop. + */ + +function noop(){}; + +/** + * Check if `obj` is a host object, + * we don't want to serialize these :) + * + * TODO: future proof, move to compoent land + * + * @param {Object} obj + * @return {Boolean} + * @api private + */ + +function isHost(obj) { + var str = {}.toString.call(obj); + + switch (str) { + case '[object File]': + case '[object Blob]': + case '[object FormData]': + return true; + default: + return false; + } +} + +/** + * Determine XHR. + */ + +request.getXHR = function () { + if (root.XMLHttpRequest + && (!root.location || 'file:' != root.location.protocol + || !root.ActiveXObject)) { + return new XMLHttpRequest; + } else { + try { return new ActiveXObject('Microsoft.XMLHTTP'); } catch(e) {} + try { return new ActiveXObject('Msxml2.XMLHTTP.6.0'); } catch(e) {} + try { return new ActiveXObject('Msxml2.XMLHTTP.3.0'); } catch(e) {} + try { return new ActiveXObject('Msxml2.XMLHTTP'); } catch(e) {} + } + return false; +}; + +/** + * Removes leading and trailing whitespace, added to support IE. + * + * @param {String} s + * @return {String} + * @api private + */ + +var trim = ''.trim + ? function(s) { return s.trim(); } + : function(s) { return s.replace(/(^\s*|\s*$)/g, ''); }; + +/** + * Check if `obj` is an object. + * + * @param {Object} obj + * @return {Boolean} + * @api private + */ + +function isObject(obj) { + return obj === Object(obj); +} + +/** + * Serialize the given `obj`. + * + * @param {Object} obj + * @return {String} + * @api private + */ + +function serialize(obj) { + if (!isObject(obj)) return obj; + var pairs = []; + for (var key in obj) { + if (null != obj[key]) { + pairs.push(encodeURIComponent(key) + + '=' + encodeURIComponent(obj[key])); + } + } + return pairs.join('&'); +} + +/** + * Expose serialization method. + */ + + request.serializeObject = serialize; + + /** + * Parse the given x-www-form-urlencoded `str`. + * + * @param {String} str + * @return {Object} + * @api private + */ + +function parseString(str) { + var obj = {}; + var pairs = str.split('&'); + var parts; + var pair; + + for (var i = 0, len = pairs.length; i < len; ++i) { + pair = pairs[i]; + parts = pair.split('='); + obj[decodeURIComponent(parts[0])] = decodeURIComponent(parts[1]); + } + + return obj; +} + +/** + * Expose parser. + */ + +request.parseString = parseString; + +/** + * Default MIME type map. + * + * superagent.types.xml = 'application/xml'; + * + */ + +request.types = { + html: 'text/html', + json: 'application/json', + xml: 'application/xml', + urlencoded: 'application/x-www-form-urlencoded', + 'form': 'application/x-www-form-urlencoded', + 'form-data': 'application/x-www-form-urlencoded' +}; + +/** + * Default serialization map. + * + * superagent.serialize['application/xml'] = function(obj){ + * return 'generated xml here'; + * }; + * + */ + + request.serialize = { + 'application/x-www-form-urlencoded': serialize, + 'application/json': JSON.stringify + }; + + /** + * Default parsers. + * + * superagent.parse['application/xml'] = function(str){ + * return { object parsed from str }; + * }; + * + */ + +request.parse = { + 'application/x-www-form-urlencoded': parseString, + 'application/json': JSON.parse +}; + +/** + * Parse the given header `str` into + * an object containing the mapped fields. + * + * @param {String} str + * @return {Object} + * @api private + */ + +function parseHeader(str) { + var lines = str.split(/\r?\n/); + var fields = {}; + var index; + var line; + var field; + var val; + + lines.pop(); // trailing CRLF + + for (var i = 0, len = lines.length; i < len; ++i) { + line = lines[i]; + index = line.indexOf(':'); + field = line.slice(0, index).toLowerCase(); + val = trim(line.slice(index + 1)); + fields[field] = val; + } + + return fields; +} + +/** + * Return the mime type for the given `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +function type(str){ + return str.split(/ *; */).shift(); +}; + +/** + * Return header field parameters. + * + * @param {String} str + * @return {Object} + * @api private + */ + +function params(str){ + return reduce(str.split(/ *; */), function(obj, str){ + var parts = str.split(/ *= */) + , key = parts.shift() + , val = parts.shift(); + + if (key && val) obj[key] = val; + return obj; + }, {}); +}; + +/** + * Initialize a new `Response` with the given `xhr`. + * + * - set flags (.ok, .error, etc) + * - parse header + * + * Examples: + * + * Aliasing `superagent` as `request` is nice: + * + * request = superagent; + * + * We can use the promise-like API, or pass callbacks: + * + * request.get('/').end(function(res){}); + * request.get('/', function(res){}); + * + * Sending data can be chained: + * + * request + * .post('/user') + * .send({ name: 'tj' }) + * .end(function(res){}); + * + * Or passed to `.send()`: + * + * request + * .post('/user') + * .send({ name: 'tj' }, function(res){}); + * + * Or passed to `.post()`: + * + * request + * .post('/user', { name: 'tj' }) + * .end(function(res){}); + * + * Or further reduced to a single call for simple cases: + * + * request + * .post('/user', { name: 'tj' }, function(res){}); + * + * @param {XMLHTTPRequest} xhr + * @param {Object} options + * @api private + */ + +function Response(req, options) { + options = options || {}; + this.req = req; + this.xhr = this.req.xhr; + // responseText is accessible only if responseType is '' or 'text' and on older browsers + this.text = ((this.req.method !='HEAD' && (this.xhr.responseType === '' || this.xhr.responseType === 'text')) || typeof this.xhr.responseType === 'undefined') + ? this.xhr.responseText + : null; + this.statusText = this.req.xhr.statusText; + this.setStatusProperties(this.xhr.status); + this.header = this.headers = parseHeader(this.xhr.getAllResponseHeaders()); + // getAllResponseHeaders sometimes falsely returns "" for CORS requests, but + // getResponseHeader still works. so we get content-type even if getting + // other headers fails. + this.header['content-type'] = this.xhr.getResponseHeader('content-type'); + this.setHeaderProperties(this.header); + this.body = this.req.method != 'HEAD' + ? this.parseBody(this.text ? this.text : this.xhr.response) + : null; +} + +/** + * Get case-insensitive `field` value. + * + * @param {String} field + * @return {String} + * @api public + */ + +Response.prototype.get = function(field){ + return this.header[field.toLowerCase()]; +}; + +/** + * Set header related properties: + * + * - `.type` the content type without params + * + * A response of "Content-Type: text/plain; charset=utf-8" + * will provide you with a `.type` of "text/plain". + * + * @param {Object} header + * @api private + */ + +Response.prototype.setHeaderProperties = function(header){ + // content-type + var ct = this.header['content-type'] || ''; + this.type = type(ct); + + // params + var obj = params(ct); + for (var key in obj) this[key] = obj[key]; +}; + +/** + * Force given parser + * + * Sets the body parser no matter type. + * + * @param {Function} + * @api public + */ + +Response.prototype.parse = function(fn){ + this.parser = fn; + return this; +}; + +/** + * Parse the given body `str`. + * + * Used for auto-parsing of bodies. Parsers + * are defined on the `superagent.parse` object. + * + * @param {String} str + * @return {Mixed} + * @api private + */ + +Response.prototype.parseBody = function(str){ + var parse = this.parser || request.parse[this.type]; + return parse && str && (str.length || str instanceof Object) + ? parse(str) + : null; +}; + +/** + * Set flags such as `.ok` based on `status`. + * + * For example a 2xx response will give you a `.ok` of __true__ + * whereas 5xx will be __false__ and `.error` will be __true__. The + * `.clientError` and `.serverError` are also available to be more + * specific, and `.statusType` is the class of error ranging from 1..5 + * sometimes useful for mapping respond colors etc. + * + * "sugar" properties are also defined for common cases. Currently providing: + * + * - .noContent + * - .badRequest + * - .unauthorized + * - .notAcceptable + * - .notFound + * + * @param {Number} status + * @api private + */ + +Response.prototype.setStatusProperties = function(status){ + // handle IE9 bug: http://stackoverflow.com/questions/10046972/msie-returns-status-code-of-1223-for-ajax-request + if (status === 1223) { + status = 204; + } + + var type = status / 100 | 0; + + // status / class + this.status = this.statusCode = status; + this.statusType = type; + + // basics + this.info = 1 == type; + this.ok = 2 == type; + this.clientError = 4 == type; + this.serverError = 5 == type; + this.error = (4 == type || 5 == type) + ? this.toError() + : false; + + // sugar + this.accepted = 202 == status; + this.noContent = 204 == status; + this.badRequest = 400 == status; + this.unauthorized = 401 == status; + this.notAcceptable = 406 == status; + this.notFound = 404 == status; + this.forbidden = 403 == status; +}; + +/** + * Return an `Error` representative of this response. + * + * @return {Error} + * @api public + */ + +Response.prototype.toError = function(){ + var req = this.req; + var method = req.method; + var url = req.url; + + var msg = 'cannot ' + method + ' ' + url + ' (' + this.status + ')'; + var err = new Error(msg); + err.status = this.status; + err.method = method; + err.url = url; + + return err; +}; + +/** + * Expose `Response`. + */ + +request.Response = Response; + +/** + * Initialize a new `Request` with the given `method` and `url`. + * + * @param {String} method + * @param {String} url + * @api public + */ + +function Request(method, url) { + var self = this; + Emitter.call(this); + this._query = this._query || []; + this.method = method; + this.url = url; + this.header = {}; + this._header = {}; + this.on('end', function(){ + var err = null; + var res = null; + + try { + res = new Response(self); + } catch(e) { + err = new Error('Parser is unable to parse the response'); + err.parse = true; + err.original = e; + return self.callback(err); + } + + self.emit('response', res); + + if (err) { + return self.callback(err, res); + } + + if (res.status >= 200 && res.status < 300) { + return self.callback(err, res); + } + + var new_err = new Error(res.statusText || 'Unsuccessful HTTP response'); + new_err.original = err; + new_err.response = res; + new_err.status = res.status; + + self.callback(new_err, res); + }); +} + +/** + * Mixin `Emitter`. + */ + +Emitter(Request.prototype); + +/** + * Allow for extension + */ + +Request.prototype.use = function(fn) { + fn(this); + return this; +} + +/** + * Set timeout to `ms`. + * + * @param {Number} ms + * @return {Request} for chaining + * @api public + */ + +Request.prototype.timeout = function(ms){ + this._timeout = ms; + return this; +}; + +/** + * Clear previous timeout. + * + * @return {Request} for chaining + * @api public + */ + +Request.prototype.clearTimeout = function(){ + this._timeout = 0; + clearTimeout(this._timer); + return this; +}; + +/** + * Abort the request, and clear potential timeout. + * + * @return {Request} + * @api public + */ + +Request.prototype.abort = function(){ + if (this.aborted) return; + this.aborted = true; + this.xhr.abort(); + this.clearTimeout(); + this.emit('abort'); + return this; +}; + +/** + * Set header `field` to `val`, or multiple fields with one object. + * + * Examples: + * + * req.get('/') + * .set('Accept', 'application/json') + * .set('X-API-Key', 'foobar') + * .end(callback); + * + * req.get('/') + * .set({ Accept: 'application/json', 'X-API-Key': 'foobar' }) + * .end(callback); + * + * @param {String|Object} field + * @param {String} val + * @return {Request} for chaining + * @api public + */ + +Request.prototype.set = function(field, val){ + if (isObject(field)) { + for (var key in field) { + this.set(key, field[key]); + } + return this; + } + this._header[field.toLowerCase()] = val; + this.header[field] = val; + return this; +}; + +/** + * Remove header `field`. + * + * Example: + * + * req.get('/') + * .unset('User-Agent') + * .end(callback); + * + * @param {String} field + * @return {Request} for chaining + * @api public + */ + +Request.prototype.unset = function(field){ + delete this._header[field.toLowerCase()]; + delete this.header[field]; + return this; +}; + +/** + * Get case-insensitive header `field` value. + * + * @param {String} field + * @return {String} + * @api private + */ + +Request.prototype.getHeader = function(field){ + return this._header[field.toLowerCase()]; +}; + +/** + * Set Content-Type to `type`, mapping values from `request.types`. + * + * Examples: + * + * superagent.types.xml = 'application/xml'; + * + * request.post('/') + * .type('xml') + * .send(xmlstring) + * .end(callback); + * + * request.post('/') + * .type('application/xml') + * .send(xmlstring) + * .end(callback); + * + * @param {String} type + * @return {Request} for chaining + * @api public + */ + +Request.prototype.type = function(type){ + this.set('Content-Type', request.types[type] || type); + return this; +}; + +/** + * Set Accept to `type`, mapping values from `request.types`. + * + * Examples: + * + * superagent.types.json = 'application/json'; + * + * request.get('/agent') + * .accept('json') + * .end(callback); + * + * request.get('/agent') + * .accept('application/json') + * .end(callback); + * + * @param {String} accept + * @return {Request} for chaining + * @api public + */ + +Request.prototype.accept = function(type){ + this.set('Accept', request.types[type] || type); + return this; +}; + +/** + * Set Authorization field value with `user` and `pass`. + * + * @param {String} user + * @param {String} pass + * @return {Request} for chaining + * @api public + */ + +Request.prototype.auth = function(user, pass){ + var str = btoa(user + ':' + pass); + this.set('Authorization', 'Basic ' + str); + return this; +}; + +/** +* Add query-string `val`. +* +* Examples: +* +* request.get('/shoes') +* .query('size=10') +* .query({ color: 'blue' }) +* +* @param {Object|String} val +* @return {Request} for chaining +* @api public +*/ + +Request.prototype.query = function(val){ + if ('string' != typeof val) val = serialize(val); + if (val) this._query.push(val); + return this; +}; + +/** + * Write the field `name` and `val` for "multipart/form-data" + * request bodies. + * + * ``` js + * request.post('/upload') + * .field('foo', 'bar') + * .end(callback); + * ``` + * + * @param {String} name + * @param {String|Blob|File} val + * @return {Request} for chaining + * @api public + */ + +Request.prototype.field = function(name, val){ + if (!this._formData) this._formData = new root.FormData(); + this._formData.append(name, val); + return this; +}; + +/** + * Queue the given `file` as an attachment to the specified `field`, + * with optional `filename`. + * + * ``` js + * request.post('/upload') + * .attach(new Blob(['hey!'], { type: "text/html"})) + * .end(callback); + * ``` + * + * @param {String} field + * @param {Blob|File} file + * @param {String} filename + * @return {Request} for chaining + * @api public + */ + +Request.prototype.attach = function(field, file, filename){ + if (!this._formData) this._formData = new root.FormData(); + this._formData.append(field, file, filename); + return this; +}; + +/** + * Send `data`, defaulting the `.type()` to "json" when + * an object is given. + * + * Examples: + * + * // querystring + * request.get('/search') + * .end(callback) + * + * // multiple data "writes" + * request.get('/search') + * .send({ search: 'query' }) + * .send({ range: '1..5' }) + * .send({ order: 'desc' }) + * .end(callback) + * + * // manual json + * request.post('/user') + * .type('json') + * .send('{"name":"tj"}) + * .end(callback) + * + * // auto json + * request.post('/user') + * .send({ name: 'tj' }) + * .end(callback) + * + * // manual x-www-form-urlencoded + * request.post('/user') + * .type('form') + * .send('name=tj') + * .end(callback) + * + * // auto x-www-form-urlencoded + * request.post('/user') + * .type('form') + * .send({ name: 'tj' }) + * .end(callback) + * + * // defaults to x-www-form-urlencoded + * request.post('/user') + * .send('name=tobi') + * .send('species=ferret') + * .end(callback) + * + * @param {String|Object} data + * @return {Request} for chaining + * @api public + */ + +Request.prototype.send = function(data){ + var obj = isObject(data); + var type = this.getHeader('Content-Type'); + + // merge + if (obj && isObject(this._data)) { + for (var key in data) { + this._data[key] = data[key]; + } + } else if ('string' == typeof data) { + if (!type) this.type('form'); + type = this.getHeader('Content-Type'); + if ('application/x-www-form-urlencoded' == type) { + this._data = this._data + ? this._data + '&' + data + : data; + } else { + this._data = (this._data || '') + data; + } + } else { + this._data = data; + } + + if (!obj || isHost(data)) return this; + if (!type) this.type('json'); + return this; +}; + +/** + * Invoke the callback with `err` and `res` + * and handle arity check. + * + * @param {Error} err + * @param {Response} res + * @api private + */ + +Request.prototype.callback = function(err, res){ + var fn = this._callback; + this.clearTimeout(); + fn(err, res); +}; + +/** + * Invoke callback with x-domain error. + * + * @api private + */ + +Request.prototype.crossDomainError = function(){ + var err = new Error('Origin is not allowed by Access-Control-Allow-Origin'); + err.crossDomain = true; + this.callback(err); +}; + +/** + * Invoke callback with timeout error. + * + * @api private + */ + +Request.prototype.timeoutError = function(){ + var timeout = this._timeout; + var err = new Error('timeout of ' + timeout + 'ms exceeded'); + err.timeout = timeout; + this.callback(err); +}; + +/** + * Enable transmission of cookies with x-domain requests. + * + * Note that for this to work the origin must not be + * using "Access-Control-Allow-Origin" with a wildcard, + * and also must set "Access-Control-Allow-Credentials" + * to "true". + * + * @api public + */ + +Request.prototype.withCredentials = function(){ + this._withCredentials = true; + return this; +}; + +/** + * Initiate request, invoking callback `fn(res)` + * with an instanceof `Response`. + * + * @param {Function} fn + * @return {Request} for chaining + * @api public + */ + +Request.prototype.end = function(fn){ + var self = this; + var xhr = this.xhr = request.getXHR(); + var query = this._query.join('&'); + var timeout = this._timeout; + var data = this._formData || this._data; + + // store callback + this._callback = fn || noop; + + // state change + xhr.onreadystatechange = function(){ + if (4 != xhr.readyState) return; + + // In IE9, reads to any property (e.g. status) off of an aborted XHR will + // result in the error "Could not complete the operation due to error c00c023f" + var status; + try { status = xhr.status } catch(e) { status = 0; } + + if (0 == status) { + if (self.timedout) return self.timeoutError(); + if (self.aborted) return; + return self.crossDomainError(); + } + self.emit('end'); + }; + + // progress + var handleProgress = function(e){ + if (e.total > 0) { + e.percent = e.loaded / e.total * 100; + } + self.emit('progress', e); + }; + if (this.hasListeners('progress')) { + xhr.onprogress = handleProgress; + } + try { + if (xhr.upload && this.hasListeners('progress')) { + xhr.upload.onprogress = handleProgress; + } + } catch(e) { + // Accessing xhr.upload fails in IE from a web worker, so just pretend it doesn't exist. + // Reported here: + // https://connect.microsoft.com/IE/feedback/details/837245/xmlhttprequest-upload-throws-invalid-argument-when-used-from-web-worker-context + } + + // timeout + if (timeout && !this._timer) { + this._timer = setTimeout(function(){ + self.timedout = true; + self.abort(); + }, timeout); + } + + // querystring + if (query) { + query = request.serializeObject(query); + this.url += ~this.url.indexOf('?') + ? '&' + query + : '?' + query; + } + + // initiate request + xhr.open(this.method, this.url, true); + + // CORS + if (this._withCredentials) xhr.withCredentials = true; + + // body + if ('GET' != this.method && 'HEAD' != this.method && 'string' != typeof data && !isHost(data)) { + // serialize stuff + var contentType = this.getHeader('Content-Type'); + var serialize = request.serialize[contentType ? contentType.split(';')[0] : '']; + if (serialize) data = serialize(data); + } + + // set header fields + for (var field in this.header) { + if (null == this.header[field]) continue; + xhr.setRequestHeader(field, this.header[field]); + } + + // send stuff + this.emit('request', this); + xhr.send(data); + return this; +}; + +/** + * Faux promise support + * + * @param {Function} fulfill + * @param {Function} reject + * @return {Request} + */ + +Request.prototype.then = function (fulfill, reject) { + return this.end(function(err, res) { + err ? reject(err) : fulfill(res); + }); +} + +/** + * Expose `Request`. + */ + +request.Request = Request; + +/** + * Issue a request: + * + * Examples: + * + * request('GET', '/users').end(callback) + * request('/users').end(callback) + * request('/users', callback) + * + * @param {String} method + * @param {String|Function} url or callback + * @return {Request} + * @api public + */ + +function request(method, url) { + // callback + if ('function' == typeof url) { + return new Request('GET', method).end(url); + } + + // url first + if (1 == arguments.length) { + return new Request('GET', method); + } + + return new Request(method, url); +} + +/** + * GET `url` with optional callback `fn(res)`. + * + * @param {String} url + * @param {Mixed|Function} data or fn + * @param {Function} fn + * @return {Request} + * @api public + */ + +request.get = function(url, data, fn){ + var req = request('GET', url); + if ('function' == typeof data) fn = data, data = null; + if (data) req.query(data); + if (fn) req.end(fn); + return req; +}; + +/** + * HEAD `url` with optional callback `fn(res)`. + * + * @param {String} url + * @param {Mixed|Function} data or fn + * @param {Function} fn + * @return {Request} + * @api public + */ + +request.head = function(url, data, fn){ + var req = request('HEAD', url); + if ('function' == typeof data) fn = data, data = null; + if (data) req.send(data); + if (fn) req.end(fn); + return req; +}; + +/** + * DELETE `url` with optional callback `fn(res)`. + * + * @param {String} url + * @param {Function} fn + * @return {Request} + * @api public + */ + +request.del = function(url, fn){ + var req = request('DELETE', url); + if (fn) req.end(fn); + return req; +}; + +/** + * PATCH `url` with optional `data` and callback `fn(res)`. + * + * @param {String} url + * @param {Mixed} data + * @param {Function} fn + * @return {Request} + * @api public + */ + +request.patch = function(url, data, fn){ + var req = request('PATCH', url); + if ('function' == typeof data) fn = data, data = null; + if (data) req.send(data); + if (fn) req.end(fn); + return req; +}; + +/** + * POST `url` with optional `data` and callback `fn(res)`. + * + * @param {String} url + * @param {Mixed} data + * @param {Function} fn + * @return {Request} + * @api public + */ + +request.post = function(url, data, fn){ + var req = request('POST', url); + if ('function' == typeof data) fn = data, data = null; + if (data) req.send(data); + if (fn) req.end(fn); + return req; +}; + +/** + * PUT `url` with optional `data` and callback `fn(res)`. + * + * @param {String} url + * @param {Mixed|Function} data or fn + * @param {Function} fn + * @return {Request} + * @api public + */ + +request.put = function(url, data, fn){ + var req = request('PUT', url); + if ('function' == typeof data) fn = data, data = null; + if (data) req.send(data); + if (fn) req.end(fn); + return req; +}; + +/** + * Expose `request`. + */ + +module.exports = request; + +},{"emitter":39,"reduce":72}],88:[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 : {}) +},{}],89:[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'; +} +},{}],90:[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":89,"_process":68,"inherits":45}],91:[function(require,module,exports){ + +/** + * Module dependencies. + */ + +var global = (function() { return this; })(); + +/** + * WebSocket constructor. + */ + +var WebSocket = global.WebSocket || global.MozWebSocket; + +/** + * Module exports. + */ + +module.exports = WebSocket ? ws : null; + +/** + * WebSocket constructor. + * + * The third `opts` options object gets ignored in web browsers, since it's + * non-standard, and throws a TypeError if passed to the constructor. + * See: https://github.com/einaros/ws/issues/227 + * + * @param {String} uri + * @param {Array} protocols (optional) + * @param {Object) opts (optional) + * @api public + */ + +function ws(uri, protocols, opts) { + var instance; + if (protocols) { + instance = new WebSocket(uri, protocols); + } else { + instance = new WebSocket(uri); + } + return instance; +} + +if (WebSocket) ws.prototype = WebSocket.prototype; + +},{}],92:[function(require,module,exports){ +module.exports=[ + { + "executables": { + "win32": [ + "pol.exe" + ] + }, + "id": 0, + "name": "FINAL FANTASY XI" + }, + { + "executables": { + "win32": [ + "ffxiv.exe", + "ffxiv_dx11.exe" + ] + }, + "id": 1, + "name": "FINAL FANTASY XIV" + }, + { + "executables": { + "win32": [ + "Wow.exe", + "Wow-64.exe" + ] + }, + "id": 3, + "name": "World of Warcraft" + }, + { + "executables": { + "darwin": [ + "LoLLauncher.app" + ], + "win32": [ + "LolClient.exe", + "League of Legends.exe" + ] + }, + "id": 4, + "name": "League of Legends" + }, + { + "executables": { + "darwin": [ + "Diablo%20III.app" + ], + "win32": [ + "Diablo III.exe" + ] + }, + "id": 5, + "name": "Diablo 3" + }, + { + "executables": { + "darwin": [ + "dota_osx.app" + ], + "win32": [ + "dota2.exe" + ] + }, + "id": 6, + "name": "DOTA 2" + }, + { + "executables": { + "darwin": [ + "Heroes.app" + ], + "win32": [ + "Heroes of the Storm.exe", + "HeroesOfTheStorm_x64.exe", + "HeroesOfTheStorm.exe" + ] + }, + "id": 7, + "name": "Heroes of the Storm" + }, + { + "executables": { + "darwin": [ + "Hearthstone.app" + ], + "win32": [ + "Hearthstone.exe" + ] + }, + "id": 8, + "name": "Hearthstone" + }, + { + "executables": { + "win32": [ + "csgo.exe" + ] + }, + "id": 9, + "name": "Counter-Strike: Global Offensive" + }, + { + "executables": { + "win32": [ + "WorldOfTanks.exe" + ] + }, + "id": 10, + "name": "World of Tanks" + }, + { + "executables": { + "darwin": [ + "gw2.app" + ], + "win32": [ + "Gw2.exe", + "Gw2-64.exe" + ] + }, + "id": 11, + "name": "Guild Wars 2" + }, + { + "executables": { + "win32": [ + "dayz.exe" + ] + }, + "id": 12, + "name": "Day Z" + }, + { + "executables": { + "darwin": [ + "starcraft%20ii.app" + ], + "win32": [ + "starcraft ii.exe", + "SC2_x64.exe", + "SC2.exe" + ] + }, + "id": 13, + "name": "Starcraft II" + }, + { + "executables": { + "win32": [ + "diablo.exe" + ] + }, + "id": 14, + "name": "Diablo" + }, + { + "executables": { + "win32": [ + "diablo ii.exe" + ] + }, + "id": 15, + "name": "Diablo 2" + }, + { + "executables": { + "win32": [ + "left4dead.exe" + ] + }, + "id": 17, + "name": "Left 4 Dead" + }, + { + "executables": { + "darwin": [ + "minecraft.app" + ], + "win32": [ + "minecraft.exe" + ] + }, + "id": 18, + "name": "Minecraft" + }, + { + "executables": { + "win32": [ + "smite.exe" + ] + }, + "id": 19, + "name": "Smite" + }, + { + "executables": { + "win32": [ + "bf4.exe" + ] + }, + "id": 20, + "name": "Battlefield 4" + }, + { + "executables": { + "win32": [ + "AoK HD.exe", + "empires2.exe" + ] + }, + "id": 101, + "name": "Age of Empires II" + }, + { + "executables": { + "win32": [ + "age3y.exe" + ] + }, + "id": 102, + "name": "Age of Empires III" + }, + { + "executables": { + "win32": [ + "AlanWake.exe" + ] + }, + "id": 104, + "name": "Alan Wake" + }, + { + "executables": { + "win32": [ + "alan_wakes_american_nightmare.exe" + ] + }, + "id": 105, + "name": "Alan Wake's American Nightmare" + }, + { + "executables": { + "win32": [ + "AlienBreed2Assault.exe" + ] + }, + "id": 106, + "name": "Alien Breed 2: Assault" + }, + { + "executables": { + "win32": [ + "Amnesia.exe" + ] + }, + "id": 107, + "name": "Amnesia: The Dark Descent" + }, + { + "executables": {}, + "id": 108, + "name": "Antichamber" + }, + { + "executables": { + "win32": [ + "ArcheAge.exe" + ] + }, + "id": 109, + "name": "ArcheAge" + }, + { + "executables": { + "win32": [ + "arma3.exe" + ] + }, + "id": 110, + "name": "Arma III" + }, + { + "executables": { + "win32": [ + "AC3SP.exe" + ] + }, + "id": 111, + "name": "Assassin's Creed 3" + }, + { + "executables": { + "win32": [ + "Bastion.exe" + ] + }, + "id": 112, + "name": "Bastion" + }, + { + "executables": { + "win32": [ + "BF2.exe" + ] + }, + "id": 113, + "name": "Battlefield 2" + }, + { + "executables": { + "win32": [ + "bf3.exe" + ] + }, + "id": 114, + "name": "Battlefield 3" + }, + { + "executables": { + "win32": [ + "Besiege.exe" + ] + }, + "id": 116, + "name": "Besiege" + }, + { + "executables": { + "win32": [ + "Bioshock.exe" + ] + }, + "id": 117, + "name": "Bioshock" + }, + { + "executables": { + "win32": [ + "Bioshock2.exe" + ] + }, + "id": 118, + "name": "BioShock II" + }, + { + "executables": { + "win32": [ + "BioShockInfinite.exe" + ] + }, + "id": 119, + "name": "BioShock Infinite" + }, + { + "executables": { + "win32": [ + "Borderlands2.exe" + ] + }, + "id": 122, + "name": "Borderlands 2" + }, + { + "executables": { + "win32": [ + "braid.exe" + ] + }, + "id": 123, + "name": "Braid" + }, + { + "executables": { + "win32": [ + "ShippingPC-StormGame.exe" + ] + }, + "id": 124, + "name": "Bulletstorm" + }, + { + "executables": { + "win32": [ + "cabal2main.exe" + ] + }, + "id": 125, + "name": "Cabal 2" + }, + { + "executables": { + "win32": [ + "CabalMain.exe" + ] + }, + "id": 126, + "name": "Cabal Online" + }, + { + "executables": { + "win32": [ + "iw4mp.exe", + "iw4sp.exe" + ] + }, + "id": 127, + "name": "Call of Duty: Modern Warfare 2" + }, + { + "executables": { + "win32": [ + "t6sp.exe" + ] + }, + "id": 128, + "name": "Call of Duty: Black Ops" + }, + { + "executables": { + "win32": [ + "iw5mp.exe" + ] + }, + "id": 129, + "name": "Call of Duty: Modern Warfare 3" + }, + { + "executables": { + "win32": [ + "RelicCOH.exe" + ] + }, + "id": 132, + "name": "Company of Heroes" + }, + { + "executables": { + "win32": [ + "Crysis64.exe" + ] + }, + "id": 135, + "name": "Crysis" + }, + { + "executables": { + "win32": [ + "Crysis2.exe" + ] + }, + "id": 136, + "name": "Crysis 2" + }, + { + "executables": { + "win32": [ + "Crysis3.exe" + ] + }, + "id": 137, + "name": "Crysis 3" + }, + { + "executables": { + "win32": [ + "Crysis.exe" + ] + }, + "id": 138, + "name": "Crysis 4 " + }, + { + "executables": { + "win32": [ + "DATA.exe", + "DARKSOULS.exe" + ] + }, + "id": 140, + "name": "Dark Souls" + }, + { + "executables": { + "win32": [ + "DarkSoulsII.exe" + ] + }, + "id": 141, + "name": "Dark Souls II" + }, + { + "executables": { + "win32": [ + "dfuw.exe" + ] + }, + "id": 142, + "name": "Darkfall: Unholy Wars" + }, + { + "executables": { + "win32": [ + "DCGAME.exe" + ] + }, + "id": 144, + "name": "DC Universe Online" + }, + { + "executables": { + "win32": [ + "DeadIslandGame.exe" + ] + }, + "id": 145, + "name": "Dead Island" + }, + { + "executables": { + "win32": [ + "deadspace2.exe" + ] + }, + "id": 146, + "name": "Dead Space 2" + }, + { + "executables": { + "win32": [ + "LOTDGame.exe" + ] + }, + "id": 147, + "name": "Deadlight" + }, + { + "executables": { + "win32": [ + "dxhr.exe", + "DXHRDC.exe" + ] + }, + "id": 148, + "name": "Deus Ex: Human Revolution" + }, + { + "executables": { + "win32": [ + "DeviMayCry4.exe", + "DevilMayCry4_DX9.exe", + "DevilMayCry4_DX10.exe", + "DevilMayCry4SpecialEdition.exe" + ] + }, + "id": 149, + "name": "Devil May Cry 4" + }, + { + "executables": { + "win32": [ + "DMC-DevilMayCry.exe" + ] + }, + "id": 150, + "name": "DmC Devil May Cry" + }, + { + "executables": { + "win32": [ + "dirt2_game.exe" + ] + }, + "id": 154, + "name": "DiRT 2" + }, + { + "executables": { + "win32": [ + "dirt3_game.exe" + ] + }, + "id": 155, + "name": "DiRT 3" + }, + { + "executables": { + "win32": [ + "dota.exe" + ] + }, + "id": 156, + "name": "DOTA" + }, + { + "executables": { + "win32": [ + "DoubleDragon.exe" + ] + }, + "id": 158, + "name": "Double Dragon Neon" + }, + { + "executables": { + "win32": [ + "DragonAge2.exe" + ] + }, + "id": 159, + "name": "Dragon Age II" + }, + { + "executables": { + "win32": [ + "DragonAgeInquisition.exe" + ] + }, + "id": 160, + "name": "Dragon Age: Inquisition" + }, + { + "executables": { + "win32": [ + "daorigins.exe" + ] + }, + "id": 161, + "name": "Dragon Age: Origins" + }, + { + "executables": { + "win32": [ + "DBXV.exe" + ] + }, + "id": 162, + "name": "Dragon Ball XenoVerse" + }, + { + "executables": { + "win32": [ + "DukeForever.exe" + ] + }, + "id": 163, + "name": "Duke Nukem Forever" + }, + { + "executables": { + "darwin": [ + "Dustforce.app" + ], + "win32": [ + "dustforce.exe" + ] + }, + "id": 164, + "name": "Dustforce" + }, + { + "executables": { + "win32": [ + "EliteDangerous32.exe" + ] + }, + "id": 165, + "name": "Elite: Dangerous" + }, + { + "executables": { + "win32": [ + "exefile.exe" + ] + }, + "id": 166, + "name": "Eve Online" + }, + { + "executables": { + "win32": [ + "eqgame.exe" + ] + }, + "id": 167, + "name": "EverQuest" + }, + { + "executables": { + "win32": [ + "EverQuest2.exe" + ] + }, + "id": 168, + "name": "EverQuest II" + }, + { + "executables": {}, + "id": 169, + "name": "EverQuest Next" + }, + { + "executables": {}, + "id": 170, + "name": "F.E.A.R." + }, + { + "executables": { + "win32": [ + "FEAR2.exe" + ] + }, + "id": 171, + "name": "F.E.A.R. 2: Project Origin" + }, + { + "executables": { + "win32": [ + "fallout3.exe" + ] + }, + "id": 172, + "name": "Fallout 3" + }, + { + "executables": { + "win32": [ + "FalloutNV.exe" + ] + }, + "id": 174, + "name": "Fallout: New Vegas" + }, + { + "executables": { + "win32": [ + "farcry3.exe" + ] + }, + "id": 175, + "name": "Far Cry 3" + }, + { + "executables": { + "win32": [ + "fifa15.exe" + ] + }, + "id": 176, + "name": "FIFA 15" + }, + { + "executables": { + "win32": [ + "FTLGame.exe" + ] + }, + "id": 180, + "name": "FTL: Faster Than Light" + }, + { + "executables": { + "win32": [ + "GTAIV.exe" + ] + }, + "id": 181, + "name": "Grand Theft Auto 4" + }, + { + "executables": { + "win32": [ + "GTA5.exe" + ] + }, + "id": 182, + "name": "Grand Theft Auto 5" + }, + { + "executables": { + "win32": [ + "Gw.exe" + ] + }, + "id": 183, + "name": "Guild Wars" + }, + { + "executables": { + "win32": [ + "H1Z1.exe" + ] + }, + "id": 186, + "name": "H1Z1" + }, + { + "executables": { + "win32": [ + "HL2HL2.exe", + "hl2.exe" + ] + }, + "id": 188, + "name": "Half Life 2" + }, + { + "executables": { + "win32": [ + "HOMEFRONT.exe" + ] + }, + "id": 195, + "name": "Homefront" + }, + { + "executables": { + "win32": [ + "invisibleinc.exe" + ] + }, + "id": 196, + "name": "Invisible Inc." + }, + { + "executables": { + "win32": [ + "LANoire.exe" + ] + }, + "id": 197, + "name": "L.A. Noire" + }, + { + "executables": { + "win32": [ + "Landmark64.exe" + ] + }, + "id": 198, + "name": "Landmark" + }, + { + "executables": { + "win32": [ + "left4dead2.exe" + ] + }, + "id": 201, + "name": "Left 4 Dead 2" + }, + { + "executables": { + "win32": [ + "lineage.exe" + ] + }, + "id": 203, + "name": "Lineage" + }, + { + "executables": { + "win32": [ + "Magicka.exe" + ] + }, + "id": 206, + "name": "Magicka" + }, + { + "executables": { + "win32": [ + "MapleStory.exe" + ] + }, + "id": 208, + "name": "MapleStory" + }, + { + "executables": {}, + "id": 209, + "name": "Mark of the Ninja" + }, + { + "executables": { + "win32": [ + "MassEffect.exe" + ] + }, + "id": 210, + "name": "Mass Effect" + }, + { + "executables": { + "win32": [ + "MassEffect2.exe" + ] + }, + "id": 211, + "name": "Mass Effect 2" + }, + { + "executables": { + "win32": [ + "MassEffect3Demo.exe", + "MassEffect3.exe" + ] + }, + "id": 212, + "name": "Mass Effect 3" + }, + { + "executables": { + "win32": [ + "METAL GEAR RISING REVENGEANCE.exe" + ] + }, + "id": 214, + "name": "Metal Gear Rising: Revengeance" + }, + { + "executables": { + "win32": [ + "metro2033.exe" + ] + }, + "id": 215, + "name": "Metro 2033" + }, + { + "executables": { + "win32": [ + "MetroLL.exe" + ] + }, + "id": 216, + "name": "Metro Last Light" + }, + { + "executables": { + "win32": [ + "MK10.exe" + ] + }, + "id": 218, + "name": "Mortal Kombat X" + }, + { + "executables": { + "win32": [ + "speed.exe" + ] + }, + "id": 219, + "name": "Need For Speed Most Wanted" + }, + { + "executables": {}, + "id": 220, + "name": "Neverwinder" + }, + { + "executables": { + "darwin": [ + "Outlast.app" + ], + "win32": [ + "OLGame.exe" + ] + }, + "id": 221, + "name": "Outlast" + }, + { + "executables": { + "win32": [ + "PapersPlease.exe" + ] + }, + "id": 222, + "name": "Papers, Please" + }, + { + "executables": { + "win32": [ + "payday_win32_release.exe" + ] + }, + "id": 223, + "name": "PAYDAY" + }, + { + "executables": { + "win32": [ + "payday2_win32_release.exe" + ] + }, + "id": 224, + "name": "PAYDAY 2" + }, + { + "executables": { + "win32": [ + "PillarsOfEternity.exe" + ] + }, + "id": 225, + "name": "Pillars of Eternity" + }, + { + "executables": { + "win32": [ + "PA.exe" + ] + }, + "id": 226, + "name": "Planetary Annihilation" + }, + { + "executables": { + "win32": [ + "planetside2_x86.exe", + "PlanetSide2_x64.exe" + ] + }, + "id": 227, + "name": "Planetside 2" + }, + { + "executables": { + "win32": [ + "hl2P.exe" + ] + }, + "id": 228, + "name": "Portal" + }, + { + "executables": { + "win32": [ + "portal2.exe" + ] + }, + "id": 229, + "name": "Portal 2" + }, + { + "executables": { + "win32": [ + "PrimalCarnageGame.exe" + ] + }, + "id": 231, + "name": "Primal Cargnage" + }, + { + "executables": { + "win32": [ + "pCARS.exe" + ] + }, + "id": 232, + "name": "Project Cars" + }, + { + "executables": { + "win32": [ + "RaceTheSun.exe" + ] + }, + "id": 233, + "name": "Race The Sun" + }, + { + "executables": { + "win32": [ + "Rage.exe" + ] + }, + "id": 234, + "name": "RAGE" + }, + { + "executables": { + "win32": [ + "ragexe.exe" + ] + }, + "id": 235, + "name": "Ragnarok Online" + }, + { + "executables": { + "win32": [ + "rift.exe" + ] + }, + "id": 236, + "name": "Rift" + }, + { + "executables": { + "win32": [ + "Rocksmith2014.exe" + ] + }, + "id": 237, + "name": "Rocksmith 2014" + }, + { + "executables": { + "win32": [ + "SwiftKit-RS.exe", + "JagexLauncher.exe", + "OSBuddy.exe" + ] + }, + "id": 238, + "name": "RuneScape" + }, + { + "executables": { + "win32": [ + "Shadowgrounds.exe" + ] + }, + "id": 239, + "name": "Shadowgrounds" + }, + { + "executables": { + "win32": [ + "survivor.exe" + ] + }, + "id": 240, + "name": "Shadowgrounds: Survivor" + }, + { + "executables": { + "win32": [ + "ShovelKnight.exe" + ] + }, + "id": 241, + "name": "Shovel Knight" + }, + { + "executables": { + "win32": [ + "SimCity.exe" + ] + }, + "id": 242, + "name": "SimCity" + }, + { + "executables": { + "win32": [ + "SporeApp.exe" + ] + }, + "id": 245, + "name": "Spore" + }, + { + "executables": { + "win32": [ + "StarCitizen.exe" + ] + }, + "id": 246, + "name": "Star Citizen" + }, + { + "executables": {}, + "id": 247, + "name": "Star Trek Online" + }, + { + "executables": { + "win32": [ + "battlefront.exe", + "starwarsbattlefront.exe" + ] + }, + "id": 248, + "name": "Star Wars Battlefront" + }, + { + "executables": { + "win32": [ + "swtor.exe" + ] + }, + "id": 249, + "name": "Star Wars: The Old Republic" + }, + { + "executables": { + "darwin": [ + "Starbound.app" + ], + "win32": [ + "starbound.exe", + "starbound_opengl.exe" + ] + }, + "id": 250, + "name": "Starbound" + }, + { + "executables": { + "win32": [ + "starcraft.exe" + ] + }, + "id": 251, + "name": "Starcraft" + }, + { + "executables": { + "win32": [ + "SSFIV.exe" + ] + }, + "id": 253, + "name": "Ultra Street Fighter IV" + }, + { + "executables": { + "win32": [ + "superhexagon.exe" + ] + }, + "id": 254, + "name": "Super Hexagon" + }, + { + "executables": { + "win32": [ + "swordandsworcery_pc.exe" + ] + }, + "id": 255, + "name": "Superbrothers: Sword & Sworcery EP" + }, + { + "executables": { + "win32": [ + "hl2TF.exe" + ] + }, + "id": 256, + "name": "Team Fortress 2" + }, + { + "executables": { + "win32": [ + "TERA.exe" + ] + }, + "id": 258, + "name": "TERA" + }, + { + "executables": { + "darwin": [ + "Terraria.app" + ], + "win32": [ + "Terraria.exe" + ] + }, + "id": 259, + "name": "Terraria" + }, + { + "executables": { + "win32": [ + "Bethesda.net_Launcher.exe", + "eso.exe" + ] + }, + "id": 260, + "name": "The Elder Scrolls Online" + }, + { + "executables": { + "win32": [ + "TESV.exe", + "TESV_original.exe" + ] + }, + "id": 261, + "name": "The Elder Scrolls V: Skyrim" + }, + { + "executables": { + "win32": [ + "TheSecretWorld.exe" + ] + }, + "id": 262, + "name": "The Secret World" + }, + { + "executables": { + "win32": [ + "TS3.exe", + "ts3w.exe" + ] + }, + "id": 264, + "name": "The Sims 3" + }, + { + "executables": { + "win32": [ + "WALKINGDEAD101.EXE" + ] + }, + "id": 265, + "name": "The Walking Dead" + }, + { + "executables": { + "win32": [ + "TheWalkingDead2.exe" + ] + }, + "id": 266, + "name": "The Walking Dead Season Two" + }, + { + "executables": { + "win32": [ + "witcher3.exe" + ] + }, + "id": 267, + "name": "The Witcher 3" + }, + { + "executables": { + "win32": [ + "Future Soldier.exe" + ] + }, + "id": 268, + "name": "Tom Clancy's Ghost Recon: Future Solider" + }, + { + "executables": { + "win32": [ + "TombRaider.exe" + ] + }, + "id": 269, + "name": "Tomb Raider (2013)" + }, + { + "executables": { + "win32": [ + "Torchlight.exe" + ] + }, + "id": 271, + "name": "Torchlight" + }, + { + "executables": { + "win32": [ + "Torchlight2.exe" + ] + }, + "id": 272, + "name": "Torchlight 2" + }, + { + "executables": { + "win32": [ + "Shogun2.exe" + ] + }, + "id": 273, + "name": "Total War: Shogun 2" + }, + { + "executables": { + "win32": [ + "Transistor.exe" + ] + }, + "id": 274, + "name": "Transistor" + }, + { + "executables": { + "darwin": [ + "Trine.app" + ], + "win32": [ + "trine.exe" + ] + }, + "id": 275, + "name": "Trine" + }, + { + "executables": { + "darwin": [ + "Trine2.app" + ], + "win32": [ + "trine2_32bit.exe" + ] + }, + "id": 276, + "name": "Trine 2" + }, + { + "executables": { + "win32": [ + "UOKR.exe" + ] + }, + "id": 277, + "name": "Ultima Online" + }, + { + "executables": { + "win32": [ + "aces.exe" + ] + }, + "id": 279, + "name": "War Thunder" + }, + { + "executables": { + "darwin": [ + "Warcraft%20III.app", + "Frozen%20Throne.app" + ], + "win32": [ + "Warcraft III.exe", + "wc3.exe", + "war3.exe" + ] + }, + "id": 281, + "name": "Warcraft 3: Reign of Chaos" + }, + { + "executables": { + "win32": [ + "Warcraft II BNE.exe" + ] + }, + "id": 282, + "name": "Warcraft II" + }, + { + "executables": { + "win32": [ + "Warframe.x64.exe", + "Warframe.exe" + ] + }, + "id": 283, + "name": "Warframe" + }, + { + "executables": { + "win32": [ + "watch_dogs.exe" + ] + }, + "id": 284, + "name": "Watch Dogs" + }, + { + "executables": { + "win32": [ + "WildStar64.exe", + "Wildstar.exe" + ] + }, + "id": 285, + "name": "WildStar" + }, + { + "executables": { + "win32": [ + "XComGame.exe", + "XcomEW.exe" + ] + }, + "id": 288, + "name": "XCOM: Enemy Unknown" + }, + { + "executables": { + "win32": [ + "DFO.exe", + "dfo.exe" + ] + }, + "id": 289, + "name": "Dungeon Fighter Online" + }, + { + "executables": { + "win32": [ + "aclauncher.exe", + "acclient.exe" + ] + }, + "id": 290, + "name": "Asheron's Call" + }, + { + "executables": { + "win32": [ + "MapleStory2.exe" + ] + }, + "id": 291, + "name": "MapleStory 2" + }, + { + "executables": { + "win32": [ + "ksp.exe" + ] + }, + "id": 292, + "name": "Kerbal Space Program" + }, + { + "executables": { + "win32": [ + "PINBALL.EXE" + ] + }, + "id": 293, + "name": "3D Pinball: Space Cadet" + }, + { + "executables": { + "win32": [ + "dave.exe" + ] + }, + "id": 294, + "name": "Dangerous Dave" + }, + { + "executables": { + "win32": [ + "iwbtgbeta(slomo).exe", + "iwbtgbeta(fs).exe" + ] + }, + "id": 295, + "name": "I Wanna Be The Guy" + }, + { + "executables": { + "win32": [ + "MechWarriorOnline.exe ", + "mwoclient.exe" + ] + }, + "id": 296, + "name": "MechWarrior Online" + }, + { + "executables": { + "win32": [ + "dontstarve_steam.exe" + ] + }, + "id": 297, + "name": "Don't Starve" + }, + { + "executables": { + "win32": [ + "GalCiv3.exe" + ] + }, + "id": 298, + "name": "Galactic Civilization 3" + }, + { + "executables": { + "win32": [ + "Risk of Rain.exe" + ] + }, + "id": 299, + "name": "Risk of Rain" + }, + { + "executables": { + "darwin": [ + "Isaac.app" + ], + "win32": [ + "Binding_of_Isaac.exe", + "Isaac.exe" + ] + }, + "id": 300, + "name": "The Binding of Isaac" + }, + { + "executables": { + "win32": [ + "RustClient.exe" + ] + }, + "id": 301, + "name": "Rust" + }, + { + "executables": { + "win32": [ + "Clicker Heroes.exe" + ] + }, + "id": 302, + "name": "Clicker Heroes" + }, + { + "executables": { + "win32": [ + "Brawlhalla.exe" + ] + }, + "id": 303, + "name": "Brawlhalla" + }, + { + "executables": { + "win32": [ + "TownOfSalem.exe" + ] + }, + "id": 304, + "name": "Town of Salem" + }, + { + "executables": { + "win32": [ + "osu!.exe" + ] + }, + "id": 305, + "name": "osu!" + }, + { + "executables": { + "win32": [ + "PathOfExileSteam.exe", + "PathOfExile.exe" + ] + }, + "id": 306, + "name": "Path of Exile" + }, + { + "executables": { + "win32": [ + "Dolphin.exe" + ] + }, + "id": 307, + "name": "Dolphin" + }, + { + "executables": { + "win32": [ + "RocketLeague.exe" + ] + }, + "id": 308, + "name": "Rocket League" + }, + { + "executables": { + "win32": [ + "TJPP.exe" + ] + }, + "id": 309, + "name": "Jackbox Party Pack" + }, + { + "executables": { + "win32": [ + "KFGame.exe" + ] + }, + "id": 310, + "name": "Killing Floor 2" + }, + { + "executables": { + "win32": [ + "ShooterGame.exe" + ] + }, + "id": 311, + "name": "Ark: Survival Evolved" + }, + { + "executables": { + "win32": [ + "LifeIsStrange.exe" + ] + }, + "id": 312, + "name": "Life Is Strange" + }, + { + "executables": { + "win32": [ + "Client_tos.exe" + ] + }, + "id": 313, + "name": "Tree of Savior" + }, + { + "executables": { + "win32": [ + "olliolli2.exe" + ] + }, + "id": 314, + "name": "OlliOlli2" + }, + { + "executables": { + "win32": [ + "cw.exe" + ] + }, + "id": 315, + "name": "Closers Dimension Conflict" + }, + { + "executables": { + "win32": [ + "ESSTEAM.exe", + "elsword.exe", + "x2.exe" + ] + }, + "id": 316, + "name": "Elsword" + }, + { + "executables": { + "win32": [ + "ori.exe" + ] + }, + "id": 317, + "name": "Ori and the Blind Forest" + }, + { + "executables": { + "win32": [ + "Skyforge.exe" + ] + }, + "id": 318, + "name": "Skyforge" + }, + { + "executables": { + "win32": [ + "projectzomboid64.exe", + "projectzomboid32.exe" + ] + }, + "id": 319, + "name": "Project Zomboid" + }, + { + "executables": { + "win32": [ + "From_The_Depths.exe" + ] + }, + "id": 320, + "name": "From The Depths" + }, + { + "executables": { + "win32": [ + "TheCrew.exe" + ] + }, + "id": 321, + "name": "The Crew" + }, + { + "executables": { + "win32": [ + "MarvelHeroes2015.exe" + ] + }, + "id": 322, + "name": "Marvel Heroes 2015" + }, + { + "executables": { + "win32": [ + "timeclickers.exe" + ] + }, + "id": 324, + "name": "Time Clickers" + }, + { + "executables": { + "win32": [ + "eurotrucks2.exe" + ] + }, + "id": 325, + "name": "Euro Truck Simulator 2" + }, + { + "executables": { + "win32": [ + "FarmingSimulator2015Game.exe" + ] + }, + "id": 326, + "name": "Farming Simulator 15" + }, + { + "executables": { + "win32": [ + "strife.exe" + ] + }, + "id": 327, + "name": "Strife" + }, + { + "executables": { + "win32": [ + "Awesomenauts.exe" + ] + }, + "id": 328, + "name": "Awesomenauts" + }, + { + "executables": { + "win32": [ + "Dofus.exe" + ] + }, + "id": 329, + "name": "Dofus" + }, + { + "executables": { + "win32": [ + "Boid.exe" + ] + }, + "id": 330, + "name": "Boid" + }, + { + "executables": { + "win32": [ + "adventure-capitalist.exe" + ] + }, + "id": 331, + "name": "AdVenture Capitalist" + }, + { + "executables": { + "win32": [ + "OrcsMustDie2.exe" + ] + }, + "id": 332, + "name": "Orcs Must Die! 2" + }, + { + "executables": { + "win32": [ + "Mountain.exe" + ] + }, + "id": 333, + "name": "Mountain" + }, + { + "executables": { + "win32": [ + "Valkyria.exe" + ] + }, + "id": 335, + "name": "Valkyria Chronicles" + }, + { + "executables": { + "win32": [ + "ffxiiiimg.exe" + ] + }, + "id": 336, + "name": "Final Fantasy XIII" + }, + { + "executables": { + "win32": [ + "TLR.exe" + ] + }, + "id": 337, + "name": "The Last Remnant" + }, + { + "executables": { + "win32": [ + "Cities.exe" + ] + }, + "id": 339, + "name": "Cities Skylines" + }, + { + "executables": { + "win32": [ + "worldofwarships.exe", + "WoWSLauncher.exe" + ] + }, + "id": 341, + "name": "World of Warships" + }, + { + "executables": { + "win32": [ + "spacegame-Win64-shipping.exe" + ] + }, + "id": 342, + "name": "Fractured Space" + }, + { + "executables": { + "win32": [ + "thespacegame.exe" + ] + }, + "id": 343, + "name": "Ascent - The Space Game" + }, + { + "executables": { + "win32": [ + "DuckGame.exe" + ] + }, + "id": 344, + "name": "Duck Game" + }, + { + "executables": { + "win32": [ + "PPSSPPWindows.exe", + "PPSSPPWindows64.exe" + ] + }, + "id": 345, + "name": "PPSSPP" + }, + { + "executables": { + "win32": [ + "MBAA.exe" + ] + }, + "id": 346, + "name": "Melty Blood Actress Again: Current Code" + }, + { + "executables": { + "win32": [ + "TheWolfAmongUs.exe" + ] + }, + "id": 347, + "name": "The Wolf Among Us" + }, + { + "executables": { + "win32": [ + "SpaceEngineers.exe" + ] + }, + "id": 348, + "name": "Space Engineers" + }, + { + "executables": { + "win32": [ + "Borderlands.exe" + ] + }, + "id": 349, + "name": "Borderlands" + }, + { + "executables": { + "win32": [ + "100orange.exe" + ] + }, + "id": 351, + "name": "100% Orange Juice" + }, + { + "executables": { + "win32": [ + "reflex.exe" + ] + }, + "id": 354, + "name": "Reflex" + }, + { + "executables": { + "win32": [ + "pso2.exe" + ] + }, + "id": 355, + "name": "Phantasy Star Online 2" + }, + { + "executables": { + "win32": [ + "AssettoCorsa.exe" + ] + }, + "id": 356, + "name": "Assetto Corsa" + }, + { + "executables": { + "win32": [ + "iw3mp.exe", + "iw3sp.exe" + ] + }, + "id": 357, + "name": "Call of Duty 4: Modern Warfare" + }, + { + "executables": { + "win32": [ + "WolfOldBlood_x64.exe" + ] + }, + "id": 358, + "name": "Wolfenstein: The Old Blood" + }, + { + "executables": { + "win32": [ + "castle.exe" + ] + }, + "id": 359, + "name": "Castle Crashers" + }, + { + "executables": { + "win32": [ + "vindictus.exe" + ] + }, + "id": 360, + "name": "Vindictus" + }, + { + "executables": { + "win32": [ + "ShooterGame-Win32-Shipping.exe" + ] + }, + "id": 361, + "name": "Dirty Bomb" + }, + { + "executables": { + "win32": [ + "BatmanAK.exe" + ] + }, + "id": 362, + "name": "Batman Arkham Knight" + }, + { + "executables": { + "win32": [ + "drt.exe" + ] + }, + "id": 363, + "name": "Dirt Rally" + }, + { + "executables": { + "win32": [ + "rFactor.exe" + ] + }, + "id": 364, + "name": "rFactor" + }, + { + "executables": { + "win32": [ + "clonk.exe" + ] + }, + "id": 365, + "name": "Clonk Rage" + }, + { + "executables": { + "win32": [ + "SRHK.exe" + ] + }, + "id": 366, + "name": "Shadowrun: Hong Kong" + }, + { + "executables": { + "win32": [ + "Insurgency.exe" + ] + }, + "id": 367, + "name": "Insurgency" + }, + { + "executables": { + "win32": [ + "StepMania.exe" + ] + }, + "id": 368, + "name": "Step Mania" + }, + { + "executables": { + "win32": [ + "FirefallCLient.exe" + ] + }, + "id": 369, + "name": "Firefall" + }, + { + "executables": { + "win32": [ + "mirrorsedge.exe" + ] + }, + "id": 370, + "name": "Mirrors Edge" + }, + { + "executables": { + "win32": [ + "MgsGroundZeroes.exe" + ] + }, + "id": 371, + "name": "Metal Gear Solid V: Ground Zeroes" + }, + { + "executables": { + "win32": [ + "mgsvtpp.exe" + ] + }, + "id": 372, + "name": "Metal Gear Solid V: The Phantom Pain" + }, + { + "executables": { + "win32": [ + "tld.exe" + ] + }, + "id": 373, + "name": "The Long Dark" + }, + { + "executables": { + "win32": [ + "TKOM.exe" + ] + }, + "id": 374, + "name": "Take On Mars" + }, + { + "executables": { + "win32": [ + "robloxplayerlauncher.exe", + "Roblox.exe", + "RobloxPlayerBeta.exe" + ] + }, + "id": 375, + "name": "Roblox" + }, + { + "executables": { + "darwin": [ + "eu4.app" + ], + "win32": [ + "eu4.exe" + ] + }, + "id": 376, + "name": "Europa Universalis 4" + }, + { + "executables": { + "win32": [ + "APB.exe" + ] + }, + "id": 377, + "name": "APB Reloaded" + }, + { + "executables": { + "win32": [ + "Robocraft.exe", + "RobocraftClient.exe" + ] + }, + "id": 378, + "name": "Robocraft" + }, + { + "executables": { + "win32": [ + "Unity.exe" + ] + }, + "id": 379, + "name": "Unity" + }, + { + "executables": { + "win32": [ + "Simpsons.exe" + ] + }, + "id": 380, + "name": "The Simpsons: Hit & Run" + }, + { + "executables": { + "win32": [ + "Dnlauncher.exe", + "DragonNest.exe" + ] + }, + "id": 381, + "name": "Dragon Nest" + }, + { + "executables": { + "win32": [ + "Trove.exe" + ] + }, + "id": 382, + "name": "Trove" + }, + { + "executables": { + "win32": [ + "EndlessLegend.exe" + ] + }, + "id": 383, + "name": "Endless Legend" + }, + { + "executables": { + "win32": [ + "TurbineLauncher.exe", + "dndclient.exe" + ] + }, + "id": 384, + "name": "Dungeons & Dragons Online" + }, + { + "executables": { + "win32": [ + "quakelive.exe", + "quakelive_steam.exe" + ] + }, + "id": 385, + "name": "Quake Live" + }, + { + "executables": { + "win32": [ + "7DaysToDie.exe" + ] + }, + "id": 386, + "name": "7DaysToDie" + }, + { + "executables": { + "win32": [ + "SpeedRunners.exe" + ] + }, + "id": 387, + "name": "SpeedRunners" + }, + { + "executables": { + "win32": [ + "gamemd.exe" + ] + }, + "id": 388, + "name": "Command & Conquer: Red Alert 2" + }, + { + "executables": { + "win32": [ + "generals.exe" + ] + }, + "id": 389, + "name": "Command & Conquer Generals: Zero Hour" + }, + { + "executables": { + "win32": [ + "Oblivion.exe" + ] + }, + "id": 390, + "name": "The Elder Scrolls 4: Oblivion" + }, + { + "executables": { + "win32": [ + "mgsi.exe" + ] + }, + "id": 391, + "name": "Metal Gear Solid" + }, + { + "executables": { + "win32": [ + "EoCApp.exe" + ] + }, + "id": 392, + "name": "Divinity - Original Sin" + }, + { + "executables": { + "win32": [ + "Torment.exe" + ] + }, + "id": 393, + "name": "Planescape: Torment" + }, + { + "executables": { + "win32": [ + "HexPatch.exe", + "Hex.exe" + ] + }, + "id": 394, + "name": "Hex: Shards of Fate" + }, + { + "executables": { + "win32": [ + "NS3FB.exe" + ] + }, + "id": 395, + "name": "Naruto Shippuden Ultimate Ninja Storm 3 Full Burst" + }, + { + "executables": { + "win32": [ + "NSUNSR.exe" + ] + }, + "id": 396, + "name": "Naruto Shippuden Ultimate Ninja Storm Revolution" + }, + { + "executables": { + "win32": [ + "SaintsRowIV.exe" + ] + }, + "id": 397, + "name": "Saints Row IV" + }, + { + "executables": { + "win32": [ + "Shadowrun.exe" + ] + }, + "id": 398, + "name": "Shadowrun" + }, + { + "executables": { + "win32": [ + "DungeonoftheEndless.exe" + ] + }, + "id": 399, + "name": "Dungeon of the Endless" + }, + { + "executables": { + "win32": [ + "Hon.exe" + ] + }, + "id": 400, + "name": "Heroes of Newerth" + }, + { + "executables": { + "win32": [ + "Mabinogi.exe" + ] + }, + "id": 401, + "name": "Mabinogi" + }, + { + "executables": { + "win32": [ + "CoD2MP_s.exe", + "CoD2SP_s.exe" + ] + }, + "id": 402, + "name": "Call of Duty 2:" + }, + { + "executables": { + "win32": [ + "CoDWaWmp.exe", + "CoDWaw.exe" + ] + }, + "id": 403, + "name": "Call of Duty: World at War" + }, + { + "executables": { + "win32": [ + "heroes.exe" + ] + }, + "id": 404, + "name": "Mabinogi Heroes (Vindictus) " + }, + { + "executables": { + "win32": [ + "KanColleViewer.exe", + "ElectronicObserver.exe" + ] + }, + "id": 405, + "name": "Kantai Collection" + }, + { + "executables": { + "win32": [ + "cyphers.exe" + ] + }, + "id": 406, + "name": "Cyphers" + }, + { + "executables": { + "win32": [ + "RelicCoH2.exe" + ] + }, + "id": 407, + "name": "Company of Heroes 2" + }, + { + "executables": { + "win32": [ + "MJ.exe" + ] + }, + "id": 408, + "name": "セガNET麻雀MJ" + }, + { + "executables": { + "win32": [ + "ge.exe" + ] + }, + "id": 409, + "name": "Granado Espada" + }, + { + "executables": { + "win32": [ + "NovaRO.exe" + ] + }, + "id": 410, + "name": "Nova Ragnarok Online" + }, + { + "executables": { + "win32": [ + "RivalsofAether.exe" + ] + }, + "id": 411, + "name": "Rivals of Aether" + }, + { + "executables": { + "win32": [ + "bfh.exe" + ] + }, + "id": 412, + "name": "Battlefield Hardline" + }, + { + "executables": { + "win32": [ + "GrowHome.exe" + ] + }, + "id": 413, + "name": "Grow Home" + }, + { + "executables": { + "win32": [ + "patriots.exe" + ] + }, + "id": 414, + "name": "Rise of Nations Extended" + }, + { + "executables": { + "win32": [ + "Railroads.exe" + ] + }, + "id": 415, + "name": "Sid Meier's Railroads!" + }, + { + "executables": { + "win32": [ + "Empire.exe" + ] + }, + "id": 416, + "name": "Empire: Total War" + }, + { + "executables": { + "win32": [ + "Napoleon.exe" + ] + }, + "id": 417, + "name": "Napoleon: Total War" + }, + { + "executables": { + "win32": [ + "gta_sa.exe" + ] + }, + "id": 418, + "name": "Grand Theft Auto: San Andreas" + }, + { + "executables": { + "win32": [ + "MadMax.exe" + ] + }, + "id": 419, + "name": "Mad Max" + }, + { + "executables": { + "win32": [ + "Titanfall.exe" + ] + }, + "id": 420, + "name": "Titanfall" + }, + { + "executables": { + "win32": [ + "age2_x1.exe" + ] + }, + "id": 421, + "name": "Age of Empires II: The Conquerors" + }, + { + "executables": { + "win32": [ + "Rome2.exe" + ] + }, + "id": 422, + "name": "Total War: ROME 2" + }, + { + "executables": { + "win32": [ + "ShadowOfMordor.exe" + ] + }, + "id": 423, + "name": "Middle-earth: Shadow of Mordor" + }, + { + "executables": { + "win32": [ + "Subnautica.exe" + ] + }, + "id": 424, + "name": "Subnautica" + }, + { + "executables": { + "win32": [ + "anno5.exe" + ] + }, + "id": 425, + "name": "Anno 2070" + }, + { + "executables": { + "win32": [ + "carrier.exe" + ] + }, + "id": 426, + "name": "Carrier Command Gaea Mission" + }, + { + "executables": { + "win32": [ + "DarksidersPC.exe" + ] + }, + "id": 427, + "name": "Darksiders" + }, + { + "executables": { + "win32": [ + "Darksiders2.exe" + ] + }, + "id": 428, + "name": "Darksiders 2" + }, + { + "executables": { + "win32": [ + "mudlet.exe" + ] + }, + "id": 429, + "name": "Mudlet" + }, + { + "executables": { + "win32": [ + "DunDefLauncher.exe", + "DunDefGame.exe" + ] + }, + "id": 430, + "name": "Dungeon Defenders II" + }, + { + "executables": { + "win32": [ + "hng.exe" + ] + }, + "id": 431, + "name": "Heroes and Generals" + }, + { + "executables": { + "win32": [ + "WFTOGame.exe" + ] + }, + "id": 432, + "name": "War For the Overworld" + }, + { + "executables": { + "win32": [ + "Talisman.exe" + ] + }, + "id": 433, + "name": "Talisman: Digital Edition" + }, + { + "executables": { + "win32": [ + "limbo.exe" + ] + }, + "id": 434, + "name": "Limbo" + }, + { + "executables": { + "win32": [ + "ibbobb.exe" + ] + }, + "id": 435, + "name": "ibb & obb" + }, + { + "executables": { + "win32": [ + "BattleBlockTheater.exe" + ] + }, + "id": 436, + "name": "BattleBlock Theater" + }, + { + "executables": { + "win32": [ + "iracinglauncher.exe", + "iracingsim.exe", + "iracingsim64.exe" + ] + }, + "id": 437, + "name": "iRacing" + }, + { + "executables": { + "win32": [ + "CivilizationV_DX11.exe" + ] + }, + "id": 438, + "name": "Civilization V" + }, + { + "executables": { + "win32": [ + "lostsaga.exe", + "LoginLauncherN.exe" + ] + }, + "id": 439, + "name": "Lost Saga" + }, + { + "executables": { + "win32": [ + "nuclearthrone.exe" + ] + }, + "id": 440, + "name": "Nuclear Throne" + }, + { + "executables": { + "win32": [ + "SwordCoast.exe" + ] + }, + "id": 441, + "name": "Sword Coast Legends" + }, + { + "executables": { + "win32": [ + "FF3_Launcher.exe" + ] + }, + "id": 442, + "name": "Final Fantasy III" + }, + { + "executables": { + "darwin": [ + "UNDERTALE.app" + ], + "win32": [ + "UNDERTALE.exe" + ] + }, + "id": 443, + "name": "Undertale" + }, + { + "executables": { + "win32": [ + "Blockland.exe" + ] + }, + "id": 444, + "name": "Blockland" + }, + { + "executables": { + "win32": [ + "DNF.exe" + ] + }, + "id": 445, + "name": "Dungeon & Fighter" + }, + { + "executables": { + "win32": [ + "Bugs.exe" + ] + }, + "id": 446, + "name": "BBLiT" + }, + { + "executables": { + "win32": [ + "grid2.exe" + ] + }, + "id": 447, + "name": "Grid 2" + }, + { + "executables": { + "win32": [ + "RainbowSix.exe" + ] + }, + "id": 448, + "name": "Rainbow Six Siege" + }, + { + "executables": { + "win32": [ + "rotaku.exe" + ] + }, + "id": 449, + "name": "Rotaku Society" + }, + { + "executables": { + "win32": [ + "Cube.exe" + ] + }, + "id": 450, + "name": "Cube World" + }, + { + "executables": { + "win32": [ + "TS4.exe" + ] + }, + "id": 451, + "name": "The Sims 4" + }, + { + "executables": { + "win32": [ + "nekopara_vol1.exe" + ] + }, + "id": 452, + "name": "Nekopara Vol. 1" + }, + { + "executables": { + "win32": [ + "nekopara_vol0.exe" + ] + }, + "id": 453, + "name": "Nekopara Vol. 0" + }, + { + "executables": { + "win32": [ + "FreeStyle2.exe" + ] + }, + "id": 454, + "name": "Freestyle Basketball 2" + }, + { + "executables": { + "win32": [ + "HMA.exe" + ] + }, + "id": 455, + "name": "Hitman: Absolution" + }, + { + "executables": { + "win32": [ + "SaintsRowTheThird_DX11.exe", + "SaintsRowTheThird.exe" + ] + }, + "id": 456, + "name": "Saints Row 3" + }, + { + "executables": { + "win32": [ + "JustCause.exe" + ] + }, + "id": 457, + "name": "Just Cause" + }, + { + "executables": { + "win32": [ + "KillingFloor.exe" + ] + }, + "id": 458, + "name": "Killing Floor" + }, + { + "executables": { + "win32": [ + "DeadIslandGame_x86_rwdi.exe" + ] + }, + "id": 459, + "name": "Dead Island Riptide" + }, + { + "executables": { + "win32": [ + "JustCause2.exe" + ] + }, + "id": 460, + "name": "Just Cause 2" + }, + { + "executables": { + "win32": [ + "altitude.exe" + ] + }, + "id": 461, + "name": "Altitude" + }, + { + "executables": { + "darwin": [ + "ygopro.app" + ], + "win32": [ + "ygopro_vs.exe" + ] + }, + "id": 462, + "name": "Yu-gi-oh Pro" + }, + { + "executables": { + "win32": [ + "bejeweled3.exe" + ] + }, + "id": 463, + "name": "Bejeweled 3" + }, + { + "executables": { + "win32": [ + "fable.exe" + ] + }, + "id": 464, + "name": "Fable: The Lost Chapters" + }, + { + "executables": { + "win32": [ + "lyne.exe" + ] + }, + "id": 465, + "name": "LYNE" + }, + { + "executables": { + "win32": [ + "Tabletop Simulator.exe" + ] + }, + "id": 466, + "name": "Tabletop Simulator" + }, + { + "executables": { + "win32": [ + "screencheat.exe" + ] + }, + "id": 467, + "name": "Screencheat" + }, + { + "executables": { + "win32": [ + "cataclysm-tiles.exe" + ] + }, + "id": 468, + "name": "Cataclysm: Dark Days Ahead" + }, + { + "executables": { + "win32": [ + "Prison Architect.exe" + ] + }, + "id": 469, + "name": "Prison Architect" + }, + { + "executables": { + "win32": [ + "armoredwarfare.exe" + ] + }, + "id": 470, + "name": "Armored Warfare" + }, + { + "executables": { + "win32": [ + "Devilian.exe" + ] + }, + "id": 471, + "name": "Devilian" + }, + { + "executables": { + "win32": [ + "aion.bin" + ] + }, + "id": 472, + "name": "Aion" + }, + { + "executables": { + "win32": [ + "Allegiance.exe" + ] + }, + "id": 473, + "name": "Allegiance" + }, + { + "executables": { + "win32": [ + "infantry.exe" + ] + }, + "id": 474, + "name": "Infantry" + }, + { + "executables": { + "win32": [ + "audiosurf.exe", + "Questviewer.exe" + ] + }, + "id": 475, + "name": "Audiosurf" + }, + { + "executables": { + "win32": [ + "audiosurf2.exe" + ] + }, + "id": 476, + "name": "Audiosurf 2" + }, + { + "executables": { + "win32": [ + "morrowind.exe" + ] + }, + "id": 477, + "name": "Morrowind" + }, + { + "executables": { + "win32": [ + "GoatGame-Win32-Shipping.exe" + ] + }, + "id": 478, + "name": "Goat Simulator" + }, + { + "executables": { + "win32": [ + "th123.exe", + "th123e.exe" + ] + }, + "id": 479, + "name": "Touhou 12.3: Hisoutensoku" + }, + { + "executables": { + "win32": [ + "th135.exe", + "th135e.exe" + ] + }, + "id": 480, + "name": "Touhou 13.5 Hopeless Mascarade" + }, + { + "executables": { + "win32": [ + "th145.exe", + "th145e.exe" + ] + }, + "id": 481, + "name": "Touhou 14.5: Urban Legend in Limbo" + }, + { + "executables": { + "win32": [ + "quake1.exe" + ] + }, + "id": 482, + "name": "Quake I" + }, + { + "executables": { + "win32": [ + "quake2.exe" + ] + }, + "id": 483, + "name": "Quake II" + }, + { + "executables": { + "win32": [ + "quake3.exe" + ] + }, + "id": 484, + "name": "Quake III" + }, + { + "executables": { + "win32": [ + "MONACO.exe" + ] + }, + "id": 485, + "name": "Monaco: What's Yours Is Mine" + }, + { + "executables": { + "win32": [ + "ToothAndTail.exe" + ] + }, + "id": 486, + "name": "Tooth & Tail" + }, + { + "executables": { + "win32": [ + "PD.exe" + ] + }, + "id": 487, + "name": "Pixel Dungeon" + }, + { + "executables": { + "win32": [ + "BlackDesert32.exe", + "BlackDesert64.exe" + ] + }, + "id": 488, + "name": "Black Desert Online" + }, + { + "executables": { + "win32": [ + "LovelyPlanet.exe" + ] + }, + "id": 489, + "name": "Lovely Planet" + }, + { + "executables": { + "win32": [ + "DeadCore.exe" + ] + }, + "id": 490, + "name": "DeadCore" + }, + { + "executables": { + "win32": [ + "fifa16.exe" + ] + }, + "id": 491, + "name": "FIFA 16" + }, + { + "executables": { + "win32": [ + "KAG.exe" + ] + }, + "id": 492, + "name": "King Arthur's Gold" + }, + { + "executables": { + "win32": [ + "TR.exe" + ] + }, + "id": 493, + "name": "Trench Run" + }, + { + "executables": { + "win32": [ + "fm.exe" + ] + }, + "id": 494, + "name": "Football Manager 2014" + }, + { + "executables": { + "win32": [ + "NecroDancer.exe" + ] + }, + "id": 495, + "name": "Crypt of the NecroDancer" + }, + { + "executables": { + "win32": [ + "EthanCarter-Win64-Shipping.exe" + ] + }, + "id": 496, + "name": "The Vanishing of Ethan Carter Redux" + }, + { + "executables": { + "win32": [ + "AstronautsGame-Win64-Shipping.exe" + ] + }, + "id": 497, + "name": "The Vanishing of Ethan Carter" + }, + { + "executables": { + "win32": [ + "fsx.exe" + ] + }, + "id": 498, + "name": "Microsoft Flight Simulator X" + }, + { + "executables": { + "win32": [ + "Prepar3D.exe" + ] + }, + "id": 499, + "name": "Prepar3D" + }, + { + "executables": { + "win32": [ + "lumini_Win64.exe" + ] + }, + "id": 500, + "name": "Lumini" + }, + { + "executables": { + "win32": [ + "BeatHazard.exe" + ] + }, + "id": 501, + "name": "Beat Hazard" + }, + { + "executables": { + "win32": [ + "TribesAscend.exe" + ] + }, + "id": 502, + "name": "Tribes Ascend" + }, + { + "executables": { + "win32": [ + "Supernova.exe" + ] + }, + "id": 503, + "name": "Supernova" + }, + { + "executables": { + "win32": [ + "NitronicRush.exe" + ] + }, + "id": 504, + "name": "Nitronic Rush" + }, + { + "executables": { + "win32": [ + "Might & Magic Heroes VI.exe" + ] + }, + "id": 505, + "name": "Might & Magic Heroes VI" + }, + { + "executables": { + "win32": [ + "AdvHD.exe" + ] + }, + "id": 506, + "name": "If My Heart Had Wings" + }, + { + "executables": { + "win32": [ + "hatoful.exe" + ] + }, + "id": 507, + "name": "Hatoful Boyfriend" + }, + { + "executables": { + "win32": [ + "HuniePop.exe" + ] + }, + "id": 508, + "name": "HuniePop" + }, + { + "executables": { + "win32": [ + "SC2VN.exe" + ] + }, + "id": 509, + "name": "SC2VN: The e-sport Visual Novel" + }, + { + "executables": { + "win32": [ + "Pyrite Heart.exe" + ] + }, + "id": 510, + "name": "Pyrite Heart" + }, + { + "executables": { + "win32": [ + "Sakura Angels.exe" + ] + }, + "id": 511, + "name": "Sakura Angels" + }, + { + "executables": { + "win32": [ + "BGI.exe" + ] + }, + "id": 512, + "name": "Go! Go! Nippon! ~My First Trip to Japan~" + }, + { + "executables": { + "win32": [ + "Sword of Asumi.exe" + ] + }, + "id": 513, + "name": "Sword of Asumi" + }, + { + "executables": { + "win32": [ + "Sakura Clicker.exe" + ] + }, + "id": 514, + "name": "Sakura Clicker" + }, + { + "executables": { + "win32": [ + "Sakura Spirit.exe" + ] + }, + "id": 515, + "name": "Sakura Spirit" + }, + { + "executables": { + "win32": [ + "NeoAquarium.exe" + ] + }, + "id": 516, + "name": "NEO AQUARIUM - The King of Crustaceans" + }, + { + "executables": { + "win32": [ + "Nicole.exe" + ] + }, + "id": 517, + "name": "Nicole (Otome Version)" + }, + { + "executables": { + "win32": [ + "LongLiveTheQueen.exe" + ] + }, + "id": 518, + "name": "Long Live The Queen" + }, + { + "executables": { + "win32": [ + "The Sacred Tears TRUE.exe" + ] + }, + "id": 519, + "name": "The Sacred Tears TRUE" + }, + { + "executables": { + "win32": [ + "trgame.exe" + ] + }, + "id": 520, + "name": "Tales Runner" + }, + { + "executables": { + "win32": [ + "CelebrityPoker.exe" + ] + }, + "id": 521, + "name": "Poker Night at the Inventory" + }, + { + "executables": { + "win32": [ + "PokerNight2.exe" + ] + }, + "id": 522, + "name": "Poker Night 2" + }, + { + "executables": { + "win32": [ + "PokeMMO.exe" + ] + }, + "id": 523, + "name": "PokeMMO" + }, + { + "executables": { + "win32": [ + "LoversInADangerousSpacetime.exe" + ] + }, + "id": 524, + "name": "Lovers in a Dangerous Spacetime" + }, + { + "executables": { + "win32": [ + "tis100.exe" + ] + }, + "id": 525, + "name": "TIS-100" + }, + { + "executables": { + "win32": [ + "TTREngine.exe" + ] + }, + "id": 526, + "name": "Toontown" + }, + { + "executables": { + "win32": [ + "mgs2_sse.exe" + ] + }, + "id": 527, + "name": "Metal Gear Solid 2: Substance" + }, + { + "executables": { + "win32": [ + "hl.exe" + ] + }, + "id": 528, + "name": "Half Life" + }, + { + "executables": { + "win32": [ + "Cloudbuilt.exe" + ] + }, + "id": 529, + "name": "Cloudbuilt" + }, + { + "executables": { + "win32": [ + "ACBSP.exe", + "ACBMP.exe" + ] + }, + "id": 530, + "name": "Assassin's Creed: Brotherhood" + }, + { + "executables": { + "win32": [ + "mm.exe" + ] + }, + "id": 531, + "name": "Dark Messiah of Might & Magic" + }, + { + "executables": { + "win32": [ + "Stalker-COP.exe" + ] + }, + "id": 532, + "name": "S.T.A.L.K.E.R.: Call of Pripyat" + }, + { + "executables": { + "win32": [ + "ROGame.exe" + ] + }, + "id": 533, + "name": "Rising Storm/Red Orchestra 2" + }, + { + "executables": { + "win32": [ + "strife-ve.exe" + ] + }, + "id": 534, + "name": "Strife: Veteran Edition" + }, + { + "executables": { + "win32": [ + "BFBC2Game.exe" + ] + }, + "id": 535, + "name": "Battlefield: Bad Company 2" + }, + { + "executables": { + "win32": [ + "FarCry2.exe" + ] + }, + "id": 536, + "name": "Far Cry 2" + }, + { + "executables": { + "win32": [ + "Nidhogg.exe" + ] + }, + "id": 537, + "name": "Nidhogg" + }, + { + "executables": { + "win32": [ + "pbbg_win32.exe" + ] + }, + "id": 538, + "name": "Phantom Break: Baggle Grounds" + }, + { + "executables": { + "darwin": [ + "Wakfu.app" + ], + "win32": [ + "Wakfu.exe" + ] + }, + "id": 539, + "name": "Wakfu" + }, + { + "executables": { + "win32": [ + "wizard101.exe" + ] + }, + "id": 540, + "name": "Wzard101" + }, + { + "executables": { + "win32": [ + "BarkleyV120.exe" + ] + }, + "id": 541, + "name": "Charles Barkley: Shut Up and Jam Gaiden" + }, + { + "executables": { + "win32": [ + "RimWorld914Win.exe" + ] + }, + "id": 542, + "name": "RimWorld" + }, + { + "executables": { + "win32": [ + "Order of Battle - Pacific.exe" + ] + }, + "id": 543, + "name": "Order of Battle" + }, + { + "executables": { + "win32": [ + "gh3.exe" + ] + }, + "id": 544, + "name": "Guitar Hero III: Legends of Rock" + }, + { + "executables": { + "win32": [ + "phase_shift.exe" + ] + }, + "id": 545, + "name": "Phase Shift" + }, + { + "executables": { + "win32": [ + "GHWT.exe" + ] + }, + "id": 546, + "name": "Guitar Hero World Tour" + }, + { + "executables": { + "win32": [ + "THEMOD 1.3.exe", + "THUG2.exe" + ] + }, + "id": 547, + "name": "Tony Hawk's Underground 2" + }, + { + "executables": { + "win32": [ + "THUGPro.exe" + ] + }, + "id": 548, + "name": "THUG Pro" + }, + { + "executables": { + "win32": [ + "THUG.exe " + ] + }, + "id": 549, + "name": "Tony Hawk's Underground" + }, + { + "executables": { + "darwin": [ + "The Binding of Isaac Rebirth.app", + "The%20Binding%20of%20Isaac%20Rebirth.app" + ], + "win32": [ + "isaac-ng.exe" + ] + }, + "id": 550, + "name": "The Binding of Isaac: Rebirth" + }, + { + "executables": { + "win32": [ + "ProjectG.exe" + ] + }, + "id": 551, + "name": "PangYa!" + }, + { + "executables": { + "win32": [ + "Overwatch.exe", + "GameClientApp.exe", + "Overwatch Launcher.exe" + ] + }, + "id": 552, + "name": "Overwatch" + }, + { + "executables": { + "win32": [ + "CivilizationBE_DX11.exe", + "CivilizationBE_Mantle.exe" + ] + }, + "id": 553, + "name": "Civilization Beyond Earth" + }, + { + "executables": { + "win32": [ + "SecretPonchosD3D11.exe" + ] + }, + "id": 554, + "name": "Secret Ponchos" + }, + { + "executables": { + "win32": [ + "Duelyst.exe" + ] + }, + "id": 555, + "name": "Duelyst" + }, + { + "executables": { + "win32": [ + "vermintide.exe" + ] + }, + "id": 556, + "name": "Warhammer: End Times - Vermintide" + }, + { + "executables": { + "darwin": [ + "Huniepop.app" + ] + }, + "id": 557, + "name": "Hunie Pop" + }, + { + "executables": { + "darwin": [ + "Reus.app" + ], + "win32": [ + "reus.exe" + ] + }, + "id": 558, + "name": "Reus" + }, + { + "executables": { + "darwin": [ + "Everlasting%20Summer.app" + ] + }, + "id": 559, + "name": "Everlasting Summer" + }, + { + "executables": { + "darwin": [ + "GunsofIcarusOnline.app" + ] + }, + "id": 560, + "name": "Guns of Icarus - Online" + }, + { + "executables": { + "darwin": [ + "Rising%20Angels%20-%20Reborn.app" + ] + }, + "id": 561, + "name": "Rising Angels - Reborn" + }, + { + "executables": { + "darwin": [ + "Hate%20Plus.app" + ] + }, + "id": 562, + "name": "Hate Plus" + }, + { + "executables": { + "win32": [ + "dcs.exe" + ] + }, + "id": 563, + "name": "DCS World" + }, + { + "executables": { + "win32": [ + "arena.exe" + ] + }, + "id": 564, + "name": "Total War: Arena" + }, + { + "executables": { + "win32": [ + "Pokemon Trading Card Game Online.exe" + ] + }, + "id": 565, + "name": "Pokemon Trading Card Game Online" + }, + { + "executables": { + "win32": [ + "Tales of Zestiria.exe" + ] + }, + "id": 566, + "name": "Tales of Zestiria" + }, + { + "executables": { + "win32": [ + "ns2.exe" + ] + }, + "id": 567, + "name": "Natural Selection 2" + }, + { + "executables": { + "win32": [ + "Rayman Legends.exe" + ] + }, + "id": 568, + "name": "Rayman Legends" + }, + { + "executables": { + "darwin": [ + "avalonlords.app" + ], + "win32": [ + "avalonlords.exe" + ] + }, + "id": 569, + "name": "Avalon Lords" + }, + { + "executables": { + "win32": [ + "th06.exe", + "th06e.exe" + ] + }, + "id": 570, + "name": "Touhou 6: Embodiment of Scarlet Devil" + }, + { + "executables": { + "win32": [ + "th07.exe", + "th07e.exe" + ] + }, + "id": 571, + "name": "Touhou 7: Perfect Cherry Blossom" + }, + { + "executables": { + "win32": [ + "th08.exe", + "th08e.exe" + ] + }, + "id": 572, + "name": "Touhou 8: Imperishable Night" + }, + { + "executables": { + "win32": [ + "th09.exe", + "th09e.exe" + ] + }, + "id": 573, + "name": "Touhou 9: Phantasmagoria Of Flower View" + }, + { + "executables": { + "win32": [ + "th095.exe", + "th095e.exe" + ] + }, + "id": 574, + "name": "Touhou 9.5: Shoot the Bullet" + }, + { + "executables": { + "win32": [ + "th10.exe", + "th10e.exe" + ] + }, + "id": 575, + "name": "Touhou 10: Mountain of Faith" + }, + { + "executables": { + "win32": [ + "th105.exe", + "th105e.exe" + ] + }, + "id": 576, + "name": "Touhou 10.5: Scarlet Weather Rhapsody" + }, + { + "executables": { + "win32": [ + "th11.exe", + "th11e.exe" + ] + }, + "id": 577, + "name": "Touhou 11: Subterranean Animism" + }, + { + "executables": { + "win32": [ + "th12.exe", + "th12e.exe" + ] + }, + "id": 578, + "name": "Touhou 12: Undefined Fantastic Object" + }, + { + "executables": { + "win32": [ + "th125.exe", + "th125e.exe" + ] + }, + "id": 579, + "name": "Touhou 12.5: Double Spoiler" + }, + { + "executables": { + "win32": [ + "th128.exe", + "th128e.exe" + ] + }, + "id": 580, + "name": "Touhou 12.8: Great Fairy Wars" + }, + { + "executables": { + "win32": [ + "th13.exe", + "th13e.exe" + ] + }, + "id": 581, + "name": "Touhou 13: Ten Desires" + }, + { + "executables": { + "win32": [ + "th14.exe", + "th14e.exe" + ] + }, + "id": 582, + "name": "Touhou 14: Double Dealing Character" + }, + { + "executables": { + "win32": [ + "th143.exe", + "th143e.exe" + ] + }, + "id": 583, + "name": "Touhou 14.3: Impossible Spell Card" + }, + { + "executables": { + "win32": [ + "th15.exe", + "th15e.exe" + ] + }, + "id": 584, + "name": "Touhou 15: Legacy of Lunatic Kingdom" + }, + { + "executables": { + "win32": [ + "grandia2.exe" + ] + }, + "id": 585, + "name": "Grandia 2" + }, + { + "executables": { + "win32": [ + "Albion-Online.exe" + ] + }, + "id": 586, + "name": "Albion Online" + }, + { + "executables": { + "win32": [ + "ThereWasACaveman.exe" + ] + }, + "id": 587, + "name": "There Was A Caveman" + }, + { + "executables": { + "win32": [ + "ASN_App_PcDx9_Final.exe" + ] + }, + "id": 588, + "name": "Sonic & All Stars Racing Transformed" + }, + { + "executables": { + "win32": [ + "Cryptark.exe" + ] + }, + "id": 589, + "name": "CRYPTARK" + }, + { + "executables": { + "win32": [ + "Entropia.exe" + ] + }, + "id": 590, + "name": "Entropia Universe" + }, + { + "executables": { + "win32": [ + "DepthGame.exe" + ] + }, + "id": 591, + "name": "Depth" + }, + { + "executables": { + "win32": [ + "Factorio.exe" + ] + }, + "id": 592, + "name": "Factorio" + }, + { + "executables": { + "win32": [ + "ChildofLight.exe" + ] + }, + "id": 593, + "name": "Child of Light" + }, + { + "executables": { + "win32": [ + "TransformersDevatstation.exe" + ] + }, + "id": 594, + "name": "Transformers: Devastation" + }, + { + "executables": { + "win32": [ + "oppw3.exe" + ] + }, + "id": 595, + "name": "One Piece Pirate Warriors 3" + }, + { + "executables": { + "win32": [ + "Astebreed.exe" + ] + }, + "id": 596, + "name": "Astebreed" + }, + { + "executables": { + "win32": [ + "ktane.exe" + ] + }, + "id": 597, + "name": "Keep Talking and Nobody Explodes" + }, + { + "executables": { + "win32": [ + "Steredenn.exe" + ] + }, + "id": 598, + "name": "Steredenn" + }, + { + "executables": { + "win32": [ + "CK2game.exe" + ] + }, + "id": 599, + "name": "Crusader Kings II" + }, + { + "executables": { + "win32": [ + "jamp.exe", + "openjk.x86.exe" + ] + }, + "id": 600, + "name": "Star Wars Jedi Knight" + }, + { + "executables": { + "win32": [ + "jk2mp.exe", + "jk2mvmp_x86.exe", + "jk2mvmp_x64.exe" + ] + }, + "id": 601, + "name": "Star Wars Jedi Knight II" + }, + { + "executables": { + "win32": [ + "FightCade.exe" + ] + }, + "id": 602, + "name": "FightCade" + }, + { + "executables": { + "win32": [ + "Downwell.exe" + ] + }, + "id": 603, + "name": "Downwell" + }, + { + "executables": { + "win32": [ + "flamebreak.exe" + ] + }, + "id": 604, + "name": "Flamebreak" + }, + { + "executables": { + "win32": [ + "Disco Dodgeball.exe" + ] + }, + "id": 605, + "name": "Robot Roller-Derby Disco Dodgeball" + }, + { + "executables": { + "win32": [ + "DarkStarOne.exe" + ] + }, + "id": 606, + "name": "DarkStar One" + }, + { + "executables": { + "win32": [ + "20XX.exe" + ] + }, + "id": 607, + "name": "20XX" + }, + { + "executables": { + "win32": [ + "wesnoth.exe" + ] + }, + "id": 608, + "name": "Battle for Wesnoth" + }, + { + "executables": { + "win32": [ + "Creativerse.exe" + ] + }, + "id": 609, + "name": "Creativerse" + }, + { + "executables": { + "win32": [ + "BlockNLoad.exe" + ] + }, + "id": 610, + "name": "Block n Load" + }, + { + "executables": { + "win32": [ + "rwr_game.exe" + ] + }, + "id": 611, + "name": "Running with Rifles" + }, + { + "executables": { + "win32": [ + "Evolve.exe" + ] + }, + "id": 612, + "name": "Evolve" + }, + { + "executables": { + "win32": [ + "et.exe" + ] + }, + "id": 613, + "name": "Wolfenstein - Enemy Territory" + }, + { + "executables": { + "win32": [ + "C9.exe" + ] + }, + "id": 614, + "name": "C9" + }, + { + "executables": { + "win32": [ + "Multi Theft Auto.exe" + ] + }, + "id": 615, + "name": "Multi Theft Auto San Andreas" + }, + { + "executables": { + "win32": [ + "SpecOpsTheLine.exe" + ] + }, + "id": 616, + "name": "Spec Ops: The Line" + }, + { + "executables": { + "win32": [ + "stanley.exe" + ] + }, + "id": 617, + "name": "The Stanley Parable" + }, + { + "executables": { + "win32": [ + "Secrets Of Grindea.exe" + ] + }, + "id": 618, + "name": "Secrets of Grindea" + }, + { + "executables": { + "win32": [ + "MugenSouls.exe" + ] + }, + "id": 619, + "name": "Mugen Souls " + }, + { + "executables": { + "win32": [ + "RebelGalaxyGOG.exe", + "RebelGalaxySteam.exe" + ] + }, + "id": 620, + "name": "Rebel Galaxy" + }, + { + "executables": { + "win32": [ + "rerev.exe" + ] + }, + "id": 621, + "name": "Resident Evil Revelations" + }, + { + "executables": { + "win32": [ + "rerev2.exe" + ] + }, + "id": 622, + "name": "Resident Evil Revelations 2" + }, + { + "executables": { + "win32": [ + "re5dx9.exe" + ] + }, + "id": 623, + "name": "Resident Evil 5" + }, + { + "executables": { + "win32": [ + "bio4.exe" + ] + }, + "id": 624, + "name": "Resident Evil 4 HD" + }, + { + "executables": { + "win32": [ + "bhd.exe" + ] + }, + "id": 625, + "name": "Resident Evil 4HD Remaster" + }, + { + "executables": { + "win32": [ + "SSF2.exe" + ] + }, + "id": 626, + "name": "Super Smash Flash 2 " + }, + { + "executables": { + "win32": [ + "AI.exe" + ] + }, + "id": 627, + "name": "Alien: Isolation" + }, + { + "executables": { + "win32": [ + "dungeonland.exe" + ] + }, + "id": 628, + "name": "Dungeonland" + }, + { + "executables": { + "win32": [ + "TerraTechWin32.exe" + ] + }, + "id": 629, + "name": "TerraTech" + }, + { + "executables": { + "win32": [ + "beginnersguide.exe" + ] + }, + "id": 630, + "name": "The Beginner's Guide" + }, + { + "executables": { + "win32": [ + "StreetFighterVBeta-Win64-Shipping.exe" + ] + }, + "id": 631, + "name": "Street Fighter V" + }, + { + "executables": { + "win32": [ + "bf4cte.exe" + ] + }, + "id": 632, + "name": "Battlefiled 4 CTE" + }, + { + "executables": { + "win32": [ + "Suguri.exe" + ] + }, + "id": 633, + "name": "Suguri" + }, + { + "executables": { + "win32": [ + "UT3.exe" + ] + }, + "id": 634, + "name": "Unreal Tournament 3" + }, + { + "executables": { + "win32": [ + "Unreal.exe" + ] + }, + "id": 635, + "name": "Unreal" + }, + { + "executables": { + "win32": [ + "AVA.exe" + ] + }, + "id": 636, + "name": "Alliance of Valiant Arms" + }, + { + "executables": { + "win32": [ + "ShooterUltimate.exe" + ] + }, + "id": 637, + "name": "PixelJunk Shooter Ultimate" + }, + { + "executables": { + "win32": [ + "pokemonshowdown.exe" + ] + }, + "id": 638, + "name": "Pokemon Showdown" + }, + { + "executables": { + "win32": [ + "SuperMeatBoy.exe" + ] + }, + "id": 639, + "name": "Super Meat Boy" + }, + { + "executables": { + "win32": [ + "Kara no Shojo 2.exe" + ] + }, + "id": 640, + "name": "Kara no Shoujo 2" + }, + { + "executables": { + "win32": [ + "Intruder.exe" + ] + }, + "id": 641, + "name": "Intruder" + }, + { + "executables": { + "win32": [ + "Aeon Rivals.exe" + ] + }, + "id": 642, + "name": "Aeon Rivals" + }, + { + "executables": { + "win32": [ + "Rats.exe" + ] + }, + "id": 643, + "name": "Bad Rats" + }, + { + "executables": { + "win32": [ + "BH6.exe" + ] + }, + "id": 644, + "name": "Resident Evil 6" + }, + { + "executables": { + "win32": [ + "ZOMBI.exe" + ] + }, + "id": 645, + "name": "Zombi" + }, + { + "executables": { + "win32": [ + "Xenonauts.exe" + ] + }, + "id": 646, + "name": "Xenonauts" + }, + { + "executables": { + "win32": [ + "OrganTrail.exe" + ] + }, + "id": 647, + "name": "Organ Trail" + }, + { + "executables": { + "darwin": [ + "LethalLeague.app" + ], + "win32": [ + "LethalLeague.exe" + ] + }, + "id": 648, + "name": "Lethal League" + }, + { + "executables": { + "win32": [ + "blobby.exe" + ] + }, + "id": 649, + "name": "Blobby Volley 2" + }, + { + "executables": { + "win32": [ + "DQXGame.exe" + ] + }, + "id": 650, + "name": "Dragon Quest X: Mezameshi Itsutsu no Shuzoku Online" + }, + { + "executables": { + "win32": [ + "Dishonored.exe" + ] + }, + "id": 651, + "name": "Dishonored" + }, + { + "executables": { + "win32": [ + "TheForest.exe" + ] + }, + "id": 652, + "name": "The Forest" + }, + { + "executables": { + "win32": [ + "ThePark.exe" + ] + }, + "id": 653, + "name": "The Park" + }, + { + "executables": { + "win32": [ + "FishingPlanet.exe" + ] + }, + "id": 654, + "name": "Fishing Planet" + }, + { + "executables": { + "win32": [ + "pso.exe" + ] + }, + "id": 655, + "name": "Phantasy Star Online" + }, + { + "executables": {}, + "id": 656, + "name": "Our Darker Purpose" + }, + { + "executables": { + "win32": [ + "Darkest.exe" + ] + }, + "id": 657, + "name": "Darkest Dungeon" + }, + { + "executables": { + "win32": [ + "UE4-Win64-Test.exe" + ] + }, + "id": 658, + "name": "Unreal Tournament 4" + }, + { + "executables": { + "win32": [ + "ed6_win2.exe" + ] + }, + "id": 659, + "name": "Trails in the Sky SC" + }, + { + "executables": { + "win32": [ + "ed6_win.exe" + ] + }, + "id": 660, + "name": "Trails in the Sky FC" + }, + { + "executables": { + "win32": [ + "kshootmania.exe" + ] + }, + "id": 661, + "name": "K-Shoot Mania" + }, + { + "executables": { + "win32": [ + "df.exe" + ] + }, + "id": 662, + "name": "Delta Force 1" + }, + { + "executables": { + "win32": [ + "BloodlineChampions.exe" + ] + }, + "id": 663, + "name": "Bloodline Champions" + }, + { + "executables": { + "win32": [ + "TmForever.exe" + ] + }, + "id": 664, + "name": "Trackmania Nations Forever" + }, + { + "executables": { + "win32": [ + "DragonFinSoup.exe" + ] + }, + "id": 666, + "name": "Dragon Fin Soup" + }, + { + "executables": { + "win32": [ + "Anno2205.exe" + ] + }, + "id": 667, + "name": "Anno 2205" + }, + { + "executables": { + "darwin": [ + "KatawaShoujo.app" + ] + }, + "id": 668, + "name": "Katawa Shoujo" + }, + { + "executables": { + "win32": [ + "NeptuniaReBirth1.exe" + ] + }, + "id": 669, + "name": "Hyperdimension Neptunia Re;Birth1" + }, + { + "executables": { + "win32": [ + "NeptuniaReBirth2.exe" + ] + }, + "id": 670, + "name": "Hyperdimension Neptunia Re;Birth2" + }, + { + "executables": { + "win32": [ + "NeptuniaReBirth3.exe" + ] + }, + "id": 671, + "name": "Hyperdimension Neptunia Re;Birth3" + }, + { + "executables": { + "win32": [ + "HatinTimeGame.exe" + ] + }, + "id": 672, + "name": "A Hat in Time" + }, + { + "executables": { + "win32": [ + "AxiomVerge.exe" + ] + }, + "id": 673, + "name": "Axiom Verge" + }, + { + "executables": { + "win32": [ + "CoJGunslinger.exe" + ] + }, + "id": 674, + "name": "Call of Juarez: Gunslinger" + }, + { + "executables": { + "darwin": [ + "CardHunter.app" + ], + "win32": [ + "CardHunter.exe" + ] + }, + "id": 675, + "name": "Card Hunter" + }, + { + "executables": { + "darwin": [ + "CargoCommander.app" + ], + "win32": [ + "CargoCommander.exe" + ] + }, + "id": 676, + "name": "Cargo Commander" + }, + { + "executables": { + "win32": [ + "DDO.exe" + ] + }, + "id": 677, + "name": "Dragon's Dogma Online" + }, + { + "executables": { + "win32": [ + "falloutw.exe" + ] + }, + "id": 678, + "name": "Fallout" + }, + { + "executables": { + "win32": [ + "FALLOUT2.EXE", + "Fallout2HR.exe" + ] + }, + "id": 679, + "name": "Fallout 2" + }, + { + "executables": { + "win32": [ + "Fallout4.exe" + ] + }, + "id": 680, + "name": "Fallout 4" + }, + { + "executables": { + "win32": [ + "FarCry4.exe" + ] + }, + "id": 681, + "name": "Far Cry 4" + }, + { + "executables": { + "win32": [ + "OpenITG-PC.exe" + ] + }, + "id": 682, + "name": "In The Groove 2" + }, + { + "executables": { + "win32": [ + "L2.bin" + ] + }, + "id": 683, + "name": "Lineage II" + }, + { + "executables": { + "win32": [ + "LordsOfTheFallen.exe" + ] + }, + "id": 684, + "name": "Lords of the Fallen" + }, + { + "executables": { + "win32": [ + "LR2.exe" + ] + }, + "id": 685, + "name": "Lunatic Rave 2" + }, + { + "executables": { + "win32": [ + "MBA.exe" + ] + }, + "id": 686, + "name": "Magical Battle Arena" + }, + { + "executables": { + "win32": [ + "MBAN_M.exe", + "MBAN_F.exe" + ] + }, + "id": 687, + "name": "Magical Battle Arena NEXT" + }, + { + "executables": { + "win32": [ + "ManiaPlanet.exe" + ] + }, + "id": 688, + "name": "ManiaPlanet" + }, + { + "executables": { + "win32": [ + "mhf.exe" + ] + }, + "id": 689, + "name": "Monster Hunter Frontier" + }, + { + "executables": { + "win32": [ + "6kinoko.exe" + ] + }, + "id": 690, + "name": "New Super Marisa Land" + }, + { + "executables": { + "win32": [ + "Nosgoth.exe" + ] + }, + "id": 691, + "name": "Nosgoth" + }, + { + "executables": { + "win32": [ + "Poi.exe" + ] + }, + "id": 692, + "name": "Poi" + }, + { + "executables": { + "win32": [ + "RogueSystemSim.exe" + ] + }, + "id": 693, + "name": "Rogue System" + }, + { + "executables": { + "darwin": [ + "SinaRun.app" + ], + "win32": [ + "SinaRun.exe" + ] + }, + "id": 694, + "name": "SinaRun" + }, + { + "executables": { + "win32": [ + "SkullGirls.exe" + ] + }, + "id": 695, + "name": "Skullgirls" + }, + { + "executables": { + "win32": [ + "Soma.exe" + ] + }, + "id": 696, + "name": "SOMA" + }, + { + "executables": { + "win32": [ + "sonic2app.exe" + ] + }, + "id": 697, + "name": "Sonic Adventure 2" + }, + { + "executables": { + "win32": [ + "SonicGenerations.exe" + ] + }, + "id": 698, + "name": "Sonic Generations" + }, + { + "executables": { + "win32": [ + "SpaceChem.exe" + ] + }, + "id": 699, + "name": "SpaceChem" + }, + { + "executables": { + "win32": [ + "SSFexe.exe" + ] + }, + "id": 700, + "name": "Super Smash Flash 1" + }, + { + "executables": { + "win32": [ + "System Shock2.exe", + "shock2.exe" + ] + }, + "id": 701, + "name": "System Shock 2" + }, + { + "executables": { + "win32": [ + "Blacklist_launcher.exe" + ] + }, + "id": 702, + "name": "Tom Clancy's Splinter Cell: Blacklist" + }, + { + "executables": { + "win32": [ + "gn_enbu.exe" + ] + }, + "id": 703, + "name": "Touhou Puppet Dance Performance" + }, + { + "executables": { + "win32": [ + "TSA.exe" + ] + }, + "id": 704, + "name": "Touhou Sky Arena" + }, + { + "executables": { + "win32": [ + "Verdun.exe" + ] + }, + "id": 705, + "name": "Verdun" + }, + { + "executables": { + "darwin": [ + "wz2100.app" + ], + "win32": [ + "wz2100.exe" + ] + }, + "id": 706, + "name": "Warzone 2100" + }, + { + "executables": { + "win32": [ + "WowT-64.exe" + ] + }, + "id": 707, + "name": "World of Warcraft PTR" + }, + { + "executables": { + "win32": [ + "Chronicon.exe" + ] + }, + "id": 708, + "name": "Chronicon" + }, + { + "executables": { + "win32": [ + "MagicDuels.exe" + ] + }, + "id": 709, + "name": "Magic Duels" + }, + { + "executables": { + "win32": [ + "BorderlandsPreSequel.exe" + ] + }, + "id": 710, + "name": "Borderlands: the Pre-Sequel" + }, + { + "executables": { + "win32": [ + "AoD.exe" + ] + }, + "id": 711, + "name": "The Age of Decadence" + }, + { + "executables": { + "win32": [ + "Doom.exe" + ] + }, + "id": 712, + "name": "Doom 3" + }, + { + "executables": { + "win32": [ + "Dead Space.exe" + ] + }, + "id": 713, + "name": "Dead Space" + }, + { + "executables": { + "win32": [ + "AvP3.exe" + ] + }, + "id": 714, + "name": "Alien Vs Predator" + }, + { + "executables": { + "win32": [ + "BlackOps3.exe" + ] + }, + "id": 715, + "name": "Call of Duty: Black Ops III" + }, + { + "executables": { + "win32": [ + "halo_online.exe" + ] + }, + "id": 716, + "name": "Halo Online" + }, + { + "executables": { + "win32": [ + "Krosmaster Arena.exe" + ] + }, + "id": 717, + "name": "Krosmaster Arena" + }, + { + "executables": { + "win32": [ + "MapleRoyals.exe" + ] + }, + "id": 718, + "name": "MapleRoyals" + }, + { + "executables": { + "win32": [ + "clragexe.exe" + ] + }, + "id": 719, + "name": "Ragnarok Online Classic" + }, + { + "executables": { + "win32": [ + "RememberingHowWeMet.exe" + ] + }, + "id": 720, + "name": "A Kiss For The Petals - Remembering How We Met" + }, + { + "executables": { + "win32": [ + "Command.exe" + ] + }, + "id": 721, + "name": "Command: Modern Air/Naval Operations " + }, + { + "executables": { + "win32": [ + "CM Black Sea.exe" + ] + }, + "id": 722, + "name": "Combat Mission: Black Sea" + }, + { + "executables": { + "win32": [ + "CM Shock Force.exe" + ] + }, + "id": 723, + "name": "Combat Mission: Shock Force" + }, + { + "executables": { + "win32": [ + "KingOfFighters2002UM.exe" + ] + }, + "id": 724, + "name": "The King Of Fighters 2002 Unlimited Match" + }, + { + "executables": { + "win32": [ + "NFSC.exe" + ] + }, + "id": 725, + "name": "Need for Speed: Carbon" + }, + { + "executables": { + "win32": [ + "th075.exe", + "th075e.exe" + ] + }, + "id": 726, + "name": "Touhou 7.5: Immaterial and Missing Power" + }, + { + "executables": { + "win32": [ + "Demul.exe" + ] + }, + "id": 727, + "name": "Demul" + }, + { + "executables": { + "win32": [ + "DeSmuMe_0.9.11_x86.exe", + "DeSmuME_0.9.11_x64.exe" + ] + }, + "id": 728, + "name": "DeSmuME" + }, + { + "executables": { + "win32": [ + "Fusion.exe" + ] + }, + "id": 729, + "name": "Kega Fusion" + }, + { + "executables": { + "win32": [ + "nullDC_Win32_Release-NoTrace.exe" + ] + }, + "id": 730, + "name": "nullDC" + }, + { + "executables": { + "win32": [ + "pcsx2-r5875.exe" + ] + }, + "id": 731, + "name": "PCSX2" + }, + { + "executables": { + "win32": [ + "Project64.exe" + ] + }, + "id": 732, + "name": "Project64" + }, + { + "executables": { + "win32": [ + "Snes9X.exe" + ] + }, + "id": 733, + "name": "Snes9x" + }, + { + "executables": { + "win32": [ + "VisualBoyAdvance.exe" + ] + }, + "id": 734, + "name": "VisualBoyAdvance" + }, + { + "executables": { + "win32": [ + "zsnesw.exe" + ] + }, + "id": 735, + "name": "ZSNES" + }, + { + "executables": { + "win32": [ + "Uplink.exe" + ] + }, + "id": 736, + "name": "Uplink" + }, + { + "executables": { + "win32": [ + "RIK.exe" + ] + }, + "id": 737, + "name": "ProjectRIK" + }, + { + "executables": { + "win32": [ + "warsow_x64.exe", + "warsow_x86.exe" + ] + }, + "id": 738, + "name": "Warsow" + }, + { + "executables": { + "win32": [ + "cactus.exe" + ] + }, + "id": 739, + "name": "Assault Android Cactus" + }, + { + "executables": { + "win32": [ + "PlantsVsZombies.exe" + ] + }, + "id": 740, + "name": "Plants vs. Zombies" + }, + { + "executables": { + "win32": [ + "HeavyWeapon.exe" + ] + }, + "id": 741, + "name": "Heavy Weapon" + }, + { + "executables": { + "win32": [ + "BejBlitz.exe" + ] + }, + "id": 742, + "name": "Bejeweled Blitz" + }, + { + "executables": { + "win32": [ + "slw.exe" + ] + }, + "id": 743, + "name": "Sonic Lost World" + }, + { + "executables": { + "win32": [ + "age.exe" + ] + }, + "id": 744, + "name": "Kamidori Alchemy Meister" + }, + { + "executables": { + "win32": [ + "psobb.exe" + ] + }, + "id": 745, + "name": "Phantasy Star Online Blue Burst" + }, + { + "executables": { + "win32": [ + "Evoland2.exe" + ] + }, + "id": 746, + "name": "Evoland 2" + }, + { + "executables": { + "win32": [ + "FFV_Game.exe" + ] + }, + "id": 747, + "name": "Final Fantasy V" + }, + { + "executables": { + "win32": [ + "TITAN.exe" + ] + }, + "id": 748, + "name": "Titan Souls" + }, + { + "executables": { + "win32": [ + "FTP.exe" + ] + }, + "id": 749, + "name": "Free To Play" + }, + { + "executables": { + "win32": [ + "Hero_Siege.exe" + ] + }, + "id": 750, + "name": "Hero Siege" + } +] +},{}]},{},[25])(25) +}); \ No newline at end of file diff --git a/web-dist/discord.min.5.1.0.js b/web-dist/discord.min.5.1.0.js new file mode 100644 index 000000000..175b899c0 --- /dev/null +++ b/web-dist/discord.min.5.1.0.js @@ -0,0 +1,9 @@ +!function(a){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=a();else if("function"==typeof define&&define.amd)define([],a);else{var b;b="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,b.Discord=a()}}(function(){return function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);var j=new Error("Cannot find module '"+g+"'");throw j.code="MODULE_NOT_FOUND",j}var k=c[g]={exports:{}};b[g][0].call(k.exports,function(a){var c=b[g][1][a];return e(c?c:a)},k,k.exports,a,b,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;g=a.length)break;f=a[e++]}else{if(e=a.next(),e.done)break;f=e.value}var g=f;b.channels.remove(g)}b.servers.remove(c)}):Promise.reject(new Error("server did not resolve"))},b.prototype.login=function(a,b){var c=this,d=this.client;return this.state!==o["default"].DISCONNECTED&&this.state!==o["default"].IDLE?Promise.reject(new Error("already logging in/logged in/ready!")):(this.state=o["default"].LOGGING_IN,k["default"].post(r.Endpoints.LOGIN).send({email:a,password:b}).end().then(function(d){var e=d.body.token;return c.state=o["default"].LOGGED_IN,c.token=e,c.email=a,c.password=b,c.getGateway().then(function(a){return c.createWS(a),e})},function(a){throw c.websocket=null,a})["catch"](function(a){throw c.state=o["default"].DISCONNECTED,d.emit("disconnected"),a}))},b.prototype.logout=function(){var a=this;return this.state===o["default"].DISCONNECTED||this.state===o["default"].IDLE?Promise.reject(new Error("Client is not logged in!")):k["default"].post(r.Endpoints.LOGOUT).set("authorization",this.token).end().then(function(){a.websocket&&(a.websocket.close(),a.websocket=null),a.token=null,a.email=null,a.password=null,a.state=o["default"].DISCONNECTED})},b.prototype.startPM=function(a){var b=this,c=this.resolver.resolveUser(a);return c?k["default"].post(""+r.Endpoints.USER_CHANNELS(c.id)).set("authorization",this.token).send({recipient_id:c.id}).end().then(function(a){return b.private_channels.add(new F["default"](a.body,b.client))}):Promise.reject(new Error("Unable to resolve resUser to a User"))},b.prototype.getGateway=function(){return k["default"].get(r.Endpoints.GATEWAY).set("authorization",this.token).end().then(function(a){return a.body.url})},b.prototype.sendMessage=function(a,b){var c=this,d=arguments.length<=2||void 0===arguments[2]?{}:arguments[2];return this.resolver.resolveChannel(a).then(function(a){var e=c.resolver.resolveString(b),f=c.resolver.resolveMentions(e);return k["default"].post(r.Endpoints.CHANNEL_MESSAGES(a.id)).set("authorization",c.token).send({content:e,mentions:f,tts:d.tts}).end().then(function(b){return a.messages.add(new J["default"](b.body,a,c.client))})})},b.prototype.deleteMessage=function(a){var b=this,c=arguments.length<=1||void 0===arguments[1]?{}:arguments[1],d=this.resolver.resolveMessage(a);if(!d)return Promise.reject(new Error("Supplied message did not resolve to a message!"));var e=c.wait?g(c.wait):Promise.resolve();return e.then(function(){return k["default"].del(r.Endpoints.CHANNEL_MESSAGE(d.channel.id,d.id)).set("authorization",b.token).end()}).then(function(){return d.channel.messages.remove(d)})},b.prototype.updateMessage=function(a,b){var c=this,d=arguments.length<=2||void 0===arguments[2]?{}:arguments[2],e=this.resolver.resolveMessage(a);if(!e)return Promise.reject(new Error("Supplied message did not resolve to a message!"));var f=this.resolver.resolveString(b),g=this.resolver.resolveMentions(f);return k["default"].patch(r.Endpoints.CHANNEL_MESSAGE(e.channel.id,e.id)).set("authorization",this.token).send({content:f,tts:d.tts,mentions:g}).end().then(function(a){return e.channel.messages.update(e,new J["default"](a.body,e.channel,c.client))})},b.prototype.sendFile=function(a,b){var c=this,d=arguments.length<=2||void 0===arguments[2]?"image.png":arguments[2];return this.resolver.resolveChannel(a).then(function(a){return k["default"].post(r.Endpoints.CHANNEL_MESSAGES(a.id)).set("authorization",c.token).attach("file",c.resolver.resolveFile(b),d).end().then(function(b){return a.messages.add(new J["default"](b.body,a,c.client))})})},b.prototype.getChannelLogs=function(a){var b=this,c=arguments.length<=1||void 0===arguments[1]?500:arguments[1],d=arguments.length<=2||void 0===arguments[2]?{}:arguments[2];return this.resolver.resolveChannel(a).then(function(a){var e={limit:c};if(d.before){var f=b.resolver.resolveMessage(d.before);f&&(e.before=f)}if(d.after){var f=b.resolver.resolveMessage(d.after);f&&(e.after=f)}return k["default"].get(r.Endpoints.CHANNEL_MESSAGES(a.id)+"?"+q["default"].stringify(e)).set("authorization",b.token).end().then(function(c){return c.body.map(function(c){return a.messages.add(new J["default"](c,a,b.client))})})})},b.prototype.getBans=function(a){var b=this;return a=this.resolver.resolveServer(a),k["default"].get(""+r.Endpoints.SERVER_BANS(a.id)).set("authorization",this.token).end().then(function(a){a.body.map(function(a){return b.users.add(new x["default"](a.user,b.client))})})},b.prototype.createChannel=function(a,b){var c=this,d=arguments.length<=2||void 0===arguments[2]?"text":arguments[2];return a=this.resolver.resolveServer(a),k["default"].post(r.Endpoints.SERVER_CHANNELS(a.id)).set("authorization",this.token).send({name:b,type:d}).end().then(function(b){var d;return d="text"===b.body.type?new B["default"](b.body,c.client,a):new D["default"](b.body,c.client,a),a.channels.add(c.channels.add(d))})},b.prototype.deleteChannel=function(a){var b=this;return this.resolver.resolveChannel(a).then(function(a){return k["default"].del(r.Endpoints.CHANNEL(a.id)).set("authorization",b.token).end().then(function(){a.server.channels.remove(a),b.channels.remove(a)})},function(a){throw a.message="Couldn't resolve to channel - "+a.toString(),a})},b.prototype.banMember=function(a,b){var c=arguments.length<=2||void 0===arguments[2]?1:arguments[2];return a=this.resolver.resolveUser(a),b=this.resolver.resolveServer(b),k["default"].put(r.Endpoints.SERVER_BANS(b.id)+"/"+a.id+"?delete-message-days="+c).set("authorization",this.token).end()},b.prototype.unbanMember=function(a,b){return b=this.resolver.resolveServer(b),a=this.resolver.resolveUser(a),k["default"].del(r.Endpoints.SERVER_BANS(b.id)+"/"+a.id).set("authorization",this.token).end()},b.prototype.kickMember=function(a,b){return a=this.resolver.resolveUser(a),b=this.resolver.resolveServer(b),k["default"].del(r.Endpoints.SERVER_MEMBERS(b.id)+"/"+a.id).set("authorization",this.token).end()},b.prototype.createRole=function(a,b){var c=this;return a=this.resolver.resolveServer(a),k["default"].post(r.Endpoints.SERVER_ROLES(a.id)).set("authorization",this.token).end().then(function(d){var e=a.roles.add(new L["default"](d.body,a,c.client));return b?c.updateRole(e,b):e})},b.prototype.updateRole=function(a,b){var c=this,d=this.resolver.resolveServer(a.server),e={color:b.color||a.color,hoist:b.hoist||a.hoist,name:b.name||a.name,permissions:a.permissions||0};if(b.permissions){e.permissions=0;for(var f=b.permissions,g=Array.isArray(f),h=0,f=g?f:f[Symbol.iterator]();;){var i;if(g){if(h>=f.length)break;i=f[h++]}else{if(h=f.next(),h.done)break;i=h.value}var j=i;j instanceof String||"string"==typeof j?e.permissions|=r.Permissions[j]||0:e.permissions|=j}}return k["default"].patch(r.Endpoints.SERVER_ROLES(d.id)+"/"+a.id).set("authorization",this.token).send(e).end().then(function(b){return d.roles.update(a,new L["default"](b.body,d,c.client))})},b.prototype.deleteRole=function(a){return k["default"].del(r.Endpoints.SERVER_ROLES(a.server.id)+"/"+a.id).set("authorization",this.token).end()},b.prototype.addMemberToRole=function(a,b){if(a=this.resolver.resolveUser(a),!a||!b)return Promise.reject(new Error("member/role not in server"));if(!b.server.memberMap[a.id])return Promise.reject(new Error("member not in server"));var c=b.server.memberMap[a.id].roles.map(function(a){return a.id}).concat(b.id);return k["default"].patch(r.Endpoints.SERVER_MEMBERS(b.server.id)+"/"+a.id).set("authorization",this.token).send({roles:c}).end()},b.prototype.removeMemberFromRole=function(a,b){if(a=this.resolver.resolveUser(a),!a||!b)return Promise.reject(new Error("member/role not in server"));if(!b.server.memberMap[a.id])return Promise.reject(new Error("member not in server"));var c=b.server.memberMap[a.id].roles.map(function(a){return a.id});for(var d in c)c[d]===b.id&&c.splice(d,1);return k["default"].patch(r.Endpoints.SERVER_MEMBERS(b.server.id)+"/"+a.id).set("authorization",this.token).send({roles:c}).end()},b.prototype.createInvite=function(a,b){var c=this;if(a instanceof z["default"]||a instanceof H["default"]||(a=this.resolver.resolveServer(a)||this.resolver.resolveChannel(a)),!a)throw new Error("couldn't resolve where");b?(b.max_age=b.maxAge||0,b.max_uses=b.maxUses||0,b.temporary=b.temporary||!1,b.xkcdpass=b.xkcd||!1):b={validate:null};var d;return d=a instanceof z["default"]?r.Endpoints.CHANNEL_INVITES(a.id):r.Endpoints.SERVER_INVITES(a.id),k["default"].post(d).set("authorization",this.token).send(b).end().then(function(a){return new N["default"](a.body,c.channels.get("id",a.body.channel.id),c.client)})},b.prototype.deleteInvite=function(a){if(a=this.resolver.resolveInviteID(a),!a)throw new Error("Not a valid invite");return k["default"].del(r.Endpoints.INVITE(a)).set("authorization",this.token).end()},b.prototype.overwritePermissions=function(a,b,c){var d=this;return this.resolver.resolveChannel(a).then(function(a){var e;b instanceof x["default"]&&(e=b);var f={};if(f.allow=0,f.deny=0,c.allow=c.allow||[],c.deny=c.deny||[],b instanceof L["default"])f.id=b.id,f.type="role";else{if(!e)throw new Error("role incorrect");f.id=e.id,f.type="member"}for(var g in c)c[g]?g instanceof String||"string"==typeof g?f.allow|=r.Permissions[g]||0:f.allow|=g:g instanceof String||"string"==typeof g?f.deny|=r.Permissions[g]||0:f.deny|=g;return k["default"].put(r.Endpoints.CHANNEL_PERMISSIONS(a.id)+"/"+f.id).set("authorization",d.token).send(f).end()})},b.prototype.setStatus=function(a,b){this.idleStatus=a||this.idleStatus||null,a&&("online"===a||"here"===a||"available"===a)&&(this.idleStatus=null),this.gameID=this.resolver.resolveGameID(b)||this.gameID||null;var c={op:3,d:{idle_since:this.idleStatus,game_id:this.gameID}};return("idle"===this.idleStatus||"away"===this.idleStatus)&&(c.d.idle_since=Date.now()),this.sendWS(c),Promise.resolve()},b.prototype.sendTyping=function(a){var b=this;return this.resolver.resolveChannel(a).then(function(a){return k["default"].post(r.Endpoints.CHANNEL(a.id)+"/typing").set("authorization",b.token).end()})},b.prototype.startTyping=function(a){var b=this;return this.resolver.resolveChannel(a).then(function(a){if(b.typingIntervals[a.id])throw new Error("Already typing in that channel");return b.typingIntervals[a.id]=setInterval(function(){return b.sendTyping(a)["catch"](function(a){return b.emit("error",a)})},4e3),b.sendTyping(a)})},b.prototype.stopTyping=function(a){var b=this;return this.resolver.resolveChannel(a).then(function(a){if(!b.typingIntervals[a.id])throw new Error("Not typing in that channel");clearInterval(b.typingIntervals[a.id]),b.typingIntervals[a.id]=!1})},b.prototype.updateDetails=function(a){return k["default"].patch(r.Endpoints.ME).set("authorization",this.token).send({avatar:this.resolver.resolveToBase64(a.avatar)||this.user.avatar,email:a.email||this.email,new_password:a.newPassword||null,password:a.password||this.password,username:a.username||this.user.username}).end()},b.prototype.setAvatar=function(a){return this.updateDetails({avatar:a})},b.prototype.setUsername=function(a){return this.updateDetails({username:a})},b.prototype.setTopic=function(a){var b=this,c=arguments.length<=1||void 0===arguments[1]?"":arguments[1];return this.resolver.resolveChannel(a).then(function(a){return k["default"].patch(r.Endpoints.CHANNEL(a.id)).set("authorization",b.token).send({name:a.name,position:a.position,topic:c}).end().then(function(b){return a.topic=b.body.topic})})},b.prototype.setChannelName=function(a){var b=this,c=arguments.length<=1||void 0===arguments[1]?"discordjs_is_the_best":arguments[1];return this.resolver.resolveChannel(a).then(function(a){return k["default"].patch(r.Endpoints.CHANNEL(a.id)).set("authorization",b.token).send({name:c,position:a.position,topic:a.topic}).end().then(function(b){return a.name=b.body.name})})},b.prototype.setChannelNameAndTopic=function(a){var b=this,c=arguments.length<=1||void 0===arguments[1]?"discordjs_is_the_best":arguments[1],d=arguments.length<=2||void 0===arguments[2]?"":arguments[2];return this.resolver.resolveChannel(a).then(function(a){return k["default"].patch(r.Endpoints.CHANNEL(a.id)).set("authorization",b.token).send({name:c,position:a.position,topic:d}).end().then(function(b){a.name=b.body.name,a.topic=b.body.topic})})},b.prototype.updateChannel=function(a,b){return this.setChannelNameAndTopic(a,b.name,b.topic)},b.prototype.ack=function(a){return a=this.resolver.resolveMessage(a),a||Promise.reject(new Error("Message does not exist")),k["default"].post(r.Endpoints.CHANNEL_MESSAGE(a.channel.id,a.id)+"/ack").set("authorization",this.token).end()},b.prototype.sendWS=function(a){this.websocket&&this.websocket.send(JSON.stringify(a))},b.prototype.createWS=function(b){var c=this,d=c.client;return this.websocket?!1:(this.websocket=new m["default"](b),this.websocket.onopen=function(){c.sendWS({op:2,d:{token:c.token,v:3,compress:c.client.options.compress,properties:{$os:"discord.js",$browser:"discord.js",$device:"discord.js",$referrer:"discord.js",$referring_domain:"discord.js"}}})},this.websocket.onclose=function(){c.websocket=null,c.state=o["default"].DISCONNECTED,d.emit("disconnected")},this.websocket.onerror=function(a){d.emit("error",a)},void(this.websocket.onmessage=function(b){"Binary"===b.type&&(h||(h=a("zlib")),b.data=h.inflateSync(b.data).toString());var e,f;try{e=JSON.parse(b.data),f=e.d}catch(b){return void d.emit("error",b)}switch(d.emit("raw",e),e.t){case r.PacketType.READY:var g=Date.now();c.user=c.users.add(new x["default"](f.user,d)),f.guilds.forEach(function(a){c.servers.add(new H["default"](a,d))}),f.private_channels.forEach(function(a){c.private_channels.add(new F["default"](a,d))}),c.state=o["default"].READY,setInterval(function(){return c.sendWS({op:1,d:Date.now()})},f.heartbeat_interval),d.emit("ready"),d.emit("debug","ready packet took "+(Date.now()-g)+"ms to process"),d.emit("debug","ready with "+c.servers.length+" servers, "+c.channels.length+" channels and "+c.users.length+" users cached."),c.readyTime=Date.now();break;case r.PacketType.MESSAGE_CREATE:var i=c.channels.get("id",f.channel_id)||c.private_channels.get("id",f.channel_id);if(i){var j=i.messages.add(new J["default"](f,i,d));c.messageAwaits[i.id+j.author.id]?(c.messageAwaits[i.id+j.author.id].map(function(a){return a(j)}),c.messageAwaits[i.id+j.author.id]=null,d.emit("message",j,!0)):d.emit("message",j),c.ack(j)}else d.emit("warn","message created but channel is not cached");break;case r.PacketType.MESSAGE_DELETE:var i=c.channels.get("id",f.channel_id)||c.private_channels.get("id",f.channel_id);if(i){var j=i.messages.get("id",f.id);d.emit("messageDeleted",j,i),j&&i.messages.remove(j)}else d.emit("warn","message was deleted but channel is not cached");break;case r.PacketType.MESSAGE_UPDATE:var i=c.channels.get("id",f.channel_id)||c.private_channels.get("id",f.channel_id);if(i){var j=i.messages.get("id",f.id);if(j){f.nonce=f.nonce||j.nonce,f.attachments=f.attachments||j.attachments,f.tts=f.tts||j.tts,f.embeds=f.embeds||j.embeds,f.timestamp=f.timestamp||j.timestamp,f.mention_everyone=f.mention_everyone||j.everyoneMentioned,f.content=f.content||j.content,f.mentions=f.mentions||j.mentions,f.author=f.author||j.author;var k=i.messages.update(j,new J["default"](f,i,d));d.emit("messageUpdated",k,j)}}else d.emit("warn","message was updated but channel is not cached");break;case r.PacketType.SERVER_CREATE:var l=c.servers.get("id",f.id);l||(c.servers.add(new H["default"](f,d)),d.emit("serverCreated",l));break;case r.PacketType.SERVER_DELETE:var l=c.servers.get("id",f.id);if(l){ +for(var m=l.channels,n=Array.isArray(m),p=0,m=n?m:m[Symbol.iterator]();;){var q;if(n){if(p>=m.length)break;q=m[p++]}else{if(p=m.next(),p.done)break;q=p.value}var i=q;c.channels.remove(i)}c.servers.remove(l),d.emit("serverDeleted",l)}else d.emit("warn","server was deleted but it was not in the cache");break;case r.PacketType.SERVER_UPDATE:var l=c.servers.get("id",f.id);if(l){f.members=f.members||[],f.channels=f.channels||[];var s=new H["default"](f,c);s.members=l.members,s.memberMap=l.memberMap,s.channels=l.channels,s.equalsStrict(l)?d.emit("debug","received server update but server already updated"):(c.servers.update(l,s),d.emit("serverUpdated",l,s))}else l||(d.emit("warn","server was updated but it was not in the cache"),c.servers.add(new H["default"](f,c)),d.emit("serverCreated",l));break;case r.PacketType.CHANNEL_CREATE:var i=c.channels.get("id",f.id);if(i)d.emit("warn","channel created but already in cache");else{var l=c.servers.get("id",f.guild_id);if(l)if(f.is_private)d.emit("channelCreated",c.private_channels.add(new F["default"](f,d)));else{var t=null;t="text"===f.type?c.channels.add(new B["default"](f,d,l)):c.channels.add(new D["default"](f,d,l)),d.emit("channelCreated",l.channels.add(t))}else d.emit("warn","channel created but server does not exist")}break;case r.PacketType.CHANNEL_DELETE:var i=c.channels.get("id",f.id);i?(i.server&&i.server.channels.remove(i),c.channels.remove(i),d.emit("channelDeleted",i)):d.emit("warn","channel deleted but already out of cache?");break;case r.PacketType.CHANNEL_UPDATE:var i=c.channels.get("id",f.id)||c.private_channels.get("id",f.id);if(i)if(i instanceof F["default"])d.emit("channelUpdated",i,c.private_channels.update(i,new F["default"](f,d)));else if(i.server)if("text"===i.type){var t=new B["default"](f,d,i.server);t.messages=i.messages,i.server.channels.update(i,t),c.channels.update(i,t),d.emit("channelUpdated",i,t)}else{var t=new D["default"](f,d,i.server);i.server.channels.update(i,t),c.channels.update(i,t),d.emit("channelUpdated",i,t)}else d.emit("warn","channel updated but server non-existant");else d.emit("warn","channel updated but not in cache");break;case r.PacketType.SERVER_ROLE_CREATE:var l=c.servers.get("id",f.guild_id);l?d.emit("serverRoleCreated",l.roles.add(new L["default"](f.role,l,d)),l):d.emit("warn","server role made but server not in cache");break;case r.PacketType.SERVER_ROLE_DELETE:var l=c.servers.get("id",f.guild_id);if(l){var u=l.roles.get("id",f.role_id);u?(l.roles.remove(u),d.emit("serverRoleDeleted",u)):d.emit("warn","server role deleted but role not in cache")}else d.emit("warn","server role deleted but server not in cache");break;case r.PacketType.SERVER_ROLE_UPDATE:var l=c.servers.get("id",f.guild_id);if(l){var u=l.roles.get("id",f.role.id);if(u){var v=new L["default"](f.role,l,d);l.roles.update(u,v),d.emit("serverRoleUpdated",u,v)}else d.emit("warn","server role updated but role not in cache")}else d.emit("warn","server role updated but server not in cache");break;case r.PacketType.SERVER_MEMBER_ADD:var l=c.servers.get("id",f.guild_id);l?(l.memberMap[f.user.id]={roles:f.roles.map(function(a){return l.roles.get("id",a)}),mute:!1,deaf:!1,joinedAt:Date.parse(f.joined_at)},d.emit("serverNewMember",l,l.members.add(c.users.add(new x["default"](f.user,d))))):d.emit("warn","server member added but server doesn't exist in cache");break;case r.PacketType.SERVER_MEMBER_REMOVE:var l=c.servers.get("id",f.guild_id);if(l){var w=c.users.get("id",f.user.id);w?(l.memberMap[f.user.id]=null,l.members.remove(w),d.emit("serverMemberRemoved",l,w)):d.emit("warn","server member removed but user doesn't exist in cache")}else d.emit("warn","server member removed but server doesn't exist in cache");break;case r.PacketType.SERVER_MEMBER_UPDATE:var l=c.servers.get("id",f.guild_id);if(l){var w=c.users.get("id",f.user.id);w?(l.memberMap[f.user.id].roles=f.roles.map(function(a){return l.roles.get("id",a)}),l.memberMap[f.user.id].mute=f.mute,l.memberMap[f.user.id].deaf=f.deaf,d.emit("serverMemberUpdated",l,w)):d.emit("warn","server member removed but user doesn't exist in cache")}else d.emit("warn","server member updated but server doesn't exist in cache");break;case r.PacketType.PRESENCE_UPDATE:var w=c.users.get("id",f.user.id);if(w){f.user.username=f.user.username||w.username,f.user.id=f.user.id||w.id,f.user.avatar=f.user.avatar||w.avatar,f.user.discriminator=f.user.discriminator||w.discriminator;var y=new x["default"](f.user,d);y.equals(w)?(d.emit("presence",w,f.status,f.game_id),w.status=f.status,w.gameID=f.game_id):(d.emit("userUpdated",w,y),c.users.update(w,y))}else d.emit("warn","presence update but user not in cache");break;case r.PacketType.TYPING:var w=c.users.get("id",f.user_id),i=c.channels.get("id",f.channel_id)||c.private_channels.get("id",f.channel_id);w&&i?(w.typing.since?(w.typing.since=Date.now(),w.typing.channel=i):(w.typing.since=Date.now(),w.typing.channel=i,d.emit("userTypingStarted",w,i)),setTimeout(function(){Date.now()-w.typing.since>5500&&(w.typing.since=null,w.typing.channel=null,d.emit("userTypingStopped",w,i))},6e3)):d.emit("warn","user typing but user or channel not existant in cache");break;case r.PacketType.SERVER_BAN_ADD:var w=c.users.get("id",f.user.id),l=c.servers.get("id",f.guild_id);w&&l?d.emit("userBanned",w,l):d.emit("warn","user banned but user/server not in cache.");break;case r.PacketType.SERVER_BAN_REMOVE:var w=c.users.get("id",f.user.id),l=c.servers.get("id",f.guild_id);w&&l?d.emit("userUnbanned",w,l):d.emit("warn","user unbanned but user/server not in cache.")}}))},i(b,[{key:"uptime",get:function(){return this.readyTime?Date.now()-this.readyTime:null}}]),b}();c["default"]=R,b.exports=c["default"]},{"../Constants":5,"../Structures/Channel":6,"../Structures/Invite":8,"../Structures/Message":9,"../Structures/PMChannel":10,"../Structures/Role":12,"../Structures/Server":13,"../Structures/TextChannel":15,"../Structures/User":16,"../Structures/VoiceChannel":17,"../Util/Cache":19,"../Voice/VoiceConnection":23,"./ConnectionState":2,"./Resolver/Resolver":4,querystring:71,superagent:87,ws:91,zlib:31}],4:[function(a,b,c){(function(d){"use strict";function e(a){return a&&a.__esModule?a:{"default":a}}function f(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}c.__esModule=!0;var g=a("fs"),h=e(g),i=a("../../Structures/User"),j=e(i),k=a("../../Structures/Channel"),l=e(k),m=a("../../Structures/TextChannel"),n=e(m),o=a("../../Structures/VoiceChannel"),p=e(o),q=a("../../Structures/ServerChannel"),r=e(q),s=a("../../Structures/PMChannel"),t=e(s),u=a("../../Structures/Server"),v=e(u),w=a("../../Structures/Message"),x=e(w),y=a("../../Structures/Invite"),z=e(y),A=a("../../../ref/gameMap"),B=e(A),C=function(){function a(b){f(this,a),this.internal=b}return a.prototype.resolveGameID=function(a){if(!isNaN(a)&&parseInt(a)%1===0)return a;if("string"==typeof a||a instanceof String){var b=a.toLowerCase(),c=B["default"].find(function(a){return a.name.toLowerCase()===b});if(c)return c.id}return null},a.prototype.resolveToBase64=function(a){return a instanceof d&&(a=a.toString("base64"),a="data:image/jpg;base64,"+a),a},a.prototype.resolveInviteID=function(a){if(a instanceof z["default"])return a.id;if("string"==typeof a||a instanceof String){if(0===a.indexOf("http")){var b=a.split("/");return b.pop()}return a}return null},a.prototype.resolveServer=function(a){return a instanceof v["default"]?a:a instanceof r["default"]?a.server:a instanceof String||"string"==typeof a?this.internal.servers.get("id",a):a instanceof x["default"]&&a.channel instanceof n["default"]?a.server:null},a.prototype.resolveFile=function(a){return"string"==typeof a||a instanceof String?h["default"].createReadStream(a):a},a.prototype.resolveMentions=function(a){for(var b=[],c=a.match(/<@[^>]*>/g)||[],d=Array.isArray(c),e=0,c=d?c:c[Symbol.iterator]();;){var f;if(d){if(e>=c.length)break;f=c[e++]}else{if(e=c.next(),e.done)break;f=e.value}var g=f;b.push(g.substring(2,g.length-1))}return b},a.prototype.resolveString=function(a){var b=a;return a instanceof Array&&(b=a.join("\n")),b.toString()},a.prototype.resolveUser=function(a){if(a instanceof j["default"])return a;if(a instanceof x["default"])return a.author;if(a instanceof n["default"]){var b=a.lastMessage;if(b)return b.author}return a instanceof v["default"]?a.owner:a instanceof t["default"]?a.recipient:a instanceof String||"string"==typeof a?this.client.internal.users.get("id",a):null},a.prototype.resolveMessage=function(a){return a instanceof n["default"]||a instanceof t["default"]?a.lastMessage:a instanceof x["default"]?a:null},a.prototype.resolveVoiceChannel=function(a){return a instanceof p["default"]?a:null},a.prototype.resolveChannel=function(a){if(a instanceof x["default"])return Promise.resolve(a.channel);if(a instanceof l["default"])return Promise.resolve(a);if(a instanceof v["default"])return Promise.resolve(a.channels.get("id",a.id));if(a instanceof String||"string"==typeof a)return Promise.resolve(this.internal.channels.get("id",a));if(a instanceof j["default"]){var b=this.internal.private_channels.find(function(b){return b.recipient.equals(a)});return b?Promise.resolve(b):this.internal.startPM(a)}var c=new Error("Could not resolve channel");return c.resource=a,Promise.reject(c)},a}();c["default"]=C,b.exports=c["default"]}).call(this,a("buffer").Buffer)},{"../../../ref/gameMap":92,"../../Structures/Channel":6,"../../Structures/Invite":8,"../../Structures/Message":9,"../../Structures/PMChannel":10,"../../Structures/Server":13,"../../Structures/ServerChannel":14,"../../Structures/TextChannel":15,"../../Structures/User":16,"../../Structures/VoiceChannel":17,buffer:38,fs:32}],5:[function(a,b,c){"use strict";c.__esModule=!0;var d="https://discordapp.com/api";c.API=d;var e={LOGIN:d+"/auth/login",LOGOUT:d+"/auth/logout",ME:d+"/users/@me",GATEWAY:d+"/gateway",USER_CHANNELS:function(a){return d+"/users/"+a+"/channels"},AVATAR:function(a,b){return d+"/users/"+a+"/avatars/"+b+".jpg"},INVITE:function(a){return d+"/invite/"+a},SERVERS:d+"/guilds",SERVER:function(a){return e.SERVERS+"/"+a},SERVER_ICON:function(a,b){return e.SERVER(a)+"/icons/"+b+".jpg"},SERVER_PRUNE:function(a){return e.SERVER(a)+"/prune"},SERVER_EMBED:function(a){return e.SERVER(a)+"/embed"},SERVER_INVITES:function(a){return e.SERVER(a)+"/invites"},SERVER_ROLES:function(a){return e.SERVER(a)+"/roles"},SERVER_BANS:function(a){return e.SERVER(a)+"/bans"},SERVER_INTEGRATIONS:function(a){return e.SERVER(a)+"/integrations"},SERVER_MEMBERS:function(a){return e.SERVER(a)+"/members"},SERVER_CHANNELS:function(a){return e.SERVER(a)+"/channels"},CHANNELS:d+"/channels",CHANNEL:function(a){return e.CHANNELS+"/"+a},CHANNEL_MESSAGES:function(a){return e.CHANNEL(a)+"/messages"},CHANNEL_INVITES:function(a){return e.CHANNEL(a)+"/invites"},CHANNEL_TYPING:function(a){return e.CHANNEL(a)+"/typing"},CHANNEL_PERMISSIONS:function(a){return e.CHANNEL(a)+"/permissions"},CHANNEL_MESSAGE:function(a,b){return e.CHANNEL_MESSAGES(a)+"/"+b}};c.Endpoints=e;var f={createInstantInvite:1,kickMembers:2,banMembers:4,manageRoles:8,managePermissions:8,manageChannels:16,manageChannel:16,manageServer:32,readMessages:1024,sendMessages:2048,sendTTSMessages:4096,manageMessages:8192,embedLinks:16384,attachFiles:32768,readMessageHistory:65536,mentionEveryone:1<<17,voiceConnect:1<<20,voiceSpeak:1<<21,voiceMuteMembers:1<<22,voiceDeafenMembers:1<<23,voiceMoveMembers:1<<24,voiceUseVAD:1<<25};c.Permissions=f;var g={READY:"READY",MESSAGE_CREATE:"MESSAGE_CREATE",MESSAGE_UPDATE:"MESSAGE_UPDATE",MESSAGE_DELETE:"MESSAGE_DELETE",SERVER_CREATE:"GUILD_CREATE",SERVER_DELETE:"GUILD_DELETE",SERVER_UPDATE:"GUILD_UPDATE",CHANNEL_CREATE:"CHANNEL_CREATE",CHANNEL_DELETE:"CHANNEL_DELETE",CHANNEL_UPDATE:"CHANNEL_UPDATE",SERVER_ROLE_CREATE:"GUILD_ROLE_CREATE",SERVER_ROLE_DELETE:"GUILD_ROLE_DELETE",SERVER_ROLE_UPDATE:"GUILD_ROLE_UPDATE",SERVER_MEMBER_ADD:"GUILD_MEMBER_ADD",SERVER_MEMBER_REMOVE:"GUILD_MEMBER_REMOVE",SERVER_MEMBER_UPDATE:"GUILD_MEMBER_UPDATE",PRESENCE_UPDATE:"PRESENCE_UPDATE",TYPING:"TYPING_START",SERVER_BAN_ADD:"GUILD_BAN_ADD",SERVER_BAN_REMOVE:"GUILD_BAN_REMOVE"};c.PacketType=g},{}],6:[function(a,b,c){"use strict";function d(a){return a&&a.__esModule?a:{"default":a}}function e(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function f(a,b){if("function"!=typeof b&&null!==b)throw new TypeError("Super expression must either be null or a function, not "+typeof b);a.prototype=Object.create(b&&b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),b&&(Object.setPrototypeOf?Object.setPrototypeOf(a,b):a.__proto__=b)}c.__esModule=!0;var g=function(){function a(a,b){for(var c=0;c=h.length)break;k=h[j++]}else{if(j=h.next(),j.done)break;k=j.value}var m=k,o=d.internal.users.get("id",m.user.id);o&&(o.status=m.status,o.gameID=m.game_id)}}return f(b,a),b.prototype.details=function(a){return a=this.client.internal.resolver.resolveUser(a),a?this.memberMap[a.id]:{}},b.prototype.detailsOf=function(a){return this.details(a)},b.prototype.rolesOfUser=function(a){return a=this.client.internal.resolver.resolveUser(a),a?this.memberMap[a.id]?this.memberMap[a.id].roles:[]:null},b.prototype.rolesOf=function(a){return this.rolesOfUser(a)},b.prototype.toString=function(){return this.name},b.prototype.equalsStrict=function(a){if(!(a instanceof b))return!1;for(var c=u,d=Array.isArray(c),e=0,c=d?c:c[Symbol.iterator]();;){var f;if(d){if(e>=c.length)break;f=c[e++]}else{if(e=c.next(),e.done)break;f=e.value}var g=f;if(a[g]!==this[g])return!1}return!0},g(b,[{key:"iconURL",get:function(){return this.icon?j.Endpoints.SERVER_ICON(this.id,this.icon):null}},{key:"afkChannel",get:function(){return this.channels.get("id",this.afkChannelID)}},{key:"defaultChannel",get:function(){return this.channels.get("id",this.id)}},{key:"owner",get:function(){return this.members.get("id",this.ownerID)}}]),b}(i["default"]);c["default"]=v,b.exports=c["default"]},{"../Constants":5,"../Util/Cache":19,"../Util/Equality":20,"./Role":12,"./TextChannel":15,"./User":16,"./VoiceChannel":17}],14:[function(a,b,c){"use strict";function d(a){return a&&a.__esModule?a:{"default":a}}function e(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function f(a,b){if("function"!=typeof b&&null!==b)throw new TypeError("Super expression must either be null or a function, not "+typeof b);a.prototype=Object.create(b&&b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),b&&(Object.setPrototypeOf?Object.setPrototypeOf(a,b):a.__proto__=b)}c.__esModule=!0;var g=a("./Channel"),h=d(g),i=a("../Util/Cache"),j=d(i),k=a("./PermissionOverwrite"),l=d(k),m=a("./ChannelPermissions"),n=d(m),o=a("../Util/ArgumentRegulariser"),p=function(a){function b(c,d,f){var g=this;e(this,b),a.call(this,c,d),this.name=c.name,this.type=c.type,this.position=c.position,this.permissionOverwrites=new j["default"],this.server=f,c.permission_overwrites.forEach(function(a){g.permissionOverwrites.add(new l["default"](a))})}return f(b,a),b.prototype.permissionsOf=function(a){if(a=this.client.internal.resolver.resolveUser(a)){if(this.server.owner.equals(a))return new n["default"](4294967295);var b=this.server.roles.get("name","@everyone"),c=[b].concat(this.server.rolesOf(a)||[]),d=c.map(function(a){return a.id}),e=[],f=[];this.permissionOverwrites.forEach(function(b){"member"===b.type&&b.id===a.id?f.push(b):"role"===b.type&&b.id in d&&e.push(b)});for(var g=0,h=c,i=Array.isArray(h),j=0,h=i?h:h[Symbol.iterator]();;){var k;if(i){if(j>=h.length)break;k=h[j++]}else{if(j=h.next(),j.done)break;k=j.value}var l=k;g|=l.permissions}for(var m=e.concat(f),o=Array.isArray(m),p=0,m=o?m:m[Symbol.iterator]();;){var q;if(o){if(p>=m.length)break;q=m[p++]}else{if(p=m.next(),p.done)break;q=p.value}var r=q;g&=~r.deny,g|=r.allow}return new n["default"](g)}return null},b.prototype.permsOf=function(a){return this.permissionsOf(a)},b.prototype.mention=function(){return"<#"+this.id+">"},b.prototype.toString=function(){return this.mention()},b.prototype.setName=function(){return this.client.setChannelName.apply(this.client,o.reg(this,arguments))},b}(h["default"]);c["default"]=p,b.exports=c["default"]},{"../Util/ArgumentRegulariser":18,"../Util/Cache":19,"./Channel":6,"./ChannelPermissions":7,"./PermissionOverwrite":11}],15:[function(a,b,c){"use strict";function d(a){return a&&a.__esModule?a:{"default":a}}function e(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function f(a,b){if("function"!=typeof b&&null!==b)throw new TypeError("Super expression must either be null or a function, not "+typeof b);a.prototype=Object.create(b&&b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),b&&(Object.setPrototypeOf?Object.setPrototypeOf(a,b):a.__proto__=b)}c.__esModule=!0;var g=function(){function a(a,b){for(var c=0;c"},b.prototype.toString=function(){return this.mention(); +},b.prototype.equalsStrict=function(a){return a instanceof b?this.id===a.id&&this.username===a.username&&this.discriminator===a.discriminator&&this.avatar===a.avatar&&this.status===a.status&&this.gameID===a.gameID:!1},b.prototype.equals=function(a){return a instanceof b?this.id===a.id&&this.username===a.username&&this.discriminator===a.discriminator&&this.avatar===a.avatar:!1},g(b,[{key:"avatarURL",get:function(){return this.avatar?j.Endpoints.AVATAR(this.id,this.avatar):null}}]),b}(i["default"]);c["default"]=k,b.exports=c["default"]},{"../Constants":5,"../Util/Equality":20}],17:[function(a,b,c){"use strict";function d(a){return a&&a.__esModule?a:{"default":a}}function e(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function f(a,b){if("function"!=typeof b&&null!==b)throw new TypeError("Super expression must either be null or a function, not "+typeof b);a.prototype=Object.create(b&&b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),b&&(Object.setPrototypeOf?Object.setPrototypeOf(a,b):a.__proto__=b)}c.__esModule=!0;var g=a("./ServerChannel"),h=d(g),i=function(a){function b(c,d,f){e(this,b),a.call(this,c,d,f)}return f(b,a),b}(h["default"]);c["default"]=i,b.exports=c["default"]},{"./ServerChannel":14}],18:[function(a,b,c){"use strict";function d(a,b){return[a].concat(Array.prototype.slice.call(b))}c.__esModule=!0,c.reg=d},{}],19:[function(a,b,c){"use strict";function d(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function e(a,b){if("function"!=typeof b&&null!==b)throw new TypeError("Super expression must either be null or a function, not "+typeof b);a.prototype=Object.create(b&&b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),b&&(Object.setPrototypeOf?Object.setPrototypeOf(a,b):a.__proto__=b)}c.__esModule=!0;var f=function(a){function b(c,e){d(this,b),a.call(this),this.discrim=c||"id"}return e(b,a),b.prototype.get=function(a,b){var c=null;return this.forEach(function(d,e,f){return d.hasOwnProperty(a)&&d[a]==b?void(c=d):void 0}),c},b.prototype.has=function(a){return!!this.get(this.discrim,a[this.discrim])},b.prototype.getAll=function(a,c){var d=new b(this.discrim);return this.forEach(function(b,e,f){return b.hasOwnProperty(a)&&b[a]==c?void d.push(b):void 0}),d},b.prototype.add=function(a){for(var b=!1,c=this,d=Array.isArray(c),e=0,c=d?c:c[Symbol.iterator]();;){var f;if(d){if(e>=c.length)break;f=c[e++]}else{if(e=c.next(),e.done)break;f=e.value}var g=f;if(g[this.discrim]===a[this.discrim]){b=g;break}}return b?b:(this.limit&&this.length>=this.limit&&this.splice(0,1),this.push(a),a)},b.prototype.update=function(a,b){var c=this.get(this.discrim,a[this.discrim]);if(c){var d=this.indexOf(c);return this[d]=b,this[d]}return!1},b.prototype.random=function(){return this[Math.floor(Math.random()*this.length)]},b.prototype.remove=function(a){var b=this.indexOf(a);if(~b)this.splice(b,1);else{var c=this.get(this.discrim,a[this.discrim]);c&&this.splice(this.indexOf(c),1)}return!1},b}(Array);c["default"]=f,b.exports=c["default"]},{}],20:[function(a,b,c){"use strict";function d(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}c.__esModule=!0;var e=function(){function a(a,b){for(var c=0;c=c.length)break;f=c[e++]}else{if(e=c.next(),e.done)break;f=e.value}var g=f,i=h["default"].spawnSync(g);if(!i.error)return this.choice=g,g}return"help"},a.prototype.encodeStream=function(a){var b=arguments.length<=1||void 0===arguments[1]?function(a,b){}:arguments[1],c=this;return new Promise(function(d,e){var f=h["default"].spawn(c.getCommand(),["-f","s16le","-ar","48000","-ac","1","-af","volume=1","pipe:1","-i","-"]);a.pipe(f.stdin),f.stdout.once("readable",function(){b(null,{proc:f,stream:f.stdout,instream:a}),d({proc:f,stream:f.stdout,instream:a})}),f.stdout.on("end",function(){b("end"),e("end")}),f.stdout.on("close",function(){b("close"),e("close")})})},a.prototype.encodeFile=function(a){var b=arguments.length<=1||void 0===arguments[1]?function(a,b){}:arguments[1],c=this;return new Promise(function(d,e){var f=h["default"].spawn(c.getCommand(),["-f","s16le","-ar","48000","-ac","1","-af","volume=1","pipe:1","-i",a]);f.stdout.once("readable",function(){b(null,{proc:f,stream:f.stdout}),d({proc:f,stream:f.stdout})}),f.stdout.on("end",function(){b("end"),e("end")}),f.stdout.on("close",function(){b("close"),e("close")})})},a}();c["default"]=j,b.exports=c["default"]},{child_process:32,"node-opus":50}],22:[function(a,b,c){"use strict";function d(a){return a&&a.__esModule?a:{"default":a}}function e(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function f(a,b){if("function"!=typeof b&&null!==b)throw new TypeError("Super expression must either be null or a function, not "+typeof b);a.prototype=Object.create(b&&b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),b&&(Object.setPrototypeOf?Object.setPrototypeOf(a,b):a.__proto__=b)}c.__esModule=!0;var g=a("events"),h=d(g),i=function(a){function b(){e(this,b),a.call(this)}return f(b,a),b}(h["default"]);c["default"]=i,b.exports=c["default"]},{events:43}],23:[function(a,b,c){(function(d){"use strict";function e(a){return a&&a.__esModule?a:{"default":a}}function f(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")}function g(a,b){if("function"!=typeof b&&null!==b)throw new TypeError("Super expression must either be null or a function, not "+typeof b);a.prototype=Object.create(b&&b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),b&&(Object.setPrototypeOf?Object.setPrototypeOf(a,b):a.__proto__=b)}c.__esModule=!0;var h=a("ws"),i=e(h),j=a("dns"),k=e(j),l=a("dgram"),m=e(l),n=a("./AudioEncoder"),o=e(n),p=a("./VoicePacket"),q=e(p),r=a("./StreamIntent"),s=e(r),t=a("events"),u=e(t),v=function(a){function b(c,d,e,g,h,i){f(this,b),a.call(this),this.id=c.id,this.voiceChannel=c,this.client=d,this.session=e,this.token=g,this.server=h,this.endpoint=i.replace(":80",""),this.vWS=null,this.ready=!1,this.vWSData={},this.encoder=new o["default"],this.udp=null,this.playingIntent=null,this.playing=!1,this.streamTime=0,this.streamProc=null,this.KAI=null,this.init()}return g(b,a),b.prototype.destroy=function(){this.stopPlaying(),this.KAI&&clearInterval(this.KAI),this.vWS.close(),this.udp.close(),this.client.internal.sendWS({op:4,d:{guild_id:null,channel_id:null,self_mute:!0,self_deaf:!1}})},b.prototype.stopPlaying=function(){this.playing=!1,this.playingIntent=null,this.instream&&(this.instream.end&&this.instream.end(),this.instream.destroy&&this.instream.destroy(),this.instream=null)},b.prototype.playStream=function(a){function b(){if(!c.playingIntent||!c.playing)return c.setSpeaking(!1),void j.emit("end");try{var l=a.read(1920);if(!l)return k?(j.emit("end"),void c.setSpeaking(!1)):(k=!0,void setTimeout(b,10*i));if(1920!==l.length){var m=new d(1920).fill(0);l.copy(m),l=m}h++,65535>f+10?f+=1:f=0,4294967295>g+9600?g+=960:g=0,c.sendBuffer(l,f,g,function(a){});var n=e+h*i;c.streamTime=h*i,setTimeout(b,i+(n-Date.now())),c.playing||c.setSpeaking(!0),j.emit("time",c.streamTime)}catch(o){j.emit("error",o)}}var c=this,e=Date.now(),f=0,g=0,h=0,i=20;c.playingIntent&&c.stopPlaying(),c.playing=!0;var j=new s["default"],k=!1;return c.playingIntent=j,c.setSpeaking(!0),b(),j},b.prototype.setSpeaking=function(a){this.playing=a,this.vWS.readyState===i["default"].OPEN&&this.vWS.send(JSON.stringify({op:5,d:{speaking:a,delay:0}}))},b.prototype.sendPacket=function(a){var b=arguments.length<=1||void 0===arguments[1]?function(a){}:arguments[1],c=this;c.playing=!0;try{c.vWS.readyState===i["default"].OPEN&&c.udp.send(a,0,a.length,c.vWSData.port,c.endpoint,b)}catch(d){return c.playing=!1,b(d),!1}},b.prototype.sendBuffer=function(a,b,c,d){var e=this;e.playing=!0;try{if(!e.encoder.opus)return e.playing=!1,e.emit("error","No Opus!"),void e.client.emit("debug","Tried to use node-opus, but opus not available - install it!");var f=e.encoder.opusBuffer(a),g=new q["default"](f,b,c,e.vWSData.ssrc);return e.sendPacket(g,d)}catch(h){return e.playing=!1,e.emit("error",h),!1}},b.prototype.test=function(){this.playFile("C:/users/amish/desktop/audio.mp3").then(function(a){a.on("time",function(a){console.log("Time",a)})})},b.prototype.playFile=function(a){var b=this,c=arguments.length<=1||void 0===arguments[1]?function(a,b){}:arguments[1],d=this;return new Promise(function(e,f){function g(){var a=arguments.length<=0||void 0===arguments[0]?!0:arguments[0];f(a),c(a)}b.encoder.encodeFile(a)["catch"](g).then(function(a){d.streamProc=a.proc;var b=d.playStream(a.stream);e(b),c(null,b)})})},b.prototype.playRawStream=function(a){var b=this,c=arguments.length<=1||void 0===arguments[1]?function(a,b){}:arguments[1],d=this;return new Promise(function(e,f){function g(){var a=arguments.length<=0||void 0===arguments[0]?!0:arguments[0];f(a),c(a)}b.encoder.encodeStream(a)["catch"](g).then(function(a){d.streamProc=a.proc,d.instream=a.instream;var b=d.playStream(a.stream);e(b),c(null,b)})})},b.prototype.init=function(){var a=this,b=this;k["default"].lookup(this.endpoint,function(c,e,f){b.endpoint=e;var g=b.vWS=new i["default"]("wss://"+a.endpoint,null,{rejectUnauthorized:!1}),h=b.udp=m["default"].createSocket("udp4"),j=!0,k="",l="";h.bind({exclusive:!0}),h.on("message",function(a,c){var d=JSON.parse(JSON.stringify(a)).data;if(j===!0){for(var e=4;e=0;f--)if(g[f]!=h[f])return!1;for(f=g.length-1;f>=0;f--)if(e=g[f],!i(a[e],b[e]))return!1;return!0}function l(a,b){return a&&b?"[object RegExp]"==Object.prototype.toString.call(b)?b.test(a):a instanceof b?!0:b.call({},a)===!0?!0:!1:!1}function m(a,b,c,d){var e;n.isString(c)&&(d=c,c=null);try{b()}catch(f){e=f}if(d=(c&&c.name?" ("+c.name+").":".")+(d?" "+d:"."),a&&!e&&g(e,c,"Missing expected exception"+d),!a&&l(e,c)&&g(e,c,"Got unwanted exception"+d),a&&e&&c&&!l(e,c)||!a&&e)throw e}var n=a("util/"),o=Array.prototype.slice,p=Object.prototype.hasOwnProperty,q=b.exports=h;q.AssertionError=function(a){this.name="AssertionError",this.actual=a.actual,this.expected=a.expected,this.operator=a.operator,a.message?(this.message=a.message,this.generatedMessage=!1):(this.message=f(this),this.generatedMessage=!0);var b=a.stackStartFunction||g;if(Error.captureStackTrace)Error.captureStackTrace(this,b);else{var c=new Error;if(c.stack){var d=c.stack,e=b.name,h=d.indexOf("\n"+e);if(h>=0){var i=d.indexOf("\n",h+1);d=d.substring(i+1)}this.stack=d}}},n.inherits(q.AssertionError,Error),q.fail=g,q.ok=h,q.equal=function(a,b,c){a!=b&&g(a,b,c,"==",q.equal)},q.notEqual=function(a,b,c){a==b&&g(a,b,c,"!=",q.notEqual)},q.deepEqual=function(a,b,c){i(a,b)||g(a,b,c,"deepEqual",q.deepEqual)},q.notDeepEqual=function(a,b,c){i(a,b)&&g(a,b,c,"notDeepEqual",q.notDeepEqual)},q.strictEqual=function(a,b,c){a!==b&&g(a,b,c,"===",q.strictEqual)},q.notStrictEqual=function(a,b,c){a===b&&g(a,b,c,"!==",q.notStrictEqual)},q["throws"]=function(a,b,c){m.apply(this,[!0].concat(o.call(arguments)))},q.doesNotThrow=function(a,b){m.apply(this,[!1].concat(o.call(arguments)))},q.ifError=function(a){if(a)throw a};var r=Object.keys||function(a){var b=[];for(var c in a)p.call(a,c)&&b.push(c);return b}},{"util/":90}],27:[function(a,b,c){var d="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";!function(a){"use strict";function b(a){var b=a.charCodeAt(0);return b===g||b===l?62:b===h||b===m?63:i>b?-1:i+10>b?b-i+26+26:k+26>b?b-k:j+26>b?b-j+26:void 0}function c(a){function c(a){j[l++]=a}var d,e,g,h,i,j;if(a.length%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var k=a.length;i="="===a.charAt(k-2)?2:"="===a.charAt(k-1)?1:0,j=new f(3*a.length/4-i),g=i>0?a.length-4:a.length;var l=0;for(d=0,e=0;g>d;d+=4,e+=3)h=b(a.charAt(d))<<18|b(a.charAt(d+1))<<12|b(a.charAt(d+2))<<6|b(a.charAt(d+3)),c((16711680&h)>>16),c((65280&h)>>8),c(255&h);return 2===i?(h=b(a.charAt(d))<<2|b(a.charAt(d+1))>>4,c(255&h)):1===i&&(h=b(a.charAt(d))<<10|b(a.charAt(d+1))<<4|b(a.charAt(d+2))>>2,c(h>>8&255),c(255&h)),j}function e(a){function b(a){return d.charAt(a)}function c(a){return b(a>>18&63)+b(a>>12&63)+b(a>>6&63)+b(63&a)}var e,f,g,h=a.length%3,i="";for(e=0,g=a.length-h;g>e;e+=3)f=(a[e]<<16)+(a[e+1]<<8)+a[e+2],i+=c(f);switch(h){case 1:f=a[a.length-1],i+=b(f>>2),i+=b(f<<4&63),i+="==";break;case 2:f=(a[a.length-2]<<8)+a[a.length-1],i+=b(f>>10),i+=b(f>>4&63),i+=b(f<<2&63),i+="="}return i}var f="undefined"!=typeof Uint8Array?Uint8Array:Array,g="+".charCodeAt(0),h="/".charCodeAt(0),i="0".charCodeAt(0),j="a".charCodeAt(0),k="A".charCodeAt(0),l="-".charCodeAt(0),m="_".charCodeAt(0);a.toByteArray=c,a.fromByteArray=e}("undefined"==typeof c?this.base64js={}:c)},{}],28:[function(a,b,c){(function(d,e){function f(b){"string"==typeof b?b={bindings:b}:b||(b={}),b.__proto__=l,b.module_root||(b.module_root=c.getRoot(c.getFileName())),".node"!=h.extname(b.bindings)&&(b.bindings+=".node");for(var d,e,f,g=[],j=0,k=b["try"].length;k>j;j++){d=i.apply(null,b["try"][j].map(function(a){return b[a]||a})),g.push(d);try{return e=b.path?a.resolve(d):a(d),b.path||(e.path=d),e}catch(m){if(!/not find/i.test(m.message))throw m}}throw f=new Error("Could not locate the bindings file. Tried:\n"+g.map(function(a){return b.arrow+a}).join("\n")),f.tries=g,f}var g=a("fs"),h=a("path"),i=h.join,j=h.dirname,k=g.existsSync||h.existsSync,l={arrow:d.env.NODE_BINDINGS_ARROW||" → ",compiled:d.env.NODE_BINDINGS_COMPILED_DIR||"compiled",platform:d.platform,arch:d.arch,version:d.versions.node,bindings:"bindings.node","try":[["module_root","build","bindings"],["module_root","build","Debug","bindings"],["module_root","build","Release","bindings"],["module_root","out","Debug","bindings"],["module_root","Debug","bindings"],["module_root","out","Release","bindings"],["module_root","Release","bindings"],["module_root","build","default","bindings"],["module_root","compiled","version","platform","arch","bindings"]]};b.exports=c=f,c.getFileName=function(a){var b,c=Error.prepareStackTrace,d=Error.stackTraceLimit,f={};return Error.stackTraceLimit=10,Error.prepareStackTrace=function(c,d){for(var f=0,g=d.length;g>f;f++)if(b=d[f].getFileName(),b!==e){if(!a)return;if(b!==a)return}},Error.captureStackTrace(f),f.stack,Error.prepareStackTrace=c,Error.stackTraceLimit=d,b},c.getRoot=function(a){for(var b,c=j(a);;){if("."===c&&(c=d.cwd()),k(i(c,"package.json"))||k(i(c,"node_modules")))return c;if(b===c)throw new Error('Could not find module root given file: "'+a+'". Do you have a `package.json` file? ');b=c,c=i(c,"..")}}}).call(this,a("_process"),"/node_modules/bindings/bindings.js")},{_process:68,fs:32,path:66}],29:[function(a,b,c){},{}],30:[function(a,b,c){(function(b,d){function e(a){if(ac.UNZIP)throw new TypeError("Bad argument");this.mode=a,this.init_done=!1,this.write_in_progress=!1,this.pending_close=!1,this.windowBits=0,this.level=0,this.memLevel=0,this.strategy=0,this.dictionary=null}function f(a,b){for(var c=0;cc.Z_MAX_CHUNK))throw new Error("Invalid chunk size: "+a.chunkSize);if(a.windowBits&&(a.windowBitsc.Z_MAX_WINDOWBITS))throw new Error("Invalid windowBits: "+a.windowBits);if(a.level&&(a.levelc.Z_MAX_LEVEL))throw new Error("Invalid compression level: "+a.level);if(a.memLevel&&(a.memLevelc.Z_MAX_MEMLEVEL))throw new Error("Invalid memLevel: "+a.memLevel);if(a.strategy&&a.strategy!=c.Z_FILTERED&&a.strategy!=c.Z_HUFFMAN_ONLY&&a.strategy!=c.Z_RLE&&a.strategy!=c.Z_FIXED&&a.strategy!=c.Z_DEFAULT_STRATEGY)throw new Error("Invalid strategy: "+a.strategy);if(a.dictionary&&!d.isBuffer(a.dictionary))throw new Error("Invalid dictionary: it should be a Buffer instance");this._binding=new p.Zlib(b);var e=this;this._hadError=!1,this._binding.onerror=function(a,b){e._binding=null,e._hadError=!0;var d=new Error(a);d.errno=b,d.code=c.codes[b],e.emit("error",d)};var f=c.Z_DEFAULT_COMPRESSION;"number"==typeof a.level&&(f=a.level);var g=c.Z_DEFAULT_STRATEGY;"number"==typeof a.strategy&&(g=a.strategy),this._binding.init(a.windowBits||c.Z_DEFAULT_WINDOWBITS,f,a.memLevel||c.Z_DEFAULT_MEMLEVEL,g,a.dictionary),this._buffer=new d(this._chunkSize),this._offset=0,this._closed=!1,this._level=f,this._strategy=g,this.once("end",this.close)}var o=a("_stream_transform"),p=a("./binding"),q=a("util"),r=a("assert").ok;p.Z_MIN_WINDOWBITS=8,p.Z_MAX_WINDOWBITS=15,p.Z_DEFAULT_WINDOWBITS=15,p.Z_MIN_CHUNK=64,p.Z_MAX_CHUNK=1/0,p.Z_DEFAULT_CHUNK=16384,p.Z_MIN_MEMLEVEL=1,p.Z_MAX_MEMLEVEL=9,p.Z_DEFAULT_MEMLEVEL=8,p.Z_MIN_LEVEL=-1,p.Z_MAX_LEVEL=9,p.Z_DEFAULT_LEVEL=p.Z_DEFAULT_COMPRESSION,Object.keys(p).forEach(function(a){a.match(/^Z/)&&(c[a]=p[a])}),c.codes={Z_OK:p.Z_OK,Z_STREAM_END:p.Z_STREAM_END,Z_NEED_DICT:p.Z_NEED_DICT,Z_ERRNO:p.Z_ERRNO,Z_STREAM_ERROR:p.Z_STREAM_ERROR,Z_DATA_ERROR:p.Z_DATA_ERROR,Z_MEM_ERROR:p.Z_MEM_ERROR,Z_BUF_ERROR:p.Z_BUF_ERROR,Z_VERSION_ERROR:p.Z_VERSION_ERROR},Object.keys(c.codes).forEach(function(a){c.codes[c.codes[a]]=a}),c.Deflate=g,c.Inflate=h,c.Gzip=i,c.Gunzip=j,c.DeflateRaw=k,c.InflateRaw=l,c.Unzip=m,c.createDeflate=function(a){return new g(a)},c.createInflate=function(a){return new h(a)},c.createDeflateRaw=function(a){return new k(a)},c.createInflateRaw=function(a){return new l(a)},c.createGzip=function(a){return new i(a)},c.createGunzip=function(a){return new j(a)},c.createUnzip=function(a){return new m(a)},c.deflate=function(a,b,c){return"function"==typeof b&&(c=b,b={}),e(new g(b),a,c)},c.deflateSync=function(a,b){return f(new g(b),a)},c.gzip=function(a,b,c){return"function"==typeof b&&(c=b,b={}),e(new i(b),a,c)},c.gzipSync=function(a,b){return f(new i(b),a)},c.deflateRaw=function(a,b,c){return"function"==typeof b&&(c=b,b={}),e(new k(b),a,c)},c.deflateRawSync=function(a,b){return f(new k(b),a)},c.unzip=function(a,b,c){return"function"==typeof b&&(c=b,b={}),e(new m(b),a,c)},c.unzipSync=function(a,b){return f(new m(b),a)},c.inflate=function(a,b,c){return"function"==typeof b&&(c=b,b={}),e(new h(b),a,c)},c.inflateSync=function(a,b){return f(new h(b),a)},c.gunzip=function(a,b,c){return"function"==typeof b&&(c=b,b={}),e(new j(b),a,c)},c.gunzipSync=function(a,b){return f(new j(b),a)},c.inflateRaw=function(a,b,c){return"function"==typeof b&&(c=b,b={}),e(new l(b),a,c)},c.inflateRawSync=function(a,b){return f(new l(b),a)},q.inherits(n,o),n.prototype.params=function(a,d,e){if(ac.Z_MAX_LEVEL)throw new RangeError("Invalid compression level: "+a);if(d!=c.Z_FILTERED&&d!=c.Z_HUFFMAN_ONLY&&d!=c.Z_RLE&&d!=c.Z_FIXED&&d!=c.Z_DEFAULT_STRATEGY)throw new TypeError("Invalid strategy: "+d);if(this._level!==a||this._strategy!==d){var f=this;this.flush(p.Z_SYNC_FLUSH,function(){f._binding.params(a,d),f._hadError||(f._level=a,f._strategy=d,e&&e())})}else b.nextTick(e)},n.prototype.reset=function(){return this._binding.reset()},n.prototype._flush=function(a){this._transform(new d(0),"",a)},n.prototype.flush=function(a,c){var e=this._writableState;if(("function"==typeof a||void 0===a&&!c)&&(c=a,a=p.Z_FULL_FLUSH),e.ended)c&&b.nextTick(c);else if(e.ending)c&&this.once("end",c);else if(e.needDrain){var f=this;this.once("drain",function(){f.flush(c)})}else this._flushFlag=a,this.write(new d(0),"",c)},n.prototype.close=function(a){if(a&&b.nextTick(a),!this._closed){this._closed=!0,this._binding.close();var c=this;b.nextTick(function(){c.emit("close")})}},n.prototype._transform=function(a,b,c){var e,f=this._writableState,g=f.ending||f.ended,h=g&&(!a||f.length===a.length);if(null===!a&&!d.isBuffer(a))return c(new Error("invalid input"));h?e=p.Z_FINISH:(e=this._flushFlag,a.length>=f.length&&(this._flushFlag=this._opts.flush||p.Z_NO_FLUSH));this._processChunk(a,e,c)},n.prototype._processChunk=function(a,b,c){function e(k,n){if(!i._hadError){var o=g-n;if(r(o>=0,"have should not go down"),o>0){var p=i._buffer.slice(i._offset,i._offset+o);i._offset+=o,j?i.push(p):(l.push(p),m+=p.length)}if((0===n||i._offset>=i._chunkSize)&&(g=i._chunkSize,i._offset=0,i._buffer=new d(i._chunkSize)),0===n){if(h+=f-k,f=k,!j)return!0;var q=i._binding.write(b,a,h,f,i._buffer,i._offset,i._chunkSize);return q.callback=e,void(q.buffer=a)}return j?void c():!1}}var f=a&&a.length,g=this._chunkSize-this._offset,h=0,i=this,j="function"==typeof c;if(!j){var k,l=[],m=0;this.on("error",function(a){k=a});do var n=this._binding.writeSync(b,a,h,f,this._buffer,this._offset,g);while(!this._hadError&&e(n[0],n[1]));if(this._hadError)throw k;var o=d.concat(l,m);return this.close(),o}var p=this._binding.write(b,a,h,f,this._buffer,this._offset,g);p.buffer=a,p.callback=e},q.inherits(g,n),q.inherits(h,n),q.inherits(i,n),q.inherits(j,n),q.inherits(k,n),q.inherits(l,n),q.inherits(m,n)}).call(this,a("_process"),a("buffer").Buffer)},{"./binding":30,_process:68,_stream_transform:37,assert:26,buffer:38,util:90}],32:[function(a,b,c){arguments[4][29][0].apply(c,arguments)},{dup:29}],33:[function(a,b,c){"use strict";function d(a){return this instanceof d?(j.call(this,a),k.call(this,a),a&&a.readable===!1&&(this.readable=!1),a&&a.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,a&&a.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",e)):new d(a)}function e(){this.allowHalfOpen||this._writableState.ended||h(f,this)}function f(a){a.end()}var g=Object.keys||function(a){var b=[];for(var c in a)b.push(c);return b};b.exports=d;var h=a("process-nextick-args"),i=a("core-util-is");i.inherits=a("inherits");var j=a("./_stream_readable"),k=a("./_stream_writable");i.inherits(d,j);for(var l=g(k.prototype),m=0;m0)if(b.ended&&!e){var h=new Error("stream.push() after EOF");a.emit("error",h)}else if(b.endEmitted&&e){var h=new Error("stream.unshift() after end event");a.emit("error",h)}else!b.decoder||e||d||(c=b.decoder.write(c)),e||(b.reading=!1),b.flowing&&0===b.length&&!b.sync?(a.emit("data",c),a.read(0)):(b.length+=b.objectMode?1:c.length,e?b.buffer.unshift(c):b.buffer.push(c),b.needReadable&&l(a)),n(a,b);else e||(b.reading=!1);return g(b)}function g(a){return!a.ended&&(a.needReadable||a.length=I?a=I:(a--,a|=a>>>1,a|=a>>>2,a|=a>>>4,a|=a>>>8,a|=a>>>16,a++),a}function i(a,b){return 0===b.length&&b.ended?0:b.objectMode?0===a?0:1:null===a||isNaN(a)?b.flowing&&b.buffer.length?b.buffer[0].length:b.length:0>=a?0:(a>b.highWaterMark&&(b.highWaterMark=h(a)),a>b.length?b.ended?b.length:(b.needReadable=!0,0):a)}function j(a,b){var c=null;return B.isBuffer(b)||"string"==typeof b||null===b||void 0===b||a.objectMode||(c=new TypeError("Invalid non-string/buffer chunk")),c}function k(a,b){if(!b.ended){if(b.decoder){var c=b.decoder.end();c&&c.length&&(b.buffer.push(c),b.length+=b.objectMode?1:c.length)}b.ended=!0,l(a)}}function l(a){var b=a._readableState;b.needReadable=!1,b.emittedReadable||(F("emitReadable",b.flowing),b.emittedReadable=!0,b.sync?z(m,a):m(a))}function m(a){F("emit readable"),a.emit("readable"),t(a)}function n(a,b){b.readingMore||(b.readingMore=!0,z(o,a,b))}function o(a,b){for(var c=b.length;!b.reading&&!b.flowing&&!b.ended&&b.length=e)c=f?d.join(""):1===d.length?d[0]:B.concat(d,e),d.length=0;else if(aj&&a>i;j++){var h=d[0],l=Math.min(a-i,h.length);f?c+=h.slice(0,l):h.copy(c,i,0,l),l0)throw new Error("endReadable called on non-empty stream");b.endEmitted||(b.ended=!0,z(w,b,a))}function w(a,b){a.endEmitted||0!==a.length||(a.endEmitted=!0,b.readable=!1,b.emit("end"))}function x(a,b){for(var c=0,d=a.length;d>c;c++)b(a[c],c)}function y(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return c;return-1}b.exports=e;var z=a("process-nextick-args"),A=a("isarray"),B=a("buffer").Buffer;e.ReadableState=d;var C,D=(a("events"),function(a,b){return a.listeners(b).length});!function(){try{C=a("stream")}catch(b){}finally{C||(C=a("events").EventEmitter)}}();var B=a("buffer").Buffer,E=a("core-util-is");E.inherits=a("inherits");var F,G=a("util");F=G&&G.debuglog?G.debuglog("stream"):function(){};var H;E.inherits(e,C),e.prototype.push=function(a,b){var c=this._readableState;return c.objectMode||"string"!=typeof a||(b=b||c.defaultEncoding,b!==c.encoding&&(a=new B(a,b),b="")),f(this,c,a,b,!1)},e.prototype.unshift=function(a){var b=this._readableState;return f(this,b,a,"",!0)},e.prototype.isPaused=function(){return this._readableState.flowing===!1},e.prototype.setEncoding=function(b){return H||(H=a("string_decoder/").StringDecoder),this._readableState.decoder=new H(b),this._readableState.encoding=b,this};var I=8388608;e.prototype.read=function(a){F("read",a);var b=this._readableState,c=a;if(("number"!=typeof a||a>0)&&(b.emittedReadable=!1),0===a&&b.needReadable&&(b.length>=b.highWaterMark||b.ended))return F("read: emitReadable",b.length,b.ended),0===b.length&&b.ended?v(this):l(this),null;if(a=i(a,b),0===a&&b.ended)return 0===b.length&&v(this),null;var d=b.needReadable;F("need readable",d),(0===b.length||b.length-a0?u(a,b):null,null===e&&(b.needReadable=!0,a=0),b.length-=a,0!==b.length||b.ended||(b.needReadable=!0),c!==a&&b.ended&&0===b.length&&v(this),null!==e&&this.emit("data",e),e},e.prototype._read=function(a){this.emit("error",new Error("not implemented"))},e.prototype.pipe=function(a,b){function d(a){F("onunpipe"),a===l&&f()}function e(){F("onend"),a.end()}function f(){F("cleanup"),a.removeListener("close",i),a.removeListener("finish",j),a.removeListener("drain",q),a.removeListener("error",h),a.removeListener("unpipe",d),l.removeListener("end",e),l.removeListener("end",f),l.removeListener("data",g),r=!0,!m.awaitDrain||a._writableState&&!a._writableState.needDrain||q()}function g(b){F("ondata");var c=a.write(b);!1===c&&(1!==m.pipesCount||m.pipes[0]!==a||1!==l.listenerCount("data")||r||(F("false write response, pause",l._readableState.awaitDrain),l._readableState.awaitDrain++),l.pause())}function h(b){F("onerror",b),k(),a.removeListener("error",h),0===D(a,"error")&&a.emit("error",b)}function i(){a.removeListener("finish",j),k()}function j(){F("onfinish"),a.removeListener("close",i),k()}function k(){F("unpipe"),l.unpipe(a)}var l=this,m=this._readableState;switch(m.pipesCount){case 0:m.pipes=a;break;case 1:m.pipes=[m.pipes,a];break;default:m.pipes.push(a)}m.pipesCount+=1,F("pipe count=%d opts=%j",m.pipesCount,b);var n=(!b||b.end!==!1)&&a!==c.stdout&&a!==c.stderr,o=n?e:f;m.endEmitted?z(o):l.once("end",o),a.on("unpipe",d);var q=p(l);a.on("drain",q);var r=!1;return l.on("data",g),a._events&&a._events.error?A(a._events.error)?a._events.error.unshift(h):a._events.error=[h,a._events.error]:a.on("error",h),a.once("close",i),a.once("finish",j),a.emit("pipe",l),m.flowing||(F("pipe resume"),l.resume()),a},e.prototype.unpipe=function(a){var b=this._readableState;if(0===b.pipesCount)return this;if(1===b.pipesCount)return a&&a!==b.pipes?this:(a||(a=b.pipes),b.pipes=null,b.pipesCount=0,b.flowing=!1,a&&a.emit("unpipe",this),this);if(!a){var c=b.pipes,d=b.pipesCount;b.pipes=null,b.pipesCount=0,b.flowing=!1;for(var e=0;d>e;e++)c[e].emit("unpipe",this);return this}var e=y(b.pipes,a);return-1===e?this:(b.pipes.splice(e,1),b.pipesCount-=1,1===b.pipesCount&&(b.pipes=b.pipes[0]),a.emit("unpipe",this),this)},e.prototype.on=function(a,b){var c=C.prototype.on.call(this,a,b);if("data"===a&&!1!==this._readableState.flowing&&this.resume(),"readable"===a&&this.readable){var d=this._readableState;d.readableListening||(d.readableListening=!0,d.emittedReadable=!1,d.needReadable=!0,d.reading?d.length&&l(this,d):z(q,this))}return c},e.prototype.addListener=e.prototype.on,e.prototype.resume=function(){var a=this._readableState;return a.flowing||(F("resume"),a.flowing=!0,r(this,a)),this},e.prototype.pause=function(){return F("call pause flowing=%j",this._readableState.flowing),!1!==this._readableState.flowing&&(F("pause"),this._readableState.flowing=!1,this.emit("pause")),this},e.prototype.wrap=function(a){var b=this._readableState,c=!1,d=this;a.on("end",function(){if(F("wrapped end"),b.decoder&&!b.ended){var a=b.decoder.end();a&&a.length&&d.push(a)}d.push(null)}),a.on("data",function(e){if(F("wrapped data"),b.decoder&&(e=b.decoder.write(e)),(!b.objectMode||null!==e&&void 0!==e)&&(b.objectMode||e&&e.length)){var f=d.push(e);f||(c=!0,a.pause())}});for(var e in a)void 0===this[e]&&"function"==typeof a[e]&&(this[e]=function(b){return function(){return a[b].apply(a,arguments)}}(e));var f=["error","close","destroy","pause","resume"];return x(f,function(b){a.on(b,d.emit.bind(d,b))}),d._read=function(b){F("wrapped _read",b),c&&(c=!1,a.resume())},d},e._fromList=u}).call(this,a("_process"))},{"./_stream_duplex":33,_process:68,buffer:38,"core-util-is":40,events:43,inherits:45,isarray:48,"process-nextick-args":67,"string_decoder/":86,util:29}],35:[function(a,b,c){"use strict";function d(a){this.afterTransform=function(b,c){return e(a,b,c)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null}function e(a,b,c){var d=a._transformState;d.transforming=!1;var e=d.writecb;if(!e)return a.emit("error",new Error("no writecb in Transform class"));d.writechunk=null,d.writecb=null,null!==c&&void 0!==c&&a.push(c),e&&e(b);var f=a._readableState;f.reading=!1,(f.needReadable||f.length-1))throw new TypeError("Unknown encoding: "+a);this._writableState.defaultEncoding=a},g.prototype._write=function(a,b,c){c(new Error("not implemented"))},g.prototype._writev=null,g.prototype.end=function(a,b,c){var d=this._writableState;"function"==typeof a?(c=a,a=null,b=null):"function"==typeof b&&(c=b,b=null),null!==a&&void 0!==a&&this.write(a,b),d.corked&&(d.corked=1,this.uncork()),d.ending||d.finished||v(this,d,c)}},{"./_stream_duplex":33,buffer:38,"core-util-is":40,events:43,inherits:45,"process-nextick-args":67,"util-deprecate":88}],37:[function(a,b,c){b.exports=a("./lib/_stream_transform.js")},{"./lib/_stream_transform.js":35}],38:[function(a,b,c){(function(b){function d(){function a(){}try{var b=new Uint8Array(1);return b.foo=function(){return 42},b.constructor=a,42===b.foo()&&b.constructor===a&&"function"==typeof b.subarray&&0===b.subarray(1,1).byteLength}catch(c){return!1}}function e(){return f.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function f(a){return this instanceof f?(this.length=0,this.parent=void 0,"number"==typeof a?g(this,a):"string"==typeof a?h(this,a,arguments.length>1?arguments[1]:"utf8"):i(this,a)):arguments.length>1?new f(a,arguments[1]):new f(a)}function g(a,b){if(a=p(a,0>b?0:0|q(b)),!f.TYPED_ARRAY_SUPPORT)for(var c=0;b>c;c++)a[c]=0;return a}function h(a,b,c){("string"!=typeof c||""===c)&&(c="utf8");var d=0|s(b,c);return a=p(a,d),a.write(b,c),a}function i(a,b){if(f.isBuffer(b))return j(a,b);if(Y(b))return k(a,b);if(null==b)throw new TypeError("must start with number, buffer, array or string");if("undefined"!=typeof ArrayBuffer){if(b.buffer instanceof ArrayBuffer)return l(a,b);if(b instanceof ArrayBuffer)return m(a,b)}return b.length?n(a,b):o(a,b)}function j(a,b){var c=0|q(b.length);return a=p(a,c),b.copy(a,0,0,c),a}function k(a,b){var c=0|q(b.length);a=p(a,c);for(var d=0;c>d;d+=1)a[d]=255&b[d];return a}function l(a,b){var c=0|q(b.length);a=p(a,c);for(var d=0;c>d;d+=1)a[d]=255&b[d];return a}function m(a,b){return f.TYPED_ARRAY_SUPPORT?(b.byteLength,a=f._augment(new Uint8Array(b))):a=l(a,new Uint8Array(b)),a}function n(a,b){var c=0|q(b.length);a=p(a,c);for(var d=0;c>d;d+=1)a[d]=255&b[d];return a}function o(a,b){var c,d=0;"Buffer"===b.type&&Y(b.data)&&(c=b.data,d=0|q(c.length)),a=p(a,d);for(var e=0;d>e;e+=1)a[e]=255&c[e];return a}function p(a,b){f.TYPED_ARRAY_SUPPORT?(a=f._augment(new Uint8Array(b)),a.__proto__=f.prototype):(a.length=b,a._isBuffer=!0);var c=0!==b&&b<=f.poolSize>>>1;return c&&(a.parent=Z),a}function q(a){if(a>=e())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+e().toString(16)+" bytes");return 0|a}function r(a,b){if(!(this instanceof r))return new r(a,b);var c=new f(a,b);return delete c.parent,c}function s(a,b){"string"!=typeof a&&(a=""+a);var c=a.length;if(0===c)return 0;for(var d=!1;;)switch(b){case"ascii":case"binary":case"raw":case"raws":return c;case"utf8":case"utf-8":return R(a).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*c;case"hex":return c>>>1;case"base64":return U(a).length;default:if(d)return R(a).length;b=(""+b).toLowerCase(),d=!0}}function t(a,b,c){var d=!1;if(b=0|b,c=void 0===c||c===1/0?this.length:0|c,a||(a="utf8"),0>b&&(b=0),c>this.length&&(c=this.length),b>=c)return"";for(;;)switch(a){case"hex":return F(this,b,c);case"utf8":case"utf-8":return B(this,b,c);case"ascii":return D(this,b,c);case"binary":return E(this,b,c);case"base64":return A(this,b,c);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return G(this,b,c);default:if(d)throw new TypeError("Unknown encoding: "+a);a=(a+"").toLowerCase(),d=!0}}function u(a,b,c,d){c=Number(c)||0;var e=a.length-c;d?(d=Number(d),d>e&&(d=e)):d=e;var f=b.length;if(f%2!==0)throw new Error("Invalid hex string");d>f/2&&(d=f/2);for(var g=0;d>g;g++){var h=parseInt(b.substr(2*g,2),16);if(isNaN(h))throw new Error("Invalid hex string");a[c+g]=h}return g}function v(a,b,c,d){return V(R(b,a.length-c),a,c,d)}function w(a,b,c,d){return V(S(b),a,c,d)}function x(a,b,c,d){return w(a,b,c,d)}function y(a,b,c,d){return V(U(b),a,c,d)}function z(a,b,c,d){return V(T(b,a.length-c),a,c,d)}function A(a,b,c){return 0===b&&c===a.length?W.fromByteArray(a):W.fromByteArray(a.slice(b,c))}function B(a,b,c){c=Math.min(a.length,c);for(var d=[],e=b;c>e;){var f=a[e],g=null,h=f>239?4:f>223?3:f>191?2:1;if(c>=e+h){var i,j,k,l;switch(h){case 1:128>f&&(g=f);break;case 2:i=a[e+1],128===(192&i)&&(l=(31&f)<<6|63&i,l>127&&(g=l));break;case 3:i=a[e+1],j=a[e+2],128===(192&i)&&128===(192&j)&&(l=(15&f)<<12|(63&i)<<6|63&j,l>2047&&(55296>l||l>57343)&&(g=l));break;case 4:i=a[e+1],j=a[e+2],k=a[e+3],128===(192&i)&&128===(192&j)&&128===(192&k)&&(l=(15&f)<<18|(63&i)<<12|(63&j)<<6|63&k,l>65535&&1114112>l&&(g=l))}}null===g?(g=65533,h=1):g>65535&&(g-=65536,d.push(g>>>10&1023|55296),g=56320|1023&g),d.push(g),e+=h}return C(d)}function C(a){var b=a.length;if($>=b)return String.fromCharCode.apply(String,a);for(var c="",d=0;b>d;)c+=String.fromCharCode.apply(String,a.slice(d,d+=$));return c}function D(a,b,c){var d="";c=Math.min(a.length,c);for(var e=b;c>e;e++)d+=String.fromCharCode(127&a[e]);return d}function E(a,b,c){var d="";c=Math.min(a.length,c);for(var e=b;c>e;e++)d+=String.fromCharCode(a[e]);return d}function F(a,b,c){var d=a.length;(!b||0>b)&&(b=0),(!c||0>c||c>d)&&(c=d);for(var e="",f=b;c>f;f++)e+=Q(a[f]);return e}function G(a,b,c){for(var d=a.slice(b,c),e="",f=0;fa)throw new RangeError("offset is not uint");if(a+b>c)throw new RangeError("Trying to access beyond buffer length")}function I(a,b,c,d,e,g){if(!f.isBuffer(a))throw new TypeError("buffer must be a Buffer instance");if(b>e||g>b)throw new RangeError("value is out of bounds");if(c+d>a.length)throw new RangeError("index out of range")}function J(a,b,c,d){0>b&&(b=65535+b+1);for(var e=0,f=Math.min(a.length-c,2);f>e;e++)a[c+e]=(b&255<<8*(d?e:1-e))>>>8*(d?e:1-e)}function K(a,b,c,d){0>b&&(b=4294967295+b+1);for(var e=0,f=Math.min(a.length-c,4);f>e;e++)a[c+e]=b>>>8*(d?e:3-e)&255}function L(a,b,c,d,e,f){if(b>e||f>b)throw new RangeError("value is out of bounds");if(c+d>a.length)throw new RangeError("index out of range");if(0>c)throw new RangeError("index out of range")}function M(a,b,c,d,e){return e||L(a,b,c,4,3.4028234663852886e38,-3.4028234663852886e38),X.write(a,b,c,d,23,4),c+4}function N(a,b,c,d,e){return e||L(a,b,c,8,1.7976931348623157e308,-1.7976931348623157e308),X.write(a,b,c,d,52,8),c+8}function O(a){if(a=P(a).replace(aa,""),a.length<2)return"";for(;a.length%4!==0;)a+="=";return a}function P(a){return a.trim?a.trim():a.replace(/^\s+|\s+$/g,"")}function Q(a){return 16>a?"0"+a.toString(16):a.toString(16)}function R(a,b){b=b||1/0;for(var c,d=a.length,e=null,f=[],g=0;d>g;g++){if(c=a.charCodeAt(g),c>55295&&57344>c){if(!e){if(c>56319){(b-=3)>-1&&f.push(239,191,189);continue}if(g+1===d){(b-=3)>-1&&f.push(239,191,189);continue}e=c;continue}if(56320>c){(b-=3)>-1&&f.push(239,191,189),e=c;continue}c=(e-55296<<10|c-56320)+65536}else e&&(b-=3)>-1&&f.push(239,191,189);if(e=null,128>c){if((b-=1)<0)break;f.push(c)}else if(2048>c){if((b-=2)<0)break;f.push(c>>6|192,63&c|128)}else if(65536>c){if((b-=3)<0)break;f.push(c>>12|224,c>>6&63|128,63&c|128)}else{if(!(1114112>c))throw new Error("Invalid code point");if((b-=4)<0)break;f.push(c>>18|240,c>>12&63|128,c>>6&63|128,63&c|128)}}return f}function S(a){for(var b=[],c=0;c>8,e=c%256,f.push(e),f.push(d);return f}function U(a){return W.toByteArray(O(a))}function V(a,b,c,d){for(var e=0;d>e&&!(e+c>=b.length||e>=a.length);e++)b[e+c]=a[e];return e}var W=a("base64-js"),X=a("ieee754"),Y=a("is-array");c.Buffer=f,c.SlowBuffer=r,c.INSPECT_MAX_BYTES=50,f.poolSize=8192;var Z={};f.TYPED_ARRAY_SUPPORT=void 0!==b.TYPED_ARRAY_SUPPORT?b.TYPED_ARRAY_SUPPORT:d(),f.TYPED_ARRAY_SUPPORT&&(f.prototype.__proto__=Uint8Array.prototype,f.__proto__=Uint8Array),f.isBuffer=function(a){return!(null==a||!a._isBuffer)},f.compare=function(a,b){if(!f.isBuffer(a)||!f.isBuffer(b))throw new TypeError("Arguments must be Buffers");if(a===b)return 0;for(var c=a.length,d=b.length,e=0,g=Math.min(c,d);g>e&&a[e]===b[e];)++e;return e!==g&&(c=a[e],d=b[e]),d>c?-1:c>d?1:0},f.isEncoding=function(a){switch(String(a).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"raw":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},f.concat=function(a,b){if(!Y(a))throw new TypeError("list argument must be an Array of Buffers.");if(0===a.length)return new f(0);var c;if(void 0===b)for(b=0,c=0;c0&&(a=this.toString("hex",0,b).match(/.{2}/g).join(" "),this.length>b&&(a+=" ... ")),""},f.prototype.compare=function(a){if(!f.isBuffer(a))throw new TypeError("Argument must be a Buffer");return this===a?0:f.compare(this,a)},f.prototype.indexOf=function(a,b){function c(a,b,c){for(var d=-1,e=0;c+e2147483647?b=2147483647:-2147483648>b&&(b=-2147483648),b>>=0,0===this.length)return-1;if(b>=this.length)return-1;if(0>b&&(b=Math.max(this.length+b,0)),"string"==typeof a)return 0===a.length?-1:String.prototype.indexOf.call(this,a,b);if(f.isBuffer(a))return c(this,a,b);if("number"==typeof a)return f.TYPED_ARRAY_SUPPORT&&"function"===Uint8Array.prototype.indexOf?Uint8Array.prototype.indexOf.call(this,a,b):c(this,[a],b);throw new TypeError("val must be string, number or Buffer")},f.prototype.get=function(a){return console.log(".get() is deprecated. Access using array indexes instead."),this.readUInt8(a)},f.prototype.set=function(a,b){return console.log(".set() is deprecated. Access using array indexes instead."),this.writeUInt8(a,b)},f.prototype.write=function(a,b,c,d){if(void 0===b)d="utf8",c=this.length,b=0;else if(void 0===c&&"string"==typeof b)d=b,c=this.length,b=0;else if(isFinite(b))b=0|b,isFinite(c)?(c=0|c,void 0===d&&(d="utf8")):(d=c,c=void 0);else{var e=d;d=b,b=0|c,c=e}var f=this.length-b;if((void 0===c||c>f)&&(c=f),a.length>0&&(0>c||0>b)||b>this.length)throw new RangeError("attempt to write outside buffer bounds");d||(d="utf8");for(var g=!1;;)switch(d){case"hex":return u(this,a,b,c);case"utf8":case"utf-8":return v(this,a,b,c);case"ascii":return w(this,a,b,c);case"binary":return x(this,a,b,c);case"base64":return y(this,a,b,c);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return z(this,a,b,c);default:if(g)throw new TypeError("Unknown encoding: "+d);d=(""+d).toLowerCase(),g=!0}},f.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var $=4096;f.prototype.slice=function(a,b){var c=this.length;a=~~a,b=void 0===b?c:~~b,0>a?(a+=c,0>a&&(a=0)):a>c&&(a=c),0>b?(b+=c,0>b&&(b=0)):b>c&&(b=c),a>b&&(b=a);var d;if(f.TYPED_ARRAY_SUPPORT)d=f._augment(this.subarray(a,b));else{var e=b-a;d=new f(e,void 0);for(var g=0;e>g;g++)d[g]=this[g+a]}return d.length&&(d.parent=this.parent||this),d},f.prototype.readUIntLE=function(a,b,c){a=0|a,b=0|b,c||H(a,b,this.length);for(var d=this[a],e=1,f=0;++f0&&(e*=256);)d+=this[a+--b]*e;return d},f.prototype.readUInt8=function(a,b){return b||H(a,1,this.length),this[a]},f.prototype.readUInt16LE=function(a,b){return b||H(a,2,this.length),this[a]|this[a+1]<<8},f.prototype.readUInt16BE=function(a,b){return b||H(a,2,this.length),this[a]<<8|this[a+1]},f.prototype.readUInt32LE=function(a,b){return b||H(a,4,this.length),(this[a]|this[a+1]<<8|this[a+2]<<16)+16777216*this[a+3]},f.prototype.readUInt32BE=function(a,b){return b||H(a,4,this.length),16777216*this[a]+(this[a+1]<<16|this[a+2]<<8|this[a+3])},f.prototype.readIntLE=function(a,b,c){a=0|a,b=0|b,c||H(a,b,this.length);for(var d=this[a],e=1,f=0;++f=e&&(d-=Math.pow(2,8*b)),d},f.prototype.readIntBE=function(a,b,c){a=0|a,b=0|b,c||H(a,b,this.length);for(var d=b,e=1,f=this[a+--d];d>0&&(e*=256);)f+=this[a+--d]*e;return e*=128,f>=e&&(f-=Math.pow(2,8*b)),f},f.prototype.readInt8=function(a,b){return b||H(a,1,this.length),128&this[a]?-1*(255-this[a]+1):this[a]},f.prototype.readInt16LE=function(a,b){b||H(a,2,this.length);var c=this[a]|this[a+1]<<8;return 32768&c?4294901760|c:c},f.prototype.readInt16BE=function(a,b){b||H(a,2,this.length);var c=this[a+1]|this[a]<<8;return 32768&c?4294901760|c:c},f.prototype.readInt32LE=function(a,b){return b||H(a,4,this.length),this[a]|this[a+1]<<8|this[a+2]<<16|this[a+3]<<24},f.prototype.readInt32BE=function(a,b){return b||H(a,4,this.length),this[a]<<24|this[a+1]<<16|this[a+2]<<8|this[a+3]},f.prototype.readFloatLE=function(a,b){return b||H(a,4,this.length),X.read(this,a,!0,23,4)},f.prototype.readFloatBE=function(a,b){return b||H(a,4,this.length),X.read(this,a,!1,23,4)},f.prototype.readDoubleLE=function(a,b){return b||H(a,8,this.length),X.read(this,a,!0,52,8)},f.prototype.readDoubleBE=function(a,b){return b||H(a,8,this.length),X.read(this,a,!1,52,8)},f.prototype.writeUIntLE=function(a,b,c,d){a=+a,b=0|b,c=0|c,d||I(this,a,b,c,Math.pow(2,8*c),0);var e=1,f=0;for(this[b]=255&a;++f=0&&(f*=256);)this[b+e]=a/f&255;return b+c},f.prototype.writeUInt8=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,1,255,0),f.TYPED_ARRAY_SUPPORT||(a=Math.floor(a)),this[b]=255&a,b+1},f.prototype.writeUInt16LE=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,2,65535,0),f.TYPED_ARRAY_SUPPORT?(this[b]=255&a,this[b+1]=a>>>8):J(this,a,b,!0),b+2},f.prototype.writeUInt16BE=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,2,65535,0),f.TYPED_ARRAY_SUPPORT?(this[b]=a>>>8,this[b+1]=255&a):J(this,a,b,!1),b+2},f.prototype.writeUInt32LE=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,4,4294967295,0),f.TYPED_ARRAY_SUPPORT?(this[b+3]=a>>>24,this[b+2]=a>>>16,this[b+1]=a>>>8,this[b]=255&a):K(this,a,b,!0),b+4},f.prototype.writeUInt32BE=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,4,4294967295,0),f.TYPED_ARRAY_SUPPORT?(this[b]=a>>>24,this[b+1]=a>>>16,this[b+2]=a>>>8,this[b+3]=255&a):K(this,a,b,!1),b+4},f.prototype.writeIntLE=function(a,b,c,d){if(a=+a,b=0|b,!d){var e=Math.pow(2,8*c-1);I(this,a,b,c,e-1,-e)}var f=0,g=1,h=0>a?1:0;for(this[b]=255&a;++f>0)-h&255;return b+c},f.prototype.writeIntBE=function(a,b,c,d){if(a=+a,b=0|b,!d){var e=Math.pow(2,8*c-1);I(this,a,b,c,e-1,-e)}var f=c-1,g=1,h=0>a?1:0;for(this[b+f]=255&a;--f>=0&&(g*=256);)this[b+f]=(a/g>>0)-h&255;return b+c},f.prototype.writeInt8=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,1,127,-128),f.TYPED_ARRAY_SUPPORT||(a=Math.floor(a)),0>a&&(a=255+a+1),this[b]=255&a,b+1},f.prototype.writeInt16LE=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,2,32767,-32768),f.TYPED_ARRAY_SUPPORT?(this[b]=255&a,this[b+1]=a>>>8):J(this,a,b,!0),b+2},f.prototype.writeInt16BE=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,2,32767,-32768),f.TYPED_ARRAY_SUPPORT?(this[b]=a>>>8,this[b+1]=255&a):J(this,a,b,!1),b+2},f.prototype.writeInt32LE=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,4,2147483647,-2147483648),f.TYPED_ARRAY_SUPPORT?(this[b]=255&a,this[b+1]=a>>>8,this[b+2]=a>>>16,this[b+3]=a>>>24):K(this,a,b,!0),b+4},f.prototype.writeInt32BE=function(a,b,c){return a=+a,b=0|b,c||I(this,a,b,4,2147483647,-2147483648),0>a&&(a=4294967295+a+1),f.TYPED_ARRAY_SUPPORT?(this[b]=a>>>24,this[b+1]=a>>>16,this[b+2]=a>>>8,this[b+3]=255&a):K(this,a,b,!1),b+4},f.prototype.writeFloatLE=function(a,b,c){return M(this,a,b,!0,c)},f.prototype.writeFloatBE=function(a,b,c){return M(this,a,b,!1,c)},f.prototype.writeDoubleLE=function(a,b,c){return N(this,a,b,!0,c)},f.prototype.writeDoubleBE=function(a,b,c){ +return N(this,a,b,!1,c)},f.prototype.copy=function(a,b,c,d){if(c||(c=0),d||0===d||(d=this.length),b>=a.length&&(b=a.length),b||(b=0),d>0&&c>d&&(d=c),d===c)return 0;if(0===a.length||0===this.length)return 0;if(0>b)throw new RangeError("targetStart out of bounds");if(0>c||c>=this.length)throw new RangeError("sourceStart out of bounds");if(0>d)throw new RangeError("sourceEnd out of bounds");d>this.length&&(d=this.length),a.length-bc&&d>b)for(e=g-1;e>=0;e--)a[e+b]=this[e+c];else if(1e3>g||!f.TYPED_ARRAY_SUPPORT)for(e=0;g>e;e++)a[e+b]=this[e+c];else a._set(this.subarray(c,c+g),b);return g},f.prototype.fill=function(a,b,c){if(a||(a=0),b||(b=0),c||(c=this.length),b>c)throw new RangeError("end < start");if(c!==b&&0!==this.length){if(0>b||b>=this.length)throw new RangeError("start out of bounds");if(0>c||c>this.length)throw new RangeError("end out of bounds");var d;if("number"==typeof a)for(d=b;c>d;d++)this[d]=a;else{var e=R(a.toString()),f=e.length;for(d=b;c>d;d++)this[d]=e[d%f]}return this}},f.prototype.toArrayBuffer=function(){if("undefined"!=typeof Uint8Array){if(f.TYPED_ARRAY_SUPPORT)return new f(this).buffer;for(var a=new Uint8Array(this.length),b=0,c=a.length;c>b;b+=1)a[b]=this[b];return a.buffer}throw new TypeError("Buffer.toArrayBuffer not supported in this browser")};var _=f.prototype;f._augment=function(a){return a.constructor=f,a._isBuffer=!0,a._set=a.set,a.get=_.get,a.set=_.set,a.write=_.write,a.toString=_.toString,a.toLocaleString=_.toString,a.toJSON=_.toJSON,a.equals=_.equals,a.compare=_.compare,a.indexOf=_.indexOf,a.copy=_.copy,a.slice=_.slice,a.readUIntLE=_.readUIntLE,a.readUIntBE=_.readUIntBE,a.readUInt8=_.readUInt8,a.readUInt16LE=_.readUInt16LE,a.readUInt16BE=_.readUInt16BE,a.readUInt32LE=_.readUInt32LE,a.readUInt32BE=_.readUInt32BE,a.readIntLE=_.readIntLE,a.readIntBE=_.readIntBE,a.readInt8=_.readInt8,a.readInt16LE=_.readInt16LE,a.readInt16BE=_.readInt16BE,a.readInt32LE=_.readInt32LE,a.readInt32BE=_.readInt32BE,a.readFloatLE=_.readFloatLE,a.readFloatBE=_.readFloatBE,a.readDoubleLE=_.readDoubleLE,a.readDoubleBE=_.readDoubleBE,a.writeUInt8=_.writeUInt8,a.writeUIntLE=_.writeUIntLE,a.writeUIntBE=_.writeUIntBE,a.writeUInt16LE=_.writeUInt16LE,a.writeUInt16BE=_.writeUInt16BE,a.writeUInt32LE=_.writeUInt32LE,a.writeUInt32BE=_.writeUInt32BE,a.writeIntLE=_.writeIntLE,a.writeIntBE=_.writeIntBE,a.writeInt8=_.writeInt8,a.writeInt16LE=_.writeInt16LE,a.writeInt16BE=_.writeInt16BE,a.writeInt32LE=_.writeInt32LE,a.writeInt32BE=_.writeInt32BE,a.writeFloatLE=_.writeFloatLE,a.writeFloatBE=_.writeFloatBE,a.writeDoubleLE=_.writeDoubleLE,a.writeDoubleBE=_.writeDoubleBE,a.fill=_.fill,a.inspect=_.inspect,a.toArrayBuffer=_.toArrayBuffer,a};var aa=/[^+\/0-9A-Za-z-_]/g}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"base64-js":27,ieee754:44,"is-array":46}],39:[function(a,b,c){function d(a){return a?e(a):void 0}function e(a){for(var b in d.prototype)a[b]=d.prototype[b];return a}b.exports=d,d.prototype.on=d.prototype.addEventListener=function(a,b){return this._callbacks=this._callbacks||{},(this._callbacks[a]=this._callbacks[a]||[]).push(b),this},d.prototype.once=function(a,b){function c(){d.off(a,c),b.apply(this,arguments)}var d=this;return this._callbacks=this._callbacks||{},c.fn=b,this.on(a,c),this},d.prototype.off=d.prototype.removeListener=d.prototype.removeAllListeners=d.prototype.removeEventListener=function(a,b){if(this._callbacks=this._callbacks||{},0==arguments.length)return this._callbacks={},this;var c=this._callbacks[a];if(!c)return this;if(1==arguments.length)return delete this._callbacks[a],this;for(var d,e=0;ed;++d)c[d].apply(this,b)}return this},d.prototype.listeners=function(a){return this._callbacks=this._callbacks||{},this._callbacks[a]||[]},d.prototype.hasListeners=function(a){return!!this.listeners(a).length}},{}],40:[function(a,b,c){(function(a){function b(a){return Array.isArray?Array.isArray(a):"[object Array]"===q(a)}function d(a){return"boolean"==typeof a}function e(a){return null===a}function f(a){return null==a}function g(a){return"number"==typeof a}function h(a){return"string"==typeof a}function i(a){return"symbol"==typeof a}function j(a){return void 0===a}function k(a){return"[object RegExp]"===q(a)}function l(a){return"object"==typeof a&&null!==a}function m(a){return"[object Date]"===q(a)}function n(a){return"[object Error]"===q(a)||a instanceof Error}function o(a){return"function"==typeof a}function p(a){return null===a||"boolean"==typeof a||"number"==typeof a||"string"==typeof a||"symbol"==typeof a||"undefined"==typeof a}function q(a){return Object.prototype.toString.call(a)}c.isArray=b,c.isBoolean=d,c.isNull=e,c.isNullOrUndefined=f,c.isNumber=g,c.isString=h,c.isSymbol=i,c.isUndefined=j,c.isRegExp=k,c.isObject=l,c.isDate=m,c.isError=n,c.isFunction=o,c.isPrimitive=p,c.isBuffer=a.isBuffer}).call(this,{isBuffer:a("../../is-buffer/index.js")})},{"../../is-buffer/index.js":47}],41:[function(a,b,c){function d(){return"WebkitAppearance"in document.documentElement.style||window.console&&(console.firebug||console.exception&&console.table)||navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)&&parseInt(RegExp.$1,10)>=31}function e(){var a=arguments,b=this.useColors;if(a[0]=(b?"%c":"")+this.namespace+(b?" %c":" ")+a[0]+(b?"%c ":" ")+"+"+c.humanize(this.diff),!b)return a;var d="color: "+this.color;a=[a[0],d,"color: inherit"].concat(Array.prototype.slice.call(a,1));var e=0,f=0;return a[0].replace(/%[a-z%]/g,function(a){"%%"!==a&&(e++,"%c"===a&&(f=e))}),a.splice(f,0,d),a}function f(){return"object"==typeof console&&console.log&&Function.prototype.apply.call(console.log,console,arguments)}function g(a){try{null==a?c.storage.removeItem("debug"):c.storage.debug=a}catch(b){}}function h(){var a;try{a=c.storage.debug}catch(b){}return a}function i(){try{return window.localStorage}catch(a){}}c=b.exports=a("./debug"),c.log=f,c.formatArgs=e,c.save=g,c.load=h,c.useColors=d,c.storage="undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage?chrome.storage.local:i(),c.colors=["lightseagreen","forestgreen","goldenrod","dodgerblue","darkorchid","crimson"],c.formatters.j=function(a){return JSON.stringify(a)},c.enable(h())},{"./debug":42}],42:[function(a,b,c){function d(){return c.colors[k++%c.colors.length]}function e(a){function b(){}function e(){var a=e,b=+new Date,f=b-(j||b);a.diff=f,a.prev=j,a.curr=b,j=b,null==a.useColors&&(a.useColors=c.useColors()),null==a.color&&a.useColors&&(a.color=d());var g=Array.prototype.slice.call(arguments);g[0]=c.coerce(g[0]),"string"!=typeof g[0]&&(g=["%o"].concat(g));var h=0;g[0]=g[0].replace(/%([a-z%])/g,function(b,d){if("%%"===b)return b;h++;var e=c.formatters[d];if("function"==typeof e){var f=g[h];b=e.call(a,f),g.splice(h,1),h--}return b}),"function"==typeof c.formatArgs&&(g=c.formatArgs.apply(a,g));var i=e.log||c.log||console.log.bind(console);i.apply(a,g)}b.enabled=!1,e.enabled=!0;var f=c.enabled(a)?e:b;return f.namespace=a,f}function f(a){c.save(a);for(var b=(a||"").split(/[\s,]+/),d=b.length,e=0;d>e;e++)b[e]&&(a=b[e].replace(/\*/g,".*?"),"-"===a[0]?c.skips.push(new RegExp("^"+a.substr(1)+"$")):c.names.push(new RegExp("^"+a+"$")))}function g(){c.enable("")}function h(a){var b,d;for(b=0,d=c.skips.length;d>b;b++)if(c.skips[b].test(a))return!1;for(b=0,d=c.names.length;d>b;b++)if(c.names[b].test(a))return!0;return!1}function i(a){return a instanceof Error?a.stack||a.message:a}c=b.exports=e,c.coerce=i,c.disable=g,c.enable=f,c.enabled=h,c.humanize=a("ms"),c.names=[],c.skips=[],c.formatters={};var j,k=0},{ms:49}],43:[function(a,b,c){function d(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function e(a){return"function"==typeof a}function f(a){return"number"==typeof a}function g(a){return"object"==typeof a&&null!==a}function h(a){return void 0===a}b.exports=d,d.EventEmitter=d,d.prototype._events=void 0,d.prototype._maxListeners=void 0,d.defaultMaxListeners=10,d.prototype.setMaxListeners=function(a){if(!f(a)||0>a||isNaN(a))throw TypeError("n must be a positive number");return this._maxListeners=a,this},d.prototype.emit=function(a){var b,c,d,f,i,j;if(this._events||(this._events={}),"error"===a&&(!this._events.error||g(this._events.error)&&!this._events.error.length)){if(b=arguments[1],b instanceof Error)throw b;throw TypeError('Uncaught, unspecified "error" event.')}if(c=this._events[a],h(c))return!1;if(e(c))switch(arguments.length){case 1:c.call(this);break;case 2:c.call(this,arguments[1]);break;case 3:c.call(this,arguments[1],arguments[2]);break;default:for(d=arguments.length,f=new Array(d-1),i=1;d>i;i++)f[i-1]=arguments[i];c.apply(this,f)}else if(g(c)){for(d=arguments.length,f=new Array(d-1),i=1;d>i;i++)f[i-1]=arguments[i];for(j=c.slice(),d=j.length,i=0;d>i;i++)j[i].apply(this,f)}return!0},d.prototype.addListener=function(a,b){var c;if(!e(b))throw TypeError("listener must be a function");if(this._events||(this._events={}),this._events.newListener&&this.emit("newListener",a,e(b.listener)?b.listener:b),this._events[a]?g(this._events[a])?this._events[a].push(b):this._events[a]=[this._events[a],b]:this._events[a]=b,g(this._events[a])&&!this._events[a].warned){var c;c=h(this._maxListeners)?d.defaultMaxListeners:this._maxListeners,c&&c>0&&this._events[a].length>c&&(this._events[a].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[a].length),"function"==typeof console.trace&&console.trace())}return this},d.prototype.on=d.prototype.addListener,d.prototype.once=function(a,b){function c(){this.removeListener(a,c),d||(d=!0,b.apply(this,arguments))}if(!e(b))throw TypeError("listener must be a function");var d=!1;return c.listener=b,this.on(a,c),this},d.prototype.removeListener=function(a,b){var c,d,f,h;if(!e(b))throw TypeError("listener must be a function");if(!this._events||!this._events[a])return this;if(c=this._events[a],f=c.length,d=-1,c===b||e(c.listener)&&c.listener===b)delete this._events[a],this._events.removeListener&&this.emit("removeListener",a,b);else if(g(c)){for(h=f;h-- >0;)if(c[h]===b||c[h].listener&&c[h].listener===b){d=h;break}if(0>d)return this;1===c.length?(c.length=0,delete this._events[a]):c.splice(d,1),this._events.removeListener&&this.emit("removeListener",a,b)}return this},d.prototype.removeAllListeners=function(a){var b,c;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[a]&&delete this._events[a],this;if(0===arguments.length){for(b in this._events)"removeListener"!==b&&this.removeAllListeners(b);return this.removeAllListeners("removeListener"),this._events={},this}if(c=this._events[a],e(c))this.removeListener(a,c);else for(;c.length;)this.removeListener(a,c[c.length-1]);return delete this._events[a],this},d.prototype.listeners=function(a){var b;return b=this._events&&this._events[a]?e(this._events[a])?[this._events[a]]:this._events[a].slice():[]},d.listenerCount=function(a,b){var c;return c=a._events&&a._events[b]?e(a._events[b])?1:a._events[b].length:0}},{}],44:[function(a,b,c){c.read=function(a,b,c,d,e){var f,g,h=8*e-d-1,i=(1<>1,k=-7,l=c?e-1:0,m=c?-1:1,n=a[b+l];for(l+=m,f=n&(1<<-k)-1,n>>=-k,k+=h;k>0;f=256*f+a[b+l],l+=m,k-=8);for(g=f&(1<<-k)-1,f>>=-k,k+=d;k>0;g=256*g+a[b+l],l+=m,k-=8);if(0===f)f=1-j;else{if(f===i)return g?NaN:(n?-1:1)*(1/0);g+=Math.pow(2,d),f-=j}return(n?-1:1)*g*Math.pow(2,f-d)},c.write=function(a,b,c,d,e,f){var g,h,i,j=8*f-e-1,k=(1<>1,m=23===e?Math.pow(2,-24)-Math.pow(2,-77):0,n=d?0:f-1,o=d?1:-1,p=0>b||0===b&&0>1/b?1:0;for(b=Math.abs(b),isNaN(b)||b===1/0?(h=isNaN(b)?1:0,g=k):(g=Math.floor(Math.log(b)/Math.LN2),b*(i=Math.pow(2,-g))<1&&(g--,i*=2),b+=g+l>=1?m/i:m*Math.pow(2,1-l),b*i>=2&&(g++,i/=2),g+l>=k?(h=0,g=k):g+l>=1?(h=(b*i-1)*Math.pow(2,e),g+=l):(h=b*Math.pow(2,l-1)*Math.pow(2,e),g=0));e>=8;a[c+n]=255&h,n+=o,h/=256,e-=8);for(g=g<0;a[c+n]=255&g,n+=o,g/=256,j-=8);a[c+n-o]|=128*p}},{}],45:[function(a,b,c){"function"==typeof Object.create?b.exports=function(a,b){a.super_=b,a.prototype=Object.create(b.prototype,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}})}:b.exports=function(a,b){a.super_=b;var c=function(){};c.prototype=b.prototype,a.prototype=new c,a.prototype.constructor=a}},{}],46:[function(a,b,c){var d=Array.isArray,e=Object.prototype.toString;b.exports=d||function(a){return!!a&&"[object Array]"==e.call(a)}},{}],47:[function(a,b,c){b.exports=function(a){return!(null==a||!(a._isBuffer||a.constructor&&"function"==typeof a.constructor.isBuffer&&a.constructor.isBuffer(a)))}},{}],48:[function(a,b,c){b.exports=Array.isArray||function(a){return"[object Array]"==Object.prototype.toString.call(a)}},{}],49:[function(a,b,c){function d(a){if(a=""+a,!(a.length>1e4)){var b=/^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(a);if(b){var c=parseFloat(b[1]),d=(b[2]||"ms").toLowerCase();switch(d){case"years":case"year":case"yrs":case"yr":case"y":return c*l;case"days":case"day":case"d":return c*k;case"hours":case"hour":case"hrs":case"hr":case"h":return c*j;case"minutes":case"minute":case"mins":case"min":case"m":return c*i;case"seconds":case"second":case"secs":case"sec":case"s":return c*h;case"milliseconds":case"millisecond":case"msecs":case"msec":case"ms":return c}}}}function e(a){return a>=k?Math.round(a/k)+"d":a>=j?Math.round(a/j)+"h":a>=i?Math.round(a/i)+"m":a>=h?Math.round(a/h)+"s":a+"ms"}function f(a){return g(a,k,"day")||g(a,j,"hour")||g(a,i,"minute")||g(a,h,"second")||a+" ms"}function g(a,b,c){return b>a?void 0:1.5*b>a?Math.floor(a/b)+" "+c:Math.ceil(a/b)+" "+c+"s"}var h=1e3,i=60*h,j=60*i,k=24*j,l=365.25*k;b.exports=function(a,b){return b=b||{},"string"==typeof a?d(a):b["long"]?f(a):e(a)}},{}],50:[function(a,b,c){"use strict";var d=a("./lib/OpusEncoder"),e=a("./lib/Encoder"),f=a("./lib/Decoder");c.OpusEncoder=d,c.Encoder=e,c.Decoder=f},{"./lib/Decoder":51,"./lib/Encoder":52,"./lib/OpusEncoder":53}],51:[function(a,b,c){var d=a("util"),e=a("stream").Transform,f=(a("ogg-packet"),a("./OpusEncoder")),g=function(a,b,c){e.call(this,{readableObjectMode:!0}),this.rate=a||48e3,this.channels=b||1,this.frameSize=c||.04*this.rate,this.encoder=null,this.header={},this.tags=null,this.pos=0,this.samplesWritten=0,this.packetBuffer=[]};d.inherits(g,e),g.prototype._transform=function(a,b,c){this.encoder?this.tags?this._processInput(a):this.tags={}:this._parseHeader(a),c()},g.prototype._parseHeader=function(a){var b=a.packet,c=b.slice(0,8);return"OpusHead"!==c.toString("ascii")?this.emit("error","Bad header"):(this.header.version=b.readUInt8(8),this.header.channels=b.readUInt8(9),this.header.preSkip=b.readUInt16LE(10),this.header.rate=b.readUInt32LE(12),this.header.gain=b.readUInt16LE(16),this.header.channelMap=b.readUInt8(18),this.emit("format",{channels:this.header.channels,sampleRate:this.header.rate,bitDepth:16,"float":!1,signed:!0,gain:this.header.gain,preSkip:this.header.preSkip,version:this.header.version}),void(this.encoder=new f(this.header.rate,this.header.channels)))},g.prototype._processInput=function(a){var b=a.packet,c=this.encoder.decode(b);this.push(c)},b.exports=g},{"./OpusEncoder":53,"ogg-packet":54,stream:75,util:90}],52:[function(a,b,c){(function(c){var d=a("util"),e=a("stream").Transform,f=a("ogg-packet"),g=a("./OpusEncoder"),h=function(a,b,d){e.call(this,{readableObjectMode:!0}),this.rate=a||48e3,this.channels=b||1,this.frameSize=d||.04*this.rate,this.encoder=new g(this.rate,this.channels),this.frameOverflow=new c(0),this.headerWritten=!1,this.pos=0,this.samplesWritten=0};d.inherits(h,e),h.prototype._transform=function(a,b,c){this.headerWritten||this._writeHeader(),this._processOutput(a),c()},h.prototype._writeHeader=function(){var a=new c("OpusHead","ascii"),b=new c([1,this.channels,0,0,(255&this.rate)>>0,(65280&this.rate)>>8,(16711680&this.rate)>>16,(4278190080&this.rate)>>24,0,0,0]),d=c.concat([a,b]),e=new f;e.packet=d,e.bytes=d.length,e.b_o_s=1,e.e_o_s=0,e.granulepos=0,e.packetno=this.pos++,this.push(e),a=new c("OpusTags","ascii");var g=new c("node-opus","ascii"),h=new c(4);h.writeUInt32LE(g.length,0);var i=new c(4);i.writeUInt32LE(0,0),d=new c.concat([a,h,g,i,new c([255])]),e=new f,e.packet=d,e.bytes=d.length,e.b_o_s=0,e.e_o_s=0,e.granulepos=0,e.packetno=this.pos++,e.flush=!0,this.push(e),this.headerWritten=!0},h.prototype._processOutput=function(a){for(var b=a.length+this.frameOverflow.length,d=2*this.frameSize*this.channels;b>=d;){var e;this.frameOverflow?(e=c.concat([this.frameOverflow,a.slice(0,d-this.frameOverflow.length)]),a=a.slice(d-this.frameOverflow.length),this.frameOverflow=null):(e=a.slice(0,d),a=a.slice(d)),this._flushFrame(e),b-=d}this.frameOverflow=a},h.prototype._flushFrame=function(a,b){var c=this.encoder.encode(a),d=new f;d.packet=c,d.bytes=c.length,d.b_o_s=0,d.e_o_s=0,d.granulepos=this.samplesWritten,d.packetno=this.pos++,d.flush=!0,this.samplesWritten+=this.frameSize,this.push(d)},h.prototype._flush=function(a){var b=new f;b.packet=new c(0),b.bytes=0,b.b_o_s=0,b.e_o_s=1,b.granulepos=this.pos,b.packetno=this.pos++,b.flush=!0,this.push(b),a()},b.exports=h}).call(this,a("buffer").Buffer)},{"./OpusEncoder":53,buffer:38,"ogg-packet":54,stream:75,util:90}],53:[function(a,b,c){"use strict";var d=a("bindings")("node-opus");b.exports=d.OpusEncoder},{bindings:28}],54:[function(a,b,c){var d=a("ref-struct");b.exports=d({packet:"uchar *",bytes:"long",b_o_s:"long",e_o_s:"long",granulepos:"int64",packetno:"int64"})},{"ref-struct":73}],55:[function(a,b,c){"use strict";var d="undefined"!=typeof Uint8Array&&"undefined"!=typeof Uint16Array&&"undefined"!=typeof Int32Array;c.assign=function(a){for(var b=Array.prototype.slice.call(arguments,1);b.length;){var c=b.shift();if(c){if("object"!=typeof c)throw new TypeError(c+"must be non-object");for(var d in c)c.hasOwnProperty(d)&&(a[d]=c[d])}}return a},c.shrinkBuf=function(a,b){return a.length===b?a:a.subarray?a.subarray(0,b):(a.length=b,a)};var e={arraySet:function(a,b,c,d,e){if(b.subarray&&a.subarray)return void a.set(b.subarray(c,c+d),e);for(var f=0;d>f;f++)a[e+f]=b[c+f]},flattenChunks:function(a){var b,c,d,e,f,g;for(d=0,b=0,c=a.length;c>b;b++)d+=a[b].length;for(g=new Uint8Array(d),e=0,b=0,c=a.length;c>b;b++)f=a[b],g.set(f,e),e+=f.length;return g}},f={arraySet:function(a,b,c,d,e){for(var f=0;d>f;f++)a[e+f]=b[c+f]},flattenChunks:function(a){return[].concat.apply([],a)}};c.setTyped=function(a){a?(c.Buf8=Uint8Array,c.Buf16=Uint16Array,c.Buf32=Int32Array,c.assign(c,e)):(c.Buf8=Array,c.Buf16=Array,c.Buf32=Array,c.assign(c,f))},c.setTyped(d)},{}],56:[function(a,b,c){"use strict";function d(a,b,c,d){for(var e=65535&a|0,f=a>>>16&65535|0,g=0;0!==c;){g=c>2e3?2e3:c,c-=g;do e=e+b[d++]|0,f=f+e|0;while(--g);e%=65521,f%=65521}return e|f<<16|0}b.exports=d},{}],57:[function(a,b,c){b.exports={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8}},{}],58:[function(a,b,c){"use strict";function d(){for(var a,b=[],c=0;256>c;c++){a=c;for(var d=0;8>d;d++)a=1&a?3988292384^a>>>1:a>>>1;b[c]=a}return b}function e(a,b,c,d){var e=f,g=d+c;a=-1^a;for(var h=d;g>h;h++)a=a>>>8^e[255&(a^b[h])];return-1^a}var f=d();b.exports=e},{}],59:[function(a,b,c){"use strict";function d(a,b){return a.msg=G[b],b}function e(a){return(a<<1)-(a>4?9:0)}function f(a){for(var b=a.length;--b>=0;)a[b]=0}function g(a){var b=a.state,c=b.pending;c>a.avail_out&&(c=a.avail_out),0!==c&&(C.arraySet(a.output,b.pending_buf,b.pending_out,c,a.next_out),a.next_out+=c,b.pending_out+=c,a.total_out+=c,a.avail_out-=c,b.pending-=c,0===b.pending&&(b.pending_out=0))}function h(a,b){D._tr_flush_block(a,a.block_start>=0?a.block_start:-1,a.strstart-a.block_start,b),a.block_start=a.strstart,g(a.strm)}function i(a,b){a.pending_buf[a.pending++]=b}function j(a,b){a.pending_buf[a.pending++]=b>>>8&255,a.pending_buf[a.pending++]=255&b}function k(a,b,c,d){var e=a.avail_in;return e>d&&(e=d),0===e?0:(a.avail_in-=e,C.arraySet(b,a.input,a.next_in,e,c),1===a.state.wrap?a.adler=E(a.adler,b,e,c):2===a.state.wrap&&(a.adler=F(a.adler,b,e,c)),a.next_in+=e,a.total_in+=e,e)}function l(a,b){var c,d,e=a.max_chain_length,f=a.strstart,g=a.prev_length,h=a.nice_match,i=a.strstart>a.w_size-ja?a.strstart-(a.w_size-ja):0,j=a.window,k=a.w_mask,l=a.prev,m=a.strstart+ia,n=j[f+g-1],o=j[f+g];a.prev_length>=a.good_match&&(e>>=2),h>a.lookahead&&(h=a.lookahead);do if(c=b,j[c+g]===o&&j[c+g-1]===n&&j[c]===j[f]&&j[++c]===j[f+1]){f+=2,c++;do;while(j[++f]===j[++c]&&j[++f]===j[++c]&&j[++f]===j[++c]&&j[++f]===j[++c]&&j[++f]===j[++c]&&j[++f]===j[++c]&&j[++f]===j[++c]&&j[++f]===j[++c]&&m>f);if(d=ia-(m-f),f=m-ia,d>g){if(a.match_start=b,g=d,d>=h)break;n=j[f+g-1],o=j[f+g]}}while((b=l[b&k])>i&&0!==--e);return g<=a.lookahead?g:a.lookahead}function m(a){var b,c,d,e,f,g=a.w_size;do{if(e=a.window_size-a.lookahead-a.strstart,a.strstart>=g+(g-ja)){C.arraySet(a.window,a.window,g,g,0),a.match_start-=g,a.strstart-=g,a.block_start-=g,c=a.hash_size,b=c;do d=a.head[--b],a.head[b]=d>=g?d-g:0;while(--c);c=g,b=c;do d=a.prev[--b],a.prev[b]=d>=g?d-g:0;while(--c);e+=g}if(0===a.strm.avail_in)break;if(c=k(a.strm,a.window,a.strstart+a.lookahead,e),a.lookahead+=c,a.lookahead+a.insert>=ha)for(f=a.strstart-a.insert,a.ins_h=a.window[f],a.ins_h=(a.ins_h<a.pending_buf_size-5&&(c=a.pending_buf_size-5);;){if(a.lookahead<=1){if(m(a),0===a.lookahead&&b===H)return sa;if(0===a.lookahead)break}a.strstart+=a.lookahead,a.lookahead=0;var d=a.block_start+c;if((0===a.strstart||a.strstart>=d)&&(a.lookahead=a.strstart-d,a.strstart=d,h(a,!1),0===a.strm.avail_out))return sa;if(a.strstart-a.block_start>=a.w_size-ja&&(h(a,!1),0===a.strm.avail_out))return sa}return a.insert=0,b===K?(h(a,!0),0===a.strm.avail_out?ua:va):a.strstart>a.block_start&&(h(a,!1),0===a.strm.avail_out)?sa:sa}function o(a,b){for(var c,d;;){if(a.lookahead=ha&&(a.ins_h=(a.ins_h<=ha)if(d=D._tr_tally(a,a.strstart-a.match_start,a.match_length-ha),a.lookahead-=a.match_length,a.match_length<=a.max_lazy_match&&a.lookahead>=ha){a.match_length--;do a.strstart++,a.ins_h=(a.ins_h<=ha&&(a.ins_h=(a.ins_h<4096)&&(a.match_length=ha-1)),a.prev_length>=ha&&a.match_length<=a.prev_length){e=a.strstart+a.lookahead-ha,d=D._tr_tally(a,a.strstart-1-a.prev_match,a.prev_length-ha),a.lookahead-=a.prev_length-1,a.prev_length-=2;do++a.strstart<=e&&(a.ins_h=(a.ins_h<=ha&&a.strstart>0&&(e=a.strstart-1,d=g[e],d===g[++e]&&d===g[++e]&&d===g[++e])){f=a.strstart+ia;do;while(d===g[++e]&&d===g[++e]&&d===g[++e]&&d===g[++e]&&d===g[++e]&&d===g[++e]&&d===g[++e]&&d===g[++e]&&f>e);a.match_length=ia-(f-e),a.match_length>a.lookahead&&(a.match_length=a.lookahead)}if(a.match_length>=ha?(c=D._tr_tally(a,1,a.match_length-ha),a.lookahead-=a.match_length,a.strstart+=a.match_length,a.match_length=0):(c=D._tr_tally(a,0,a.window[a.strstart]),a.lookahead--,a.strstart++),c&&(h(a,!1),0===a.strm.avail_out))return sa}return a.insert=0,b===K?(h(a,!0),0===a.strm.avail_out?ua:va):a.last_lit&&(h(a,!1),0===a.strm.avail_out)?sa:ta}function r(a,b){for(var c;;){if(0===a.lookahead&&(m(a),0===a.lookahead)){if(b===H)return sa;break}if(a.match_length=0,c=D._tr_tally(a,0,a.window[a.strstart]),a.lookahead--,a.strstart++,c&&(h(a,!1),0===a.strm.avail_out))return sa}return a.insert=0,b===K?(h(a,!0),0===a.strm.avail_out?ua:va):a.last_lit&&(h(a,!1),0===a.strm.avail_out)?sa:ta}function s(a){a.window_size=2*a.w_size,f(a.head),a.max_lazy_match=B[a.level].max_lazy,a.good_match=B[a.level].good_length,a.nice_match=B[a.level].nice_length,a.max_chain_length=B[a.level].max_chain,a.strstart=0,a.block_start=0,a.lookahead=0,a.insert=0,a.match_length=a.prev_length=ha-1,a.match_available=0,a.ins_h=0}function t(){this.strm=null,this.status=0,this.pending_buf=null,this.pending_buf_size=0,this.pending_out=0,this.pending=0,this.wrap=0,this.gzhead=null,this.gzindex=0,this.method=Y,this.last_flush=-1,this.w_size=0,this.w_bits=0,this.w_mask=0,this.window=null,this.window_size=0,this.prev=null,this.head=null,this.ins_h=0,this.hash_size=0,this.hash_bits=0,this.hash_mask=0,this.hash_shift=0,this.block_start=0,this.match_length=0,this.prev_match=0,this.match_available=0,this.strstart=0,this.match_start=0,this.lookahead=0,this.prev_length=0,this.max_chain_length=0,this.max_lazy_match=0,this.level=0,this.strategy=0,this.good_match=0,this.nice_match=0,this.dyn_ltree=new C.Buf16(2*fa),this.dyn_dtree=new C.Buf16(2*(2*da+1)),this.bl_tree=new C.Buf16(2*(2*ea+1)),f(this.dyn_ltree),f(this.dyn_dtree),f(this.bl_tree),this.l_desc=null,this.d_desc=null,this.bl_desc=null,this.bl_count=new C.Buf16(ga+1),this.heap=new C.Buf16(2*ca+1),f(this.heap),this.heap_len=0,this.heap_max=0,this.depth=new C.Buf16(2*ca+1),f(this.depth),this.l_buf=0,this.lit_bufsize=0,this.last_lit=0,this.d_buf=0,this.opt_len=0,this.static_len=0,this.matches=0,this.insert=0,this.bi_buf=0,this.bi_valid=0}function u(a){var b;return a&&a.state?(a.total_in=a.total_out=0,a.data_type=X,b=a.state,b.pending=0,b.pending_out=0,b.wrap<0&&(b.wrap=-b.wrap),b.status=b.wrap?la:qa,a.adler=2===b.wrap?0:1,b.last_flush=H,D._tr_init(b),M):d(a,O)}function v(a){var b=u(a);return b===M&&s(a.state),b}function w(a,b){return a&&a.state?2!==a.state.wrap?O:(a.state.gzhead=b,M):O}function x(a,b,c,e,f,g){if(!a)return O;var h=1;if(b===R&&(b=6),0>e?(h=0,e=-e):e>15&&(h=2,e-=16),1>f||f>Z||c!==Y||8>e||e>15||0>b||b>9||0>g||g>V)return d(a,O);8===e&&(e=9);var i=new t;return a.state=i,i.strm=a,i.wrap=h,i.gzhead=null,i.w_bits=e,i.w_size=1<>1,i.l_buf=3*i.lit_bufsize,i.level=b,i.strategy=g,i.method=c,v(a)}function y(a,b){return x(a,b,Y,$,_,W)}function z(a,b){var c,h,k,l;if(!a||!a.state||b>L||0>b)return a?d(a,O):O;if(h=a.state,!a.output||!a.input&&0!==a.avail_in||h.status===ra&&b!==K)return d(a,0===a.avail_out?Q:O);if(h.strm=a,c=h.last_flush,h.last_flush=b,h.status===la)if(2===h.wrap)a.adler=0,i(h,31),i(h,139),i(h,8),h.gzhead?(i(h,(h.gzhead.text?1:0)+(h.gzhead.hcrc?2:0)+(h.gzhead.extra?4:0)+(h.gzhead.name?8:0)+(h.gzhead.comment?16:0)),i(h,255&h.gzhead.time),i(h,h.gzhead.time>>8&255),i(h,h.gzhead.time>>16&255),i(h,h.gzhead.time>>24&255),i(h,9===h.level?2:h.strategy>=T||h.level<2?4:0),i(h,255&h.gzhead.os),h.gzhead.extra&&h.gzhead.extra.length&&(i(h,255&h.gzhead.extra.length),i(h,h.gzhead.extra.length>>8&255)),h.gzhead.hcrc&&(a.adler=F(a.adler,h.pending_buf,h.pending,0)),h.gzindex=0,h.status=ma):(i(h,0),i(h,0),i(h,0),i(h,0),i(h,0),i(h,9===h.level?2:h.strategy>=T||h.level<2?4:0),i(h,wa),h.status=qa);else{var m=Y+(h.w_bits-8<<4)<<8,n=-1;n=h.strategy>=T||h.level<2?0:h.level<6?1:6===h.level?2:3,m|=n<<6,0!==h.strstart&&(m|=ka),m+=31-m%31,h.status=qa,j(h,m),0!==h.strstart&&(j(h,a.adler>>>16),j(h,65535&a.adler)),a.adler=1}if(h.status===ma)if(h.gzhead.extra){for(k=h.pending;h.gzindex<(65535&h.gzhead.extra.length)&&(h.pending!==h.pending_buf_size||(h.gzhead.hcrc&&h.pending>k&&(a.adler=F(a.adler,h.pending_buf,h.pending-k,k)),g(a),k=h.pending,h.pending!==h.pending_buf_size));)i(h,255&h.gzhead.extra[h.gzindex]),h.gzindex++;h.gzhead.hcrc&&h.pending>k&&(a.adler=F(a.adler,h.pending_buf,h.pending-k,k)),h.gzindex===h.gzhead.extra.length&&(h.gzindex=0,h.status=na)}else h.status=na;if(h.status===na)if(h.gzhead.name){k=h.pending;do{if(h.pending===h.pending_buf_size&&(h.gzhead.hcrc&&h.pending>k&&(a.adler=F(a.adler,h.pending_buf,h.pending-k,k)),g(a),k=h.pending,h.pending===h.pending_buf_size)){l=1;break}l=h.gzindexk&&(a.adler=F(a.adler,h.pending_buf,h.pending-k,k)),0===l&&(h.gzindex=0,h.status=oa)}else h.status=oa;if(h.status===oa)if(h.gzhead.comment){k=h.pending;do{if(h.pending===h.pending_buf_size&&(h.gzhead.hcrc&&h.pending>k&&(a.adler=F(a.adler,h.pending_buf,h.pending-k,k)),g(a),k=h.pending,h.pending===h.pending_buf_size)){l=1;break}l=h.gzindexk&&(a.adler=F(a.adler,h.pending_buf,h.pending-k,k)),0===l&&(h.status=pa)}else h.status=pa;if(h.status===pa&&(h.gzhead.hcrc?(h.pending+2>h.pending_buf_size&&g(a),h.pending+2<=h.pending_buf_size&&(i(h,255&a.adler),i(h,a.adler>>8&255),a.adler=0,h.status=qa)):h.status=qa),0!==h.pending){if(g(a),0===a.avail_out)return h.last_flush=-1,M}else if(0===a.avail_in&&e(b)<=e(c)&&b!==K)return d(a,Q);if(h.status===ra&&0!==a.avail_in)return d(a,Q);if(0!==a.avail_in||0!==h.lookahead||b!==H&&h.status!==ra){var o=h.strategy===T?r(h,b):h.strategy===U?q(h,b):B[h.level].func(h,b);if((o===ua||o===va)&&(h.status=ra),o===sa||o===ua)return 0===a.avail_out&&(h.last_flush=-1),M;if(o===ta&&(b===I?D._tr_align(h):b!==L&&(D._tr_stored_block(h,0,0,!1),b===J&&(f(h.head), +0===h.lookahead&&(h.strstart=0,h.block_start=0,h.insert=0))),g(a),0===a.avail_out))return h.last_flush=-1,M}return b!==K?M:h.wrap<=0?N:(2===h.wrap?(i(h,255&a.adler),i(h,a.adler>>8&255),i(h,a.adler>>16&255),i(h,a.adler>>24&255),i(h,255&a.total_in),i(h,a.total_in>>8&255),i(h,a.total_in>>16&255),i(h,a.total_in>>24&255)):(j(h,a.adler>>>16),j(h,65535&a.adler)),g(a),h.wrap>0&&(h.wrap=-h.wrap),0!==h.pending?M:N)}function A(a){var b;return a&&a.state?(b=a.state.status,b!==la&&b!==ma&&b!==na&&b!==oa&&b!==pa&&b!==qa&&b!==ra?d(a,O):(a.state=null,b===qa?d(a,P):M)):O}var B,C=a("../utils/common"),D=a("./trees"),E=a("./adler32"),F=a("./crc32"),G=a("./messages"),H=0,I=1,J=3,K=4,L=5,M=0,N=1,O=-2,P=-3,Q=-5,R=-1,S=1,T=2,U=3,V=4,W=0,X=2,Y=8,Z=9,$=15,_=8,aa=29,ba=256,ca=ba+1+aa,da=30,ea=19,fa=2*ca+1,ga=15,ha=3,ia=258,ja=ia+ha+1,ka=32,la=42,ma=69,na=73,oa=91,pa=103,qa=113,ra=666,sa=1,ta=2,ua=3,va=4,wa=3,xa=function(a,b,c,d,e){this.good_length=a,this.max_lazy=b,this.nice_length=c,this.max_chain=d,this.func=e};B=[new xa(0,0,0,0,n),new xa(4,4,8,4,o),new xa(4,5,16,8,o),new xa(4,6,32,32,o),new xa(4,4,16,16,p),new xa(8,16,32,32,p),new xa(8,16,128,128,p),new xa(8,32,128,256,p),new xa(32,128,258,1024,p),new xa(32,258,258,4096,p)],c.deflateInit=y,c.deflateInit2=x,c.deflateReset=v,c.deflateResetKeep=u,c.deflateSetHeader=w,c.deflate=z,c.deflateEnd=A,c.deflateInfo="pako deflate (from Nodeca project)"},{"../utils/common":55,"./adler32":56,"./crc32":58,"./messages":63,"./trees":64}],60:[function(a,b,c){"use strict";var d=30,e=12;b.exports=function(a,b){var c,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C;c=a.state,f=a.next_in,B=a.input,g=f+(a.avail_in-5),h=a.next_out,C=a.output,i=h-(b-a.avail_out),j=h+(a.avail_out-257),k=c.dmax,l=c.wsize,m=c.whave,n=c.wnext,o=c.window,p=c.hold,q=c.bits,r=c.lencode,s=c.distcode,t=(1<q&&(p+=B[f++]<>>24,p>>>=w,q-=w,w=v>>>16&255,0===w)C[h++]=65535&v;else{if(!(16&w)){if(0===(64&w)){v=r[(65535&v)+(p&(1<q&&(p+=B[f++]<>>=w,q-=w),15>q&&(p+=B[f++]<>>24,p>>>=w,q-=w,w=v>>>16&255,!(16&w)){if(0===(64&w)){v=s[(65535&v)+(p&(1<q&&(p+=B[f++]<q&&(p+=B[f++]<k){a.msg="invalid distance too far back",c.mode=d;break a}if(p>>>=w,q-=w,w=h-i,y>w){if(w=y-w,w>m&&c.sane){a.msg="invalid distance too far back",c.mode=d;break a}if(z=0,A=o,0===n){if(z+=l-w,x>w){x-=w;do C[h++]=o[z++];while(--w);z=h-y,A=C}}else if(w>n){if(z+=l+n-w,w-=n,x>w){x-=w;do C[h++]=o[z++];while(--w);if(z=0,x>n){w=n,x-=w;do C[h++]=o[z++];while(--w);z=h-y,A=C}}}else if(z+=n-w,x>w){x-=w;do C[h++]=o[z++];while(--w);z=h-y,A=C}for(;x>2;)C[h++]=A[z++],C[h++]=A[z++],C[h++]=A[z++],x-=3;x&&(C[h++]=A[z++],x>1&&(C[h++]=A[z++]))}else{z=h-y;do C[h++]=C[z++],C[h++]=C[z++],C[h++]=C[z++],x-=3;while(x>2);x&&(C[h++]=C[z++],x>1&&(C[h++]=C[z++]))}break}}break}}while(g>f&&j>h);x=q>>3,f-=x,q-=x<<3,p&=(1<f?5+(g-f):5-(f-g),a.avail_out=j>h?257+(j-h):257-(h-j),c.hold=p,c.bits=q}},{}],61:[function(a,b,c){"use strict";function d(a){return(a>>>24&255)+(a>>>8&65280)+((65280&a)<<8)+((255&a)<<24)}function e(){this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=null,this.distcode=null,this.lenbits=0,this.distbits=0,this.ncode=0,this.nlen=0,this.ndist=0,this.have=0,this.next=null,this.lens=new r.Buf16(320),this.work=new r.Buf16(288),this.lendyn=null,this.distdyn=null,this.sane=0,this.back=0,this.was=0}function f(a){var b;return a&&a.state?(b=a.state,a.total_in=a.total_out=b.total=0,a.msg="",b.wrap&&(a.adler=1&b.wrap),b.mode=K,b.last=0,b.havedict=0,b.dmax=32768,b.head=null,b.hold=0,b.bits=0,b.lencode=b.lendyn=new r.Buf32(oa),b.distcode=b.distdyn=new r.Buf32(pa),b.sane=1,b.back=-1,C):F}function g(a){var b;return a&&a.state?(b=a.state,b.wsize=0,b.whave=0,b.wnext=0,f(a)):F}function h(a,b){var c,d;return a&&a.state?(d=a.state,0>b?(c=0,b=-b):(c=(b>>4)+1,48>b&&(b&=15)),b&&(8>b||b>15)?F:(null!==d.window&&d.wbits!==b&&(d.window=null),d.wrap=c,d.wbits=b,g(a))):F}function i(a,b){var c,d;return a?(d=new e,a.state=d,d.window=null,c=h(a,b),c!==C&&(a.state=null),c):F}function j(a){return i(a,ra)}function k(a){if(sa){var b;for(p=new r.Buf32(512),q=new r.Buf32(32),b=0;144>b;)a.lens[b++]=8;for(;256>b;)a.lens[b++]=9;for(;280>b;)a.lens[b++]=7;for(;288>b;)a.lens[b++]=8;for(v(x,a.lens,0,288,p,0,a.work,{bits:9}),b=0;32>b;)a.lens[b++]=5;v(y,a.lens,0,32,q,0,a.work,{bits:5}),sa=!1}a.lencode=p,a.lenbits=9,a.distcode=q,a.distbits=5}function l(a,b,c,d){var e,f=a.state;return null===f.window&&(f.wsize=1<=f.wsize?(r.arraySet(f.window,b,c-f.wsize,f.wsize,0),f.wnext=0,f.whave=f.wsize):(e=f.wsize-f.wnext,e>d&&(e=d),r.arraySet(f.window,b,c-d,e,f.wnext),d-=e,d?(r.arraySet(f.window,b,c-d,d,0),f.wnext=d,f.whave=f.wsize):(f.wnext+=e,f.wnext===f.wsize&&(f.wnext=0),f.whaven;){if(0===i)break a;i--,m+=e[g++]<>>8&255,c.check=t(c.check,Ba,2,0),m=0,n=0,c.mode=L;break}if(c.flags=0,c.head&&(c.head.done=!1),!(1&c.wrap)||(((255&m)<<8)+(m>>8))%31){a.msg="incorrect header check",c.mode=la;break}if((15&m)!==J){a.msg="unknown compression method",c.mode=la;break}if(m>>>=4,n-=4,wa=(15&m)+8,0===c.wbits)c.wbits=wa;else if(wa>c.wbits){a.msg="invalid window size",c.mode=la;break}c.dmax=1<n;){if(0===i)break a;i--,m+=e[g++]<>8&1),512&c.flags&&(Ba[0]=255&m,Ba[1]=m>>>8&255,c.check=t(c.check,Ba,2,0)),m=0,n=0,c.mode=M;case M:for(;32>n;){if(0===i)break a;i--,m+=e[g++]<>>8&255,Ba[2]=m>>>16&255,Ba[3]=m>>>24&255,c.check=t(c.check,Ba,4,0)),m=0,n=0,c.mode=N;case N:for(;16>n;){if(0===i)break a;i--,m+=e[g++]<>8),512&c.flags&&(Ba[0]=255&m,Ba[1]=m>>>8&255,c.check=t(c.check,Ba,2,0)),m=0,n=0,c.mode=O;case O:if(1024&c.flags){for(;16>n;){if(0===i)break a;i--,m+=e[g++]<>>8&255,c.check=t(c.check,Ba,2,0)),m=0,n=0}else c.head&&(c.head.extra=null);c.mode=P;case P:if(1024&c.flags&&(q=c.length,q>i&&(q=i),q&&(c.head&&(wa=c.head.extra_len-c.length,c.head.extra||(c.head.extra=new Array(c.head.extra_len)),r.arraySet(c.head.extra,e,g,q,wa)),512&c.flags&&(c.check=t(c.check,e,q,g)),i-=q,g+=q,c.length-=q),c.length))break a;c.length=0,c.mode=Q;case Q:if(2048&c.flags){if(0===i)break a;q=0;do wa=e[g+q++],c.head&&wa&&c.length<65536&&(c.head.name+=String.fromCharCode(wa));while(wa&&i>q);if(512&c.flags&&(c.check=t(c.check,e,q,g)),i-=q,g+=q,wa)break a}else c.head&&(c.head.name=null);c.length=0,c.mode=R;case R:if(4096&c.flags){if(0===i)break a;q=0;do wa=e[g+q++],c.head&&wa&&c.length<65536&&(c.head.comment+=String.fromCharCode(wa));while(wa&&i>q);if(512&c.flags&&(c.check=t(c.check,e,q,g)),i-=q,g+=q,wa)break a}else c.head&&(c.head.comment=null);c.mode=S;case S:if(512&c.flags){for(;16>n;){if(0===i)break a;i--,m+=e[g++]<>9&1,c.head.done=!0),a.adler=c.check=0,c.mode=V;break;case T:for(;32>n;){if(0===i)break a;i--,m+=e[g++]<>>=7&n,n-=7&n,c.mode=ia;break}for(;3>n;){if(0===i)break a;i--,m+=e[g++]<>>=1,n-=1,3&m){case 0:c.mode=X;break;case 1:if(k(c),c.mode=ba,b===B){m>>>=2,n-=2;break a}break;case 2:c.mode=$;break;case 3:a.msg="invalid block type",c.mode=la}m>>>=2,n-=2;break;case X:for(m>>>=7&n,n-=7&n;32>n;){if(0===i)break a;i--,m+=e[g++]<>>16^65535)){a.msg="invalid stored block lengths",c.mode=la;break}if(c.length=65535&m,m=0,n=0,c.mode=Y,b===B)break a;case Y:c.mode=Z;case Z:if(q=c.length){if(q>i&&(q=i),q>j&&(q=j),0===q)break a;r.arraySet(f,e,g,q,h),i-=q,g+=q,j-=q,h+=q,c.length-=q;break}c.mode=V;break;case $:for(;14>n;){if(0===i)break a;i--,m+=e[g++]<>>=5,n-=5,c.ndist=(31&m)+1,m>>>=5,n-=5,c.ncode=(15&m)+4,m>>>=4,n-=4,c.nlen>286||c.ndist>30){a.msg="too many length or distance symbols",c.mode=la;break}c.have=0,c.mode=_;case _:for(;c.haven;){if(0===i)break a;i--,m+=e[g++]<>>=3,n-=3}for(;c.have<19;)c.lens[Ca[c.have++]]=0;if(c.lencode=c.lendyn,c.lenbits=7,ya={bits:c.lenbits},xa=v(w,c.lens,0,19,c.lencode,0,c.work,ya),c.lenbits=ya.bits,xa){a.msg="invalid code lengths set",c.mode=la;break}c.have=0,c.mode=aa;case aa:for(;c.have>>24,ra=Aa>>>16&255,sa=65535&Aa,!(n>=qa);){if(0===i)break a;i--,m+=e[g++]<sa)m>>>=qa,n-=qa,c.lens[c.have++]=sa;else{if(16===sa){for(za=qa+2;za>n;){if(0===i)break a;i--,m+=e[g++]<>>=qa,n-=qa,0===c.have){a.msg="invalid bit length repeat",c.mode=la;break}wa=c.lens[c.have-1],q=3+(3&m),m>>>=2,n-=2}else if(17===sa){for(za=qa+3;za>n;){if(0===i)break a;i--,m+=e[g++]<>>=qa,n-=qa,wa=0,q=3+(7&m),m>>>=3,n-=3}else{for(za=qa+7;za>n;){if(0===i)break a;i--,m+=e[g++]<>>=qa,n-=qa,wa=0,q=11+(127&m),m>>>=7,n-=7}if(c.have+q>c.nlen+c.ndist){a.msg="invalid bit length repeat",c.mode=la;break}for(;q--;)c.lens[c.have++]=wa}}if(c.mode===la)break;if(0===c.lens[256]){a.msg="invalid code -- missing end-of-block",c.mode=la;break}if(c.lenbits=9,ya={bits:c.lenbits},xa=v(x,c.lens,0,c.nlen,c.lencode,0,c.work,ya),c.lenbits=ya.bits,xa){a.msg="invalid literal/lengths set",c.mode=la;break}if(c.distbits=6,c.distcode=c.distdyn,ya={bits:c.distbits},xa=v(y,c.lens,c.nlen,c.ndist,c.distcode,0,c.work,ya),c.distbits=ya.bits,xa){a.msg="invalid distances set",c.mode=la;break}if(c.mode=ba,b===B)break a;case ba:c.mode=ca;case ca:if(i>=6&&j>=258){a.next_out=h,a.avail_out=j,a.next_in=g,a.avail_in=i,c.hold=m,c.bits=n,u(a,p),h=a.next_out,f=a.output,j=a.avail_out,g=a.next_in,e=a.input,i=a.avail_in,m=c.hold,n=c.bits,c.mode===V&&(c.back=-1);break}for(c.back=0;Aa=c.lencode[m&(1<>>24,ra=Aa>>>16&255,sa=65535&Aa,!(n>=qa);){if(0===i)break a;i--,m+=e[g++]<>ta)],qa=Aa>>>24,ra=Aa>>>16&255,sa=65535&Aa,!(n>=ta+qa);){if(0===i)break a;i--,m+=e[g++]<>>=ta,n-=ta,c.back+=ta}if(m>>>=qa,n-=qa,c.back+=qa,c.length=sa,0===ra){c.mode=ha;break}if(32&ra){c.back=-1,c.mode=V;break}if(64&ra){a.msg="invalid literal/length code",c.mode=la;break}c.extra=15&ra,c.mode=da;case da:if(c.extra){for(za=c.extra;za>n;){if(0===i)break a;i--,m+=e[g++]<>>=c.extra,n-=c.extra,c.back+=c.extra}c.was=c.length,c.mode=ea;case ea:for(;Aa=c.distcode[m&(1<>>24,ra=Aa>>>16&255,sa=65535&Aa,!(n>=qa);){if(0===i)break a;i--,m+=e[g++]<>ta)],qa=Aa>>>24,ra=Aa>>>16&255,sa=65535&Aa,!(n>=ta+qa);){if(0===i)break a;i--,m+=e[g++]<>>=ta,n-=ta,c.back+=ta}if(m>>>=qa,n-=qa,c.back+=qa,64&ra){a.msg="invalid distance code",c.mode=la;break}c.offset=sa,c.extra=15&ra,c.mode=fa;case fa:if(c.extra){for(za=c.extra;za>n;){if(0===i)break a;i--,m+=e[g++]<>>=c.extra,n-=c.extra,c.back+=c.extra}if(c.offset>c.dmax){a.msg="invalid distance too far back",c.mode=la;break}c.mode=ga;case ga:if(0===j)break a;if(q=p-j,c.offset>q){if(q=c.offset-q,q>c.whave&&c.sane){a.msg="invalid distance too far back",c.mode=la;break}q>c.wnext?(q-=c.wnext,oa=c.wsize-q):oa=c.wnext-q,q>c.length&&(q=c.length),pa=c.window}else pa=f,oa=h-c.offset,q=c.length;q>j&&(q=j),j-=q,c.length-=q;do f[h++]=pa[oa++];while(--q);0===c.length&&(c.mode=ca);break;case ha:if(0===j)break a;f[h++]=c.length,j--,c.mode=ca;break;case ia:if(c.wrap){for(;32>n;){if(0===i)break a;i--,m|=e[g++]<n;){if(0===i)break a;i--,m+=e[g++]<=D;D++)P[D]=0;for(E=0;o>E;E++)P[b[c+E]]++;for(H=C,G=e;G>=1&&0===P[G];G--);if(H>G&&(H=G),0===G)return p[q++]=20971520,p[q++]=20971520,s.bits=1,0;for(F=1;G>F&&0===P[F];F++);for(F>H&&(H=F),K=1,D=1;e>=D;D++)if(K<<=1,K-=P[D],0>K)return-1;if(K>0&&(a===h||1!==G))return-1;for(Q[1]=0,D=1;e>D;D++)Q[D+1]=Q[D]+P[D];for(E=0;o>E;E++)0!==b[c+E]&&(r[Q[b[c+E]]++]=E);if(a===h?(N=R=r,y=19):a===i?(N=k,O-=257,R=l,S-=257,y=256):(N=m,R=n,y=-1),M=0,E=0,D=F,x=q,I=H,J=0,v=-1,L=1<f||a===j&&L>g)return 1;for(var T=0;;){T++,z=D-J,r[E]y?(A=R[S+r[E]],B=N[O+r[E]]):(A=96,B=0),t=1<>J)+u]=z<<24|A<<16|B|0;while(0!==u);for(t=1<>=1;if(0!==t?(M&=t-1,M+=t):M=0,E++,0===--P[D]){if(D===G)break;D=b[c+r[E]]}if(D>H&&(M&w)!==v){for(0===J&&(J=H),x+=F,I=D-J,K=1<I+J&&(K-=P[I+J],!(0>=K));)I++,K<<=1;if(L+=1<f||a===j&&L>g)return 1;v=M&w,p[v]=H<<24|I<<16|x-q|0}}return 0!==M&&(p[x+M]=D-J<<24|64<<16|0),s.bits=H,0}},{"../utils/common":55}],63:[function(a,b,c){"use strict";b.exports={2:"need dictionary",1:"stream end",0:"","-1":"file error","-2":"stream error","-3":"data error","-4":"insufficient memory","-5":"buffer error","-6":"incompatible version"}},{}],64:[function(a,b,c){"use strict";function d(a){for(var b=a.length;--b>=0;)a[b]=0}function e(a){return 256>a?ga[a]:ga[256+(a>>>7)]}function f(a,b){a.pending_buf[a.pending++]=255&b,a.pending_buf[a.pending++]=b>>>8&255}function g(a,b,c){a.bi_valid>V-c?(a.bi_buf|=b<>V-a.bi_valid,a.bi_valid+=c-V):(a.bi_buf|=b<>>=1,c<<=1;while(--b>0);return c>>>1}function j(a){16===a.bi_valid?(f(a,a.bi_buf),a.bi_buf=0,a.bi_valid=0):a.bi_valid>=8&&(a.pending_buf[a.pending++]=255&a.bi_buf,a.bi_buf>>=8,a.bi_valid-=8)}function k(a,b){var c,d,e,f,g,h,i=b.dyn_tree,j=b.max_code,k=b.stat_desc.static_tree,l=b.stat_desc.has_stree,m=b.stat_desc.extra_bits,n=b.stat_desc.extra_base,o=b.stat_desc.max_length,p=0;for(f=0;U>=f;f++)a.bl_count[f]=0;for(i[2*a.heap[a.heap_max]+1]=0,c=a.heap_max+1;T>c;c++)d=a.heap[c],f=i[2*i[2*d+1]+1]+1,f>o&&(f=o,p++),i[2*d+1]=f,d>j||(a.bl_count[f]++,g=0,d>=n&&(g=m[d-n]),h=i[2*d],a.opt_len+=h*(f+g),l&&(a.static_len+=h*(k[2*d+1]+g)));if(0!==p){do{for(f=o-1;0===a.bl_count[f];)f--;a.bl_count[f]--,a.bl_count[f+1]+=2,a.bl_count[o]--,p-=2}while(p>0);for(f=o;0!==f;f--)for(d=a.bl_count[f];0!==d;)e=a.heap[--c],e>j||(i[2*e+1]!==f&&(a.opt_len+=(f-i[2*e+1])*i[2*e],i[2*e+1]=f),d--)}}function l(a,b,c){var d,e,f=new Array(U+1),g=0;for(d=1;U>=d;d++)f[d]=g=g+c[d-1]<<1;for(e=0;b>=e;e++){var h=a[2*e+1];0!==h&&(a[2*e]=i(f[h]++,h))}}function m(){var a,b,c,d,e,f=new Array(U+1);for(c=0,d=0;O-1>d;d++)for(ia[d]=c,a=0;a<1<<_[d];a++)ha[c++]=d;for(ha[c-1]=d,e=0,d=0;16>d;d++)for(ja[d]=e,a=0;a<1<>=7;R>d;d++)for(ja[d]=e<<7,a=0;a<1<=b;b++)f[b]=0;for(a=0;143>=a;)ea[2*a+1]=8,a++,f[8]++;for(;255>=a;)ea[2*a+1]=9,a++,f[9]++;for(;279>=a;)ea[2*a+1]=7,a++,f[7]++;for(;287>=a;)ea[2*a+1]=8,a++,f[8]++;for(l(ea,Q+1,f),a=0;R>a;a++)fa[2*a+1]=5,fa[2*a]=i(a,5);ka=new na(ea,_,P+1,Q,U),la=new na(fa,aa,0,R,U),ma=new na(new Array(0),ba,0,S,W)}function n(a){var b;for(b=0;Q>b;b++)a.dyn_ltree[2*b]=0;for(b=0;R>b;b++)a.dyn_dtree[2*b]=0;for(b=0;S>b;b++)a.bl_tree[2*b]=0;a.dyn_ltree[2*X]=1,a.opt_len=a.static_len=0,a.last_lit=a.matches=0}function o(a){a.bi_valid>8?f(a,a.bi_buf):a.bi_valid>0&&(a.pending_buf[a.pending++]=a.bi_buf),a.bi_buf=0,a.bi_valid=0}function p(a,b,c,d){o(a),d&&(f(a,c),f(a,~c)),E.arraySet(a.pending_buf,a.window,b,c,a.pending),a.pending+=c}function q(a,b,c,d){var e=2*b,f=2*c;return a[e]c;c++)0!==f[2*c]?(a.heap[++a.heap_len]=j=c,a.depth[c]=0):f[2*c+1]=0;for(;a.heap_len<2;)e=a.heap[++a.heap_len]=2>j?++j:0,f[2*e]=1,a.depth[e]=0,a.opt_len--,h&&(a.static_len-=g[2*e+1]);for(b.max_code=j,c=a.heap_len>>1;c>=1;c--)r(a,f,c);e=i;do c=a.heap[1],a.heap[1]=a.heap[a.heap_len--],r(a,f,1),d=a.heap[1],a.heap[--a.heap_max]=c,a.heap[--a.heap_max]=d,f[2*e]=f[2*c]+f[2*d],a.depth[e]=(a.depth[c]>=a.depth[d]?a.depth[c]:a.depth[d])+1,f[2*c+1]=f[2*d+1]=e,a.heap[1]=e++,r(a,f,1);while(a.heap_len>=2);a.heap[--a.heap_max]=a.heap[1],k(a,b),l(f,j,a.bl_count)}function u(a,b,c){var d,e,f=-1,g=b[1],h=0,i=7,j=4;for(0===g&&(i=138,j=3),b[2*(c+1)+1]=65535,d=0;c>=d;d++)e=g,g=b[2*(d+1)+1],++hh?a.bl_tree[2*e]+=h:0!==e?(e!==f&&a.bl_tree[2*e]++,a.bl_tree[2*Y]++):10>=h?a.bl_tree[2*Z]++:a.bl_tree[2*$]++,h=0,f=e,0===g?(i=138,j=3):e===g?(i=6,j=3):(i=7,j=4))}function v(a,b,c){var d,e,f=-1,i=b[1],j=0,k=7,l=4;for(0===i&&(k=138,l=3),d=0;c>=d;d++)if(e=i,i=b[2*(d+1)+1],!(++jj){do h(a,e,a.bl_tree);while(0!==--j)}else 0!==e?(e!==f&&(h(a,e,a.bl_tree),j--),h(a,Y,a.bl_tree),g(a,j-3,2)):10>=j?(h(a,Z,a.bl_tree),g(a,j-3,3)):(h(a,$,a.bl_tree),g(a,j-11,7));j=0,f=e,0===i?(k=138,l=3):e===i?(k=6,l=3):(k=7,l=4)}}function w(a){var b;for(u(a,a.dyn_ltree,a.l_desc.max_code),u(a,a.dyn_dtree,a.d_desc.max_code),t(a,a.bl_desc),b=S-1;b>=3&&0===a.bl_tree[2*ca[b]+1];b--);return a.opt_len+=3*(b+1)+5+5+4,b}function x(a,b,c,d){var e;for(g(a,b-257,5),g(a,c-1,5),g(a,d-4,4),e=0;d>e;e++)g(a,a.bl_tree[2*ca[e]+1],3);v(a,a.dyn_ltree,b-1),v(a,a.dyn_dtree,c-1)}function y(a){var b,c=4093624447;for(b=0;31>=b;b++,c>>>=1)if(1&c&&0!==a.dyn_ltree[2*b])return G;if(0!==a.dyn_ltree[18]||0!==a.dyn_ltree[20]||0!==a.dyn_ltree[26])return H;for(b=32;P>b;b++)if(0!==a.dyn_ltree[2*b])return H;return G}function z(a){pa||(m(),pa=!0),a.l_desc=new oa(a.dyn_ltree,ka),a.d_desc=new oa(a.dyn_dtree,la),a.bl_desc=new oa(a.bl_tree,ma),a.bi_buf=0,a.bi_valid=0,n(a)}function A(a,b,c,d){g(a,(J<<1)+(d?1:0),3),p(a,b,c,!0)}function B(a){g(a,K<<1,3),h(a,X,ea),j(a)}function C(a,b,c,d){var e,f,h=0;a.level>0?(a.strm.data_type===I&&(a.strm.data_type=y(a)),t(a,a.l_desc),t(a,a.d_desc),h=w(a),e=a.opt_len+3+7>>>3,f=a.static_len+3+7>>>3,e>=f&&(e=f)):e=f=c+5,e>=c+4&&-1!==b?A(a,b,c,d):a.strategy===F||f===e?(g(a,(K<<1)+(d?1:0),3),s(a,ea,fa)):(g(a,(L<<1)+(d?1:0),3),x(a,a.l_desc.max_code+1,a.d_desc.max_code+1,h+1),s(a,a.dyn_ltree,a.dyn_dtree)),n(a),d&&o(a)}function D(a,b,c){return a.pending_buf[a.d_buf+2*a.last_lit]=b>>>8&255,a.pending_buf[a.d_buf+2*a.last_lit+1]=255&b,a.pending_buf[a.l_buf+a.last_lit]=255&c,a.last_lit++,0===b?a.dyn_ltree[2*c]++:(a.matches++,b--,a.dyn_ltree[2*(ha[c]+P+1)]++,a.dyn_dtree[2*e(b)]++),a.last_lit===a.lit_bufsize-1}var E=a("../utils/common"),F=4,G=0,H=1,I=2,J=0,K=1,L=2,M=3,N=258,O=29,P=256,Q=P+1+O,R=30,S=19,T=2*Q+1,U=15,V=16,W=7,X=256,Y=16,Z=17,$=18,_=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0],aa=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13],ba=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7],ca=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],da=512,ea=new Array(2*(Q+2));d(ea);var fa=new Array(2*R);d(fa);var ga=new Array(da);d(ga);var ha=new Array(N-M+1);d(ha);var ia=new Array(O);d(ia);var ja=new Array(R);d(ja);var ka,la,ma,na=function(a,b,c,d,e){this.static_tree=a,this.extra_bits=b,this.extra_base=c,this.elems=d,this.max_length=e,this.has_stree=a&&a.length},oa=function(a,b){this.dyn_tree=a,this.max_code=0,this.stat_desc=b},pa=!1;c._tr_init=z,c._tr_stored_block=A,c._tr_flush_block=C,c._tr_tally=D,c._tr_align=B},{"../utils/common":55}],65:[function(a,b,c){"use strict";function d(){this.input=null,this.next_in=0,this.avail_in=0,this.total_in=0,this.output=null,this.next_out=0,this.avail_out=0,this.total_out=0,this.msg="",this.state=null,this.data_type=2,this.adler=0}b.exports=d},{}],66:[function(a,b,c){(function(a){function b(a,b){for(var c=0,d=a.length-1;d>=0;d--){var e=a[d];"."===e?a.splice(d,1):".."===e?(a.splice(d,1),c++):c&&(a.splice(d,1),c--)}if(b)for(;c--;c)a.unshift("..");return a}function d(a,b){if(a.filter)return a.filter(b);for(var c=[],d=0;d=-1&&!e;f--){var g=f>=0?arguments[f]:a.cwd();if("string"!=typeof g)throw new TypeError("Arguments to path.resolve must be strings");g&&(c=g+"/"+c,e="/"===g.charAt(0))}return c=b(d(c.split("/"),function(a){return!!a}),!e).join("/"),(e?"/":"")+c||"."},c.normalize=function(a){var e=c.isAbsolute(a),f="/"===g(a,-1);return a=b(d(a.split("/"),function(a){return!!a}),!e).join("/"),a||e||(a="."),a&&f&&(a+="/"),(e?"/":"")+a},c.isAbsolute=function(a){return"/"===a.charAt(0)},c.join=function(){var a=Array.prototype.slice.call(arguments,0);return c.normalize(d(a,function(a,b){if("string"!=typeof a)throw new TypeError("Arguments to path.join must be strings");return a}).join("/"))},c.relative=function(a,b){function d(a){for(var b=0;b=0&&""===a[c];c--);return b>c?[]:a.slice(b,c-b+1)}a=c.resolve(a).substr(1),b=c.resolve(b).substr(1);for(var e=d(a.split("/")),f=d(b.split("/")),g=Math.min(e.length,f.length),h=g,i=0;g>i;i++)if(e[i]!==f[i]){h=i;break}for(var j=[],i=h;ib&&(b=a.length+b),a.substr(b,c)}}).call(this,a("_process"))},{_process:68}],67:[function(a,b,c){(function(a){"use strict";function c(b){for(var c=new Array(arguments.length-1),d=0;d1)for(var c=1;c0&&j>i&&(j=i);for(var k=0;j>k;++k){var l,m,n,o,p=a[k].replace(h,"%20"),q=p.indexOf(c);q>=0?(l=p.substr(0,q),m=p.substr(q+1)):(l=p,m=""),n=decodeURIComponent(l),o=decodeURIComponent(m),d(g,n)?e(g[n])?g[n].push(o):g[n]=[g[n],o]:g[n]=o}return g};var e=Array.isArray||function(a){return"[object Array]"===Object.prototype.toString.call(a)}},{}],70:[function(a,b,c){"use strict";function d(a,b){if(a.map)return a.map(b);for(var c=[],d=0;dd;)f=b.call(null,f,a[d],++d,a);return f}},{}],73:[function(a,b,c){(function(c){function d(){function a(b,d){if(!(this instanceof a))return new a(b,d);m("creating new struct instance");var e;if(c.isBuffer(b)?(m("using passed-in Buffer instance to back the struct",b),l(b.length>=a.size,"Buffer instance must be at least "+a.size+" bytes to back this struct type"),e=b,b=d):(m("creating new Buffer instance to back the struct (size: %d)",a.size),e=new c(a.size)),e.type=a,this["ref.buffer"]=e,b)for(var f in b)this[f]=b[f];a._instanceCreated=!0}m('defining new struct "type"'),a.prototype=Object.create(n,{constructor:{value:a,enumerable:!1,writable:!0,configurable:!0}}),a.defineProperty=h,a.toString=g,a.fields={},a.size=0,a.alignment=0,a.indirection=1,a.get=e,a.set=f;var b=arguments[0];return Array.isArray(b)?b.forEach(function(b){var c=b[0],d=b[1];a.defineProperty(d,c)}):"object"==typeof b&&Object.keys(b).forEach(function(c){var d=b[c];a.defineProperty(c,d)}),a}function e(a,b){return m('Struct "type" getter for buffer at offset',a,b),b>0&&(a=a.slice(b)),new this(a)}function f(a,b,c){m('Struct "type" setter for buffer at offset',a,b,c);var d=c instanceof this;d?c["ref.buffer"].copy(a,b,0,this.size):(b>0&&(a=a.slice(b)),new this(a,c))}function g(){return"[StructType]"}function h(a,b){m("defining new struct type field",a),b=j.coerceType(b),l(!this._instanceCreated,'an instance of this Struct type has already been created, cannot add new "fields" anymore'),l.equal("string",typeof a,'expected a "string" field name'),l(b&&/object|function/i.test(typeof b)&&"size"in b&&"indirection"in b,'expected a "type" object describing the field type: "'+b+'"'),l(b.indirection>1||b.size>0,'"type" object must have a size greater than 0'),l(!(a in this.prototype),'the field "'+a+'" already exists in this Struct type');var c={type:b};this.fields[a]=c;var d={enumerable:!0,configurable:!0};d.get=function(){return m('getting "%s" struct field (offset: %d)',a,c.offset),j.get(this["ref.buffer"],c.offset,b)},d.set=function(d){return m('setting "%s" struct field (offset: %d)',a,c.offset,d),j.set(this["ref.buffer"],c.offset,d,b)},i(this),Object.defineProperty(this.prototype,a,d)}function i(a){function b(b){var c=a.size,d=1===b.indirection?b.alignment:j.alignof.pointer,e=(d-c%d)%d,f=1===b.indirection?b.size:j.sizeof.pointer;return c+=e,l.equal(c%d,0,"offset should align"),a.size=c+f,c}a.size=0,a.alignment=0;var c=Object.keys(a.fields);c.forEach(function(b){var c=a.fields[b],d=c.type,e=d.alignment||j.alignof.pointer;d.indirection>1&&(e=j.alignof.pointer),a.alignment=Math.max(a.alignment,e)}),c.forEach(function(c){var d=a.fields[c],e=d.type;if(null!=e.fixedLength){d.offset=b(e.type);for(var f=1;f0&&(m("additional padding to the end of struct:",a.alignment-d),a.size+=a.alignment-d)}var j=a("ref"),k=a("util"),l=a("assert"),m=a("debug")("ref:struct");b.exports=d;var n={};n["ref.buffer"]=j.NULL,n.toObject=function(){var a={};return Object.keys(this.constructor.fields).forEach(function(b){a[b]=this[b]},this),a},n.toJSON=function(){return this.toObject()},n.inspect=function(){var a=this.toObject();return Object.keys(this).forEach(function(b){a[b]=this[b]},this),k.inspect(a)},n.ref=function(){return this["ref.buffer"]}}).call(this,a("buffer").Buffer)},{assert:26,buffer:38,debug:41,ref:74,util:90}],74:[function(a,b,c){ +(function(d){function e(a){return"refinspect"===a.name?a:function(){var b=a.apply(this,arguments);return b.replace("Buffer","Buffer@0x"+this.hexAddress())}}var f=a("assert"),g=a("debug")("ref");c=b.exports=a("bindings")("binding"),c.refType=function(a){var b=c.coerceType(a),d=Object.create(b);return d.indirection++,b.name&&(d.name=b.name+"*"),d},c.derefType=function(a){var b=c.coerceType(a);if(1===b.indirection)throw new Error("Cannot create deref'd type for type with indirection 1");var d=Object.getPrototypeOf(b);return d.indirection!==b.indirection-1&&(d=Object.create(b),d.indirection--),d},c.coerceType=function(a){var b=a;if("string"==typeof b){if(b=c.types[a])return b;if(b=a.replace(/\s+/g,"").toLowerCase(),"pointer"===b)b=c.refType(c.types["void"]);else if("string"===b)b=c.types.CString;else{var d=0;if(b=b.replace(/\*/g,function(){return d++,""}),b=c.types[b],d>0){if(!(b&&"size"in b&&"indirection"in b))throw new TypeError('could not determine a proper "type" from: '+JSON.stringify(a));for(var e=0;d>e;e++)b=c.refType(b)}}}if(!(b&&"size"in b&&"indirection"in b))throw new TypeError('could not determine a proper "type" from: '+JSON.stringify(a));return b},c.getType=function(a){return a.type||(g('WARN: no "type" found on buffer, setting default "type"',a),a.type={},a.type.size=a.length,a.type.indirection=1,a.type.get=function(){throw new Error('unknown "type"; cannot get()')},a.type.set=function(){throw new Error('unknown "type"; cannot set()')}),c.coerceType(a.type)},c.get=function(a,b,d){if(b||(b=0),d=d?c.coerceType(d):c.getType(a),g("get(): (offset: %d)",b,a),f(d.indirection>0,'"indirection" level must be at least 1'),1===d.indirection)return d.get(a,b);var e=2===d.indirection?d.size:c.sizeof.pointer,h=c.readPointer(a,b,e);return h.type=c.derefType(d),h},c.set=function(a,b,d,e){b||(b=0),e=e?c.coerceType(e):c.getType(a),g("set(): (offset: %d)",b,a,d),f(e.indirection>=1,'"indirection" level must be at least 1'),1===e.indirection?e.set(a,b,d):c.writePointer(a,b,d)},c.alloc=function(a,b){var e=c.coerceType(a);g('allocating Buffer for type with "size"',e.size);var f;f=1===e.indirection?e.size:c.sizeof.pointer;var h=new d(f);return h.type=e,arguments.length>=2&&(g("setting value on allocated buffer",b),c.set(h,0,b,e)),h},c.allocCString=function(a,b){if(null==a||d.isBuffer(a)&&c.isNull(a))return c.NULL;var e=d.byteLength(a,b)+1,f=new d(e);return c.writeCString(f,0,a,b),f.type=m,f},c.writeCString=function(a,b,c,e){f(d.isBuffer(a),"expected a Buffer as the first argument"),f.equal("string",typeof c,'expected a "string" as the third argument'),b||(b=0),e||(e="utf8");var g=a.length-b,h=a.write(c,b,g,e);a.writeUInt8(0,b+h)},c["readInt64"+c.endianness]=c.readInt64,c["readUInt64"+c.endianness]=c.readUInt64,c["writeInt64"+c.endianness]=c.writeInt64,c["writeUInt64"+c.endianness]=c.writeUInt64;var h="LE"==c.endianness?"BE":"LE",i=new d(c.sizeof.int64),j=new d(c.sizeof.uint64);c["readInt64"+h]=function(a,b){for(var d=0;d=1&&8>=d);var e="int"+8*d;b&&(e="u"+e);var g=c.types[e];f(g),c.types[a]=Object.create(g)}),Object.keys(c.alignof).forEach(function(a){"pointer"!==a&&(c.types[a].alignment=c.alignof[a],f(c.types[a].alignment>0))}),c.types.bool.get=function(a){return function(b,c){return a(b,c)?!0:!1}}(c.types.bool.get),c.types.bool.set=function(a){return function(b,c,d){return"number"!=typeof d&&(d=d?1:0),a(b,c,d)}}(c.types.bool.set),Object.keys(c.types).forEach(function(a){c.types[a].name=a});var m=c.refType(c.types["char"]);if(c.NULL.type=c.types["void"],c.NULL_POINTER=c.ref(c.NULL),d.prototype.address=function(){return c.address(this,0)},d.prototype.hexAddress=function(){return c.hexAddress(this,0)},d.prototype.isNull=function(){return c.isNull(this,0)},d.prototype.ref=function(){return c.ref(this)},d.prototype.deref=function(){return c.deref(this)},d.prototype.readObject=function(a){return c.readObject(this,a)},d.prototype.writeObject=function(a,b){return c.writeObject(this,b,a)},d.prototype.readPointer=function(a,b){return c.readPointer(this,a,b)},d.prototype.writePointer=function(a,b){return c.writePointer(this,b,a)},d.prototype.readCString=function(a){return c.readCString(this,a)},d.prototype.writeCString=function(a,b,d){return c.writeCString(this,b,a,d)},d.prototype.readInt64BE=function(a){return c.readInt64BE(this,a)},d.prototype.writeInt64BE=function(a,b){return c.writeInt64BE(this,b,a)},d.prototype.readUInt64BE=function(a){return c.readUInt64BE(this,a)},d.prototype.writeUInt64BE=function(a,b){return c.writeUInt64BE(this,b,a)},d.prototype.readInt64LE=function(a){return c.readInt64LE(this,a)},d.prototype.writeInt64LE=function(a,b){return c.writeInt64LE(this,b,a)},d.prototype.readUInt64LE=function(a){return c.readUInt64LE(this,a)},d.prototype.writeUInt64LE=function(a,b){return c.writeUInt64LE(this,b,a)},d.prototype.reinterpret=function(a,b){return c.reinterpret(this,a,b)},d.prototype.reinterpretUntilZeros=function(a,b){return c.reinterpretUntilZeros(this,a,b)},d.prototype.inspect=e(d.prototype.inspect),!(c.NULL instanceof d)){g("extending SlowBuffer's prototype since it doesn't inherit from Buffer.prototype");var n=a("buffer").SlowBuffer;n.prototype.address=d.prototype.address,n.prototype.hexAddress=d.prototype.hexAddress,n.prototype.isNull=d.prototype.isNull,n.prototype.ref=d.prototype.ref,n.prototype.deref=d.prototype.deref,n.prototype.readObject=d.prototype.readObject,n.prototype.writeObject=d.prototype.writeObject,n.prototype.readPointer=d.prototype.readPointer,n.prototype.writePointer=d.prototype.writePointer,n.prototype.readCString=d.prototype.readCString,n.prototype.writeCString=d.prototype.writeCString,n.prototype.reinterpret=d.prototype.reinterpret,n.prototype.reinterpretUntilZeros=d.prototype.reinterpretUntilZeros,n.prototype.readInt64BE=d.prototype.readInt64BE,n.prototype.writeInt64BE=d.prototype.writeInt64BE,n.prototype.readUInt64BE=d.prototype.readUInt64BE,n.prototype.writeUInt64BE=d.prototype.writeUInt64BE,n.prototype.readInt64LE=d.prototype.readInt64LE,n.prototype.writeInt64LE=d.prototype.writeInt64LE,n.prototype.readUInt64LE=d.prototype.readUInt64LE,n.prototype.writeUInt64LE=d.prototype.writeUInt64LE,n.prototype.inspect=e(n.prototype.inspect)}}).call(this,a("buffer").Buffer)},{assert:26,bindings:28,buffer:38,debug:41}],75:[function(a,b,c){function d(){e.call(this)}b.exports=d;var e=a("events").EventEmitter,f=a("inherits");f(d,e),d.Readable=a("readable-stream/readable.js"),d.Writable=a("readable-stream/writable.js"),d.Duplex=a("readable-stream/duplex.js"),d.Transform=a("readable-stream/transform.js"),d.PassThrough=a("readable-stream/passthrough.js"),d.Stream=d,d.prototype.pipe=function(a,b){function c(b){a.writable&&!1===a.write(b)&&j.pause&&j.pause()}function d(){j.readable&&j.resume&&j.resume()}function f(){k||(k=!0,a.end())}function g(){k||(k=!0,"function"==typeof a.destroy&&a.destroy())}function h(a){if(i(),0===e.listenerCount(this,"error"))throw a}function i(){j.removeListener("data",c),a.removeListener("drain",d),j.removeListener("end",f),j.removeListener("close",g),j.removeListener("error",h),a.removeListener("error",h),j.removeListener("end",i),j.removeListener("close",i),a.removeListener("close",i)}var j=this;j.on("data",c),a.on("drain",d),a._isStdio||b&&b.end===!1||(j.on("end",f),j.on("close",g));var k=!1;return j.on("error",h),a.on("error",h),j.on("end",i),j.on("close",i),a.on("close",i),a.emit("pipe",j),a}},{events:43,inherits:45,"readable-stream/duplex.js":76,"readable-stream/passthrough.js":82,"readable-stream/readable.js":83,"readable-stream/transform.js":84,"readable-stream/writable.js":85}],76:[function(a,b,c){b.exports=a("./lib/_stream_duplex.js")},{"./lib/_stream_duplex.js":77}],77:[function(a,b,c){arguments[4][33][0].apply(c,arguments)},{"./_stream_readable":79,"./_stream_writable":81,"core-util-is":40,dup:33,inherits:45,"process-nextick-args":67}],78:[function(a,b,c){"use strict";function d(a){return this instanceof d?void e.call(this,a):new d(a)}b.exports=d;var e=a("./_stream_transform"),f=a("core-util-is");f.inherits=a("inherits"),f.inherits(d,e),d.prototype._transform=function(a,b,c){c(null,a)}},{"./_stream_transform":80,"core-util-is":40,inherits:45}],79:[function(a,b,c){arguments[4][34][0].apply(c,arguments)},{"./_stream_duplex":77,_process:68,buffer:38,"core-util-is":40,dup:34,events:43,inherits:45,isarray:48,"process-nextick-args":67,"string_decoder/":86,util:29}],80:[function(a,b,c){arguments[4][35][0].apply(c,arguments)},{"./_stream_duplex":77,"core-util-is":40,dup:35,inherits:45}],81:[function(a,b,c){arguments[4][36][0].apply(c,arguments)},{"./_stream_duplex":77,buffer:38,"core-util-is":40,dup:36,events:43,inherits:45,"process-nextick-args":67,"util-deprecate":88}],82:[function(a,b,c){b.exports=a("./lib/_stream_passthrough.js")},{"./lib/_stream_passthrough.js":78}],83:[function(a,b,c){var d=function(){try{return a("stream")}catch(b){}}();c=b.exports=a("./lib/_stream_readable.js"),c.Stream=d||c,c.Readable=c,c.Writable=a("./lib/_stream_writable.js"),c.Duplex=a("./lib/_stream_duplex.js"),c.Transform=a("./lib/_stream_transform.js"),c.PassThrough=a("./lib/_stream_passthrough.js")},{"./lib/_stream_duplex.js":77,"./lib/_stream_passthrough.js":78,"./lib/_stream_readable.js":79,"./lib/_stream_transform.js":80,"./lib/_stream_writable.js":81}],84:[function(a,b,c){arguments[4][37][0].apply(c,arguments)},{"./lib/_stream_transform.js":80,dup:37}],85:[function(a,b,c){b.exports=a("./lib/_stream_writable.js")},{"./lib/_stream_writable.js":81}],86:[function(a,b,c){function d(a){if(a&&!i(a))throw new Error("Unknown encoding: "+a)}function e(a){return a.toString(this.encoding)}function f(a){this.charReceived=a.length%2,this.charLength=this.charReceived?2:0}function g(a){this.charReceived=a.length%3,this.charLength=this.charReceived?3:0}var h=a("buffer").Buffer,i=h.isEncoding||function(a){switch(a&&a.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}},j=c.StringDecoder=function(a){switch(this.encoding=(a||"utf8").toLowerCase().replace(/[-_]/,""),d(a),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=f;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=g;break;default:return void(this.write=e)}this.charBuffer=new h(6),this.charReceived=0,this.charLength=0};j.prototype.write=function(a){for(var b="";this.charLength;){var c=a.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:a.length;if(a.copy(this.charBuffer,this.charReceived,0,c),this.charReceived+=c,this.charReceived=55296&&56319>=d)){if(this.charReceived=this.charLength=0,0===a.length)return b;break}this.charLength+=this.surrogateSize,b=""}this.detectIncompleteChar(a);var e=a.length;this.charLength&&(a.copy(this.charBuffer,0,a.length-this.charReceived,e),e-=this.charReceived),b+=a.toString(this.encoding,0,e);var e=b.length-1,d=b.charCodeAt(e);if(d>=55296&&56319>=d){var f=this.surrogateSize;return this.charLength+=f,this.charReceived+=f,this.charBuffer.copy(this.charBuffer,f,0,f),a.copy(this.charBuffer,0,0,f),b.substring(0,e)}return b},j.prototype.detectIncompleteChar=function(a){for(var b=a.length>=3?3:a.length;b>0;b--){var c=a[a.length-b];if(1==b&&c>>5==6){this.charLength=2;break}if(2>=b&&c>>4==14){this.charLength=3;break}if(3>=b&&c>>3==30){this.charLength=4;break}}this.charReceived=b},j.prototype.end=function(a){var b="";if(a&&a.length&&(b=this.write(a)),this.charReceived){var c=this.charReceived,d=this.charBuffer,e=this.encoding;b+=d.slice(0,c).toString(e)}return b}},{buffer:38}],87:[function(a,b,c){function d(){}function e(a){var b={}.toString.call(a);switch(b){case"[object File]":case"[object Blob]":case"[object FormData]":return!0;default:return!1}}function f(a){return a===Object(a)}function g(a){if(!f(a))return a;var b=[];for(var c in a)null!=a[c]&&b.push(encodeURIComponent(c)+"="+encodeURIComponent(a[c]));return b.join("&")}function h(a){for(var b,c,d={},e=a.split("&"),f=0,g=e.length;g>f;++f)c=e[f],b=c.split("="),d[decodeURIComponent(b[0])]=decodeURIComponent(b[1]);return d}function i(a){var b,c,d,e,f=a.split(/\r?\n/),g={};f.pop();for(var h=0,i=f.length;i>h;++h)c=f[h],b=c.indexOf(":"),d=c.slice(0,b).toLowerCase(),e=r(c.slice(b+1)),g[d]=e;return g}function j(a){return a.split(/ *; */).shift()}function k(a){return q(a.split(/ *; */),function(a,b){var c=b.split(/ *= */),d=c.shift(),e=c.shift();return d&&e&&(a[d]=e),a},{})}function l(a,b){b=b||{},this.req=a,this.xhr=this.req.xhr,this.text="HEAD"!=this.req.method&&(""===this.xhr.responseType||"text"===this.xhr.responseType)||"undefined"==typeof this.xhr.responseType?this.xhr.responseText:null,this.statusText=this.req.xhr.statusText,this.setStatusProperties(this.xhr.status),this.header=this.headers=i(this.xhr.getAllResponseHeaders()),this.header["content-type"]=this.xhr.getResponseHeader("content-type"),this.setHeaderProperties(this.header),this.body="HEAD"!=this.req.method?this.parseBody(this.text?this.text:this.xhr.response):null}function m(a,b){var c=this;p.call(this),this._query=this._query||[],this.method=a,this.url=b,this.header={},this._header={},this.on("end",function(){var a=null,b=null;try{b=new l(c)}catch(d){return a=new Error("Parser is unable to parse the response"),a.parse=!0,a.original=d,c.callback(a)}if(c.emit("response",b),a)return c.callback(a,b);if(b.status>=200&&b.status<300)return c.callback(a,b);var e=new Error(b.statusText||"Unsuccessful HTTP response");e.original=a,e.response=b,e.status=b.status,c.callback(e,b)})}function n(a,b){return"function"==typeof b?new m("GET",a).end(b):1==arguments.length?new m("GET",a):new m(a,b)}var o,p=a("emitter"),q=a("reduce");o="undefined"!=typeof window?window:"undefined"!=typeof self?self:this,n.getXHR=function(){if(!(!o.XMLHttpRequest||o.location&&"file:"==o.location.protocol&&o.ActiveXObject))return new XMLHttpRequest;try{return new ActiveXObject("Microsoft.XMLHTTP")}catch(a){}try{return new ActiveXObject("Msxml2.XMLHTTP.6.0")}catch(a){}try{return new ActiveXObject("Msxml2.XMLHTTP.3.0")}catch(a){}try{return new ActiveXObject("Msxml2.XMLHTTP")}catch(a){}return!1};var r="".trim?function(a){return a.trim()}:function(a){return a.replace(/(^\s*|\s*$)/g,"")};n.serializeObject=g,n.parseString=h,n.types={html:"text/html",json:"application/json",xml:"application/xml",urlencoded:"application/x-www-form-urlencoded",form:"application/x-www-form-urlencoded","form-data":"application/x-www-form-urlencoded"},n.serialize={"application/x-www-form-urlencoded":g,"application/json":JSON.stringify},n.parse={"application/x-www-form-urlencoded":h,"application/json":JSON.parse},l.prototype.get=function(a){return this.header[a.toLowerCase()]},l.prototype.setHeaderProperties=function(a){var b=this.header["content-type"]||"";this.type=j(b);var c=k(b);for(var d in c)this[d]=c[d]},l.prototype.parse=function(a){return this.parser=a,this},l.prototype.parseBody=function(a){var b=this.parser||n.parse[this.type];return b&&a&&(a.length||a instanceof Object)?b(a):null},l.prototype.setStatusProperties=function(a){1223===a&&(a=204);var b=a/100|0;this.status=this.statusCode=a,this.statusType=b,this.info=1==b,this.ok=2==b,this.clientError=4==b,this.serverError=5==b,this.error=4==b||5==b?this.toError():!1,this.accepted=202==a,this.noContent=204==a,this.badRequest=400==a,this.unauthorized=401==a,this.notAcceptable=406==a,this.notFound=404==a,this.forbidden=403==a},l.prototype.toError=function(){var a=this.req,b=a.method,c=a.url,d="cannot "+b+" "+c+" ("+this.status+")",e=new Error(d);return e.status=this.status,e.method=b,e.url=c,e},n.Response=l,p(m.prototype),m.prototype.use=function(a){return a(this),this},m.prototype.timeout=function(a){return this._timeout=a,this},m.prototype.clearTimeout=function(){return this._timeout=0,clearTimeout(this._timer),this},m.prototype.abort=function(){return this.aborted?void 0:(this.aborted=!0,this.xhr.abort(),this.clearTimeout(),this.emit("abort"),this)},m.prototype.set=function(a,b){if(f(a)){for(var c in a)this.set(c,a[c]);return this}return this._header[a.toLowerCase()]=b,this.header[a]=b,this},m.prototype.unset=function(a){return delete this._header[a.toLowerCase()],delete this.header[a],this},m.prototype.getHeader=function(a){return this._header[a.toLowerCase()]},m.prototype.type=function(a){return this.set("Content-Type",n.types[a]||a),this},m.prototype.accept=function(a){return this.set("Accept",n.types[a]||a),this},m.prototype.auth=function(a,b){var c=btoa(a+":"+b);return this.set("Authorization","Basic "+c),this},m.prototype.query=function(a){return"string"!=typeof a&&(a=g(a)),a&&this._query.push(a),this},m.prototype.field=function(a,b){return this._formData||(this._formData=new o.FormData),this._formData.append(a,b),this},m.prototype.attach=function(a,b,c){return this._formData||(this._formData=new o.FormData),this._formData.append(a,b,c),this},m.prototype.send=function(a){var b=f(a),c=this.getHeader("Content-Type");if(b&&f(this._data))for(var d in a)this._data[d]=a[d];else"string"==typeof a?(c||this.type("form"),c=this.getHeader("Content-Type"),"application/x-www-form-urlencoded"==c?this._data=this._data?this._data+"&"+a:a:this._data=(this._data||"")+a):this._data=a;return!b||e(a)?this:(c||this.type("json"),this)},m.prototype.callback=function(a,b){var c=this._callback;this.clearTimeout(),c(a,b)},m.prototype.crossDomainError=function(){var a=new Error("Origin is not allowed by Access-Control-Allow-Origin");a.crossDomain=!0,this.callback(a)},m.prototype.timeoutError=function(){var a=this._timeout,b=new Error("timeout of "+a+"ms exceeded");b.timeout=a,this.callback(b)},m.prototype.withCredentials=function(){return this._withCredentials=!0,this},m.prototype.end=function(a){var b=this,c=this.xhr=n.getXHR(),f=this._query.join("&"),g=this._timeout,h=this._formData||this._data;this._callback=a||d,c.onreadystatechange=function(){if(4==c.readyState){var a;try{a=c.status}catch(d){a=0}if(0==a){if(b.timedout)return b.timeoutError();if(b.aborted)return;return b.crossDomainError()}b.emit("end")}};var i=function(a){a.total>0&&(a.percent=a.loaded/a.total*100),b.emit("progress",a)};this.hasListeners("progress")&&(c.onprogress=i);try{c.upload&&this.hasListeners("progress")&&(c.upload.onprogress=i)}catch(j){}if(g&&!this._timer&&(this._timer=setTimeout(function(){b.timedout=!0,b.abort()},g)),f&&(f=n.serializeObject(f),this.url+=~this.url.indexOf("?")?"&"+f:"?"+f),c.open(this.method,this.url,!0),this._withCredentials&&(c.withCredentials=!0),"GET"!=this.method&&"HEAD"!=this.method&&"string"!=typeof h&&!e(h)){var k=this.getHeader("Content-Type"),l=n.serialize[k?k.split(";")[0]:""];l&&(h=l(h))}for(var m in this.header)null!=this.header[m]&&c.setRequestHeader(m,this.header[m]);return this.emit("request",this),c.send(h),this},m.prototype.then=function(a,b){return this.end(function(c,d){c?b(c):a(d)})},n.Request=m,n.get=function(a,b,c){var d=n("GET",a);return"function"==typeof b&&(c=b,b=null),b&&d.query(b),c&&d.end(c),d},n.head=function(a,b,c){var d=n("HEAD",a);return"function"==typeof b&&(c=b,b=null),b&&d.send(b),c&&d.end(c),d},n.del=function(a,b){var c=n("DELETE",a);return b&&c.end(b),c},n.patch=function(a,b,c){var d=n("PATCH",a);return"function"==typeof b&&(c=b,b=null),b&&d.send(b),c&&d.end(c),d},n.post=function(a,b,c){var d=n("POST",a);return"function"==typeof b&&(c=b,b=null),b&&d.send(b),c&&d.end(c),d},n.put=function(a,b,c){var d=n("PUT",a);return"function"==typeof b&&(c=b,b=null),b&&d.send(b),c&&d.end(c),d},b.exports=n},{emitter:39,reduce:72}],88:[function(a,b,c){(function(a){function c(a,b){function c(){if(!e){if(d("throwDeprecation"))throw new Error(b);d("traceDeprecation")?console.trace(b):console.warn(b),e=!0}return a.apply(this,arguments)}if(d("noDeprecation"))return a;var e=!1;return c}function d(b){try{if(!a.localStorage)return!1}catch(c){return!1}var d=a.localStorage[b];return null==d?!1:"true"===String(d).toLowerCase()}b.exports=c}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],89:[function(a,b,c){b.exports=function(a){return a&&"object"==typeof a&&"function"==typeof a.copy&&"function"==typeof a.fill&&"function"==typeof a.readUInt8}},{}],90:[function(a,b,c){(function(b,d){function e(a,b){var d={seen:[],stylize:g};return arguments.length>=3&&(d.depth=arguments[2]),arguments.length>=4&&(d.colors=arguments[3]),p(b)?d.showHidden=b:b&&c._extend(d,b),v(d.showHidden)&&(d.showHidden=!1),v(d.depth)&&(d.depth=2),v(d.colors)&&(d.colors=!1),v(d.customInspect)&&(d.customInspect=!0),d.colors&&(d.stylize=f),i(d,a,d.depth)}function f(a,b){var c=e.styles[b];return c?"["+e.colors[c][0]+"m"+a+"["+e.colors[c][1]+"m":a}function g(a,b){return a}function h(a){var b={};return a.forEach(function(a,c){b[a]=!0}),b}function i(a,b,d){if(a.customInspect&&b&&A(b.inspect)&&b.inspect!==c.inspect&&(!b.constructor||b.constructor.prototype!==b)){var e=b.inspect(d,a);return t(e)||(e=i(a,e,d)),e}var f=j(a,b);if(f)return f;var g=Object.keys(b),p=h(g);if(a.showHidden&&(g=Object.getOwnPropertyNames(b)),z(b)&&(g.indexOf("message")>=0||g.indexOf("description")>=0))return k(b);if(0===g.length){if(A(b)){var q=b.name?": "+b.name:"";return a.stylize("[Function"+q+"]","special")}if(w(b))return a.stylize(RegExp.prototype.toString.call(b),"regexp");if(y(b))return a.stylize(Date.prototype.toString.call(b),"date");if(z(b))return k(b)}var r="",s=!1,u=["{","}"];if(o(b)&&(s=!0,u=["[","]"]),A(b)){var v=b.name?": "+b.name:"";r=" [Function"+v+"]"}if(w(b)&&(r=" "+RegExp.prototype.toString.call(b)),y(b)&&(r=" "+Date.prototype.toUTCString.call(b)),z(b)&&(r=" "+k(b)),0===g.length&&(!s||0==b.length))return u[0]+r+u[1];if(0>d)return w(b)?a.stylize(RegExp.prototype.toString.call(b),"regexp"):a.stylize("[Object]","special");a.seen.push(b);var x;return x=s?l(a,b,d,p,g):g.map(function(c){return m(a,b,d,p,c,s)}),a.seen.pop(),n(x,r,u)}function j(a,b){if(v(b))return a.stylize("undefined","undefined");if(t(b)){var c="'"+JSON.stringify(b).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return a.stylize(c,"string")}return s(b)?a.stylize(""+b,"number"):p(b)?a.stylize(""+b,"boolean"):q(b)?a.stylize("null","null"):void 0}function k(a){return"["+Error.prototype.toString.call(a)+"]"}function l(a,b,c,d,e){for(var f=[],g=0,h=b.length;h>g;++g)F(b,String(g))?f.push(m(a,b,c,d,String(g),!0)):f.push("");return e.forEach(function(e){e.match(/^\d+$/)||f.push(m(a,b,c,d,e,!0))}),f}function m(a,b,c,d,e,f){var g,h,j;if(j=Object.getOwnPropertyDescriptor(b,e)||{value:b[e]},j.get?h=j.set?a.stylize("[Getter/Setter]","special"):a.stylize("[Getter]","special"):j.set&&(h=a.stylize("[Setter]","special")),F(d,e)||(g="["+e+"]"),h||(a.seen.indexOf(j.value)<0?(h=q(c)?i(a,j.value,null):i(a,j.value,c-1),h.indexOf("\n")>-1&&(h=f?h.split("\n").map(function(a){return" "+a}).join("\n").substr(2):"\n"+h.split("\n").map(function(a){return" "+a}).join("\n"))):h=a.stylize("[Circular]","special")),v(g)){if(f&&e.match(/^\d+$/))return h;g=JSON.stringify(""+e),g.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(g=g.substr(1,g.length-2),g=a.stylize(g,"name")):(g=g.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),g=a.stylize(g,"string"))}return g+": "+h}function n(a,b,c){var d=0,e=a.reduce(function(a,b){return d++,b.indexOf("\n")>=0&&d++,a+b.replace(/\u001b\[\d\d?m/g,"").length+1},0);return e>60?c[0]+(""===b?"":b+"\n ")+" "+a.join(",\n ")+" "+c[1]:c[0]+b+" "+a.join(", ")+" "+c[1]}function o(a){return Array.isArray(a)}function p(a){return"boolean"==typeof a}function q(a){return null===a}function r(a){return null==a}function s(a){return"number"==typeof a}function t(a){return"string"==typeof a}function u(a){return"symbol"==typeof a}function v(a){return void 0===a}function w(a){return x(a)&&"[object RegExp]"===C(a)}function x(a){return"object"==typeof a&&null!==a}function y(a){return x(a)&&"[object Date]"===C(a)}function z(a){return x(a)&&("[object Error]"===C(a)||a instanceof Error)}function A(a){return"function"==typeof a}function B(a){return null===a||"boolean"==typeof a||"number"==typeof a||"string"==typeof a||"symbol"==typeof a||"undefined"==typeof a}function C(a){return Object.prototype.toString.call(a)}function D(a){return 10>a?"0"+a.toString(10):a.toString(10)}function E(){var a=new Date,b=[D(a.getHours()),D(a.getMinutes()),D(a.getSeconds())].join(":");return[a.getDate(),J[a.getMonth()],b].join(" ")}function F(a,b){return Object.prototype.hasOwnProperty.call(a,b)}var G=/%[sdj%]/g;c.format=function(a){if(!t(a)){for(var b=[],c=0;c=f)return a;switch(a){case"%s":return String(d[c++]);case"%d":return Number(d[c++]);case"%j":try{return JSON.stringify(d[c++])}catch(b){return"[Circular]"}default:return a}}),h=d[c];f>c;h=d[++c])g+=q(h)||!x(h)?" "+h:" "+e(h);return g},c.deprecate=function(a,e){function f(){if(!g){if(b.throwDeprecation)throw new Error(e);b.traceDeprecation?console.trace(e):console.error(e),g=!0}return a.apply(this,arguments)}if(v(d.process))return function(){return c.deprecate(a,e).apply(this,arguments)};if(b.noDeprecation===!0)return a;var g=!1;return f};var H,I={};c.debuglog=function(a){if(v(H)&&(H=b.env.NODE_DEBUG||""),a=a.toUpperCase(),!I[a])if(new RegExp("\\b"+a+"\\b","i").test(H)){var d=b.pid;I[a]=function(){var b=c.format.apply(c,arguments);console.error("%s %d: %s",a,d,b)}}else I[a]=function(){};return I[a]},c.inspect=e,e.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]},e.styles={special:"cyan",number:"yellow","boolean":"yellow",undefined:"grey","null":"bold",string:"green",date:"magenta",regexp:"red"},c.isArray=o,c.isBoolean=p,c.isNull=q,c.isNullOrUndefined=r,c.isNumber=s,c.isString=t,c.isSymbol=u,c.isUndefined=v,c.isRegExp=w,c.isObject=x,c.isDate=y,c.isError=z,c.isFunction=A,c.isPrimitive=B,c.isBuffer=a("./support/isBuffer");var J=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];c.log=function(){console.log("%s - %s",E(),c.format.apply(c,arguments))},c.inherits=a("inherits"),c._extend=function(a,b){if(!b||!x(b))return a;for(var c=Object.keys(b),d=c.length;d--;)a[c[d]]=b[c[d]];return a}}).call(this,a("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":89,_process:68,inherits:45}],91:[function(a,b,c){function d(a,b,c){var d;return d=b?new f(a,b):new f(a)}var e=function(){return this}(),f=e.WebSocket||e.MozWebSocket;b.exports=f?d:null,f&&(d.prototype=f.prototype)},{}],92:[function(a,b,c){b.exports=[{executables:{win32:["pol.exe"]},id:0,name:"FINAL FANTASY XI"},{executables:{win32:["ffxiv.exe","ffxiv_dx11.exe"]},id:1,name:"FINAL FANTASY XIV"},{executables:{win32:["Wow.exe","Wow-64.exe"]},id:3,name:"World of Warcraft"},{executables:{darwin:["LoLLauncher.app"],win32:["LolClient.exe","League of Legends.exe"]},id:4,name:"League of Legends"},{executables:{darwin:["Diablo%20III.app"],win32:["Diablo III.exe"]},id:5,name:"Diablo 3"},{executables:{darwin:["dota_osx.app"],win32:["dota2.exe"]},id:6,name:"DOTA 2"},{executables:{darwin:["Heroes.app"],win32:["Heroes of the Storm.exe","HeroesOfTheStorm_x64.exe","HeroesOfTheStorm.exe"]},id:7,name:"Heroes of the Storm"},{executables:{darwin:["Hearthstone.app"],win32:["Hearthstone.exe"]},id:8,name:"Hearthstone"},{executables:{win32:["csgo.exe"]},id:9,name:"Counter-Strike: Global Offensive"},{executables:{win32:["WorldOfTanks.exe"]},id:10,name:"World of Tanks"},{executables:{darwin:["gw2.app"],win32:["Gw2.exe","Gw2-64.exe"]},id:11,name:"Guild Wars 2"},{executables:{win32:["dayz.exe"]},id:12,name:"Day Z"},{executables:{darwin:["starcraft%20ii.app"],win32:["starcraft ii.exe","SC2_x64.exe","SC2.exe"] +},id:13,name:"Starcraft II"},{executables:{win32:["diablo.exe"]},id:14,name:"Diablo"},{executables:{win32:["diablo ii.exe"]},id:15,name:"Diablo 2"},{executables:{win32:["left4dead.exe"]},id:17,name:"Left 4 Dead"},{executables:{darwin:["minecraft.app"],win32:["minecraft.exe"]},id:18,name:"Minecraft"},{executables:{win32:["smite.exe"]},id:19,name:"Smite"},{executables:{win32:["bf4.exe"]},id:20,name:"Battlefield 4"},{executables:{win32:["AoK HD.exe","empires2.exe"]},id:101,name:"Age of Empires II"},{executables:{win32:["age3y.exe"]},id:102,name:"Age of Empires III"},{executables:{win32:["AlanWake.exe"]},id:104,name:"Alan Wake"},{executables:{win32:["alan_wakes_american_nightmare.exe"]},id:105,name:"Alan Wake's American Nightmare"},{executables:{win32:["AlienBreed2Assault.exe"]},id:106,name:"Alien Breed 2: Assault"},{executables:{win32:["Amnesia.exe"]},id:107,name:"Amnesia: The Dark Descent"},{executables:{},id:108,name:"Antichamber"},{executables:{win32:["ArcheAge.exe"]},id:109,name:"ArcheAge"},{executables:{win32:["arma3.exe"]},id:110,name:"Arma III"},{executables:{win32:["AC3SP.exe"]},id:111,name:"Assassin's Creed 3"},{executables:{win32:["Bastion.exe"]},id:112,name:"Bastion"},{executables:{win32:["BF2.exe"]},id:113,name:"Battlefield 2"},{executables:{win32:["bf3.exe"]},id:114,name:"Battlefield 3"},{executables:{win32:["Besiege.exe"]},id:116,name:"Besiege"},{executables:{win32:["Bioshock.exe"]},id:117,name:"Bioshock"},{executables:{win32:["Bioshock2.exe"]},id:118,name:"BioShock II"},{executables:{win32:["BioShockInfinite.exe"]},id:119,name:"BioShock Infinite"},{executables:{win32:["Borderlands2.exe"]},id:122,name:"Borderlands 2"},{executables:{win32:["braid.exe"]},id:123,name:"Braid"},{executables:{win32:["ShippingPC-StormGame.exe"]},id:124,name:"Bulletstorm"},{executables:{win32:["cabal2main.exe"]},id:125,name:"Cabal 2"},{executables:{win32:["CabalMain.exe"]},id:126,name:"Cabal Online"},{executables:{win32:["iw4mp.exe","iw4sp.exe"]},id:127,name:"Call of Duty: Modern Warfare 2"},{executables:{win32:["t6sp.exe"]},id:128,name:"Call of Duty: Black Ops"},{executables:{win32:["iw5mp.exe"]},id:129,name:"Call of Duty: Modern Warfare 3"},{executables:{win32:["RelicCOH.exe"]},id:132,name:"Company of Heroes"},{executables:{win32:["Crysis64.exe"]},id:135,name:"Crysis"},{executables:{win32:["Crysis2.exe"]},id:136,name:"Crysis 2"},{executables:{win32:["Crysis3.exe"]},id:137,name:"Crysis 3"},{executables:{win32:["Crysis.exe"]},id:138,name:"Crysis 4 "},{executables:{win32:["DATA.exe","DARKSOULS.exe"]},id:140,name:"Dark Souls"},{executables:{win32:["DarkSoulsII.exe"]},id:141,name:"Dark Souls II"},{executables:{win32:["dfuw.exe"]},id:142,name:"Darkfall: Unholy Wars"},{executables:{win32:["DCGAME.exe"]},id:144,name:"DC Universe Online"},{executables:{win32:["DeadIslandGame.exe"]},id:145,name:"Dead Island"},{executables:{win32:["deadspace2.exe"]},id:146,name:"Dead Space 2"},{executables:{win32:["LOTDGame.exe"]},id:147,name:"Deadlight"},{executables:{win32:["dxhr.exe","DXHRDC.exe"]},id:148,name:"Deus Ex: Human Revolution"},{executables:{win32:["DeviMayCry4.exe","DevilMayCry4_DX9.exe","DevilMayCry4_DX10.exe","DevilMayCry4SpecialEdition.exe"]},id:149,name:"Devil May Cry 4"},{executables:{win32:["DMC-DevilMayCry.exe"]},id:150,name:"DmC Devil May Cry"},{executables:{win32:["dirt2_game.exe"]},id:154,name:"DiRT 2"},{executables:{win32:["dirt3_game.exe"]},id:155,name:"DiRT 3"},{executables:{win32:["dota.exe"]},id:156,name:"DOTA"},{executables:{win32:["DoubleDragon.exe"]},id:158,name:"Double Dragon Neon"},{executables:{win32:["DragonAge2.exe"]},id:159,name:"Dragon Age II"},{executables:{win32:["DragonAgeInquisition.exe"]},id:160,name:"Dragon Age: Inquisition"},{executables:{win32:["daorigins.exe"]},id:161,name:"Dragon Age: Origins"},{executables:{win32:["DBXV.exe"]},id:162,name:"Dragon Ball XenoVerse"},{executables:{win32:["DukeForever.exe"]},id:163,name:"Duke Nukem Forever"},{executables:{darwin:["Dustforce.app"],win32:["dustforce.exe"]},id:164,name:"Dustforce"},{executables:{win32:["EliteDangerous32.exe"]},id:165,name:"Elite: Dangerous"},{executables:{win32:["exefile.exe"]},id:166,name:"Eve Online"},{executables:{win32:["eqgame.exe"]},id:167,name:"EverQuest"},{executables:{win32:["EverQuest2.exe"]},id:168,name:"EverQuest II"},{executables:{},id:169,name:"EverQuest Next"},{executables:{},id:170,name:"F.E.A.R."},{executables:{win32:["FEAR2.exe"]},id:171,name:"F.E.A.R. 2: Project Origin"},{executables:{win32:["fallout3.exe"]},id:172,name:"Fallout 3"},{executables:{win32:["FalloutNV.exe"]},id:174,name:"Fallout: New Vegas"},{executables:{win32:["farcry3.exe"]},id:175,name:"Far Cry 3"},{executables:{win32:["fifa15.exe"]},id:176,name:"FIFA 15"},{executables:{win32:["FTLGame.exe"]},id:180,name:"FTL: Faster Than Light"},{executables:{win32:["GTAIV.exe"]},id:181,name:"Grand Theft Auto 4"},{executables:{win32:["GTA5.exe"]},id:182,name:"Grand Theft Auto 5"},{executables:{win32:["Gw.exe"]},id:183,name:"Guild Wars"},{executables:{win32:["H1Z1.exe"]},id:186,name:"H1Z1"},{executables:{win32:["HL2HL2.exe","hl2.exe"]},id:188,name:"Half Life 2"},{executables:{win32:["HOMEFRONT.exe"]},id:195,name:"Homefront"},{executables:{win32:["invisibleinc.exe"]},id:196,name:"Invisible Inc."},{executables:{win32:["LANoire.exe"]},id:197,name:"L.A. Noire"},{executables:{win32:["Landmark64.exe"]},id:198,name:"Landmark"},{executables:{win32:["left4dead2.exe"]},id:201,name:"Left 4 Dead 2"},{executables:{win32:["lineage.exe"]},id:203,name:"Lineage"},{executables:{win32:["Magicka.exe"]},id:206,name:"Magicka"},{executables:{win32:["MapleStory.exe"]},id:208,name:"MapleStory"},{executables:{},id:209,name:"Mark of the Ninja"},{executables:{win32:["MassEffect.exe"]},id:210,name:"Mass Effect"},{executables:{win32:["MassEffect2.exe"]},id:211,name:"Mass Effect 2"},{executables:{win32:["MassEffect3Demo.exe","MassEffect3.exe"]},id:212,name:"Mass Effect 3"},{executables:{win32:["METAL GEAR RISING REVENGEANCE.exe"]},id:214,name:"Metal Gear Rising: Revengeance"},{executables:{win32:["metro2033.exe"]},id:215,name:"Metro 2033"},{executables:{win32:["MetroLL.exe"]},id:216,name:"Metro Last Light"},{executables:{win32:["MK10.exe"]},id:218,name:"Mortal Kombat X"},{executables:{win32:["speed.exe"]},id:219,name:"Need For Speed Most Wanted"},{executables:{},id:220,name:"Neverwinder"},{executables:{darwin:["Outlast.app"],win32:["OLGame.exe"]},id:221,name:"Outlast"},{executables:{win32:["PapersPlease.exe"]},id:222,name:"Papers, Please"},{executables:{win32:["payday_win32_release.exe"]},id:223,name:"PAYDAY"},{executables:{win32:["payday2_win32_release.exe"]},id:224,name:"PAYDAY 2"},{executables:{win32:["PillarsOfEternity.exe"]},id:225,name:"Pillars of Eternity"},{executables:{win32:["PA.exe"]},id:226,name:"Planetary Annihilation"},{executables:{win32:["planetside2_x86.exe","PlanetSide2_x64.exe"]},id:227,name:"Planetside 2"},{executables:{win32:["hl2P.exe"]},id:228,name:"Portal"},{executables:{win32:["portal2.exe"]},id:229,name:"Portal 2"},{executables:{win32:["PrimalCarnageGame.exe"]},id:231,name:"Primal Cargnage"},{executables:{win32:["pCARS.exe"]},id:232,name:"Project Cars"},{executables:{win32:["RaceTheSun.exe"]},id:233,name:"Race The Sun"},{executables:{win32:["Rage.exe"]},id:234,name:"RAGE"},{executables:{win32:["ragexe.exe"]},id:235,name:"Ragnarok Online"},{executables:{win32:["rift.exe"]},id:236,name:"Rift"},{executables:{win32:["Rocksmith2014.exe"]},id:237,name:"Rocksmith 2014"},{executables:{win32:["SwiftKit-RS.exe","JagexLauncher.exe","OSBuddy.exe"]},id:238,name:"RuneScape"},{executables:{win32:["Shadowgrounds.exe"]},id:239,name:"Shadowgrounds"},{executables:{win32:["survivor.exe"]},id:240,name:"Shadowgrounds: Survivor"},{executables:{win32:["ShovelKnight.exe"]},id:241,name:"Shovel Knight"},{executables:{win32:["SimCity.exe"]},id:242,name:"SimCity"},{executables:{win32:["SporeApp.exe"]},id:245,name:"Spore"},{executables:{win32:["StarCitizen.exe"]},id:246,name:"Star Citizen"},{executables:{},id:247,name:"Star Trek Online"},{executables:{win32:["battlefront.exe","starwarsbattlefront.exe"]},id:248,name:"Star Wars Battlefront"},{executables:{win32:["swtor.exe"]},id:249,name:"Star Wars: The Old Republic"},{executables:{darwin:["Starbound.app"],win32:["starbound.exe","starbound_opengl.exe"]},id:250,name:"Starbound"},{executables:{win32:["starcraft.exe"]},id:251,name:"Starcraft"},{executables:{win32:["SSFIV.exe"]},id:253,name:"Ultra Street Fighter IV"},{executables:{win32:["superhexagon.exe"]},id:254,name:"Super Hexagon"},{executables:{win32:["swordandsworcery_pc.exe"]},id:255,name:"Superbrothers: Sword & Sworcery EP"},{executables:{win32:["hl2TF.exe"]},id:256,name:"Team Fortress 2"},{executables:{win32:["TERA.exe"]},id:258,name:"TERA"},{executables:{darwin:["Terraria.app"],win32:["Terraria.exe"]},id:259,name:"Terraria"},{executables:{win32:["Bethesda.net_Launcher.exe","eso.exe"]},id:260,name:"The Elder Scrolls Online"},{executables:{win32:["TESV.exe","TESV_original.exe"]},id:261,name:"The Elder Scrolls V: Skyrim"},{executables:{win32:["TheSecretWorld.exe"]},id:262,name:"The Secret World"},{executables:{win32:["TS3.exe","ts3w.exe"]},id:264,name:"The Sims 3"},{executables:{win32:["WALKINGDEAD101.EXE"]},id:265,name:"The Walking Dead"},{executables:{win32:["TheWalkingDead2.exe"]},id:266,name:"The Walking Dead Season Two"},{executables:{win32:["witcher3.exe"]},id:267,name:"The Witcher 3"},{executables:{win32:["Future Soldier.exe"]},id:268,name:"Tom Clancy's Ghost Recon: Future Solider"},{executables:{win32:["TombRaider.exe"]},id:269,name:"Tomb Raider (2013)"},{executables:{win32:["Torchlight.exe"]},id:271,name:"Torchlight"},{executables:{win32:["Torchlight2.exe"]},id:272,name:"Torchlight 2"},{executables:{win32:["Shogun2.exe"]},id:273,name:"Total War: Shogun 2"},{executables:{win32:["Transistor.exe"]},id:274,name:"Transistor"},{executables:{darwin:["Trine.app"],win32:["trine.exe"]},id:275,name:"Trine"},{executables:{darwin:["Trine2.app"],win32:["trine2_32bit.exe"]},id:276,name:"Trine 2"},{executables:{win32:["UOKR.exe"]},id:277,name:"Ultima Online"},{executables:{win32:["aces.exe"]},id:279,name:"War Thunder"},{executables:{darwin:["Warcraft%20III.app","Frozen%20Throne.app"],win32:["Warcraft III.exe","wc3.exe","war3.exe"]},id:281,name:"Warcraft 3: Reign of Chaos"},{executables:{win32:["Warcraft II BNE.exe"]},id:282,name:"Warcraft II"},{executables:{win32:["Warframe.x64.exe","Warframe.exe"]},id:283,name:"Warframe"},{executables:{win32:["watch_dogs.exe"]},id:284,name:"Watch Dogs"},{executables:{win32:["WildStar64.exe","Wildstar.exe"]},id:285,name:"WildStar"},{executables:{win32:["XComGame.exe","XcomEW.exe"]},id:288,name:"XCOM: Enemy Unknown"},{executables:{win32:["DFO.exe","dfo.exe"]},id:289,name:"Dungeon Fighter Online"},{executables:{win32:["aclauncher.exe","acclient.exe"]},id:290,name:"Asheron's Call"},{executables:{win32:["MapleStory2.exe"]},id:291,name:"MapleStory 2"},{executables:{win32:["ksp.exe"]},id:292,name:"Kerbal Space Program"},{executables:{win32:["PINBALL.EXE"]},id:293,name:"3D Pinball: Space Cadet"},{executables:{win32:["dave.exe"]},id:294,name:"Dangerous Dave"},{executables:{win32:["iwbtgbeta(slomo).exe","iwbtgbeta(fs).exe"]},id:295,name:"I Wanna Be The Guy"},{executables:{win32:["MechWarriorOnline.exe ","mwoclient.exe"]},id:296,name:"MechWarrior Online"},{executables:{win32:["dontstarve_steam.exe"]},id:297,name:"Don't Starve"},{executables:{win32:["GalCiv3.exe"]},id:298,name:"Galactic Civilization 3"},{executables:{win32:["Risk of Rain.exe"]},id:299,name:"Risk of Rain"},{executables:{darwin:["Isaac.app"],win32:["Binding_of_Isaac.exe","Isaac.exe"]},id:300,name:"The Binding of Isaac"},{executables:{win32:["RustClient.exe"]},id:301,name:"Rust"},{executables:{win32:["Clicker Heroes.exe"]},id:302,name:"Clicker Heroes"},{executables:{win32:["Brawlhalla.exe"]},id:303,name:"Brawlhalla"},{executables:{win32:["TownOfSalem.exe"]},id:304,name:"Town of Salem"},{executables:{win32:["osu!.exe"]},id:305,name:"osu!"},{executables:{win32:["PathOfExileSteam.exe","PathOfExile.exe"]},id:306,name:"Path of Exile"},{executables:{win32:["Dolphin.exe"]},id:307,name:"Dolphin"},{executables:{win32:["RocketLeague.exe"]},id:308,name:"Rocket League"},{executables:{win32:["TJPP.exe"]},id:309,name:"Jackbox Party Pack"},{executables:{win32:["KFGame.exe"]},id:310,name:"Killing Floor 2"},{executables:{win32:["ShooterGame.exe"]},id:311,name:"Ark: Survival Evolved"},{executables:{win32:["LifeIsStrange.exe"]},id:312,name:"Life Is Strange"},{executables:{win32:["Client_tos.exe"]},id:313,name:"Tree of Savior"},{executables:{win32:["olliolli2.exe"]},id:314,name:"OlliOlli2"},{executables:{win32:["cw.exe"]},id:315,name:"Closers Dimension Conflict"},{executables:{win32:["ESSTEAM.exe","elsword.exe","x2.exe"]},id:316,name:"Elsword"},{executables:{win32:["ori.exe"]},id:317,name:"Ori and the Blind Forest"},{executables:{win32:["Skyforge.exe"]},id:318,name:"Skyforge"},{executables:{win32:["projectzomboid64.exe","projectzomboid32.exe"]},id:319,name:"Project Zomboid"},{executables:{win32:["From_The_Depths.exe"]},id:320,name:"From The Depths"},{executables:{win32:["TheCrew.exe"]},id:321,name:"The Crew"},{executables:{win32:["MarvelHeroes2015.exe"]},id:322,name:"Marvel Heroes 2015"},{executables:{win32:["timeclickers.exe"]},id:324,name:"Time Clickers"},{executables:{win32:["eurotrucks2.exe"]},id:325,name:"Euro Truck Simulator 2"},{executables:{win32:["FarmingSimulator2015Game.exe"]},id:326,name:"Farming Simulator 15"},{executables:{win32:["strife.exe"]},id:327,name:"Strife"},{executables:{win32:["Awesomenauts.exe"]},id:328,name:"Awesomenauts"},{executables:{win32:["Dofus.exe"]},id:329,name:"Dofus"},{executables:{win32:["Boid.exe"]},id:330,name:"Boid"},{executables:{win32:["adventure-capitalist.exe"]},id:331,name:"AdVenture Capitalist"},{executables:{win32:["OrcsMustDie2.exe"]},id:332,name:"Orcs Must Die! 2"},{executables:{win32:["Mountain.exe"]},id:333,name:"Mountain"},{executables:{win32:["Valkyria.exe"]},id:335,name:"Valkyria Chronicles"},{executables:{win32:["ffxiiiimg.exe"]},id:336,name:"Final Fantasy XIII"},{executables:{win32:["TLR.exe"]},id:337,name:"The Last Remnant"},{executables:{win32:["Cities.exe"]},id:339,name:"Cities Skylines"},{executables:{win32:["worldofwarships.exe","WoWSLauncher.exe"]},id:341,name:"World of Warships"},{executables:{win32:["spacegame-Win64-shipping.exe"]},id:342,name:"Fractured Space"},{executables:{win32:["thespacegame.exe"]},id:343,name:"Ascent - The Space Game"},{executables:{win32:["DuckGame.exe"]},id:344,name:"Duck Game"},{executables:{win32:["PPSSPPWindows.exe","PPSSPPWindows64.exe"]},id:345,name:"PPSSPP"},{executables:{win32:["MBAA.exe"]},id:346,name:"Melty Blood Actress Again: Current Code"},{executables:{win32:["TheWolfAmongUs.exe"]},id:347,name:"The Wolf Among Us"},{executables:{win32:["SpaceEngineers.exe"]},id:348,name:"Space Engineers"},{executables:{win32:["Borderlands.exe"]},id:349,name:"Borderlands"},{executables:{win32:["100orange.exe"]},id:351,name:"100% Orange Juice"},{executables:{win32:["reflex.exe"]},id:354,name:"Reflex"},{executables:{win32:["pso2.exe"]},id:355,name:"Phantasy Star Online 2"},{executables:{win32:["AssettoCorsa.exe"]},id:356,name:"Assetto Corsa"},{executables:{win32:["iw3mp.exe","iw3sp.exe"]},id:357,name:"Call of Duty 4: Modern Warfare"},{executables:{win32:["WolfOldBlood_x64.exe"]},id:358,name:"Wolfenstein: The Old Blood"},{executables:{win32:["castle.exe"]},id:359,name:"Castle Crashers"},{executables:{win32:["vindictus.exe"]},id:360,name:"Vindictus"},{executables:{win32:["ShooterGame-Win32-Shipping.exe"]},id:361,name:"Dirty Bomb"},{executables:{win32:["BatmanAK.exe"]},id:362,name:"Batman Arkham Knight"},{executables:{win32:["drt.exe"]},id:363,name:"Dirt Rally"},{executables:{win32:["rFactor.exe"]},id:364,name:"rFactor"},{executables:{win32:["clonk.exe"]},id:365,name:"Clonk Rage"},{executables:{win32:["SRHK.exe"]},id:366,name:"Shadowrun: Hong Kong"},{executables:{win32:["Insurgency.exe"]},id:367,name:"Insurgency"},{executables:{win32:["StepMania.exe"]},id:368,name:"Step Mania"},{executables:{win32:["FirefallCLient.exe"]},id:369,name:"Firefall"},{executables:{win32:["mirrorsedge.exe"]},id:370,name:"Mirrors Edge"},{executables:{win32:["MgsGroundZeroes.exe"]},id:371,name:"Metal Gear Solid V: Ground Zeroes"},{executables:{win32:["mgsvtpp.exe"]},id:372,name:"Metal Gear Solid V: The Phantom Pain"},{executables:{win32:["tld.exe"]},id:373,name:"The Long Dark"},{executables:{win32:["TKOM.exe"]},id:374,name:"Take On Mars"},{executables:{win32:["robloxplayerlauncher.exe","Roblox.exe","RobloxPlayerBeta.exe"]},id:375,name:"Roblox"},{executables:{darwin:["eu4.app"],win32:["eu4.exe"]},id:376,name:"Europa Universalis 4"},{executables:{win32:["APB.exe"]},id:377,name:"APB Reloaded"},{executables:{win32:["Robocraft.exe","RobocraftClient.exe"]},id:378,name:"Robocraft"},{executables:{win32:["Unity.exe"]},id:379,name:"Unity"},{executables:{win32:["Simpsons.exe"]},id:380,name:"The Simpsons: Hit & Run"},{executables:{win32:["Dnlauncher.exe","DragonNest.exe"]},id:381,name:"Dragon Nest"},{executables:{win32:["Trove.exe"]},id:382,name:"Trove"},{executables:{win32:["EndlessLegend.exe"]},id:383,name:"Endless Legend"},{executables:{win32:["TurbineLauncher.exe","dndclient.exe"]},id:384,name:"Dungeons & Dragons Online"},{executables:{win32:["quakelive.exe","quakelive_steam.exe"]},id:385,name:"Quake Live"},{executables:{win32:["7DaysToDie.exe"]},id:386,name:"7DaysToDie"},{executables:{win32:["SpeedRunners.exe"]},id:387,name:"SpeedRunners"},{executables:{win32:["gamemd.exe"]},id:388,name:"Command & Conquer: Red Alert 2"},{executables:{win32:["generals.exe"]},id:389,name:"Command & Conquer Generals: Zero Hour"},{executables:{win32:["Oblivion.exe"]},id:390,name:"The Elder Scrolls 4: Oblivion"},{executables:{win32:["mgsi.exe"]},id:391,name:"Metal Gear Solid"},{executables:{win32:["EoCApp.exe"]},id:392,name:"Divinity - Original Sin"},{executables:{win32:["Torment.exe"]},id:393,name:"Planescape: Torment"},{executables:{win32:["HexPatch.exe","Hex.exe"]},id:394,name:"Hex: Shards of Fate"},{executables:{win32:["NS3FB.exe"]},id:395,name:"Naruto Shippuden Ultimate Ninja Storm 3 Full Burst"},{executables:{win32:["NSUNSR.exe"]},id:396,name:"Naruto Shippuden Ultimate Ninja Storm Revolution"},{executables:{win32:["SaintsRowIV.exe"]},id:397,name:"Saints Row IV"},{executables:{win32:["Shadowrun.exe"]},id:398,name:"Shadowrun"},{executables:{win32:["DungeonoftheEndless.exe"]},id:399,name:"Dungeon of the Endless"},{executables:{win32:["Hon.exe"]},id:400,name:"Heroes of Newerth"},{executables:{win32:["Mabinogi.exe"]},id:401,name:"Mabinogi"},{executables:{win32:["CoD2MP_s.exe","CoD2SP_s.exe"]},id:402,name:"Call of Duty 2:"},{executables:{win32:["CoDWaWmp.exe","CoDWaw.exe"]},id:403,name:"Call of Duty: World at War"},{executables:{win32:["heroes.exe"]},id:404,name:"Mabinogi Heroes (Vindictus) "},{executables:{win32:["KanColleViewer.exe","ElectronicObserver.exe"]},id:405,name:"Kantai Collection"},{executables:{win32:["cyphers.exe"]},id:406,name:"Cyphers"},{executables:{win32:["RelicCoH2.exe"]},id:407,name:"Company of Heroes 2"},{executables:{win32:["MJ.exe"]},id:408,name:"セガNET麻雀MJ"},{executables:{win32:["ge.exe"]},id:409,name:"Granado Espada"},{executables:{win32:["NovaRO.exe"]},id:410,name:"Nova Ragnarok Online"},{executables:{win32:["RivalsofAether.exe"]},id:411,name:"Rivals of Aether"},{executables:{win32:["bfh.exe"]},id:412,name:"Battlefield Hardline"},{executables:{win32:["GrowHome.exe"]},id:413,name:"Grow Home"},{executables:{win32:["patriots.exe"]},id:414,name:"Rise of Nations Extended"},{executables:{win32:["Railroads.exe"]},id:415,name:"Sid Meier's Railroads!"},{executables:{win32:["Empire.exe"]},id:416,name:"Empire: Total War"},{executables:{win32:["Napoleon.exe"]},id:417,name:"Napoleon: Total War"},{executables:{win32:["gta_sa.exe"]},id:418,name:"Grand Theft Auto: San Andreas"},{executables:{win32:["MadMax.exe"]},id:419,name:"Mad Max"},{executables:{win32:["Titanfall.exe"]},id:420,name:"Titanfall"},{executables:{win32:["age2_x1.exe"]},id:421,name:"Age of Empires II: The Conquerors"},{executables:{win32:["Rome2.exe"]},id:422,name:"Total War: ROME 2"},{executables:{win32:["ShadowOfMordor.exe"]},id:423,name:"Middle-earth: Shadow of Mordor"},{executables:{win32:["Subnautica.exe"]},id:424,name:"Subnautica"},{executables:{win32:["anno5.exe"]},id:425,name:"Anno 2070"},{executables:{win32:["carrier.exe"]},id:426,name:"Carrier Command Gaea Mission"},{executables:{win32:["DarksidersPC.exe"]},id:427,name:"Darksiders"},{executables:{win32:["Darksiders2.exe"]},id:428,name:"Darksiders 2"},{executables:{win32:["mudlet.exe"]},id:429,name:"Mudlet"},{executables:{win32:["DunDefLauncher.exe","DunDefGame.exe"]},id:430,name:"Dungeon Defenders II"},{executables:{win32:["hng.exe"]},id:431,name:"Heroes and Generals"},{executables:{win32:["WFTOGame.exe"]},id:432,name:"War For the Overworld"},{executables:{win32:["Talisman.exe"]},id:433,name:"Talisman: Digital Edition"},{executables:{win32:["limbo.exe"]},id:434,name:"Limbo"},{executables:{win32:["ibbobb.exe"]},id:435,name:"ibb & obb"},{executables:{win32:["BattleBlockTheater.exe"]},id:436,name:"BattleBlock Theater"},{executables:{win32:["iracinglauncher.exe","iracingsim.exe","iracingsim64.exe"]},id:437,name:"iRacing"},{executables:{win32:["CivilizationV_DX11.exe"]},id:438,name:"Civilization V"},{executables:{win32:["lostsaga.exe","LoginLauncherN.exe"]},id:439,name:"Lost Saga"},{executables:{win32:["nuclearthrone.exe"]},id:440,name:"Nuclear Throne"},{executables:{win32:["SwordCoast.exe"]},id:441,name:"Sword Coast Legends"},{executables:{win32:["FF3_Launcher.exe"]},id:442,name:"Final Fantasy III"},{executables:{darwin:["UNDERTALE.app"],win32:["UNDERTALE.exe"]},id:443,name:"Undertale"},{executables:{win32:["Blockland.exe"]},id:444,name:"Blockland"},{executables:{win32:["DNF.exe"]},id:445,name:"Dungeon & Fighter"},{executables:{win32:["Bugs.exe"]},id:446,name:"BBLiT"},{executables:{win32:["grid2.exe"]},id:447,name:"Grid 2"},{executables:{win32:["RainbowSix.exe"]},id:448,name:"Rainbow Six Siege"},{executables:{win32:["rotaku.exe"]},id:449,name:"Rotaku Society"},{executables:{win32:["Cube.exe"]},id:450,name:"Cube World"},{executables:{win32:["TS4.exe"]},id:451,name:"The Sims 4"},{executables:{win32:["nekopara_vol1.exe"]},id:452,name:"Nekopara Vol. 1"},{executables:{win32:["nekopara_vol0.exe"]},id:453,name:"Nekopara Vol. 0"},{executables:{win32:["FreeStyle2.exe"]},id:454,name:"Freestyle Basketball 2"},{executables:{win32:["HMA.exe"]},id:455,name:"Hitman: Absolution"},{executables:{win32:["SaintsRowTheThird_DX11.exe","SaintsRowTheThird.exe"]},id:456,name:"Saints Row 3"},{executables:{win32:["JustCause.exe"]},id:457,name:"Just Cause"},{executables:{win32:["KillingFloor.exe"]},id:458,name:"Killing Floor"},{executables:{win32:["DeadIslandGame_x86_rwdi.exe"]},id:459,name:"Dead Island Riptide"},{executables:{win32:["JustCause2.exe"]},id:460,name:"Just Cause 2"},{executables:{win32:["altitude.exe"]},id:461,name:"Altitude"},{executables:{darwin:["ygopro.app"],win32:["ygopro_vs.exe"]},id:462,name:"Yu-gi-oh Pro"},{executables:{win32:["bejeweled3.exe"]},id:463,name:"Bejeweled 3"},{executables:{win32:["fable.exe"]},id:464,name:"Fable: The Lost Chapters"},{executables:{win32:["lyne.exe"]},id:465,name:"LYNE"},{executables:{win32:["Tabletop Simulator.exe"]},id:466,name:"Tabletop Simulator"},{executables:{win32:["screencheat.exe"]},id:467,name:"Screencheat"},{executables:{win32:["cataclysm-tiles.exe"]},id:468,name:"Cataclysm: Dark Days Ahead"},{executables:{win32:["Prison Architect.exe"]},id:469,name:"Prison Architect"},{executables:{win32:["armoredwarfare.exe"]},id:470,name:"Armored Warfare"},{executables:{win32:["Devilian.exe"]},id:471,name:"Devilian"},{executables:{win32:["aion.bin"]},id:472,name:"Aion"},{executables:{win32:["Allegiance.exe"]},id:473,name:"Allegiance"},{executables:{win32:["infantry.exe"]},id:474,name:"Infantry"},{executables:{win32:["audiosurf.exe","Questviewer.exe"]},id:475,name:"Audiosurf"},{executables:{win32:["audiosurf2.exe"]},id:476,name:"Audiosurf 2"},{executables:{win32:["morrowind.exe"]},id:477,name:"Morrowind"},{executables:{win32:["GoatGame-Win32-Shipping.exe"]},id:478,name:"Goat Simulator"},{executables:{win32:["th123.exe","th123e.exe"]},id:479,name:"Touhou 12.3: Hisoutensoku"},{executables:{win32:["th135.exe","th135e.exe"]},id:480,name:"Touhou 13.5 Hopeless Mascarade"},{executables:{win32:["th145.exe","th145e.exe"]},id:481,name:"Touhou 14.5: Urban Legend in Limbo"},{executables:{win32:["quake1.exe"]},id:482,name:"Quake I"},{executables:{win32:["quake2.exe"]},id:483,name:"Quake II"},{executables:{win32:["quake3.exe"]},id:484,name:"Quake III"},{executables:{win32:["MONACO.exe"]},id:485,name:"Monaco: What's Yours Is Mine"},{executables:{win32:["ToothAndTail.exe"]},id:486,name:"Tooth & Tail"},{executables:{win32:["PD.exe"]},id:487,name:"Pixel Dungeon"},{executables:{win32:["BlackDesert32.exe","BlackDesert64.exe"]},id:488,name:"Black Desert Online"},{executables:{win32:["LovelyPlanet.exe"]},id:489,name:"Lovely Planet"},{executables:{win32:["DeadCore.exe"]},id:490,name:"DeadCore"},{executables:{win32:["fifa16.exe"]},id:491,name:"FIFA 16"},{executables:{win32:["KAG.exe"]},id:492,name:"King Arthur's Gold"},{executables:{win32:["TR.exe"]},id:493,name:"Trench Run"},{executables:{win32:["fm.exe"]},id:494,name:"Football Manager 2014"},{executables:{win32:["NecroDancer.exe"]},id:495,name:"Crypt of the NecroDancer"},{executables:{win32:["EthanCarter-Win64-Shipping.exe"]},id:496,name:"The Vanishing of Ethan Carter Redux"},{executables:{win32:["AstronautsGame-Win64-Shipping.exe"]},id:497,name:"The Vanishing of Ethan Carter"},{executables:{win32:["fsx.exe"]},id:498,name:"Microsoft Flight Simulator X"},{executables:{win32:["Prepar3D.exe"]},id:499,name:"Prepar3D"},{executables:{win32:["lumini_Win64.exe"]},id:500,name:"Lumini"},{executables:{win32:["BeatHazard.exe"]},id:501,name:"Beat Hazard"},{executables:{win32:["TribesAscend.exe"]},id:502,name:"Tribes Ascend"},{executables:{win32:["Supernova.exe"]},id:503,name:"Supernova"},{executables:{win32:["NitronicRush.exe"]},id:504,name:"Nitronic Rush"},{executables:{win32:["Might & Magic Heroes VI.exe"]},id:505,name:"Might & Magic Heroes VI"},{executables:{win32:["AdvHD.exe"]},id:506,name:"If My Heart Had Wings"},{executables:{win32:["hatoful.exe"]},id:507,name:"Hatoful Boyfriend"},{executables:{win32:["HuniePop.exe"]},id:508,name:"HuniePop"},{executables:{win32:["SC2VN.exe"]},id:509,name:"SC2VN: The e-sport Visual Novel"},{executables:{win32:["Pyrite Heart.exe"]},id:510,name:"Pyrite Heart"},{executables:{win32:["Sakura Angels.exe"]},id:511,name:"Sakura Angels"},{executables:{win32:["BGI.exe"]},id:512,name:"Go! Go! Nippon! ~My First Trip to Japan~"},{executables:{win32:["Sword of Asumi.exe"]},id:513,name:"Sword of Asumi"},{executables:{win32:["Sakura Clicker.exe"]},id:514,name:"Sakura Clicker"},{executables:{win32:["Sakura Spirit.exe"]},id:515,name:"Sakura Spirit"},{executables:{win32:["NeoAquarium.exe"]},id:516,name:"NEO AQUARIUM - The King of Crustaceans"},{executables:{win32:["Nicole.exe"]},id:517,name:"Nicole (Otome Version)"},{executables:{win32:["LongLiveTheQueen.exe"]},id:518,name:"Long Live The Queen"},{executables:{win32:["The Sacred Tears TRUE.exe"]},id:519,name:"The Sacred Tears TRUE"},{executables:{win32:["trgame.exe"]},id:520,name:"Tales Runner"},{executables:{win32:["CelebrityPoker.exe"]},id:521,name:"Poker Night at the Inventory"},{executables:{win32:["PokerNight2.exe"]},id:522,name:"Poker Night 2"},{executables:{win32:["PokeMMO.exe"]},id:523,name:"PokeMMO"},{executables:{win32:["LoversInADangerousSpacetime.exe"]},id:524,name:"Lovers in a Dangerous Spacetime"},{executables:{win32:["tis100.exe"]},id:525,name:"TIS-100"},{executables:{win32:["TTREngine.exe"]},id:526,name:"Toontown"},{executables:{win32:["mgs2_sse.exe"]},id:527,name:"Metal Gear Solid 2: Substance"},{executables:{win32:["hl.exe"]},id:528,name:"Half Life"},{executables:{win32:["Cloudbuilt.exe"]},id:529,name:"Cloudbuilt"},{executables:{win32:["ACBSP.exe","ACBMP.exe"]},id:530,name:"Assassin's Creed: Brotherhood"},{executables:{win32:["mm.exe"]},id:531,name:"Dark Messiah of Might & Magic"},{executables:{win32:["Stalker-COP.exe"]},id:532,name:"S.T.A.L.K.E.R.: Call of Pripyat"},{executables:{win32:["ROGame.exe"]},id:533,name:"Rising Storm/Red Orchestra 2"},{executables:{win32:["strife-ve.exe"]},id:534,name:"Strife: Veteran Edition"},{executables:{win32:["BFBC2Game.exe"]},id:535,name:"Battlefield: Bad Company 2"},{executables:{win32:["FarCry2.exe"]},id:536,name:"Far Cry 2"},{executables:{win32:["Nidhogg.exe"]},id:537,name:"Nidhogg"},{executables:{win32:["pbbg_win32.exe"]},id:538,name:"Phantom Break: Baggle Grounds"},{executables:{darwin:["Wakfu.app"],win32:["Wakfu.exe"]},id:539,name:"Wakfu"},{executables:{win32:["wizard101.exe"]},id:540,name:"Wzard101"},{executables:{win32:["BarkleyV120.exe"]},id:541,name:"Charles Barkley: Shut Up and Jam Gaiden"},{executables:{win32:["RimWorld914Win.exe"]},id:542,name:"RimWorld"},{executables:{win32:["Order of Battle - Pacific.exe"]},id:543,name:"Order of Battle"},{executables:{win32:["gh3.exe"]},id:544,name:"Guitar Hero III: Legends of Rock"},{executables:{win32:["phase_shift.exe"]},id:545,name:"Phase Shift"},{executables:{win32:["GHWT.exe"]},id:546,name:"Guitar Hero World Tour"},{executables:{win32:["THEMOD 1.3.exe","THUG2.exe"]},id:547,name:"Tony Hawk's Underground 2"},{executables:{win32:["THUGPro.exe"]},id:548,name:"THUG Pro"},{executables:{win32:["THUG.exe "]},id:549,name:"Tony Hawk's Underground"},{executables:{darwin:["The Binding of Isaac Rebirth.app","The%20Binding%20of%20Isaac%20Rebirth.app"],win32:["isaac-ng.exe"]},id:550,name:"The Binding of Isaac: Rebirth"},{executables:{win32:["ProjectG.exe"]},id:551,name:"PangYa!"},{executables:{win32:["Overwatch.exe","GameClientApp.exe","Overwatch Launcher.exe"]},id:552,name:"Overwatch"},{executables:{win32:["CivilizationBE_DX11.exe","CivilizationBE_Mantle.exe"]},id:553,name:"Civilization Beyond Earth"},{executables:{win32:["SecretPonchosD3D11.exe"]},id:554,name:"Secret Ponchos"},{executables:{win32:["Duelyst.exe"]},id:555,name:"Duelyst"},{executables:{win32:["vermintide.exe"]},id:556,name:"Warhammer: End Times - Vermintide"},{executables:{darwin:["Huniepop.app"]},id:557,name:"Hunie Pop"},{executables:{darwin:["Reus.app"],win32:["reus.exe"]},id:558,name:"Reus"},{executables:{darwin:["Everlasting%20Summer.app"]},id:559,name:"Everlasting Summer"},{executables:{darwin:["GunsofIcarusOnline.app"]},id:560,name:"Guns of Icarus - Online"},{executables:{darwin:["Rising%20Angels%20-%20Reborn.app"]},id:561,name:"Rising Angels - Reborn"},{executables:{darwin:["Hate%20Plus.app"]},id:562,name:"Hate Plus"},{executables:{win32:["dcs.exe"]},id:563,name:"DCS World"},{executables:{win32:["arena.exe"]},id:564,name:"Total War: Arena"},{executables:{win32:["Pokemon Trading Card Game Online.exe"]},id:565,name:"Pokemon Trading Card Game Online"},{executables:{win32:["Tales of Zestiria.exe"]},id:566,name:"Tales of Zestiria"},{executables:{win32:["ns2.exe"]},id:567,name:"Natural Selection 2"},{executables:{win32:["Rayman Legends.exe"]},id:568,name:"Rayman Legends"},{executables:{darwin:["avalonlords.app"],win32:["avalonlords.exe"]},id:569,name:"Avalon Lords"},{executables:{win32:["th06.exe","th06e.exe"]},id:570,name:"Touhou 6: Embodiment of Scarlet Devil"},{executables:{win32:["th07.exe","th07e.exe"]},id:571,name:"Touhou 7: Perfect Cherry Blossom"},{executables:{win32:["th08.exe","th08e.exe"]},id:572,name:"Touhou 8: Imperishable Night"},{executables:{win32:["th09.exe","th09e.exe"]},id:573,name:"Touhou 9: Phantasmagoria Of Flower View"},{executables:{win32:["th095.exe","th095e.exe"]},id:574,name:"Touhou 9.5: Shoot the Bullet"},{executables:{win32:["th10.exe","th10e.exe"]},id:575,name:"Touhou 10: Mountain of Faith"},{executables:{win32:["th105.exe","th105e.exe"]},id:576,name:"Touhou 10.5: Scarlet Weather Rhapsody"},{executables:{win32:["th11.exe","th11e.exe"]},id:577,name:"Touhou 11: Subterranean Animism" +},{executables:{win32:["th12.exe","th12e.exe"]},id:578,name:"Touhou 12: Undefined Fantastic Object"},{executables:{win32:["th125.exe","th125e.exe"]},id:579,name:"Touhou 12.5: Double Spoiler"},{executables:{win32:["th128.exe","th128e.exe"]},id:580,name:"Touhou 12.8: Great Fairy Wars"},{executables:{win32:["th13.exe","th13e.exe"]},id:581,name:"Touhou 13: Ten Desires"},{executables:{win32:["th14.exe","th14e.exe"]},id:582,name:"Touhou 14: Double Dealing Character"},{executables:{win32:["th143.exe","th143e.exe"]},id:583,name:"Touhou 14.3: Impossible Spell Card"},{executables:{win32:["th15.exe","th15e.exe"]},id:584,name:"Touhou 15: Legacy of Lunatic Kingdom"},{executables:{win32:["grandia2.exe"]},id:585,name:"Grandia 2"},{executables:{win32:["Albion-Online.exe"]},id:586,name:"Albion Online"},{executables:{win32:["ThereWasACaveman.exe"]},id:587,name:"There Was A Caveman"},{executables:{win32:["ASN_App_PcDx9_Final.exe"]},id:588,name:"Sonic & All Stars Racing Transformed"},{executables:{win32:["Cryptark.exe"]},id:589,name:"CRYPTARK"},{executables:{win32:["Entropia.exe"]},id:590,name:"Entropia Universe"},{executables:{win32:["DepthGame.exe"]},id:591,name:"Depth"},{executables:{win32:["Factorio.exe"]},id:592,name:"Factorio"},{executables:{win32:["ChildofLight.exe"]},id:593,name:"Child of Light"},{executables:{win32:["TransformersDevatstation.exe"]},id:594,name:"Transformers: Devastation"},{executables:{win32:["oppw3.exe"]},id:595,name:"One Piece Pirate Warriors 3"},{executables:{win32:["Astebreed.exe"]},id:596,name:"Astebreed"},{executables:{win32:["ktane.exe"]},id:597,name:"Keep Talking and Nobody Explodes"},{executables:{win32:["Steredenn.exe"]},id:598,name:"Steredenn"},{executables:{win32:["CK2game.exe"]},id:599,name:"Crusader Kings II"},{executables:{win32:["jamp.exe","openjk.x86.exe"]},id:600,name:"Star Wars Jedi Knight"},{executables:{win32:["jk2mp.exe","jk2mvmp_x86.exe","jk2mvmp_x64.exe"]},id:601,name:"Star Wars Jedi Knight II"},{executables:{win32:["FightCade.exe"]},id:602,name:"FightCade"},{executables:{win32:["Downwell.exe"]},id:603,name:"Downwell"},{executables:{win32:["flamebreak.exe"]},id:604,name:"Flamebreak"},{executables:{win32:["Disco Dodgeball.exe"]},id:605,name:"Robot Roller-Derby Disco Dodgeball"},{executables:{win32:["DarkStarOne.exe"]},id:606,name:"DarkStar One"},{executables:{win32:["20XX.exe"]},id:607,name:"20XX"},{executables:{win32:["wesnoth.exe"]},id:608,name:"Battle for Wesnoth"},{executables:{win32:["Creativerse.exe"]},id:609,name:"Creativerse"},{executables:{win32:["BlockNLoad.exe"]},id:610,name:"Block n Load"},{executables:{win32:["rwr_game.exe"]},id:611,name:"Running with Rifles"},{executables:{win32:["Evolve.exe"]},id:612,name:"Evolve"},{executables:{win32:["et.exe"]},id:613,name:"Wolfenstein - Enemy Territory"},{executables:{win32:["C9.exe"]},id:614,name:"C9"},{executables:{win32:["Multi Theft Auto.exe"]},id:615,name:"Multi Theft Auto San Andreas"},{executables:{win32:["SpecOpsTheLine.exe"]},id:616,name:"Spec Ops: The Line"},{executables:{win32:["stanley.exe"]},id:617,name:"The Stanley Parable"},{executables:{win32:["Secrets Of Grindea.exe"]},id:618,name:"Secrets of Grindea"},{executables:{win32:["MugenSouls.exe"]},id:619,name:"Mugen Souls "},{executables:{win32:["RebelGalaxyGOG.exe","RebelGalaxySteam.exe"]},id:620,name:"Rebel Galaxy"},{executables:{win32:["rerev.exe"]},id:621,name:"Resident Evil Revelations"},{executables:{win32:["rerev2.exe"]},id:622,name:"Resident Evil Revelations 2"},{executables:{win32:["re5dx9.exe"]},id:623,name:"Resident Evil 5"},{executables:{win32:["bio4.exe"]},id:624,name:"Resident Evil 4 HD"},{executables:{win32:["bhd.exe"]},id:625,name:"Resident Evil 4HD Remaster"},{executables:{win32:["SSF2.exe"]},id:626,name:"Super Smash Flash 2 "},{executables:{win32:["AI.exe"]},id:627,name:"Alien: Isolation"},{executables:{win32:["dungeonland.exe"]},id:628,name:"Dungeonland"},{executables:{win32:["TerraTechWin32.exe"]},id:629,name:"TerraTech"},{executables:{win32:["beginnersguide.exe"]},id:630,name:"The Beginner's Guide"},{executables:{win32:["StreetFighterVBeta-Win64-Shipping.exe"]},id:631,name:"Street Fighter V"},{executables:{win32:["bf4cte.exe"]},id:632,name:"Battlefiled 4 CTE"},{executables:{win32:["Suguri.exe"]},id:633,name:"Suguri"},{executables:{win32:["UT3.exe"]},id:634,name:"Unreal Tournament 3"},{executables:{win32:["Unreal.exe"]},id:635,name:"Unreal"},{executables:{win32:["AVA.exe"]},id:636,name:"Alliance of Valiant Arms"},{executables:{win32:["ShooterUltimate.exe"]},id:637,name:"PixelJunk Shooter Ultimate"},{executables:{win32:["pokemonshowdown.exe"]},id:638,name:"Pokemon Showdown"},{executables:{win32:["SuperMeatBoy.exe"]},id:639,name:"Super Meat Boy"},{executables:{win32:["Kara no Shojo 2.exe"]},id:640,name:"Kara no Shoujo 2"},{executables:{win32:["Intruder.exe"]},id:641,name:"Intruder"},{executables:{win32:["Aeon Rivals.exe"]},id:642,name:"Aeon Rivals"},{executables:{win32:["Rats.exe"]},id:643,name:"Bad Rats"},{executables:{win32:["BH6.exe"]},id:644,name:"Resident Evil 6"},{executables:{win32:["ZOMBI.exe"]},id:645,name:"Zombi"},{executables:{win32:["Xenonauts.exe"]},id:646,name:"Xenonauts"},{executables:{win32:["OrganTrail.exe"]},id:647,name:"Organ Trail"},{executables:{darwin:["LethalLeague.app"],win32:["LethalLeague.exe"]},id:648,name:"Lethal League"},{executables:{win32:["blobby.exe"]},id:649,name:"Blobby Volley 2"},{executables:{win32:["DQXGame.exe"]},id:650,name:"Dragon Quest X: Mezameshi Itsutsu no Shuzoku Online"},{executables:{win32:["Dishonored.exe"]},id:651,name:"Dishonored"},{executables:{win32:["TheForest.exe"]},id:652,name:"The Forest"},{executables:{win32:["ThePark.exe"]},id:653,name:"The Park"},{executables:{win32:["FishingPlanet.exe"]},id:654,name:"Fishing Planet"},{executables:{win32:["pso.exe"]},id:655,name:"Phantasy Star Online"},{executables:{},id:656,name:"Our Darker Purpose"},{executables:{win32:["Darkest.exe"]},id:657,name:"Darkest Dungeon"},{executables:{win32:["UE4-Win64-Test.exe"]},id:658,name:"Unreal Tournament 4"},{executables:{win32:["ed6_win2.exe"]},id:659,name:"Trails in the Sky SC"},{executables:{win32:["ed6_win.exe"]},id:660,name:"Trails in the Sky FC"},{executables:{win32:["kshootmania.exe"]},id:661,name:"K-Shoot Mania"},{executables:{win32:["df.exe"]},id:662,name:"Delta Force 1"},{executables:{win32:["BloodlineChampions.exe"]},id:663,name:"Bloodline Champions"},{executables:{win32:["TmForever.exe"]},id:664,name:"Trackmania Nations Forever"},{executables:{win32:["DragonFinSoup.exe"]},id:666,name:"Dragon Fin Soup"},{executables:{win32:["Anno2205.exe"]},id:667,name:"Anno 2205"},{executables:{darwin:["KatawaShoujo.app"]},id:668,name:"Katawa Shoujo"},{executables:{win32:["NeptuniaReBirth1.exe"]},id:669,name:"Hyperdimension Neptunia Re;Birth1"},{executables:{win32:["NeptuniaReBirth2.exe"]},id:670,name:"Hyperdimension Neptunia Re;Birth2"},{executables:{win32:["NeptuniaReBirth3.exe"]},id:671,name:"Hyperdimension Neptunia Re;Birth3"},{executables:{win32:["HatinTimeGame.exe"]},id:672,name:"A Hat in Time"},{executables:{win32:["AxiomVerge.exe"]},id:673,name:"Axiom Verge"},{executables:{win32:["CoJGunslinger.exe"]},id:674,name:"Call of Juarez: Gunslinger"},{executables:{darwin:["CardHunter.app"],win32:["CardHunter.exe"]},id:675,name:"Card Hunter"},{executables:{darwin:["CargoCommander.app"],win32:["CargoCommander.exe"]},id:676,name:"Cargo Commander"},{executables:{win32:["DDO.exe"]},id:677,name:"Dragon's Dogma Online"},{executables:{win32:["falloutw.exe"]},id:678,name:"Fallout"},{executables:{win32:["FALLOUT2.EXE","Fallout2HR.exe"]},id:679,name:"Fallout 2"},{executables:{win32:["Fallout4.exe"]},id:680,name:"Fallout 4"},{executables:{win32:["FarCry4.exe"]},id:681,name:"Far Cry 4"},{executables:{win32:["OpenITG-PC.exe"]},id:682,name:"In The Groove 2"},{executables:{win32:["L2.bin"]},id:683,name:"Lineage II"},{executables:{win32:["LordsOfTheFallen.exe"]},id:684,name:"Lords of the Fallen"},{executables:{win32:["LR2.exe"]},id:685,name:"Lunatic Rave 2"},{executables:{win32:["MBA.exe"]},id:686,name:"Magical Battle Arena"},{executables:{win32:["MBAN_M.exe","MBAN_F.exe"]},id:687,name:"Magical Battle Arena NEXT"},{executables:{win32:["ManiaPlanet.exe"]},id:688,name:"ManiaPlanet"},{executables:{win32:["mhf.exe"]},id:689,name:"Monster Hunter Frontier"},{executables:{win32:["6kinoko.exe"]},id:690,name:"New Super Marisa Land"},{executables:{win32:["Nosgoth.exe"]},id:691,name:"Nosgoth"},{executables:{win32:["Poi.exe"]},id:692,name:"Poi"},{executables:{win32:["RogueSystemSim.exe"]},id:693,name:"Rogue System"},{executables:{darwin:["SinaRun.app"],win32:["SinaRun.exe"]},id:694,name:"SinaRun"},{executables:{win32:["SkullGirls.exe"]},id:695,name:"Skullgirls"},{executables:{win32:["Soma.exe"]},id:696,name:"SOMA"},{executables:{win32:["sonic2app.exe"]},id:697,name:"Sonic Adventure 2"},{executables:{win32:["SonicGenerations.exe"]},id:698,name:"Sonic Generations"},{executables:{win32:["SpaceChem.exe"]},id:699,name:"SpaceChem"},{executables:{win32:["SSFexe.exe"]},id:700,name:"Super Smash Flash 1"},{executables:{win32:["System Shock2.exe","shock2.exe"]},id:701,name:"System Shock 2"},{executables:{win32:["Blacklist_launcher.exe"]},id:702,name:"Tom Clancy's Splinter Cell: Blacklist"},{executables:{win32:["gn_enbu.exe"]},id:703,name:"Touhou Puppet Dance Performance"},{executables:{win32:["TSA.exe"]},id:704,name:"Touhou Sky Arena"},{executables:{win32:["Verdun.exe"]},id:705,name:"Verdun"},{executables:{darwin:["wz2100.app"],win32:["wz2100.exe"]},id:706,name:"Warzone 2100"},{executables:{win32:["WowT-64.exe"]},id:707,name:"World of Warcraft PTR"},{executables:{win32:["Chronicon.exe"]},id:708,name:"Chronicon"},{executables:{win32:["MagicDuels.exe"]},id:709,name:"Magic Duels"},{executables:{win32:["BorderlandsPreSequel.exe"]},id:710,name:"Borderlands: the Pre-Sequel"},{executables:{win32:["AoD.exe"]},id:711,name:"The Age of Decadence"},{executables:{win32:["Doom.exe"]},id:712,name:"Doom 3"},{executables:{win32:["Dead Space.exe"]},id:713,name:"Dead Space"},{executables:{win32:["AvP3.exe"]},id:714,name:"Alien Vs Predator"},{executables:{win32:["BlackOps3.exe"]},id:715,name:"Call of Duty: Black Ops III"},{executables:{win32:["halo_online.exe"]},id:716,name:"Halo Online"},{executables:{win32:["Krosmaster Arena.exe"]},id:717,name:"Krosmaster Arena"},{executables:{win32:["MapleRoyals.exe"]},id:718,name:"MapleRoyals"},{executables:{win32:["clragexe.exe"]},id:719,name:"Ragnarok Online Classic"},{executables:{win32:["RememberingHowWeMet.exe"]},id:720,name:"A Kiss For The Petals - Remembering How We Met"},{executables:{win32:["Command.exe"]},id:721,name:"Command: Modern Air/Naval Operations "},{executables:{win32:["CM Black Sea.exe"]},id:722,name:"Combat Mission: Black Sea"},{executables:{win32:["CM Shock Force.exe"]},id:723,name:"Combat Mission: Shock Force"},{executables:{win32:["KingOfFighters2002UM.exe"]},id:724,name:"The King Of Fighters 2002 Unlimited Match"},{executables:{win32:["NFSC.exe"]},id:725,name:"Need for Speed: Carbon"},{executables:{win32:["th075.exe","th075e.exe"]},id:726,name:"Touhou 7.5: Immaterial and Missing Power"},{executables:{win32:["Demul.exe"]},id:727,name:"Demul"},{executables:{win32:["DeSmuMe_0.9.11_x86.exe","DeSmuME_0.9.11_x64.exe"]},id:728,name:"DeSmuME"},{executables:{win32:["Fusion.exe"]},id:729,name:"Kega Fusion"},{executables:{win32:["nullDC_Win32_Release-NoTrace.exe"]},id:730,name:"nullDC"},{executables:{win32:["pcsx2-r5875.exe"]},id:731,name:"PCSX2"},{executables:{win32:["Project64.exe"]},id:732,name:"Project64"},{executables:{win32:["Snes9X.exe"]},id:733,name:"Snes9x"},{executables:{win32:["VisualBoyAdvance.exe"]},id:734,name:"VisualBoyAdvance"},{executables:{win32:["zsnesw.exe"]},id:735,name:"ZSNES"},{executables:{win32:["Uplink.exe"]},id:736,name:"Uplink"},{executables:{win32:["RIK.exe"]},id:737,name:"ProjectRIK"},{executables:{win32:["warsow_x64.exe","warsow_x86.exe"]},id:738,name:"Warsow"},{executables:{win32:["cactus.exe"]},id:739,name:"Assault Android Cactus"},{executables:{win32:["PlantsVsZombies.exe"]},id:740,name:"Plants vs. Zombies"},{executables:{win32:["HeavyWeapon.exe"]},id:741,name:"Heavy Weapon"},{executables:{win32:["BejBlitz.exe"]},id:742,name:"Bejeweled Blitz"},{executables:{win32:["slw.exe"]},id:743,name:"Sonic Lost World"},{executables:{win32:["age.exe"]},id:744,name:"Kamidori Alchemy Meister"},{executables:{win32:["psobb.exe"]},id:745,name:"Phantasy Star Online Blue Burst"},{executables:{win32:["Evoland2.exe"]},id:746,name:"Evoland 2"},{executables:{win32:["FFV_Game.exe"]},id:747,name:"Final Fantasy V"},{executables:{win32:["TITAN.exe"]},id:748,name:"Titan Souls"},{executables:{win32:["FTP.exe"]},id:749,name:"Free To Play"},{executables:{win32:["Hero_Siege.exe"]},id:750,name:"Hero Siege"}]},{}]},{},[25])(25)}); \ No newline at end of file