diff --git a/.babelrc b/.babelrc
new file mode 100644
index 000000000..b39fb63ff
--- /dev/null
+++ b/.babelrc
@@ -0,0 +1,5 @@
+{
+    "presets": [
+        "es2015"
+    ]
+}
\ No newline at end of file
diff --git a/lib/Client/Client.js b/lib/Client/Client.js
index 97f8eff62..8ccbf3f19 100644
--- a/lib/Client/Client.js
+++ b/lib/Client/Client.js
@@ -1,764 +1,1028 @@
 "use strict";
 
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 InternalClient = require("./InternalClient.js");
 var EventEmitter = require("events");
 
-class Client extends EventEmitter {
+var Client = (function (_EventEmitter) {
+	_inherits(Client, _EventEmitter);
+
 	/*
  	this class is an interface for the internal
  	client.
  */
-	constructor(options) {
-		super();
-		this.options = options || {};
-		this.internal = new InternalClient(this);
+
+	function Client(options) {
+		_classCallCheck(this, Client);
+
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Client).call(this));
+
+		_this.options = options || {};
+		_this.internal = new InternalClient(_this);
+		return _this;
 	}
 
-	get users() {
-		return this.internal.users;
-	}
+	_createClass(Client, [{
+		key: "login",
 
-	get channels() {
-		return this.internal.channels;
-	}
+		// def login
+		value: function login(email, password) {
+			var cb = arguments.length <= 2 || arguments[2] === undefined ? function (err, token) {} : arguments[2];
 
-	get servers() {
-		return this.internal.servers;
-	}
+			var self = this;
+			return new Promise(function (resolve, reject) {
 
-	get privateChannels() {
-		return this.internal.private_channels;
-	}
-
-	get voiceConnection() {
-		return this.internal.voiceConnection;
-	}
-
-	get readyTime() {
-		return this.internal.readyTime;
-	}
-
-	get uptime() {
-		return this.internal.uptime;
-	}
-
-	get user() {
-		return this.internal.user;
-	}
-
-	// def login
-	login(email, password, cb = function (err, token) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.login(email, password).then(token => {
-				cb(null, token);
-				resolve(token);
-			}).catch(e => {
-				cb(e);
-				reject(e);
+				self.internal.login(email, password).then(function (token) {
+					cb(null, token);
+					resolve(token);
+				}).catch(function (e) {
+					cb(e);
+					reject(e);
+				});
 			});
-		});
-	}
+		}
 
-	// def logout
-	logout(cb = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
+		// def logout
 
-			self.internal.logout().then(() => {
-				cb();
-				resolve();
-			}).catch(e => {
-				cb(e);
-				reject(e);
+	}, {
+		key: "logout",
+		value: function logout() {
+			var cb = arguments.length <= 0 || arguments[0] === undefined ? function (err) {} : arguments[0];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.logout().then(function () {
+					cb();
+					resolve();
+				}).catch(function (e) {
+					cb(e);
+					reject(e);
+				});
 			});
-		});
-	}
-	// def sendMessage
-	sendMessage(where, content, options = {}, callback = function (e, m) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
+		}
+		// def sendMessage
 
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
+	}, {
+		key: "sendMessage",
+		value: function sendMessage(where, content) {
+			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, m) {} : arguments[3];
 
-			self.internal.sendMessage(where, content, options).then(m => {
-				callback(null, m);
-				resolve(m);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
+			var self = this;
+			return new Promise(function (resolve, reject) {
 
-	// def sendTTSMessage
-	sendTTSMessage(where, content, callback = function (e, m) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.sendMessage(where, content, { tts: true }).then(m => {
-				callback(null, m);
-				resolve(m);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-	// def reply
-	reply(where, content, options = {}, callback = function (e, m) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
+				if (typeof options === "function") {
+					// options is the callback
+					callback = options;
+				}
 
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
-
-			var msg = self.internal.resolver.resolveMessage(where);
-			if (msg) {
-				content = msg.author + ", " + content;
-				self.internal.sendMessage(msg, content, options).then(m => {
+				self.internal.sendMessage(where, content, options).then(function (m) {
 					callback(null, m);
 					resolve(m);
-				}).catch(e => {
+				}).catch(function (e) {
 					callback(e);
 					reject(e);
 				});
-			} else {
-				var err = new Error("Destination not resolvable to a message!");
-				callback(err);
-				reject(err);
-			}
-		});
-	}
-
-	// def replyTTS
-	replyTTS(where, content, callback = function () {}) {
-		return new Promise((resolve, reject) => {
-			self.reply(where, content, { tts: true }).then(m => {
-				callback(null, m);
-				resolve(m);
-			}).catch(e => {
-				callback(e);
-				reject(e);
 			});
-		});
-	}
-	// def deleteMessage
-	deleteMessage(msg, options = {}, callback = function (e) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
+		}
 
-			self.internal.deleteMessage(msg, options).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
+		// def sendTTSMessage
+
+	}, {
+		key: "sendTTSMessage",
+		value: function sendTTSMessage(where, content) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (e, m) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.sendMessage(where, content, { tts: true }).then(function (m) {
+					callback(null, m);
+					resolve(m);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
 			});
-		});
-	}
-	//def updateMessage
-	updateMessage(msg, content, options = {}, callback = function (err, msg) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
+		}
+		// def reply
 
-			self.internal.updateMessage(msg, content, options).then(msg => {
-				callback(null, msg);
-				resolve(msg);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
+	}, {
+		key: "reply",
+		value: function reply(where, content) {
+			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, m) {} : arguments[3];
 
-	// def getChannelLogs
-	getChannelLogs(where, limit = 500, options = {}, callback = function (err, logs) {}) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
 
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
-			self.internal.getChannelLogs(where, limit, options).then(logs => {
-				callback(null, logs);
-				resolve(logs);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def getBans
-	getBans(where, callback = function (err, bans) {}) {
-
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.getBans(where).then(bans => {
-				callback(null, bans);
-				resolve(bans);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def sendFile
-	sendFile(where, attachment, name = "image.png", callback = function (err, m) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.sendFile(where, attachment, name).then(m => {
-				callback(null, m);
-				resolve(m);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def joinServer
-	joinServer(invite, callback = function (err, srv) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.joinServer(invite).then(srv => {
-				callback(null, srv);
-				resolve(srv);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def createServer
-	createServer(name, region = "london", callback = function (err, srv) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.createServer(name, region).then(srv => {
-				callback(null, srv);
-				resolve(srv);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def leaveServer
-	leaveServer(server, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.leaveServer(server).then(() => {
-				callback();resolve();
-			}).catch(e => {
-				callback(e);reject(e);
-			});
-		});
-	}
-
-	// def createChannel
-	createChannel(server, name, type = "text", callback = function (err, channel) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof type === "function") {
-				// options is the callback
-				callback = type;
-			}
-			self.internal.createChannel(server, name, type).then(channel => {
-				callback(channel);resolve(channel);
-			}).catch(e => {
-				callback(e);reject(e);
-			});
-		});
-	}
-
-	// def deleteChannel
-	deleteChannel(channel, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.deleteChannel(channel).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);reject(e);
-			});
-		});
-	}
-
-	//def banMember
-	banMember(user, server, length = 1, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof length === "function") {
-				// length is the callback
-				callback = length;
-			}
-			self.internal.banMember(user, server, length).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);reject(e);
-			});
-		});
-	}
-
-	//def unbanMember
-	unbanMember(user, server, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.unbanMember(user, server).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);reject(e);
-			});
-		});
-	}
-
-	//def kickMember
-	kickMember(user, server, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.kickMember(user, server).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);reject(e);
-			});
-		});
-	}
-
-	//def createRole
-	createRole(server, data = null, callback = function (err, res) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof data === "function") {
-				// data is the callback
-				callback = data;
-			}
-			self.internal.createRole(server, data).then(role => {
-				callback(null, role);
-				resolve(role);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def updateRole
-	updateRole(role, data = null, callback = function (err, res) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof data === "function") {
-				// data is the callback
-				callback = data;
-			}
-			self.internal.updateRole(role, data).then(role => {
-				callback(null, role);
-				resolve(role);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def deleteRole
-	deleteRole(role, callback = function (err) {}) {
-
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.deleteRole(role).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def addMemberToRole
-	addMemberToRole(member, role, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.addMemberToRole(member, role).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def addUserToRole
-	addUserToRole(member, role, callback = function (err) {}) {
-		return this.addMemberToRole(member, role, callback);
-	}
-
-	// def removeMemberFromRole
-	removeMemberFromRole(member, role, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.removeMemberFromRole(member, role).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def removeUserFromRole
-	removeUserFromRole(member, role, callback = function (err) {}) {
-		return this.removeUserFromRole(member, role, callback);
-	}
-
-	// def createInvite
-	createInvite(chanServ, options, callback = function (err, invite) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof options === "function") {
-				// length is the callback
-				callback = options;
-			}
-
-			self.internal.createInvite(chanServ, options).then(invite => {
-				callback(null, invite);
-				resolve(invite);
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def deleteInvite
-	deleteInvite(invite, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.deleteInvite(invite).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def overwritePermissions
-	overwritePermissions(channel, role, options = {}, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.overwritePermissions(channel, role, options).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def setStatus
-	setStatus(idleStatus, gameID, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof gameID === "function") {
-				// gameID is the callback
-				callback = gameID;
-			} else if (typeof idleStatus === "function") {
-				// idleStatus is the callback
-				callback = idleStatus;
-			}
-
-			self.internal.setStatus(idleStatus, gameID).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def sendTyping
-	sendTyping(channel, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.sendTyping(channel).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	// def setTopic
-	setTopic(channel, topic, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.setTopic(channel, topic).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def setChannelName
-	setChannelName(channel, name, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.setChannelName(channel, name).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def setChannelNameAndTopic
-	setChannelNameAndTopic(channel, name, topic, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.setChannelNameAndTopic(channel, name, topic).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def updateChannel
-	updateChannel(channel, data, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.updateChannel(channel, data).then(() => {
-				callback();
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def startTyping
-	startTyping(channel, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.startTyping(channel).then(() => {
-				callback(null);
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def stopTyping
-	stopTyping(channel, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.stopTyping(channel).then(() => {
-				callback(null);
-				resolve();
-			}).catch(e => {
-				callback(e);
-				reject(e);
-			});
-		});
-	}
-
-	//def updateDetails
-	updateDetails(details, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.updateDetails(details).then(() => {
-				callback();
-				resolve();
-			}).catch(err => {
-				callback(err);
-				reject(err);
-			});
-		});
-	}
-
-	//def setUsername
-	setUsername(name, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.setUsername(name).then(() => {
-				callback();
-				resolve();
-			}).catch(err => {
-				callback(err);
-				reject(err);
-			});
-		});
-	}
-
-	//def setAvatar
-	setAvatar(avatar, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.setAvatar(avatar).then(() => {
-				callback();
-				resolve();
-			}).catch(err => {
-				callback(err);
-				reject(err);
-			});
-		});
-	}
-
-	//def joinVoiceChannel
-	joinVoiceChannel(channel, callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.joinVoiceChannel(channel).then(chan => {
-				callback(null, chan);
-				resolve(chan);
-			}).catch(err => {
-				callback(err);
-				reject(err);
-			});
-		});
-	}
-
-	// def leaveVoiceChannel
-	leaveVoiceChannel(callback = function (err) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.leaveVoiceChannel().then(() => {
-				callback();
-				resolve();
-			}).catch(err => {
-				callback(err);
-				reject(err);
-			});
-		});
-	}
-
-	// def awaitResponse
-	awaitResponse(msg, toSend = null, options = null, callback = function (e, newMsg) {}) {
-
-		var self = this;
-
-		return new Promise((resolve, reject) => {
-
-			function error(e) {
-				callback(e);
-				reject(e);
-			}
-
-			if (toSend) {
-				if (typeof toSend === "function") {
-					// (msg, callback)
-					callback = toSend;
-					final();
-				} else {
-					// (msg, toSend, ...)
-					if (options) {
-						if (typeof options === "function") {
-							//(msg, toSend, callback)
-							callback = options;
-							this.sendMessage(msg, toSend).then(final).catch(error);
-						} else {
-							//(msg, toSend, options, callback)
-							this.sendMessage(msg, toSend, options).then(final).catch(error);
-						}
-					} else {
-						// (msg, toSend) promise
-						this.sendMessage(msg, toSend).then(final).catch(error);
-					}
+				if (typeof options === "function") {
+					// options is the callback
+					callback = options;
 				}
-			} else {
-				// (msg) promise
-				final();
-			}
 
-			function final() {
-				self.internal.awaitResponse(msg).then(newMsg => {
-					resolve(newMsg);
-					callback(null, newMsg);
-				}).catch(error);
-			}
-		});
-	}
+				var msg = self.internal.resolver.resolveMessage(where);
+				if (msg) {
+					content = msg.author + ", " + content;
+					self.internal.sendMessage(msg, content, options).then(function (m) {
+						callback(null, m);
+						resolve(m);
+					}).catch(function (e) {
+						callback(e);
+						reject(e);
+					});
+				} else {
+					var err = new Error("Destination not resolvable to a message!");
+					callback(err);
+					reject(err);
+				}
+			});
+		}
 
-	setStatusIdle() {
-		this.setStatus("idle");
-	}
+		// def replyTTS
 
-	setStatusOnline(cb = function (err) {}) {
-		this.setStatus("online");
-	}
+	}, {
+		key: "replyTTS",
+		value: function replyTTS(where, content) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function () {} : arguments[2];
 
-	setStatusActive() {
-		this.setStatusOnline();
-	}
+			return new Promise(function (resolve, reject) {
+				self.reply(where, content, { tts: true }).then(function (m) {
+					callback(null, m);
+					resolve(m);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+		// def deleteMessage
 
-	setStatusHere() {
-		this.setStatusOnline();
-	}
+	}, {
+		key: "deleteMessage",
+		value: function deleteMessage(msg) {
+			var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (e) {} : arguments[2];
 
-	setStatusAvailable() {
-		this.setStatusOnline();
-	}
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof options === "function") {
+					// options is the callback
+					callback = options;
+				}
 
-	setStatusAway() {
-		this.setStatusIdle();
-	}
+				self.internal.deleteMessage(msg, options).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+		//def updateMessage
 
-	setPlayingGame(game) {
-		this.setStatus(null, game);
-	}
-}
+	}, {
+		key: "updateMessage",
+		value: function updateMessage(msg, content) {
+			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err, msg) {} : arguments[3];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof options === "function") {
+					// options is the callback
+					callback = options;
+				}
+
+				self.internal.updateMessage(msg, content, options).then(function (msg) {
+					callback(null, msg);
+					resolve(msg);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def getChannelLogs
+
+	}, {
+		key: "getChannelLogs",
+		value: function getChannelLogs(where) {
+			var limit = arguments.length <= 1 || arguments[1] === undefined ? 500 : arguments[1];
+			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err, logs) {} : arguments[3];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof options === "function") {
+					// options is the callback
+					callback = options;
+				}
+				self.internal.getChannelLogs(where, limit, options).then(function (logs) {
+					callback(null, logs);
+					resolve(logs);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def getBans
+
+	}, {
+		key: "getBans",
+		value: function getBans(where) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, bans) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.getBans(where).then(function (bans) {
+					callback(null, bans);
+					resolve(bans);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def sendFile
+
+	}, {
+		key: "sendFile",
+		value: function sendFile(where, attachment) {
+			var name = arguments.length <= 2 || arguments[2] === undefined ? "image.png" : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err, m) {} : arguments[3];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.sendFile(where, attachment, name).then(function (m) {
+					callback(null, m);
+					resolve(m);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def joinServer
+
+	}, {
+		key: "joinServer",
+		value: function joinServer(invite) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, srv) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.joinServer(invite).then(function (srv) {
+					callback(null, srv);
+					resolve(srv);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def createServer
+
+	}, {
+		key: "createServer",
+		value: function createServer(name) {
+			var region = arguments.length <= 1 || arguments[1] === undefined ? "london" : arguments[1];
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err, srv) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.createServer(name, region).then(function (srv) {
+					callback(null, srv);
+					resolve(srv);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def leaveServer
+
+	}, {
+		key: "leaveServer",
+		value: function leaveServer(server) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.leaveServer(server).then(function () {
+					callback();resolve();
+				}).catch(function (e) {
+					callback(e);reject(e);
+				});
+			});
+		}
+
+		// def createChannel
+
+	}, {
+		key: "createChannel",
+		value: function createChannel(server, name) {
+			var type = arguments.length <= 2 || arguments[2] === undefined ? "text" : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err, channel) {} : arguments[3];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof type === "function") {
+					// options is the callback
+					callback = type;
+				}
+				self.internal.createChannel(server, name, type).then(function (channel) {
+					callback(channel);resolve(channel);
+				}).catch(function (e) {
+					callback(e);reject(e);
+				});
+			});
+		}
+
+		// def deleteChannel
+
+	}, {
+		key: "deleteChannel",
+		value: function deleteChannel(channel) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.deleteChannel(channel).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);reject(e);
+				});
+			});
+		}
+
+		//def banMember
+
+	}, {
+		key: "banMember",
+		value: function banMember(user, server) {
+			var length = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err) {} : arguments[3];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof length === "function") {
+					// length is the callback
+					callback = length;
+				}
+				self.internal.banMember(user, server, length).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);reject(e);
+				});
+			});
+		}
+
+		//def unbanMember
+
+	}, {
+		key: "unbanMember",
+		value: function unbanMember(user, server) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.unbanMember(user, server).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);reject(e);
+				});
+			});
+		}
+
+		//def kickMember
+
+	}, {
+		key: "kickMember",
+		value: function kickMember(user, server) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.kickMember(user, server).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);reject(e);
+				});
+			});
+		}
+
+		//def createRole
+
+	}, {
+		key: "createRole",
+		value: function createRole(server) {
+			var data = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err, res) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof data === "function") {
+					// data is the callback
+					callback = data;
+				}
+				self.internal.createRole(server, data).then(function (role) {
+					callback(null, role);
+					resolve(role);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def updateRole
+
+	}, {
+		key: "updateRole",
+		value: function updateRole(role) {
+			var data = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err, res) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof data === "function") {
+					// data is the callback
+					callback = data;
+				}
+				self.internal.updateRole(role, data).then(function (role) {
+					callback(null, role);
+					resolve(role);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def deleteRole
+
+	}, {
+		key: "deleteRole",
+		value: function deleteRole(role) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.deleteRole(role).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def addMemberToRole
+
+	}, {
+		key: "addMemberToRole",
+		value: function addMemberToRole(member, role) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.addMemberToRole(member, role).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def addUserToRole
+
+	}, {
+		key: "addUserToRole",
+		value: function addUserToRole(member, role) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			return this.addMemberToRole(member, role, callback);
+		}
+
+		// def removeMemberFromRole
+
+	}, {
+		key: "removeMemberFromRole",
+		value: function removeMemberFromRole(member, role) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.removeMemberFromRole(member, role).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def removeUserFromRole
+
+	}, {
+		key: "removeUserFromRole",
+		value: function removeUserFromRole(member, role) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			return this.removeUserFromRole(member, role, callback);
+		}
+
+		// def createInvite
+
+	}, {
+		key: "createInvite",
+		value: function createInvite(chanServ, options) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err, invite) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof options === "function") {
+					// length is the callback
+					callback = options;
+				}
+
+				self.internal.createInvite(chanServ, options).then(function (invite) {
+					callback(null, invite);
+					resolve(invite);
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def deleteInvite
+
+	}, {
+		key: "deleteInvite",
+		value: function deleteInvite(invite) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.deleteInvite(invite).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def overwritePermissions
+
+	}, {
+		key: "overwritePermissions",
+		value: function overwritePermissions(channel, role) {
+			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err) {} : arguments[3];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.overwritePermissions(channel, role, options).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def setStatus
+
+	}, {
+		key: "setStatus",
+		value: function setStatus(idleStatus, gameID) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (typeof gameID === "function") {
+					// gameID is the callback
+					callback = gameID;
+				} else if (typeof idleStatus === "function") {
+					// idleStatus is the callback
+					callback = idleStatus;
+				}
+
+				self.internal.setStatus(idleStatus, gameID).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def sendTyping
+
+	}, {
+		key: "sendTyping",
+		value: function sendTyping(channel) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.sendTyping(channel).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		// def setTopic
+
+	}, {
+		key: "setTopic",
+		value: function setTopic(channel, topic) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.setTopic(channel, topic).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def setChannelName
+
+	}, {
+		key: "setChannelName",
+		value: function setChannelName(channel, name) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.setChannelName(channel, name).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def setChannelNameAndTopic
+
+	}, {
+		key: "setChannelNameAndTopic",
+		value: function setChannelNameAndTopic(channel, name, topic) {
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (err) {} : arguments[3];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.setChannelNameAndTopic(channel, name, topic).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def updateChannel
+
+	}, {
+		key: "updateChannel",
+		value: function updateChannel(channel, data) {
+			var callback = arguments.length <= 2 || arguments[2] === undefined ? function (err) {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.updateChannel(channel, data).then(function () {
+					callback();
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def startTyping
+
+	}, {
+		key: "startTyping",
+		value: function startTyping(channel) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.startTyping(channel).then(function () {
+					callback(null);
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def stopTyping
+
+	}, {
+		key: "stopTyping",
+		value: function stopTyping(channel) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.stopTyping(channel).then(function () {
+					callback(null);
+					resolve();
+				}).catch(function (e) {
+					callback(e);
+					reject(e);
+				});
+			});
+		}
+
+		//def updateDetails
+
+	}, {
+		key: "updateDetails",
+		value: function updateDetails(details) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.updateDetails(details).then(function () {
+					callback();
+					resolve();
+				}).catch(function (err) {
+					callback(err);
+					reject(err);
+				});
+			});
+		}
+
+		//def setUsername
+
+	}, {
+		key: "setUsername",
+		value: function setUsername(name) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.setUsername(name).then(function () {
+					callback();
+					resolve();
+				}).catch(function (err) {
+					callback(err);
+					reject(err);
+				});
+			});
+		}
+
+		//def setAvatar
+
+	}, {
+		key: "setAvatar",
+		value: function setAvatar(avatar) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.setAvatar(avatar).then(function () {
+					callback();
+					resolve();
+				}).catch(function (err) {
+					callback(err);
+					reject(err);
+				});
+			});
+		}
+
+		//def joinVoiceChannel
+
+	}, {
+		key: "joinVoiceChannel",
+		value: function joinVoiceChannel(channel) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.internal.joinVoiceChannel(channel).then(function (chan) {
+					callback(null, chan);
+					resolve(chan);
+				}).catch(function (err) {
+					callback(err);
+					reject(err);
+				});
+			});
+		}
+
+		// def leaveVoiceChannel
+
+	}, {
+		key: "leaveVoiceChannel",
+		value: function leaveVoiceChannel() {
+			var callback = arguments.length <= 0 || arguments[0] === undefined ? function (err) {} : arguments[0];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.internal.leaveVoiceChannel().then(function () {
+					callback();
+					resolve();
+				}).catch(function (err) {
+					callback(err);
+					reject(err);
+				});
+			});
+		}
+
+		// def awaitResponse
+
+	}, {
+		key: "awaitResponse",
+		value: function awaitResponse(msg) {
+			var toSend = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
+
+			var _this2 = this;
+
+			var options = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];
+			var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, newMsg) {} : arguments[3];
+
+			var self = this;
+
+			return new Promise(function (resolve, reject) {
+
+				function error(e) {
+					callback(e);
+					reject(e);
+				}
+
+				if (toSend) {
+					if (typeof toSend === "function") {
+						// (msg, callback)
+						callback = toSend;
+						final();
+					} else {
+						// (msg, toSend, ...)
+						if (options) {
+							if (typeof options === "function") {
+								//(msg, toSend, callback)
+								callback = options;
+								_this2.sendMessage(msg, toSend).then(final).catch(error);
+							} else {
+								//(msg, toSend, options, callback)
+								_this2.sendMessage(msg, toSend, options).then(final).catch(error);
+							}
+						} else {
+							// (msg, toSend) promise
+							_this2.sendMessage(msg, toSend).then(final).catch(error);
+						}
+					}
+				} else {
+					// (msg) promise
+					final();
+				}
+
+				function final() {
+					self.internal.awaitResponse(msg).then(function (newMsg) {
+						resolve(newMsg);
+						callback(null, newMsg);
+					}).catch(error);
+				}
+			});
+		}
+	}, {
+		key: "setStatusIdle",
+		value: function setStatusIdle() {
+			this.setStatus("idle");
+		}
+	}, {
+		key: "setStatusOnline",
+		value: function setStatusOnline() {
+			var cb = arguments.length <= 0 || arguments[0] === undefined ? function (err) {} : arguments[0];
+
+			this.setStatus("online");
+		}
+	}, {
+		key: "setStatusActive",
+		value: function setStatusActive() {
+			this.setStatusOnline();
+		}
+	}, {
+		key: "setStatusHere",
+		value: function setStatusHere() {
+			this.setStatusOnline();
+		}
+	}, {
+		key: "setStatusAvailable",
+		value: function setStatusAvailable() {
+			this.setStatusOnline();
+		}
+	}, {
+		key: "setStatusAway",
+		value: function setStatusAway() {
+			this.setStatusIdle();
+		}
+	}, {
+		key: "setPlayingGame",
+		value: function setPlayingGame(game) {
+			this.setStatus(null, game);
+		}
+	}, {
+		key: "users",
+		get: function get() {
+			return this.internal.users;
+		}
+	}, {
+		key: "channels",
+		get: function get() {
+			return this.internal.channels;
+		}
+	}, {
+		key: "servers",
+		get: function get() {
+			return this.internal.servers;
+		}
+	}, {
+		key: "privateChannels",
+		get: function get() {
+			return this.internal.private_channels;
+		}
+	}, {
+		key: "voiceConnection",
+		get: function get() {
+			return this.internal.voiceConnection;
+		}
+	}, {
+		key: "readyTime",
+		get: function get() {
+			return this.internal.readyTime;
+		}
+	}, {
+		key: "uptime",
+		get: function get() {
+			return this.internal.uptime;
+		}
+	}, {
+		key: "user",
+		get: function get() {
+			return this.internal.user;
+		}
+	}]);
+
+	return Client;
+})(EventEmitter);
 
 module.exports = Client;
\ No newline at end of file
diff --git a/lib/Client/ConnectionState.js b/lib/Client/ConnectionState.js
index c27246c09..86fb95261 100644
--- a/lib/Client/ConnectionState.js
+++ b/lib/Client/ConnectionState.js
@@ -1,3 +1,5 @@
+"use strict";
+
 exports.IDLE = 0;
 exports.LOGGING_IN = 1;
 exports.LOGGED_IN = 2;
diff --git a/lib/Client/InternalClient.js b/lib/Client/InternalClient.js
index f54817352..ba7d8ce55 100644
--- a/lib/Client/InternalClient.js
+++ b/lib/Client/InternalClient.js
@@ -1,5 +1,9 @@
 "use strict";
 
+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 EventEmitter = require("events");
 var request = require("superagent");
 var WebSocket = require("ws");
@@ -25,8 +29,10 @@ var User = require("../Structures/User.js"),
 
 var zlib;
 
-class InternalClient {
-	constructor(discordClient) {
+var InternalClient = (function () {
+	function InternalClient(discordClient) {
+		_classCallCheck(this, InternalClient);
+
 		this.client = discordClient;
 		this.state = ConnectionState.IDLE;
 		this.websocket = null;
@@ -48,1447 +54,1687 @@ class InternalClient {
 		this.messageAwaits = {};
 	}
 
-	get uptime() {
-		return this.readyTime ? Date.now() - this.readyTime : null;
-	}
+	_createClass(InternalClient, [{
+		key: "leaveVoiceChannel",
 
-	//def leaveVoiceChannel
-	leaveVoiceChannel() {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (self.voiceConnection) {
-				self.voiceConnection.destroy();
-				self.voiceConnection = null;
-				resolve();
-			} else {
-				resolve();
-			}
-		});
-	}
-
-	//def awaitResponse
-	awaitResponse(msg) {
-		return new Promise((resolve, reject) => {
-
-			msg = this.resolver.resolveMessage(msg);
-
-			if (!msg) {
-				reject(new Error("message undefined"));
-				return;
-			}
-
-			var awaitID = msg.channel.id + msg.author.id;
-
-			if (!this.messageAwaits[awaitID]) {
-				this.messageAwaits[awaitID] = [];
-			}
-
-			this.messageAwaits[awaitID].push(resolve);
-		});
-	}
-
-	//def joinVoiceChannel
-	joinVoiceChannel(chann) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			var channel = self.resolver.resolveVoiceChannel(chann);
-
-			if (channel) {
-
-				self.leaveVoiceChannel().then(next);
-
-				function next() {
-					var session,
-					    token,
-					    server = channel.server,
-					    endpoint;
-
-					var check = m => {
-						var data = JSON.parse(m);
-						if (data.t === "VOICE_STATE_UPDATE") {
-							session = data.d.session_id;
-						} else if (data.t === "VOICE_SERVER_UPDATE") {
-							token = data.d.token;
-							endpoint = data.d.endpoint;
-							var chan = self.voiceConnection = new VoiceConnection(channel, self.client, session, token, server, endpoint);
-
-							chan.on("ready", () => resolve(chan));
-							chan.on("error", reject);
-
-							self.client.emit("debug", "removed temporary voice websocket listeners");
-							self.websocket.removeListener("message", check);
-						}
-					};
-
-					self.websocket.on("message", check);
-					self.sendWS({
-						op: 4,
-						d: {
-							"guild_id": server.id,
-							"channel_id": channel.id,
-							"self_mute": false,
-							"self_deaf": false
-						}
-					});
-				}
-			} else {
-				reject(new Error("voice channel does not exist"));
-			}
-		});
-	}
-
-	// def createServer
-	createServer(name, region = "london") {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			name = self.resolver.resolveString(name);
-
-			request.post(Endpoints.SERVERS).set("authorization", self.token).send({ name, region }).end((err, res) => {
-				if (err) {
-					reject(new Error(err));
+		//def leaveVoiceChannel
+		value: function leaveVoiceChannel() {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				if (self.voiceConnection) {
+					self.voiceConnection.destroy();
+					self.voiceConnection = null;
+					resolve();
 				} else {
-					// valid server, wait until it is cached
-					var inter = setInterval(() => {
-						if (self.servers.get("id", res.body.id)) {
-							clearInterval(inter);
-							resolve(self.servers.get("id", res.body.id));
-						}
-					}, 20);
+					resolve();
 				}
 			});
-		});
-	}
+		}
 
-	//def joinServer
-	joinServer(invite) {
-		var self = this;
-		return new Promise((resolve, reject) => {
+		//def awaitResponse
 
-			invite = self.resolver.resolveInviteID(invite);
-			if (invite) {
-				request.post(Endpoints.INVITE(invite)).set("authorization", self.token).end((err, res) => {
+	}, {
+		key: "awaitResponse",
+		value: function awaitResponse(msg) {
+			var _this = this;
+
+			return new Promise(function (resolve, reject) {
+
+				msg = _this.resolver.resolveMessage(msg);
+
+				if (!msg) {
+					reject(new Error("message undefined"));
+					return;
+				}
+
+				var awaitID = msg.channel.id + msg.author.id;
+
+				if (!_this.messageAwaits[awaitID]) {
+					_this.messageAwaits[awaitID] = [];
+				}
+
+				_this.messageAwaits[awaitID].push(resolve);
+			});
+		}
+
+		//def joinVoiceChannel
+
+	}, {
+		key: "joinVoiceChannel",
+		value: function joinVoiceChannel(chann) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				var channel = self.resolver.resolveVoiceChannel(chann);
+
+				if (channel) {
+					var next = function next() {
+						var session,
+						    token,
+						    server = channel.server,
+						    endpoint;
+
+						var check = function check(m) {
+							var data = JSON.parse(m);
+							if (data.t === "VOICE_STATE_UPDATE") {
+								session = data.d.session_id;
+							} else if (data.t === "VOICE_SERVER_UPDATE") {
+								token = data.d.token;
+								endpoint = data.d.endpoint;
+								var chan = self.voiceConnection = new VoiceConnection(channel, self.client, session, token, server, endpoint);
+
+								chan.on("ready", function () {
+									return resolve(chan);
+								});
+								chan.on("error", reject);
+
+								self.client.emit("debug", "removed temporary voice websocket listeners");
+								self.websocket.removeListener("message", check);
+							}
+						};
+
+						self.websocket.on("message", check);
+						self.sendWS({
+							op: 4,
+							d: {
+								"guild_id": server.id,
+								"channel_id": channel.id,
+								"self_mute": false,
+								"self_deaf": false
+							}
+						});
+					};
+
+					self.leaveVoiceChannel().then(next);
+				} else {
+					reject(new Error("voice channel does not exist"));
+				}
+			});
+		}
+
+		// def createServer
+
+	}, {
+		key: "createServer",
+		value: function createServer(name) {
+			var region = arguments.length <= 1 || arguments[1] === undefined ? "london" : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				name = self.resolver.resolveString(name);
+
+				request.post(Endpoints.SERVERS).set("authorization", self.token).send({ name: name, region: region }).end(function (err, res) {
 					if (err) {
-						reject(err);
+						reject(new Error(err));
 					} else {
-						// valid server, wait until it is received via ws and cached
-						var inter = setInterval(() => {
-							if (self.servers.get("id", res.body.guild.id)) {
+						// valid server, wait until it is cached
+						var inter = setInterval(function () {
+							if (self.servers.get("id", res.body.id)) {
 								clearInterval(inter);
-								resolve(self.servers.get("id", res.body.guild.id));
+								resolve(self.servers.get("id", res.body.id));
 							}
 						}, 20);
 					}
 				});
-			} else {
-				reject(new Error("Not a valid invite"));
-			}
-		});
-	}
+			});
+		}
 
-	//def leaveServer
-	leaveServer(srv) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			var server = self.resolver.resolveServer(srv);
-			if (server) {
+		//def joinServer
 
-				request.del(Endpoints.SERVER(server.id)).set("authorization", self.token).end((err, res) => {
-					if (err) {
-						reject(new Error(err));
-					} else {
-						// remove channels of server then the server
-						for (var chan of server.channels) {
-							self.channels.remove(chan);
+	}, {
+		key: "joinServer",
+		value: function joinServer(invite) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				invite = self.resolver.resolveInviteID(invite);
+				if (invite) {
+					request.post(Endpoints.INVITE(invite)).set("authorization", self.token).end(function (err, res) {
+						if (err) {
+							reject(err);
+						} else {
+							// valid server, wait until it is received via ws and cached
+							var inter = setInterval(function () {
+								if (self.servers.get("id", res.body.guild.id)) {
+									clearInterval(inter);
+									resolve(self.servers.get("id", res.body.guild.id));
+								}
+							}, 20);
 						}
-						// remove server
-						self.servers.remove(server);
-						resolve();
-					}
-				});
-			} else {
-				reject(new Error("server did not resolve"));
-			}
-		});
-	}
-
-	// def login
-	login(email, password) {
-		var self = this;
-		var client = self.client;
-		return new Promise((resolve, reject) => {
-			if (self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE) {
-
-				self.state = ConnectionState.LOGGING_IN;
-
-				request.post(Endpoints.LOGIN).send({ email, password }).end(function (err, res) {
-
-					if (err) {
-						self.state = ConnectionState.DISCONNECTED;
-						self.websocket = null;
-						client.emit("disconnected");
-						reject(new Error(err));
-					} else {
-						var token = res.body.token;
-						self.state = ConnectionState.LOGGED_IN;
-						self.token = token;
-						self.email = email;
-						self.password = password;
-
-						self.getGateway().then(url => {
-
-							self.createWS(url);
-							resolve(token);
-						}).catch(e => {
-							self.state = ConnectionState.DISCONNECTED;
-							client.emit("disconnected");
-							reject(new Error(err));
-						});
-					}
-				});
-			} else {
-				reject(new Error("already logging in/logged in/ready!"));
-			}
-		});
-	}
-
-	// def logout
-	logout() {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			if (self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE) {
-				reject(new Error("Client is not logged in!"));
-				return;
-			}
-
-			request.post(Endpoints.LOGOUT).set("authorization", self.token).end((err, res) => {
-				if (err) {
-					reject(new Error(err));
+					});
 				} else {
-					if (this.websocket) {
-						this.websocket.close();
-						this.websocket = null;
-					}
-					self.token = null;
-					self.email = null;
-					self.password = null;
-					self.state = ConnectionState.DISCONNECTED;
-					resolve();
+					reject(new Error("Not a valid invite"));
 				}
 			});
-		});
-	}
+		}
 
-	// def startPM
-	startPM(resUser) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			var user = self.resolver.resolveUser(resUser);
+		//def leaveServer
 
-			if (user) {
+	}, {
+		key: "leaveServer",
+		value: function leaveServer(srv) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				var server = self.resolver.resolveServer(srv);
+				if (server) {
 
-				// start the PM
-				request.post(`${ Endpoints.USER_CHANNELS(user.id) }`).set("authorization", self.token).send({
-					recipient_id: user.id
-				}).end((err, res) => {
-					if (err) {
-						reject(new Error(err));
-					} else {
-						resolve(self.private_channels.add(new PMChannel(res.body, self.client)));
-					}
-				});
-			} else {
-				reject(new Error("Unable to resolve resUser to a User"));
-			}
-		});
-	}
-
-	// def getGateway
-	getGateway() {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			request.get(Endpoints.GATEWAY).set("authorization", self.token).end(function (err, res) {
-				if (err) reject(err);else resolve(res.body.url);
-			});
-		});
-	}
-
-	// def sendMessage
-	sendMessage(where, _content, options = {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(where).then(next).catch(e => reject(new Error("Error resolving destination - " + e)));
-
-			function next(destination) {
-				//var destination;
-				var content = self.resolver.resolveString(_content);
-				var mentions = self.resolver.resolveMentions(content);
-
-				request.post(Endpoints.CHANNEL_MESSAGES(destination.id)).set("authorization", self.token).send({
-					content: content,
-					mentions: mentions,
-					tts: options.tts
-				}).end((err, res) => {
-					if (err) {
-						reject(new Error(err));
-					} else {
-
-						resolve(destination.messages.add(new Message(res.body, destination, self.client)));
-					}
-				});
-			}
-		});
-	}
-	// def deleteMessage
-	deleteMessage(_message, options = {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			var message = self.resolver.resolveMessage(_message);
-
-			if (message) {
-
-				if (options.wait) {
-					setTimeout(deleteMsg, options.wait);
-				} else {
-					deleteMsg();
-				}
-
-				function deleteMsg() {
-					request.del(Endpoints.CHANNEL_MESSAGE(message.channel.id, message.id)).set("authorization", self.token).end((err, res) => {
+					request.del(Endpoints.SERVER(server.id)).set("authorization", self.token).end(function (err, res) {
 						if (err) {
 							reject(new Error(err));
 						} else {
-							message.channel.messages.remove(message);
+							// remove channels of server then the server
+							var _iteratorNormalCompletion = true;
+							var _didIteratorError = false;
+							var _iteratorError = undefined;
+
+							try {
+								for (var _iterator = server.channels[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+									var chan = _step.value;
+
+									self.channels.remove(chan);
+								}
+								// remove server
+							} catch (err) {
+								_didIteratorError = true;
+								_iteratorError = err;
+							} finally {
+								try {
+									if (!_iteratorNormalCompletion && _iterator.return) {
+										_iterator.return();
+									}
+								} finally {
+									if (_didIteratorError) {
+										throw _iteratorError;
+									}
+								}
+							}
+
+							self.servers.remove(server);
+							resolve();
+						}
+					});
+				} else {
+					reject(new Error("server did not resolve"));
+				}
+			});
+		}
+
+		// def login
+
+	}, {
+		key: "login",
+		value: function login(email, password) {
+			var self = this;
+			var client = self.client;
+			return new Promise(function (resolve, reject) {
+				if (self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE) {
+
+					self.state = ConnectionState.LOGGING_IN;
+
+					request.post(Endpoints.LOGIN).send({ email: email, password: password }).end(function (err, res) {
+
+						if (err) {
+							self.state = ConnectionState.DISCONNECTED;
+							self.websocket = null;
+							client.emit("disconnected");
+							reject(new Error(err));
+						} else {
+							var token = res.body.token;
+							self.state = ConnectionState.LOGGED_IN;
+							self.token = token;
+							self.email = email;
+							self.password = password;
+
+							self.getGateway().then(function (url) {
+
+								self.createWS(url);
+								resolve(token);
+							}).catch(function (e) {
+								self.state = ConnectionState.DISCONNECTED;
+								client.emit("disconnected");
+								reject(new Error(err));
+							});
+						}
+					});
+				} else {
+					reject(new Error("already logging in/logged in/ready!"));
+				}
+			});
+		}
+
+		// def logout
+
+	}, {
+		key: "logout",
+		value: function logout() {
+			var _this2 = this;
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				if (self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE) {
+					reject(new Error("Client is not logged in!"));
+					return;
+				}
+
+				request.post(Endpoints.LOGOUT).set("authorization", self.token).end(function (err, res) {
+					if (err) {
+						reject(new Error(err));
+					} else {
+						if (_this2.websocket) {
+							_this2.websocket.close();
+							_this2.websocket = null;
+						}
+						self.token = null;
+						self.email = null;
+						self.password = null;
+						self.state = ConnectionState.DISCONNECTED;
+						resolve();
+					}
+				});
+			});
+		}
+
+		// def startPM
+
+	}, {
+		key: "startPM",
+		value: function startPM(resUser) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				var user = self.resolver.resolveUser(resUser);
+
+				if (user) {
+
+					// start the PM
+					request.post("" + Endpoints.USER_CHANNELS(user.id)).set("authorization", self.token).send({
+						recipient_id: user.id
+					}).end(function (err, res) {
+						if (err) {
+							reject(new Error(err));
+						} else {
+							resolve(self.private_channels.add(new PMChannel(res.body, self.client)));
+						}
+					});
+				} else {
+					reject(new Error("Unable to resolve resUser to a User"));
+				}
+			});
+		}
+
+		// def getGateway
+
+	}, {
+		key: "getGateway",
+		value: function getGateway() {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				request.get(Endpoints.GATEWAY).set("authorization", self.token).end(function (err, res) {
+					if (err) reject(err);else resolve(res.body.url);
+				});
+			});
+		}
+
+		// def sendMessage
+
+	}, {
+		key: "sendMessage",
+		value: function sendMessage(where, _content) {
+			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(where).then(next).catch(function (e) {
+					return reject(new Error("Error resolving destination - " + e));
+				});
+
+				function next(destination) {
+					//var destination;
+					var content = self.resolver.resolveString(_content);
+					var mentions = self.resolver.resolveMentions(content);
+
+					request.post(Endpoints.CHANNEL_MESSAGES(destination.id)).set("authorization", self.token).send({
+						content: content,
+						mentions: mentions,
+						tts: options.tts
+					}).end(function (err, res) {
+						if (err) {
+							reject(new Error(err));
+						} else {
+
+							resolve(destination.messages.add(new Message(res.body, destination, self.client)));
+						}
+					});
+				}
+			});
+		}
+		// def deleteMessage
+
+	}, {
+		key: "deleteMessage",
+		value: function deleteMessage(_message) {
+			var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				var message = self.resolver.resolveMessage(_message);
+
+				if (message) {
+					var _deleteMsg = function _deleteMsg() {
+						request.del(Endpoints.CHANNEL_MESSAGE(message.channel.id, message.id)).set("authorization", self.token).end(function (err, res) {
+							if (err) {
+								reject(new Error(err));
+							} else {
+								message.channel.messages.remove(message);
+								resolve();
+							}
+						});
+					};
+
+					if (options.wait) {
+						setTimeout(_deleteMsg, options.wait);
+					} else {
+						_deleteMsg();
+					}
+				} else {
+					reject(new Error("Supplied message did not resolve to a message!"));
+				}
+			});
+		}
+
+		// def updateMessage
+
+	}, {
+		key: "updateMessage",
+		value: function updateMessage(msg, _content) {
+			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				var message = self.resolver.resolveMessage(msg);
+
+				if (message) {
+
+					var content = self.resolver.resolveString(_content);
+					var mentions = self.resolver.resolveMentions(content);
+
+					request.patch(Endpoints.CHANNEL_MESSAGE(message.channel.id, message.id)).set("authorization", self.token).send({
+						content: content,
+						tts: options.tts,
+						mentions: mentions
+					}).end(function (err, res) {
+						if (err) {
+							reject(new Error(err));
+						} else {
+							resolve(message.channel.messages.update(message, new Message(res.body, message.channel, self.client)));
+						}
+					});
+				} else {
+					reject(new Error("Supplied message did not resolve to a message!"));
+				}
+			});
+		}
+
+		// def sendFile
+
+	}, {
+		key: "sendFile",
+		value: function sendFile(where, _file) {
+			var name = arguments.length <= 2 || arguments[2] === undefined ? "image.png" : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				self.resolver.resolveChannel(where).then(next).catch(function (e) {
+					return reject(new Error("couldn't resolve to channel - " + e));
+				});
+
+				function next(channel) {
+
+					var file = self.resolver.resolveFile(_file);
+
+					request.post(Endpoints.CHANNEL_MESSAGES(channel.id)).set("authorization", self.token).attach("file", file, name).end(function (err, res) {
+
+						if (err) {
+							reject(new Error(err));
+						} else {
+							resolve(channel.messages.add(new Message(res.body, channel, self.client)));
+						}
+					});
+				}
+			});
+		}
+
+		// def getChannelLogs
+
+	}, {
+		key: "getChannelLogs",
+		value: function getChannelLogs(_channel) {
+			var limit = arguments.length <= 1 || arguments[1] === undefined ? 500 : arguments[1];
+			var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(_channel).then(next).catch(function (e) {
+					return reject(new Error("couldn't resolve to channel - " + e));
+				});
+
+				function next(channel) {
+
+					if (options.before) options.before = self.resolver.resolveMessage(options.before);
+					if (options.after) options.after = self.resolver.resolveMessage(options.after);
+
+					var params = [];
+					if (options.before) params.push("before=" + options.before.id);
+					if (options.after) params.push("after=" + options.after.id);
+
+					var joinedParams = params.join();
+					if (joinedParams !== "") joinedParams = "&" + params.join();
+
+					request.get(Endpoints.CHANNEL_MESSAGES(channel.id) + "?limit=" + limit + joinedParams).set("authorization", self.token).end(function (err, res) {
+						if (err) {
+							reject(new Error(err));
+						} else {
+							var logs = [];
+							res.body.forEach(function (msg) {
+								logs.push(channel.messages.add(new Message(msg, channel, self.client)));
+							});
+							resolve(logs);
+						}
+					});
+				}
+			});
+		}
+
+		// def getBans
+
+	}, {
+		key: "getBans",
+		value: function getBans(server) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				server = self.resolver.resolveServer(server);
+
+				request.get("" + Endpoints.SERVER_BANS(server.id)).set("authorization", self.token).end(function (err, res) {
+					if (err) {
+						reject(new Error(err));
+					} else {
+						var bans = [];
+						res.body.forEach(function (ban) {
+							bans.push(self.users.add(new User(ban.user, self.client)));
+						});
+						resolve(bans);
+					}
+				});
+			});
+		}
+
+		// def createChannel
+
+	}, {
+		key: "createChannel",
+		value: function createChannel(server, name) {
+			var type = arguments.length <= 2 || arguments[2] === undefined ? "text" : arguments[2];
+
+			var self = this;
+
+			return new Promise(function (resolve, reject) {
+
+				server = self.resolver.resolveServer(server);
+
+				request.post(Endpoints.SERVER_CHANNELS(server.id)).set("authorization", self.token).send({
+					name: name, type: type
+				}).end(function (err, res) {
+					if (err) {
+						reject(err);
+					} else {
+						var channel;
+						if (res.body.type === "text") {
+							channel = new TextChannel(res.body, self.client, server);
+						} else {
+							channel = new VoiceChannel(res.body, self.client, server);
+						}
+						resolve(server.channels.add(self.channels.add(channel)));
+					}
+				});
+			});
+		}
+
+		// def deleteChannel
+
+	}, {
+		key: "deleteChannel",
+		value: function deleteChannel(_channel) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(_channel).then(next).catch(reject);
+
+				function next(channel) {
+					request.del(Endpoints.CHANNEL(channel.id)).set("authorization", self.token).end(function (err, res) {
+						if (err) {
+							reject(err);
+						} else {
+							channel.server.channels.remove(channel);
+							self.channels.remove(channel);
 							resolve();
 						}
 					});
 				}
-			} else {
-				reject(new Error("Supplied message did not resolve to a message!"));
-			}
-		});
-	}
-
-	// def updateMessage
-	updateMessage(msg, _content, options = {}) {
-
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			var message = self.resolver.resolveMessage(msg);
-
-			if (message) {
-
-				var content = self.resolver.resolveString(_content);
-				var mentions = self.resolver.resolveMentions(content);
-
-				request.patch(Endpoints.CHANNEL_MESSAGE(message.channel.id, message.id)).set("authorization", self.token).send({
-					content: content,
-					tts: options.tts,
-					mentions: mentions
-				}).end((err, res) => {
-					if (err) {
-						reject(new Error(err));
-					} else {
-						resolve(message.channel.messages.update(message, new Message(res.body, message.channel, self.client)));
-					}
-				});
-			} else {
-				reject(new Error("Supplied message did not resolve to a message!"));
-			}
-		});
-	}
-
-	// def sendFile
-	sendFile(where, _file, name = "image.png") {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.resolver.resolveChannel(where).then(next).catch(e => reject(new Error("couldn't resolve to channel - " + e)));
-
-			function next(channel) {
-
-				var file = self.resolver.resolveFile(_file);
-
-				request.post(Endpoints.CHANNEL_MESSAGES(channel.id)).set("authorization", self.token).attach("file", file, name).end((err, res) => {
-
-					if (err) {
-						reject(new Error(err));
-					} else {
-						resolve(channel.messages.add(new Message(res.body, channel, self.client)));
-					}
-				});
-			}
-		});
-	}
-
-	// def getChannelLogs
-	getChannelLogs(_channel, limit = 500, options = {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(_channel).then(next).catch(e => reject(new Error("couldn't resolve to channel - " + e)));
-
-			function next(channel) {
-
-				if (options.before) options.before = self.resolver.resolveMessage(options.before);
-				if (options.after) options.after = self.resolver.resolveMessage(options.after);
-
-				var params = [];
-				if (options.before) params.push("before=" + options.before.id);
-				if (options.after) params.push("after=" + options.after.id);
-
-				var joinedParams = params.join();
-				if (joinedParams !== "") joinedParams = "&" + params.join();
-
-				request.get(`${ Endpoints.CHANNEL_MESSAGES(channel.id) }?limit=${ limit }${ joinedParams }`).set("authorization", self.token).end((err, res) => {
-					if (err) {
-						reject(new Error(err));
-					} else {
-						var logs = [];
-						res.body.forEach(msg => {
-							logs.push(channel.messages.add(new Message(msg, channel, self.client)));
-						});
-						resolve(logs);
-					}
-				});
-			}
-		});
-	}
-
-	// def getBans
-	getBans(server) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			server = self.resolver.resolveServer(server);
-
-			request.get(`${ Endpoints.SERVER_BANS(server.id) }`).set("authorization", self.token).end((err, res) => {
-				if (err) {
-					reject(new Error(err));
-				} else {
-					var bans = [];
-					res.body.forEach(ban => {
-						bans.push(self.users.add(new User(ban.user, self.client)));
-					});
-					resolve(bans);
-				}
 			});
-		});
-	}
+		}
 
-	// def createChannel
-	createChannel(server, name, type = "text") {
-		var self = this;
+		// def banMember
 
-		return new Promise((resolve, reject) => {
+	}, {
+		key: "banMember",
+		value: function banMember(user, server) {
+			var length = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2];
 
-			server = self.resolver.resolveServer(server);
+			var self = this;
+			return new Promise(function (resolve, reject) {
 
-			request.post(Endpoints.SERVER_CHANNELS(server.id)).set("authorization", self.token).send({
-				name, type
-			}).end((err, res) => {
-				if (err) {
-					reject(err);
-				} else {
-					var channel;
-					if (res.body.type === "text") {
-						channel = new TextChannel(res.body, self.client, server);
-					} else {
-						channel = new VoiceChannel(res.body, self.client, server);
-					}
-					resolve(server.channels.add(self.channels.add(channel)));
-				}
-			});
-		});
-	}
+				user = self.resolver.resolveUser(user);
+				server = self.resolver.resolveServer(server);
 
-	// def deleteChannel
-	deleteChannel(_channel) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(_channel).then(next).catch(reject);
-
-			function next(channel) {
-				request.del(Endpoints.CHANNEL(channel.id)).set("authorization", self.token).end(function (err, res) {
-					if (err) {
-						reject(err);
-					} else {
-						channel.server.channels.remove(channel);
-						self.channels.remove(channel);
-						resolve();
-					}
-				});
-			}
-		});
-	}
-
-	// def banMember
-	banMember(user, server, length = 1) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			user = self.resolver.resolveUser(user);
-			server = self.resolver.resolveServer(server);
-
-			request.put(`${ Endpoints.SERVER_BANS(server.id) }/${ user.id }/?delete-message-days=${ length }`).set("authorization", self.token).end((err, res) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
-				}
-			});
-		});
-	}
-
-	// def unbanMember
-	unbanMember(user, server) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			server = self.resolver.resolveServer(server);
-			user = self.resolver.resolveUser(user);
-
-			request.del(`${ Endpoints.SERVER_BANS(server.id) }/${ user.id }`).set("authorization", self.token).end((err, res) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
-				}
-			});
-		});
-	}
-
-	// def kickMember
-	kickMember(user, server) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			user = self.resolver.resolveUser(user);
-			server = self.resolver.resolveServer(server);
-
-			request.del(`${ Endpoints.SERVER_MEMBERS(server.id) }/${ user.id }`).set("authorization", self.token).end((err, res) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
-				}
-			});
-		});
-	}
-
-	// def createRole
-	createRole(server, data) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			server = self.resolver.resolveServer(server);
-
-			request.post(Endpoints.SERVER_ROLES(server.id)).set("authorization", self.token).end((err, res) => {
-				if (err) {
-					reject(err);
-				} else {
-
-					var role = server.roles.add(new Role(res.body, server, self.client));
-
-					if (data) {
-
-						self.updateRole(role, data).then(resolve).catch(reject);
-					} else {
-						resolve(role);
-					}
-				}
-			});
-		});
-	}
-	// def updateRole
-	updateRole(role, data) {
-		var self = this;
-		data = data || {};
-		data.permissions = data.permissions || [];
-		return new Promise((resolve, reject) => {
-
-			var server = self.resolver.resolveServer(role.server);
-
-			var permissions = 0;
-			for (var perm of data.permissions) {
-				if (perm instanceof String || typeof perm === "string") {
-					permissions |= Constants.Permissions[perm] || 0;
-				} else {
-					permissions |= perm;
-				}
-			}
-
-			data.color = data.color || 0;
-
-			request.patch(Endpoints.SERVER_ROLES(server.id) + "/" + role.id).set("authorization", self.token).send({
-				color: data.color || role.color,
-				hoist: data.hoist || role.hoist,
-				name: data.name || role.name,
-				permissions: permissions
-			}).end((err, res) => {
-				if (err) {
-					reject(err);
-				} else {
-					var nrole = new Role(res.body, server, self.client);
-					resolve(server.roles.update(role, nrole));
-				}
-			});
-		});
-	}
-
-	// def deleteRole
-	deleteRole(role) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			request.del(Endpoints.SERVER_ROLES(role.server.id) + "/" + role.id).set("authorization", self.token).end((err, res) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
-					// the ws cache will handle it
-					// role.server.roles.remove(role);
-				}
-			});
-		});
-	}
-
-	//def addMemberToRole
-	addMemberToRole(member, role) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			member = self.resolver.resolveUser(member);
-
-			if (!member || !role) {
-				reject(new Error("member/role not in server"));
-				return;
-			}
-
-			if (role.server.memberMap[member.id]) {
-
-				var roleIDS = role.server.memberMap[member.id].roles.map(r => r.id).concat(role.id);
-
-				request.patch(Endpoints.SERVER_MEMBERS(role.server.id) + "/" + member.id).set("authorization", self.token).send({
-					roles: roleIDS
-				}).end(err => {
+				request.put(Endpoints.SERVER_BANS(server.id) + "/" + user.id + "/?delete-message-days=" + length).set("authorization", self.token).end(function (err, res) {
 					if (err) {
 						reject(err);
 					} else {
 						resolve();
 					}
 				});
-			} else {
-				reject(new Error("member not in server"));
-			}
-		});
-	}
-
-	//def removeMemberFromRole
-	removeMemberFromRole(member, role) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			member = self.resolver.resolveUser(member);
-
-			if (!member || !role) {
-				reject(new Error("member/role not in server"));
-				return;
-			}
-
-			if (role.server.memberMap[member.id]) {
-
-				var roleIDS = role.server.memberMap[member.id].roles.map(r => r.id);
-
-				for (var item in roleIDS) {
-					if (roleIDS[item] === role.id) {
-						roleIDS.splice(item, 1);
-					}
-				}
-
-				request.patch(Endpoints.SERVER_MEMBERS(role.server.id) + "/" + member.id).set("authorization", self.token).send({
-					roles: roleIDS
-				}).end(err => {
-					if (err) {
-						reject(err);
-					} else {
-						resolve();
-					}
-				});
-			} else {
-				reject(new Error("member not in server"));
-			}
-		});
-	}
-
-	// def createInvite
-	createInvite(chanServ, options) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			if (chanServ instanceof Channel) {
-				// do something
-			} else if (chanServ instanceof Server) {
-					// do something
-				} else {
-						chanServ = self.resolver.resolveServer(chanServ) || self.resolver.resolveChannel(chanServ);
-					}
-
-			if (!chanServ) {
-				reject(new Error("couldn't resolve where"));
-				return;
-			}
-
-			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 Channel) {
-				epoint = Endpoints.CHANNEL_INVITES(chanServ.id);
-			} else {
-				epoint = Endpoints.SERVER_INVITES(chanServ.id);
-			}
-
-			request.post(epoint).set("authorization", self.token).send(options).end((err, res) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve(new Invite(res.body, self.channels.get("id", res.body.channel.id), self.client));
-				}
 			});
-		});
-	}
+		}
 
-	//def deleteInvite
-	deleteInvite(invite) {
-		var self = this;
-		return new Promise((resolve, reject) => {
+		// def unbanMember
 
-			invite = self.resolver.resolveInviteID(invite);
-			if (invite) {
-				request.del(Endpoints.INVITE(invite)).set("authorization", self.token).end((err, res) => {
+	}, {
+		key: "unbanMember",
+		value: function unbanMember(user, server) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				server = self.resolver.resolveServer(server);
+				user = self.resolver.resolveUser(user);
+
+				request.del(Endpoints.SERVER_BANS(server.id) + "/" + user.id).set("authorization", self.token).end(function (err, res) {
 					if (err) {
 						reject(err);
 					} else {
 						resolve();
 					}
 				});
-			} else {
-				reject(new Error("Not a valid invite"));
-			}
-		});
-	}
+			});
+		}
 
-	//def overwritePermissions
-	overwritePermissions(channel, role, updated) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			channel = self.resolver.resolveChannel(channel).catch(reject).then(next);
-			function next(channel) {
+		// def kickMember
 
-				var user;
-				if (role instanceof User) {
-					user = role;
+	}, {
+		key: "kickMember",
+		value: function kickMember(user, server) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				user = self.resolver.resolveUser(user);
+				server = self.resolver.resolveServer(server);
+
+				request.del(Endpoints.SERVER_MEMBERS(server.id) + "/" + user.id).set("authorization", self.token).end(function (err, res) {
+					if (err) {
+						reject(err);
+					} else {
+						resolve();
+					}
+				});
+			});
+		}
+
+		// def createRole
+
+	}, {
+		key: "createRole",
+		value: function createRole(server, data) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				server = self.resolver.resolveServer(server);
+
+				request.post(Endpoints.SERVER_ROLES(server.id)).set("authorization", self.token).end(function (err, res) {
+					if (err) {
+						reject(err);
+					} else {
+
+						var role = server.roles.add(new Role(res.body, server, self.client));
+
+						if (data) {
+
+							self.updateRole(role, data).then(resolve).catch(reject);
+						} else {
+							resolve(role);
+						}
+					}
+				});
+			});
+		}
+		// def updateRole
+
+	}, {
+		key: "updateRole",
+		value: function updateRole(role, data) {
+			var self = this;
+			data = data || {};
+			data.permissions = data.permissions || [];
+			return new Promise(function (resolve, reject) {
+
+				var server = self.resolver.resolveServer(role.server);
+
+				var permissions = 0;
+				var _iteratorNormalCompletion2 = true;
+				var _didIteratorError2 = false;
+				var _iteratorError2 = undefined;
+
+				try {
+					for (var _iterator2 = data.permissions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+						var perm = _step2.value;
+
+						if (perm instanceof String || typeof perm === "string") {
+							permissions |= Constants.Permissions[perm] || 0;
+						} else {
+							permissions |= perm;
+						}
+					}
+				} catch (err) {
+					_didIteratorError2 = true;
+					_iteratorError2 = err;
+				} finally {
+					try {
+						if (!_iteratorNormalCompletion2 && _iterator2.return) {
+							_iterator2.return();
+						}
+					} finally {
+						if (_didIteratorError2) {
+							throw _iteratorError2;
+						}
+					}
 				}
 
-				var data = {};
-				data.allow = 0;
-				data.deny = 0;
+				data.color = data.color || 0;
 
-				updated.allow = updated.allow || [];
-				updated.deny = updated.deny || [];
+				request.patch(Endpoints.SERVER_ROLES(server.id) + "/" + role.id).set("authorization", self.token).send({
+					color: data.color || role.color,
+					hoist: data.hoist || role.hoist,
+					name: data.name || role.name,
+					permissions: permissions
+				}).end(function (err, res) {
+					if (err) {
+						reject(err);
+					} else {
+						var nrole = new Role(res.body, server, self.client);
+						resolve(server.roles.update(role, nrole));
+					}
+				});
+			});
+		}
 
-				if (role instanceof Role) {
-					data.id = role.id;
-					data.type = "role";
-				} else if (user) {
-					data.id = user.id;
-					data.type = "member";
-				} else {
-					reject(new Error("role incorrect"));
+		// def deleteRole
+
+	}, {
+		key: "deleteRole",
+		value: function deleteRole(role) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				request.del(Endpoints.SERVER_ROLES(role.server.id) + "/" + role.id).set("authorization", self.token).end(function (err, res) {
+					if (err) {
+						reject(err);
+					} else {
+						resolve();
+						// the ws cache will handle it
+						// role.server.roles.remove(role);
+					}
+				});
+			});
+		}
+
+		//def addMemberToRole
+
+	}, {
+		key: "addMemberToRole",
+		value: function addMemberToRole(member, role) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				member = self.resolver.resolveUser(member);
+
+				if (!member || !role) {
+					reject(new Error("member/role not in server"));
 					return;
 				}
 
-				for (var perm in updated) {
-					if (updated[perm]) {
-						if (perm instanceof String || typeof perm === "string") {
-							data.allow |= Constants.Permissions[perm] || 0;
+				if (role.server.memberMap[member.id]) {
+
+					var roleIDS = role.server.memberMap[member.id].roles.map(function (r) {
+						return r.id;
+					}).concat(role.id);
+
+					request.patch(Endpoints.SERVER_MEMBERS(role.server.id) + "/" + member.id).set("authorization", self.token).send({
+						roles: roleIDS
+					}).end(function (err) {
+						if (err) {
+							reject(err);
 						} else {
-							data.allow |= perm;
+							resolve();
 						}
-					} else {
-						if (perm instanceof String || typeof perm === "string") {
-							data.deny |= Constants.Permissions[perm] || 0;
-						} else {
-							data.deny |= perm;
-						}
-					}
+					});
+				} else {
+					reject(new Error("member not in server"));
+				}
+			});
+		}
+
+		//def removeMemberFromRole
+
+	}, {
+		key: "removeMemberFromRole",
+		value: function removeMemberFromRole(member, role) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				member = self.resolver.resolveUser(member);
+
+				if (!member || !role) {
+					reject(new Error("member/role not in server"));
+					return;
 				}
 
-				request.put(Endpoints.CHANNEL_PERMISSIONS(channel.id) + "/" + data.id).set("authorization", self.token).send(data).end(function (err) {
+				if (role.server.memberMap[member.id]) {
+
+					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);
+						}
+					}
+
+					request.patch(Endpoints.SERVER_MEMBERS(role.server.id) + "/" + member.id).set("authorization", self.token).send({
+						roles: roleIDS
+					}).end(function (err) {
+						if (err) {
+							reject(err);
+						} else {
+							resolve();
+						}
+					});
+				} else {
+					reject(new Error("member not in server"));
+				}
+			});
+		}
+
+		// def createInvite
+
+	}, {
+		key: "createInvite",
+		value: function createInvite(chanServ, options) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				if (chanServ instanceof Channel) {
+					// do something
+				} else if (chanServ instanceof Server) {
+						// do something
+					} else {
+							chanServ = self.resolver.resolveServer(chanServ) || self.resolver.resolveChannel(chanServ);
+						}
+
+				if (!chanServ) {
+					reject(new Error("couldn't resolve where"));
+					return;
+				}
+
+				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 Channel) {
+					epoint = Endpoints.CHANNEL_INVITES(chanServ.id);
+				} else {
+					epoint = Endpoints.SERVER_INVITES(chanServ.id);
+				}
+
+				request.post(epoint).set("authorization", self.token).send(options).end(function (err, res) {
+					if (err) {
+						reject(err);
+					} else {
+						resolve(new Invite(res.body, self.channels.get("id", res.body.channel.id), self.client));
+					}
+				});
+			});
+		}
+
+		//def deleteInvite
+
+	}, {
+		key: "deleteInvite",
+		value: function deleteInvite(invite) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				invite = self.resolver.resolveInviteID(invite);
+				if (invite) {
+					request.del(Endpoints.INVITE(invite)).set("authorization", self.token).end(function (err, res) {
+						if (err) {
+							reject(err);
+						} else {
+							resolve();
+						}
+					});
+				} else {
+					reject(new Error("Not a valid invite"));
+				}
+			});
+		}
+
+		//def overwritePermissions
+
+	}, {
+		key: "overwritePermissions",
+		value: function overwritePermissions(channel, role, updated) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				channel = self.resolver.resolveChannel(channel).catch(reject).then(next);
+				function next(channel) {
+
+					var user;
+					if (role instanceof User) {
+						user = role;
+					}
+
+					var data = {};
+					data.allow = 0;
+					data.deny = 0;
+
+					updated.allow = updated.allow || [];
+					updated.deny = updated.deny || [];
+
+					if (role instanceof Role) {
+						data.id = role.id;
+						data.type = "role";
+					} else if (user) {
+						data.id = user.id;
+						data.type = "member";
+					} else {
+						reject(new Error("role incorrect"));
+						return;
+					}
+
+					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;
+							}
+						}
+					}
+
+					request.put(Endpoints.CHANNEL_PERMISSIONS(channel.id) + "/" + data.id).set("authorization", self.token).send(data).end(function (err) {
+						if (err) {
+							reject(err);
+						} else {
+							resolve();
+						}
+					});
+				}
+			});
+		}
+
+		//def setStatus
+
+	}, {
+		key: "setStatus",
+		value: function setStatus(idleStatus, gameID) {
+			var self = this;
+
+			self.idleStatus = idleStatus || self.idleStatus || null;
+			if (idleStatus) {
+				if (idleStatus == "online" || idleStatus == "here" || idleStatus == "available") {
+					self.idleStatus = null;
+				}
+			}
+			self.gameID = self.resolver.resolveGameID(gameID) || self.gameID || null;
+
+			return new Promise(function (resolve, reject) {
+
+				var packet = {
+					op: 3,
+					d: {
+						idle_since: self.idleStatus,
+						game_id: self.gameID
+					}
+				};
+
+				if (self.idleStatus == "idle" || self.idleStatus == "away") {
+					packet.d.idle_since = Date.now();
+				}
+
+				self.sendWS(packet);
+
+				resolve();
+			});
+		}
+
+		//def sendTyping
+
+	}, {
+		key: "sendTyping",
+		value: function sendTyping(channel) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(channel).then(next).catch(reject);
+
+				function next(channel) {
+
+					request.post(Endpoints.CHANNEL(channel.id) + "/typing").set("authorization", self.token).end(function (err, res) {
+						if (err) {
+							reject(err);
+						} else {
+							resolve();
+						}
+					});
+				}
+			});
+		}
+
+		//def startTyping
+
+	}, {
+		key: "startTyping",
+		value: function startTyping(channel) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(channel).then(next).catch(reject);
+
+				function next(channel) {
+
+					if (self.typingIntervals[channel.id]) {
+						// typing interval already exists, leave it alone
+						reject(new Error("Already typing in that channel"));
+						return;
+					}
+
+					self.sendTyping(channel);
+
+					self.typingIntervals[channel.id] = setInterval(function () {
+						return self.sendTyping(channel);
+					}, 4000);
+				}
+			});
+		}
+
+		//def stopTyping
+
+	}, {
+		key: "stopTyping",
+		value: function stopTyping(channel) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(channel).then(next).catch(reject);
+
+				function next(channel) {
+
+					if (!self.typingIntervals[channel.id]) {
+						// typing interval doesn't exist
+						reject(new Error("Not typing in that channel"));
+						return;
+					}
+
+					clearInterval(self.typingIntervals[channel.id]);
+					self.typingIntervals[channel.id] = false;
+				}
+			});
+		}
+
+		//def updateDetails
+
+	}, {
+		key: "updateDetails",
+		value: function updateDetails(data) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				request.patch(Endpoints.ME).set("authorization", self.token).send({
+					avatar: self.resolver.resolveToBase64(data.avatar) || self.user.avatar,
+					email: data.email || self.email,
+					new_password: data.newPassword || null,
+					password: data.password || self.password,
+					username: data.username || self.user.username
+				}).end(function (err) {
 					if (err) {
 						reject(err);
 					} else {
 						resolve();
 					}
 				});
-			}
-		});
-	}
-
-	//def setStatus
-	setStatus(idleStatus, gameID) {
-		var self = this;
-
-		self.idleStatus = idleStatus || self.idleStatus || null;
-		if (idleStatus) {
-			if (idleStatus == "online" || idleStatus == "here" || idleStatus == "available") {
-				self.idleStatus = null;
-			}
+			});
 		}
-		self.gameID = self.resolver.resolveGameID(gameID) || self.gameID || null;
 
-		return new Promise((resolve, reject) => {
+		//def setAvatar
 
-			var packet = {
-				op: 3,
-				d: {
-					idle_since: self.idleStatus,
-					game_id: self.gameID
+	}, {
+		key: "setAvatar",
+		value: function setAvatar(avatar) {
+			return this.updateDetails({ avatar: avatar });
+		}
+
+		//def setUsername
+
+	}, {
+		key: "setUsername",
+		value: function setUsername(username) {
+			return this.updateDetails({ username: username });
+		}
+
+		//def setTopic
+
+	}, {
+		key: "setTopic",
+		value: function setTopic(chann) {
+			var topic = arguments.length <= 1 || arguments[1] === undefined ? "" : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(chann).then(next).catch(reject);
+
+				function next(channel) {
+
+					request.patch(Endpoints.CHANNEL(channel.id)).set("authorization", self.token).send({
+						name: channel.name,
+						position: channel.position,
+						topic: topic
+					}).end(function (err, res) {
+						if (err) {
+							reject(err);
+						} else {
+							channel.topic = res.body.topic;
+							resolve();
+						}
+					});
 				}
+			});
+		}
+
+		//def setChannelName
+
+	}, {
+		key: "setChannelName",
+		value: function setChannelName(chann) {
+			var name = arguments.length <= 1 || arguments[1] === undefined ? "discordjs_is_the_best" : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(chann).then(next).catch(reject);
+
+				function next(channel) {
+
+					request.patch(Endpoints.CHANNEL(channel.id)).set("authorization", self.token).send({
+						name: name,
+						position: channel.position,
+						topic: channel.topic
+					}).end(function (err, res) {
+						if (err) {
+							reject(err);
+						} else {
+							channel.name = res.body.name;
+							resolve();
+						}
+					});
+				}
+			});
+		}
+
+		//def setChannelNameAndTopic
+
+	}, {
+		key: "setChannelNameAndTopic",
+		value: function setChannelNameAndTopic(chann) {
+			var name = arguments.length <= 1 || arguments[1] === undefined ? "discordjs_is_the_best" : arguments[1];
+			var topic = arguments.length <= 2 || arguments[2] === undefined ? "" : arguments[2];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				self.resolver.resolveChannel(chann).then(next).catch(reject);
+
+				function next(channel) {
+
+					request.patch(Endpoints.CHANNEL(channel.id)).set("authorization", self.token).send({
+						name: name,
+						position: channel.position,
+						topic: topic
+					}).end(function (err, res) {
+						if (err) {
+							reject(err);
+						} else {
+							channel.name = res.body.name;
+							channel.topic = res.body.topic;
+							resolve();
+						}
+					});
+				}
+			});
+		}
+
+		//def updateChannel
+
+	}, {
+		key: "updateChannel",
+		value: function updateChannel(chann, data) {
+			return this.setChannelNameAndTopic(chann, data.name, data.topic);
+		}
+
+		//def ack
+
+	}, {
+		key: "ack",
+		value: function ack(msg) {
+			var self = this;
+			return new Promise(function (resolve, reject) {
+
+				msg = self.resolver.resolveMessage(msg);
+
+				if (msg) {
+
+					request.post(Endpoints.CHANNEL_MESSAGE(msg.channel.id, msg.id) + "/ack").set("authorization", self.token).end(function (err) {
+						if (err) {
+							reject(err);
+						} else {
+							resolve();
+						}
+					});
+				} else {
+					reject(new Error("Message does not exist"));
+				}
+			});
+		}
+	}, {
+		key: "sendWS",
+		value: function sendWS(object) {
+			if (this.websocket) this.websocket.send(JSON.stringify(object));
+		}
+	}, {
+		key: "createWS",
+		value: function createWS(url) {
+			var self = this;
+			var client = self.client;
+
+			if (this.websocket) return false;
+
+			this.websocket = new WebSocket(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"
+						}
+					}
+				});
 			};
 
-			if (self.idleStatus == "idle" || self.idleStatus == "away") {
-				packet.d.idle_since = Date.now();
-			}
+			this.websocket.onclose = function () {
+				self.websocket = null;
+				self.state = ConnectionState.DISCONNECTED;
+				client.emit("disconnected");
+			};
 
-			self.sendWS(packet);
-
-			resolve();
-		});
-	}
-
-	//def sendTyping
-	sendTyping(channel) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(channel).then(next).catch(reject);
-
-			function next(channel) {
-
-				request.post(Endpoints.CHANNEL(channel.id) + "/typing").set("authorization", self.token).end((err, res) => {
-					if (err) {
-						reject(err);
-					} else {
-						resolve();
-					}
-				});
-			}
-		});
-	}
-
-	//def startTyping
-	startTyping(channel) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(channel).then(next).catch(reject);
-
-			function next(channel) {
-
-				if (self.typingIntervals[channel.id]) {
-					// typing interval already exists, leave it alone
-					reject(new Error("Already typing in that channel"));
-					return;
-				}
-
-				self.sendTyping(channel);
-
-				self.typingIntervals[channel.id] = setInterval(() => self.sendTyping(channel), 4000);
-			}
-		});
-	}
-
-	//def stopTyping
-	stopTyping(channel) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(channel).then(next).catch(reject);
-
-			function next(channel) {
-
-				if (!self.typingIntervals[channel.id]) {
-					// typing interval doesn't exist
-					reject(new Error("Not typing in that channel"));
-					return;
-				}
-
-				clearInterval(self.typingIntervals[channel.id]);
-				self.typingIntervals[channel.id] = false;
-			}
-		});
-	}
-
-	//def updateDetails
-	updateDetails(data) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			request.patch(Endpoints.ME).set("authorization", self.token).send({
-				avatar: self.resolver.resolveToBase64(data.avatar) || self.user.avatar,
-				email: data.email || self.email,
-				new_password: data.newPassword || null,
-				password: data.password || self.password,
-				username: data.username || self.user.username
-			}).end(err => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
-				}
-			});
-		});
-	}
-
-	//def setAvatar
-	setAvatar(avatar) {
-		return this.updateDetails({ avatar });
-	}
-
-	//def setUsername
-	setUsername(username) {
-		return this.updateDetails({ username });
-	}
-
-	//def setTopic
-	setTopic(chann, topic = "") {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(chann).then(next).catch(reject);
-
-			function next(channel) {
-
-				request.patch(Endpoints.CHANNEL(channel.id)).set("authorization", self.token).send({
-					name: channel.name,
-					position: channel.position,
-					topic: topic
-				}).end((err, res) => {
-					if (err) {
-						reject(err);
-					} else {
-						channel.topic = res.body.topic;
-						resolve();
-					}
-				});
-			}
-		});
-	}
-
-	//def setChannelName
-	setChannelName(chann, name = "discordjs_is_the_best") {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(chann).then(next).catch(reject);
-
-			function next(channel) {
-
-				request.patch(Endpoints.CHANNEL(channel.id)).set("authorization", self.token).send({
-					name: name,
-					position: channel.position,
-					topic: channel.topic
-				}).end((err, res) => {
-					if (err) {
-						reject(err);
-					} else {
-						channel.name = res.body.name;
-						resolve();
-					}
-				});
-			}
-		});
-	}
-
-	//def setChannelNameAndTopic
-	setChannelNameAndTopic(chann, name = "discordjs_is_the_best", topic = "") {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.resolver.resolveChannel(chann).then(next).catch(reject);
-
-			function next(channel) {
-
-				request.patch(Endpoints.CHANNEL(channel.id)).set("authorization", self.token).send({
-					name: name,
-					position: channel.position,
-					topic: topic
-				}).end((err, res) => {
-					if (err) {
-						reject(err);
-					} else {
-						channel.name = res.body.name;
-						channel.topic = res.body.topic;
-						resolve();
-					}
-				});
-			}
-		});
-	}
-
-	//def updateChannel
-	updateChannel(chann, data) {
-		return this.setChannelNameAndTopic(chann, data.name, data.topic);
-	}
-
-	//def ack
-	ack(msg) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			msg = self.resolver.resolveMessage(msg);
-
-			if (msg) {
-
-				request.post(Endpoints.CHANNEL_MESSAGE(msg.channel.id, msg.id) + "/ack").set("authorization", self.token).end(err => {
-					if (err) {
-						reject(err);
-					} else {
-						resolve();
-					}
-				});
-			} else {
-				reject(new Error("Message does not exist"));
-			}
-		});
-	}
-
-	sendWS(object) {
-		if (this.websocket) this.websocket.send(JSON.stringify(object));
-	}
-
-	createWS(url) {
-		var self = this;
-		var client = self.client;
-
-		if (this.websocket) return false;
-
-		this.websocket = new WebSocket(url);
-
-		this.websocket.onopen = () => {
-
-			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 = () => {
-			self.websocket = null;
-			self.state = ConnectionState.DISCONNECTED;
-			client.emit("disconnected");
-		};
-
-		this.websocket.onerror = e => {
-			client.emit("error", e);
-		};
-
-		this.websocket.onmessage = 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) {
+			this.websocket.onerror = function (e) {
 				client.emit("error", e);
-				return;
-			}
+			};
 
-			client.emit("raw", packet);
+			this.websocket.onmessage = function (e) {
 
-			switch (packet.t) {
+				if (e.type === "Binary") {
+					if (!zlib) zlib = require("zlib");
+					e.data = zlib.inflateSync(e.data).toString();
+				}
 
-				case PacketType.READY:
-					var startTime = Date.now();
-					self.user = self.users.add(new User(data.user, client));
-					data.guilds.forEach(server => {
-						self.servers.add(new Server(server, client));
-					});
-					data.private_channels.forEach(pm => {
-						self.private_channels.add(new PMChannel(pm, client));
-					});
-					self.state = ConnectionState.READY;
+				var packet, data;
+				try {
+					packet = JSON.parse(e.data);
+					data = packet.d;
+				} catch (e) {
+					client.emit("error", e);
+					return;
+				}
 
-					setInterval(() => self.sendWS({ op: 1, d: Date.now() }), data.heartbeat_interval);
+				client.emit("raw", packet);
 
-					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.`);
+				switch (packet.t) {
 
-					self.readyTime = Date.now();
-					break;
+					case PacketType.READY:
+						var startTime = Date.now();
+						self.user = self.users.add(new User(data.user, client));
+						data.guilds.forEach(function (server) {
+							self.servers.add(new Server(server, client));
+						});
+						data.private_channels.forEach(function (pm) {
+							self.private_channels.add(new PMChannel(pm, client));
+						});
+						self.state = ConnectionState.READY;
 
-				case 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 Message(data, channel, client));
+						setInterval(function () {
+							return self.sendWS({ op: 1, d: Date.now() });
+						}, data.heartbeat_interval);
 
-						if (self.messageAwaits[channel.id + msg.author.id]) {
-							self.messageAwaits[channel.id + msg.author.id].map(fn => fn(msg));
-							self.messageAwaits[channel.id + msg.author.id] = null;
-							client.emit("message", msg, true); //2nd param is isAwaitedMessage
+						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 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 Message(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("message", msg);
+							client.emit("warn", "message created but channel is not cached");
+						}
+						break;
+					case 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);
+							if (msg) {
+								channel.messages.remove(msg);
 							}
-						self.ack(msg);
-					} else {
-						client.emit("warn", "message created but channel is not cached");
-					}
-					break;
-				case 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);
-						if (msg) {
-							channel.messages.remove(msg);
-						}
-					} else {
-						client.emit("warn", "message was deleted but channel is not cached");
-					}
-					break;
-				case 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 Message(data, channel, client));
-							client.emit("messageUpdated", nmsg, msg);
-						}
-					} else {
-						client.emit("warn", "message was updated but channel is not cached");
-					}
-					break;
-				case PacketType.SERVER_CREATE:
-					var server = self.servers.get("id", data.id);
-					if (!server) {
-						self.servers.add(new Server(data, client));
-						client.emit("serverCreated", server);
-					}
-					break;
-				case PacketType.SERVER_DELETE:
-					var server = self.servers.get("id", data.id);
-					if (server) {
-
-						for (var channel of server.channels) {
-							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 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 Server(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);
+							client.emit("warn", "message was deleted but channel is not cached");
 						}
-					} else if (!server) {
-						client.emit("warn", "server was updated but it was not in the cache");
-						self.servers.add(new Server(data, self));
-						client.emit("serverCreated", server);
-					}
-					break;
-				case PacketType.CHANNEL_CREATE:
+						break;
+					case 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);
 
-					var channel = self.channels.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 Message(data, channel, client));
+								client.emit("messageUpdated", nmsg, msg);
+							}
+						} else {
+							client.emit("warn", "message was updated but channel is not cached");
+						}
+						break;
+					case PacketType.SERVER_CREATE:
+						var server = self.servers.get("id", data.id);
+						if (!server) {
+							self.servers.add(new Server(data, client));
+							client.emit("serverCreated", server);
+						}
+						break;
+					case PacketType.SERVER_DELETE:
+						var server = self.servers.get("id", data.id);
+						if (server) {
+							var _iteratorNormalCompletion3 = true;
+							var _didIteratorError3 = false;
+							var _iteratorError3 = undefined;
 
-					if (!channel) {
+							try {
 
+								for (var _iterator3 = server.channels[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+									var channel = _step3.value;
+
+									self.channels.remove(channel);
+								}
+							} catch (err) {
+								_didIteratorError3 = true;
+								_iteratorError3 = err;
+							} finally {
+								try {
+									if (!_iteratorNormalCompletion3 && _iterator3.return) {
+										_iterator3.return();
+									}
+								} finally {
+									if (_didIteratorError3) {
+										throw _iteratorError3;
+									}
+								}
+							}
+
+							self.servers.remove(server);
+							client.emit("serverDeleted", server);
+						} else {
+							client.emit("warn", "server was deleted but it was not in the cache");
+						}
+						break;
+					case 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 Server(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 Server(data, self));
+							client.emit("serverCreated", server);
+						}
+						break;
+					case 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 PMChannel(data, client)));
+								} else {
+									var chan = null;
+									if (data.type === "text") {
+										chan = self.channels.add(new TextChannel(data, client, server));
+									} else {
+										chan = self.channels.add(new VoiceChannel(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 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 PacketType.CHANNEL_UPDATE:
+						var channel = self.channels.get("id", data.id) || self.private_channels.get("id", data.id);
+						if (channel) {
+
+							if (channel instanceof PMChannel) {
+								//PM CHANNEL
+								client.emit("channelUpdated", channel, self.private_channels.update(channel, new PMChannel(data, client)));
+							} else {
+								if (channel.server) {
+									if (channel.type === "text") {
+										//TEXT CHANNEL
+										var chan = new TextChannel(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 VoiceChannel(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 PacketType.SERVER_ROLE_CREATE:
 						var server = self.servers.get("id", data.guild_id);
 						if (server) {
-							if (data.is_private) {
-								client.emit("channelCreated", self.private_channels.add(new PMChannel(data, client)));
+							client.emit("serverRoleCreated", server.roles.add(new Role(data.role, server, client)), server);
+						} else {
+							client.emit("warn", "server role made but server not in cache");
+						}
+						break;
+					case 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 {
-								var chan = null;
-								if (data.type === "text") {
-									chan = self.channels.add(new TextChannel(data, client, server));
-								} else {
-									chan = self.channels.add(new VoiceChannel(data, client, server));
-								}
-								client.emit("channelCreated", server.channels.add(chan));
+								client.emit("warn", "server role deleted but role not in cache");
 							}
 						} else {
-							client.emit("warn", "channel created but server does not exist");
+							client.emit("warn", "server role deleted but server not in cache");
 						}
-					} else {
-						client.emit("warn", "channel created but already in cache");
-					}
-
-					break;
-				case 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 PacketType.CHANNEL_UPDATE:
-					var channel = self.channels.get("id", data.id) || self.private_channels.get("id", data.id);
-					if (channel) {
-
-						if (channel instanceof PMChannel) {
-							//PM CHANNEL
-							client.emit("channelUpdated", channel, self.private_channels.update(channel, new PMChannel(data, client)));
-						} else {
-							if (channel.server) {
-								if (channel.type === "text") {
-									//TEXT CHANNEL
-									var chan = new TextChannel(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 VoiceChannel(data, client, channel.server);
-									channel.server.channels.update(channel, chan);
-									self.channels.update(channel, chan);
-									client.emit("channelUpdated", channel, chan);
-								}
+						break;
+					case 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 Role(data.role, server, client);
+								server.roles.update(role, newRole);
+								client.emit("serverRoleUpdated", role, newRole);
 							} else {
-								client.emit("warn", "channel updated but server non-existant");
+								client.emit("warn", "server role updated but role not in cache");
 							}
-						}
-					} else {
-						client.emit("warn", "channel updated but not in cache");
-					}
-					break;
-				case PacketType.SERVER_ROLE_CREATE:
-					var server = self.servers.get("id", data.guild_id);
-					if (server) {
-						client.emit("serverRoleCreated", server.roles.add(new Role(data.role, server, client)), server);
-					} else {
-						client.emit("warn", "server role made but server not in cache");
-					}
-					break;
-				case 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");
+							client.emit("warn", "server role updated but server not in cache");
 						}
-					} else {
-						client.emit("warn", "server role deleted but server not in cache");
-					}
-					break;
-				case 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 Role(data.role, server, client);
-							server.roles.update(role, newRole);
-							client.emit("serverRoleUpdated", role, newRole);
+						break;
+					case 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 User(data.user, client))));
 						} else {
-							client.emit("warn", "server role updated but role not in cache");
+							client.emit("warn", "server member added but server doesn't exist in cache");
 						}
-					} else {
-						client.emit("warn", "server role updated but server not in cache");
-					}
-					break;
-				case PacketType.SERVER_MEMBER_ADD:
-					var server = self.servers.get("id", data.guild_id);
-					if (server) {
-
-						server.memberMap[data.user.id] = {
-							roles: data.roles.map(pid => 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 User(data.user, client))));
-					} else {
-						client.emit("warn", "server member added but server doesn't exist in cache");
-					}
-					break;
-				case 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 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(pid => 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 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 User(data.user, client);
-
-						if (presenceUser.equalsStrict(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("userUpdate", user, presenceUser);
-							self.users.update(user, presenceUser);
-						}
-					} else {
-						client.emit("warn", "presence update but user not in cache");
-					}
-
-					break;
-				case 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("userTypingStart", user, channel);
-						}
-						setTimeout(() => {
-							if (Date.now() - user.typing.since > 5500) {
-								// they haven't typed since
-								user.typing.since = null;
-								user.typing.channel = null;
-								client.emit("userTypingStop", user, channel);
+						break;
+					case 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");
 							}
-						}, 6000);
-					} else {
-						client.emit("warn", "user typing but user or channel not existant in cache");
-					}
-					break;
-				case PacketType.SERVER_BAN_ADD:
-					var user = self.users.get("id", data.user.id);
-					var server = self.servers.get("id", data.guild_id);
+						} else {
+							client.emit("warn", "server member removed but server doesn't exist in cache");
+						}
+						break;
+					case 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 PacketType.PRESENCE_UPDATE:
 
-					if (user && server) {
-						client.emit("userBanned", user, server);
-					} else {
-						client.emit("warn", "user banned but user/server not in cache.");
-					}
-					break;
-				case PacketType.SERVER_BAN_REMOVE:
-					var user = self.users.get("id", data.user.id);
-					var server = self.servers.get("id", data.guild_id);
+						var user = self.users.get("id", data.user.id);
 
-					if (user && server) {
-						client.emit("userUnbanned", user, server);
-					} else {
-						client.emit("warn", "user unbanned but user/server not in cache.");
-					}
-					break;
-			}
-		};
-	}
-}
+						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 User(data.user, client);
+
+							if (presenceUser.equalsStrict(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("userUpdate", user, presenceUser);
+								self.users.update(user, presenceUser);
+							}
+						} else {
+							client.emit("warn", "presence update but user not in cache");
+						}
+
+						break;
+					case 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("userTypingStart", 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("userTypingStop", user, channel);
+								}
+							}, 6000);
+						} else {
+							client.emit("warn", "user typing but user or channel not existant in cache");
+						}
+						break;
+					case 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 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;
+				}
+			};
+		}
+	}, {
+		key: "uptime",
+		get: function get() {
+			return this.readyTime ? Date.now() - this.readyTime : null;
+		}
+	}]);
+
+	return InternalClient;
+})();
 
 module.exports = InternalClient;
\ No newline at end of file
diff --git a/lib/Client/Resolver/Resolver.js b/lib/Client/Resolver/Resolver.js
index f42555eca..ab40e4336 100644
--- a/lib/Client/Resolver/Resolver.js
+++ b/lib/Client/Resolver/Resolver.js
@@ -2,6 +2,11 @@
 /* global Buffer */
 
 ;
+
+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 fs = require("fs");
 
 var User = require("../../Structures/User.js"),
@@ -15,176 +20,263 @@ var User = require("../../Structures/User.js"),
     Invite = require("../../Structures/Invite.js"),
     Games = require("../../../ref/gameMap.js");
 
-class Resolver {
-	constructor(internal) {
+var Resolver = (function () {
+	function Resolver(internal) {
+		_classCallCheck(this, Resolver);
+
 		this.internal = internal;
 	}
 
-	resolveGameID(resource) {
-		if (!isNaN(resource) && parseInt(resource) % 1 === 0) {
-			return resource;
-		} else if (typeof resource == "string" || resource instanceof String) {
+	_createClass(Resolver, [{
+		key: "resolveGameID",
+		value: function resolveGameID(resource) {
+			if (!isNaN(resource) && parseInt(resource) % 1 === 0) {
+				return resource;
+			} else if (typeof resource == "string" || resource instanceof String) {
+				var _iteratorNormalCompletion = true;
+				var _didIteratorError = false;
+				var _iteratorError = undefined;
 
-			for (var game of Games) {
-				if (game.name.toUpperCase() === resource.toUpperCase()) {
-					return game.id;
+				try {
+
+					for (var _iterator = Games[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+						var game = _step.value;
+
+						if (game.name.toUpperCase() === resource.toUpperCase()) {
+							return game.id;
+						}
+					}
+				} catch (err) {
+					_didIteratorError = true;
+					_iteratorError = err;
+				} finally {
+					try {
+						if (!_iteratorNormalCompletion && _iterator.return) {
+							_iterator.return();
+						}
+					} finally {
+						if (_didIteratorError) {
+							throw _iteratorError;
+						}
+					}
 				}
 			}
+
+			return null;
 		}
-
-		return null;
-	}
-
-	resolveToBase64(resource) {
-		if (resource instanceof Buffer) {
-			resource = resource.toString("base64");
-			resource = "data:image/jpg;base64," + resource;
+	}, {
+		key: "resolveToBase64",
+		value: function resolveToBase64(resource) {
+			if (resource instanceof Buffer) {
+				resource = resource.toString("base64");
+				resource = "data:image/jpg;base64," + resource;
+			}
+			return resource;
 		}
-		return resource;
-	}
+	}, {
+		key: "resolveInviteID",
+		value: function resolveInviteID(resource) {
+			if (resource instanceof Invite) {
+				return resource.id;
+			} else if (typeof resource == "string" || resource instanceof String) {
 
-	resolveInviteID(resource) {
-		if (resource instanceof Invite) {
-			return resource.id;
-		} else if (typeof resource == "string" || resource instanceof String) {
-
-			if (resource.indexOf("http") === 0) {
-				var split = resource.split("/");
-				return split.pop();
+				if (resource.indexOf("http") === 0) {
+					var split = resource.split("/");
+					return split.pop();
+				} else {
+					return resource;
+				}
+			}
+			return null;
+		}
+	}, {
+		key: "resolveServer",
+		value: function resolveServer(resource) {
+			if (resource instanceof Server) {
+				return resource;
+			} else if (resource instanceof ServerChannel) {
+				return resource.server;
+			} else if (resource instanceof String || typeof resource === "string") {
+				return this.internal.servers.get("id", resource);
+			} else if (resource instanceof Message) {
+				if (resource.channel instanceof TextChannel) {
+					return resource.server;
+				}
+			}
+			return null;
+		}
+	}, {
+		key: "resolveFile",
+		value: function resolveFile(resource) {
+			if (typeof resource === "string" || resource instanceof String) {
+				return fs.createReadStream(resource);
 			} else {
 				return resource;
 			}
 		}
-		return null;
-	}
+	}, {
+		key: "resolveMentions",
+		value: function resolveMentions(resource) {
+			// resource is a string
+			var _mentions = [];
+			var _iteratorNormalCompletion2 = true;
+			var _didIteratorError2 = false;
+			var _iteratorError2 = undefined;
 
-	resolveServer(resource) {
-		if (resource instanceof Server) {
-			return resource;
-		} else if (resource instanceof ServerChannel) {
-			return resource.server;
-		} else if (resource instanceof String || typeof resource === "string") {
-			return this.internal.servers.get("id", resource);
-		} else if (resource instanceof Message) {
-			if (resource.channel instanceof TextChannel) {
-				return resource.server;
-			}
-		}
-		return null;
-	}
+			try {
+				for (var _iterator2 = (resource.match(/<@[^>]*>/g) || [])[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+					var mention = _step2.value;
 
-	resolveFile(resource) {
-		if (typeof resource === "string" || resource instanceof String) {
-			return fs.createReadStream(resource);
-		} else {
-			return resource;
-		}
-	}
-
-	resolveMentions(resource) {
-		// resource is a string
-		var _mentions = [];
-		for (var mention of resource.match(/<@[^>]*>/g) || []) {
-			_mentions.push(mention.substring(2, mention.length - 1));
-		}
-		return _mentions;
-	}
-
-	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();
-	}
-
-	resolveUser(resource) {
-		/*
-  	accepts a Message, Channel, Server, String ID, User, PMChannel
-  */
-		var found = null;
-		if (resource instanceof User) {
-			found = resource;
-		} else if (resource instanceof Message) {
-			found = resource.author;
-		} else if (resource instanceof TextChannel) {
-			var lmsg = resource.lastMessage;
-			if (lmsg) {
-				found = lmsg.author;
-			}
-		} else if (resource instanceof Server) {
-			found = resource.owner;
-		} else if (resource instanceof PMChannel) {
-			found = resource.recipient;
-		} else if (resource instanceof String || typeof resource === "string") {
-			found = this.client.internal.users.get("id", resource);
-		}
-
-		return found;
-	}
-
-	resolveMessage(resource) {
-		// accepts a Message, PMChannel & TextChannel
-		var found = null;
-
-		if (resource instanceof TextChannel || resource instanceof PMChannel) {
-			found = resource.lastMessage;
-		} else if (resource instanceof Message) {
-			found = resource;
-		}
-
-		return found;
-	}
-
-	resolveVoiceChannel(resource) {
-		// resolveChannel will also work but this is more apt
-		if (resource instanceof VoiceChannel) {
-			return resource;
-		}
-		return null;
-	}
-
-	resolveChannel(resource) {
-		/*
-  	accepts a Message, Channel, Server, String ID, User
-   */
-		var self = this;
-
-		return new Promise((resolve, reject) => {
-			var found = null;
-			if (resource instanceof Message) {
-				found = resource.channel;
-			} else if (resource instanceof Channel) {
-				found = resource;
-			} else if (resource instanceof Server) {
-				found = resource.channels.get("id", resource.id);
-			} else if (resource instanceof String || typeof resource === "string") {
-				found = self.internal.channels.get("id", resource);
-			} else if (resource instanceof User) {
-				// see if a PM exists
-				var chatFound = false;
-				for (var pmchat of self.internal.private_channels) {
-					if (pmchat.recipient.equals(resource)) {
-						chatFound = pmchat;
-						break;
+					_mentions.push(mention.substring(2, mention.length - 1));
+				}
+			} catch (err) {
+				_didIteratorError2 = true;
+				_iteratorError2 = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion2 && _iterator2.return) {
+						_iterator2.return();
+					}
+				} finally {
+					if (_didIteratorError2) {
+						throw _iteratorError2;
 					}
 				}
-				if (chatFound) {
-					// a PM already exists!
-					found = chatFound;
-				} else {
-					// PM does not exist :\
-					self.internal.startPM(resource).then(pmchannel => resolve(pmchannel)).catch(e => reject(e));
-					return;
-				}
 			}
-			if (found) resolve(found);else reject(new Error("Didn't found anything"));
-		});
-	}
-}
+
+			return _mentions;
+		}
+	}, {
+		key: "resolveString",
+		value: 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();
+		}
+	}, {
+		key: "resolveUser",
+		value: function resolveUser(resource) {
+			/*
+   	accepts a Message, Channel, Server, String ID, User, PMChannel
+   */
+			var found = null;
+			if (resource instanceof User) {
+				found = resource;
+			} else if (resource instanceof Message) {
+				found = resource.author;
+			} else if (resource instanceof TextChannel) {
+				var lmsg = resource.lastMessage;
+				if (lmsg) {
+					found = lmsg.author;
+				}
+			} else if (resource instanceof Server) {
+				found = resource.owner;
+			} else if (resource instanceof PMChannel) {
+				found = resource.recipient;
+			} else if (resource instanceof String || typeof resource === "string") {
+				found = this.client.internal.users.get("id", resource);
+			}
+
+			return found;
+		}
+	}, {
+		key: "resolveMessage",
+		value: function resolveMessage(resource) {
+			// accepts a Message, PMChannel & TextChannel
+			var found = null;
+
+			if (resource instanceof TextChannel || resource instanceof PMChannel) {
+				found = resource.lastMessage;
+			} else if (resource instanceof Message) {
+				found = resource;
+			}
+
+			return found;
+		}
+	}, {
+		key: "resolveVoiceChannel",
+		value: function resolveVoiceChannel(resource) {
+			// resolveChannel will also work but this is more apt
+			if (resource instanceof VoiceChannel) {
+				return resource;
+			}
+			return null;
+		}
+	}, {
+		key: "resolveChannel",
+		value: function resolveChannel(resource) {
+			/*
+   	accepts a Message, Channel, Server, String ID, User
+    */
+			var self = this;
+
+			return new Promise(function (resolve, reject) {
+				var found = null;
+				if (resource instanceof Message) {
+					found = resource.channel;
+				} else if (resource instanceof Channel) {
+					found = resource;
+				} else if (resource instanceof Server) {
+					found = resource.channels.get("id", resource.id);
+				} else if (resource instanceof String || typeof resource === "string") {
+					found = self.internal.channels.get("id", resource);
+				} else if (resource instanceof User) {
+					// see if a PM exists
+					var chatFound = false;
+					var _iteratorNormalCompletion3 = true;
+					var _didIteratorError3 = false;
+					var _iteratorError3 = undefined;
+
+					try {
+						for (var _iterator3 = self.internal.private_channels[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+							var pmchat = _step3.value;
+
+							if (pmchat.recipient.equals(resource)) {
+								chatFound = pmchat;
+								break;
+							}
+						}
+					} catch (err) {
+						_didIteratorError3 = true;
+						_iteratorError3 = err;
+					} finally {
+						try {
+							if (!_iteratorNormalCompletion3 && _iterator3.return) {
+								_iterator3.return();
+							}
+						} finally {
+							if (_didIteratorError3) {
+								throw _iteratorError3;
+							}
+						}
+					}
+
+					if (chatFound) {
+						// a PM already exists!
+						found = chatFound;
+					} else {
+						// PM does not exist :\
+						self.internal.startPM(resource).then(function (pmchannel) {
+							return resolve(pmchannel);
+						}).catch(function (e) {
+							return reject(e);
+						});
+						return;
+					}
+				}
+				if (found) resolve(found);else reject(new Error("Didn't found anything"));
+			});
+		}
+	}]);
+
+	return Resolver;
+})();
+
 module.exports = Resolver;
\ No newline at end of file
diff --git a/lib/Constants.js b/lib/Constants.js
index e808bf747..572f3c8f2 100644
--- a/lib/Constants.js
+++ b/lib/Constants.js
@@ -1,35 +1,75 @@
+"use strict";
+
 var API = "https://discordapp.com/api";
 var Endpoints = {
 	// general endpoints
-	LOGIN: `${ API }/auth/login`,
-	LOGOUT: `${ API }/auth/logout`,
-	ME: `${ API }/users/@me`,
-	GATEWAY: `${ API }/gateway`,
-	USER_CHANNELS: userID => `${ API }/users/${ userID }/channels`,
-	AVATAR: (userID, avatar) => `${ API }/users/${ userID }/avatars/${ avatar }.jpg`,
-	INVITE: id => `${ API }/invite/${ id }`,
+	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: serverID => `${ Endpoints.SERVERS }/${ serverID }`,
-	SERVER_ICON: (serverID, hash) => `${ Endpoints.SERVER(serverID) }/icons/${ hash }.jpg`,
-	SERVER_PRUNE: serverID => `${ Endpoints.SERVER(serverID) }/prune`,
-	SERVER_EMBED: serverID => `${ Endpoints.SERVER(serverID) }/embed`,
-	SERVER_INVITES: serverID => `${ Endpoints.SERVER(serverID) }/invites`,
-	SERVER_ROLES: serverID => `${ Endpoints.SERVER(serverID) }/roles`,
-	SERVER_BANS: serverID => `${ Endpoints.SERVER(serverID) }/bans`,
-	SERVER_INTEGRATIONS: serverID => `${ Endpoints.SERVER(serverID) }/integrations`,
-	SERVER_MEMBERS: serverID => `${ Endpoints.SERVER(serverID) }/members`,
-	SERVER_CHANNELS: serverID => `${ Endpoints.SERVER(serverID) }/channels`,
+	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: channelID => `${ Endpoints.CHANNELS }/${ channelID }`,
-	CHANNEL_MESSAGES: channelID => `${ Endpoints.CHANNEL(channelID) }/messages`,
-	CHANNEL_INVITES: channelID => `${ Endpoints.CHANNEL(channelID) }/invites`,
-	CHANNEL_TYPING: channelID => `${ Endpoints.CHANNEL(channelID) }/typing`,
-	CHANNEL_PERMISSIONS: channelID => `${ Endpoints.CHANNEL(channelID) }/permissions`,
-	CHANNEL_MESSAGE: (channelID, messageID) => `${ Endpoints.CHANNEL_MESSAGES(channelID) }/${ messageID }`
+	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;
+	}
 };
 
 var Permissions = {
diff --git a/lib/Structures/Channel.js b/lib/Structures/Channel.js
index 3680913ac..ebcbf2e7d 100644
--- a/lib/Structures/Channel.js
+++ b/lib/Structures/Channel.js
@@ -1,26 +1,44 @@
 "use strict";
 
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 Equality = require("../Util/Equality.js");
 var Cache = require("../Util/Cache.js");
 var PermissionOverwrite = require("./PermissionOverwrite.js");
 var reg = require("../Util/ArgumentRegulariser.js").reg;
 
-class Channel extends Equality {
+var Channel = (function (_Equality) {
+	_inherits(Channel, _Equality);
 
-	constructor(data, client) {
-		super();
-		this.id = data.id;
-		this.client = client;
+	function Channel(data, client) {
+		_classCallCheck(this, Channel);
+
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Channel).call(this));
+
+		_this.id = data.id;
+		_this.client = client;
+		return _this;
 	}
 
-	get isPrivate() {
-		return !!this.server;
-	}
+	_createClass(Channel, [{
+		key: "delete",
+		value: function _delete() {
+			return this.client.deleteChannel.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "isPrivate",
+		get: function get() {
+			return !!this.server;
+		}
+	}]);
 
-	delete() {
-		return this.client.deleteChannel.apply(this.client, reg(this, arguments));
-	}
-
-}
+	return Channel;
+})(Equality);
 
 module.exports = Channel;
\ No newline at end of file
diff --git a/lib/Structures/ChannelPermissions.js b/lib/Structures/ChannelPermissions.js
index 2f7f61b82..cbd4d00d2 100644
--- a/lib/Structures/ChannelPermissions.js
+++ b/lib/Structures/ChannelPermissions.js
@@ -1,64 +1,82 @@
 "use strict";
 
+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 Permissions = require("../Constants.js").Permissions;
 
-class ChannelPermissions {
-	constructor(permissions) {
+var ChannelPermissions = (function () {
+	function ChannelPermissions(permissions) {
+		_classCallCheck(this, ChannelPermissions);
+
 		this.permissions = permissions;
 	}
 
-	serialise(explicit) {
+	_createClass(ChannelPermissions, [{
+		key: "serialise",
+		value: function serialise(explicit) {
+			var _this = this;
 
-		var hp = perm => this.hasPermission(perm, explicit);
+			var hp = function hp(perm) {
+				return _this.hasPermission(perm, explicit);
+			};
 
-		return {
-			// general
-			createInstantInvite: hp(Permissions.createInstantInvite),
-			kickMembers: hp(Permissions.kickMembers),
-			banMembers: hp(Permissions.banMembers),
-			managePermissions: hp(Permissions.managePermissions),
-			manageChannel: hp(Permissions.manageChannel),
-			manageServer: hp(Permissions.manageServer),
-			// text
-			readMessages: hp(Permissions.readMessages),
-			sendMessages: hp(Permissions.sendMessages),
-			sendTTSMessages: hp(Permissions.sendTTSMessages),
-			manageMessages: hp(Permissions.manageMessages),
-			embedLinks: hp(Permissions.embedLinks),
-			attachFiles: hp(Permissions.attachFiles),
-			readMessageHistory: hp(Permissions.readMessageHistory),
-			mentionEveryone: hp(Permissions.mentionEveryone),
-			// voice
-			voiceConnect: hp(Permissions.voiceConnect),
-			voiceSpeak: hp(Permissions.voiceSpeak),
-			voiceMuteMembers: hp(Permissions.voiceMuteMembers),
-			voiceDeafenMembers: hp(Permissions.voiceDeafenMembers),
-			voiceMoveMembers: hp(Permissions.voiceMoveMembers),
-			voiceUseVAD: hp(Permissions.voiceUseVAD)
-		};
-	}
-
-	serialize() {
-		// ;n;
-		return this.serialise();
-	}
-
-	hasPermission(perm, explicit = false) {
-		if (perm instanceof String || typeof perm === "string") {
-			perm = Permissions[perm];
+			return {
+				// general
+				createInstantInvite: hp(Permissions.createInstantInvite),
+				kickMembers: hp(Permissions.kickMembers),
+				banMembers: hp(Permissions.banMembers),
+				managePermissions: hp(Permissions.managePermissions),
+				manageChannel: hp(Permissions.manageChannel),
+				manageServer: hp(Permissions.manageServer),
+				// text
+				readMessages: hp(Permissions.readMessages),
+				sendMessages: hp(Permissions.sendMessages),
+				sendTTSMessages: hp(Permissions.sendTTSMessages),
+				manageMessages: hp(Permissions.manageMessages),
+				embedLinks: hp(Permissions.embedLinks),
+				attachFiles: hp(Permissions.attachFiles),
+				readMessageHistory: hp(Permissions.readMessageHistory),
+				mentionEveryone: hp(Permissions.mentionEveryone),
+				// voice
+				voiceConnect: hp(Permissions.voiceConnect),
+				voiceSpeak: hp(Permissions.voiceSpeak),
+				voiceMuteMembers: hp(Permissions.voiceMuteMembers),
+				voiceDeafenMembers: hp(Permissions.voiceDeafenMembers),
+				voiceMoveMembers: hp(Permissions.voiceMoveMembers),
+				voiceUseVAD: hp(Permissions.voiceUseVAD)
+			};
 		}
-		if (!perm) {
-			return false;
+	}, {
+		key: "serialize",
+		value: function serialize() {
+			// ;n;
+			return this.serialise();
 		}
-		if (!explicit) {
-			// implicit permissions allowed
-			if (!!(this.permissions & Permissions.manageRoles)) {
-				// manageRoles allowed, they have all permissions
-				return true;
+	}, {
+		key: "hasPermission",
+		value: function hasPermission(perm) {
+			var explicit = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
+
+			if (perm instanceof String || typeof perm === "string") {
+				perm = Permissions[perm];
 			}
+			if (!perm) {
+				return false;
+			}
+			if (!explicit) {
+				// implicit permissions allowed
+				if (!!(this.permissions & Permissions.manageRoles)) {
+					// manageRoles allowed, they have all permissions
+					return true;
+				}
+			}
+			return !!(this.permissions & perm);
 		}
-		return !!(this.permissions & perm);
-	}
-}
+	}]);
+
+	return ChannelPermissions;
+})();
 
 module.exports = ChannelPermissions;
\ No newline at end of file
diff --git a/lib/Structures/Invite.js b/lib/Structures/Invite.js
index 1b2231647..a9602112f 100644
--- a/lib/Structures/Invite.js
+++ b/lib/Structures/Invite.js
@@ -1,10 +1,16 @@
 "use strict";
 
+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 Server = require("./Server.js");
 var ServerChannel = require("./ServerChannel.js");
 
-class Invite {
-    constructor(data, chan, client) {
+var Invite = (function () {
+    function Invite(data, chan, client) {
+        _classCallCheck(this, Invite);
+
         this.maxAge = data.max_age;
         this.code = data.code;
         this.server = chan.server;
@@ -18,9 +24,14 @@ class Invite {
         this.xkcd = data.xkcdpass;
     }
 
-    toString() {
-        return `https://discord.gg/${ this.code }`;
-    }
-}
+    _createClass(Invite, [{
+        key: "toString",
+        value: function toString() {
+            return "https://discord.gg/" + this.code;
+        }
+    }]);
+
+    return Invite;
+})();
 
 module.exports = Invite;
\ No newline at end of file
diff --git a/lib/Structures/Message.js b/lib/Structures/Message.js
index 84e5ae0ac..1f158c029 100644
--- a/lib/Structures/Message.js
+++ b/lib/Structures/Message.js
@@ -1,70 +1,95 @@
 "use strict";
 
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 = require("../Util/Cache.js");
 var User = require("./User.js");
 var reg = require("../Util/ArgumentRegulariser.js").reg;
 var Equality = require("../Util/Equality");
 
-class Message extends Equality {
-	constructor(data, channel, client) {
-		super();
-		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;
+var Message = (function (_Equality) {
+	_inherits(Message, _Equality);
 
-		if (data.edited_timestamp) this.editedTimestamp = Date.parse(data.edited_timestamp);
+	function Message(data, channel, client) {
+		_classCallCheck(this, Message);
 
-		if (data.author instanceof User) this.author = data.author;else this.author = client.internal.users.add(new User(data.author, client));
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Message).call(this));
 
-		this.content = data.content;
-		this.mentions = new Cache();
+		_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;
 
-		data.mentions.forEach(mention => {
+		if (data.edited_timestamp) _this.editedTimestamp = Date.parse(data.edited_timestamp);
+
+		if (data.author instanceof User) _this.author = data.author;else _this.author = client.internal.users.add(new User(data.author, client));
+
+		_this.content = data.content;
+		_this.mentions = new Cache();
+
+		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 User) this.mentions.push(mention);else this.mentions.add(client.internal.users.add(new User(mention, client)));
+			if (mention instanceof User) _this.mentions.push(mention);else _this.mentions.add(client.internal.users.add(new User(mention, client)));
 		});
+		return _this;
 	}
 
-	isMentioned(user) {
-		user = this.client.internal.resolver.resolveUser(user);
-		if (user) {
-			return this.mentions.has("id", user.id);
-		} else {
-			return false;
+	_createClass(Message, [{
+		key: "isMentioned",
+		value: function isMentioned(user) {
+			user = this.client.internal.resolver.resolveUser(user);
+			if (user) {
+				return this.mentions.has("id", user.id);
+			} else {
+				return false;
+			}
 		}
-	}
+	}, {
+		key: "toString",
+		value: function toString() {
+			return this.content;
+		}
+	}, {
+		key: "delete",
+		value: function _delete() {
+			return this.client.deleteMessage.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "update",
+		value: function update() {
+			return this.client.updateMessage.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "reply",
+		value: function reply() {
+			return this.client.reply.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "replyTTS",
+		value: function replyTTS() {
+			return this.client.replyTTS.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "sender",
+		get: function get() {
+			return this.author;
+		}
+	}]);
 
-	toString() {
-		return this.content;
-	}
-
-	delete() {
-		return this.client.deleteMessage.apply(this.client, reg(this, arguments));
-	}
-
-	update() {
-		return this.client.updateMessage.apply(this.client, reg(this, arguments));
-	}
-
-	reply() {
-		return this.client.reply.apply(this.client, reg(this, arguments));
-	}
-
-	replyTTS() {
-		return this.client.replyTTS.apply(this.client, reg(this, arguments));
-	}
-
-	get sender() {
-		return this.author;
-	}
-}
+	return Message;
+})(Equality);
 
 module.exports = Message;
\ No newline at end of file
diff --git a/lib/Structures/PMChannel.js b/lib/Structures/PMChannel.js
index 80085b683..bd94242da 100644
--- a/lib/Structures/PMChannel.js
+++ b/lib/Structures/PMChannel.js
@@ -1,37 +1,59 @@
 "use strict";
 
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 Channel = require("./Channel.js");
 var User = require("./User.js");
 var Equality = require("../Util/Equality.js");
 var Cache = require("../Util/Cache.js");
 var reg = require("../Util/ArgumentRegulariser.js").reg;
 
-class PMChannel extends Channel {
-	constructor(data, client) {
-		super(data, client);
+var PMChannel = (function (_Channel) {
+	_inherits(PMChannel, _Channel);
 
-		this.type = data.type || "text";
-		this.lastMessageId = data.last_message_id;
-		this.messages = new Cache("id", 1000);
-		this.recipient = this.client.internal.users.add(new User(data.recipient, this.client));
+	function PMChannel(data, client) {
+		_classCallCheck(this, PMChannel);
+
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(PMChannel).call(this, data, client));
+
+		_this.type = data.type || "text";
+		_this.lastMessageId = data.last_message_id;
+		_this.messages = new Cache("id", 1000);
+		_this.recipient = _this.client.internal.users.add(new User(data.recipient, _this.client));
+		return _this;
 	}
 
 	/* warning! may return null */
-	get lastMessage() {
-		return this.messages.get("id", this.lastMessageID);
-	}
 
-	toString() {
-		return this.recipient.toString();
-	}
+	_createClass(PMChannel, [{
+		key: "toString",
+		value: function toString() {
+			return this.recipient.toString();
+		}
+	}, {
+		key: "sendMessage",
+		value: function sendMessage() {
+			return this.client.sendMessage.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "sendTTSMessage",
+		value: function sendTTSMessage() {
+			return this.client.sendTTSMessage.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "lastMessage",
+		get: function get() {
+			return this.messages.get("id", this.lastMessageID);
+		}
+	}]);
 
-	sendMessage() {
-		return this.client.sendMessage.apply(this.client, reg(this, arguments));
-	}
-
-	sendTTSMessage() {
-		return this.client.sendTTSMessage.apply(this.client, reg(this, arguments));
-	}
-}
+	return PMChannel;
+})(Channel);
 
 module.exports = PMChannel;
\ No newline at end of file
diff --git a/lib/Structures/PermissionOverwrite.js b/lib/Structures/PermissionOverwrite.js
index eef57fe68..86f45918a 100644
--- a/lib/Structures/PermissionOverwrite.js
+++ b/lib/Structures/PermissionOverwrite.js
@@ -1,10 +1,15 @@
 "use strict";
 
+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 Permissions = require("../Constants.js").Permissions;
 
-class PermissionOverwrite {
+var PermissionOverwrite = (function () {
+	function PermissionOverwrite(data) {
+		_classCallCheck(this, PermissionOverwrite);
 
-	constructor(data) {
 		this.id = data.id;
 		this.type = data.type; // member or role
 		this.deny = data.deny;
@@ -12,59 +17,73 @@ class PermissionOverwrite {
 	}
 
 	// returns an array of allowed permissions
-	get allowed() {
-		var allowed = [];
-		for (var permName in Permissions) {
-			if (permName === "manageRoles" || permName === "manageChannels") {
-				// these permissions do not exist in overwrites.
-				continue;
-			}
 
-			if (!!(this.allow & Permissions[permName])) {
-				allowed.push(permName);
-			}
+	_createClass(PermissionOverwrite, [{
+		key: "setAllowed",
+		value: function setAllowed(allowedArray) {
+			var _this = this;
+
+			allowedArray.forEach(function (permission) {
+				if (permission instanceof String || typeof permission === "string") {
+					permission = Permissions[permission];
+				}
+				if (permission) {
+					_this.allow |= 1 << permission;
+				}
+			});
 		}
-		return allowed;
-	}
+	}, {
+		key: "setDenied",
+		value: function setDenied(deniedArray) {
+			var _this2 = this;
 
-	// returns an array of denied permissions
-	get denied() {
-		var denied = [];
-		for (var permName in Permissions) {
-			if (permName === "manageRoles" || permName === "manageChannels") {
-				// these permissions do not exist in overwrites.
-				continue;
-			}
-
-			if (!!(this.deny & Permissions[permName])) {
-				denied.push(permName);
-			}
+			deniedArray.forEach(function (permission) {
+				if (permission instanceof String || typeof permission === "string") {
+					permission = Permissions[permission];
+				}
+				if (permission) {
+					_this2.deny |= 1 << permission;
+				}
+			});
 		}
-		return denied;
-	}
+	}, {
+		key: "allowed",
+		get: function get() {
+			var allowed = [];
+			for (var permName in Permissions) {
+				if (permName === "manageRoles" || permName === "manageChannels") {
+					// these permissions do not exist in overwrites.
+					continue;
+				}
 
-	setAllowed(allowedArray) {
-		allowedArray.forEach(permission => {
-			if (permission instanceof String || typeof permission === "string") {
-				permission = Permissions[permission];
+				if (!!(this.allow & Permissions[permName])) {
+					allowed.push(permName);
+				}
 			}
-			if (permission) {
-				this.allow |= 1 << permission;
-			}
-		});
-	}
+			return allowed;
+		}
 
-	setDenied(deniedArray) {
-		deniedArray.forEach(permission => {
-			if (permission instanceof String || typeof permission === "string") {
-				permission = Permissions[permission];
-			}
-			if (permission) {
-				this.deny |= 1 << permission;
-			}
-		});
-	}
+		// returns an array of denied permissions
 
-}
+	}, {
+		key: "denied",
+		get: function get() {
+			var denied = [];
+			for (var permName in Permissions) {
+				if (permName === "manageRoles" || permName === "manageChannels") {
+					// these permissions do not exist in overwrites.
+					continue;
+				}
+
+				if (!!(this.deny & Permissions[permName])) {
+					denied.push(permName);
+				}
+			}
+			return denied;
+		}
+	}]);
+
+	return PermissionOverwrite;
+})();
 
 module.exports = PermissionOverwrite;
\ No newline at end of file
diff --git a/lib/Structures/Role.js b/lib/Structures/Role.js
index 5fea1d4d6..567fa42ff 100644
--- a/lib/Structures/Role.js
+++ b/lib/Structures/Role.js
@@ -1,5 +1,9 @@
 "use strict";
 
+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 Permissions = require("../Constants.js").Permissions;
 /*
 
@@ -14,10 +18,14 @@ example data
     color: 0 }
 */
 
-const DefaultRole = [Permissions.createInstantInvite, Permissions.readMessages, Permissions.readMessageHistory, Permissions.sendMessages, Permissions.sendTTSMessages, Permissions.embedLinks, Permissions.attachFiles, Permissions.readMessageHistory, Permissions.mentionEveryone, Permissions.voiceConnect, Permissions.voiceSpeak, Permissions.voiceUseVAD].reduce((previous, current) => previous | current, 0);
+var DefaultRole = [Permissions.createInstantInvite, Permissions.readMessages, Permissions.readMessageHistory, Permissions.sendMessages, Permissions.sendTTSMessages, Permissions.embedLinks, Permissions.attachFiles, Permissions.readMessageHistory, Permissions.mentionEveryone, Permissions.voiceConnect, Permissions.voiceSpeak, Permissions.voiceUseVAD].reduce(function (previous, current) {
+	return previous | current;
+}, 0);
+
+var Role = (function () {
+	function Role(data, server, client) {
+		_classCallCheck(this, Role);
 
-class Role {
-	constructor(data, server, client) {
 		this.position = data.position || -1;
 		this.permissions = data.permissions || (data.name === "@everyone" ? DefaultRole : 0);
 		this.name = data.name || "@everyone";
@@ -29,96 +37,113 @@ class Role {
 		this.client = client;
 	}
 
-	serialise(explicit) {
+	_createClass(Role, [{
+		key: "serialise",
+		value: function serialise(explicit) {
+			var _this = this;
 
-		var hp = perm => this.hasPermission(perm, explicit);
+			var hp = function hp(perm) {
+				return _this.hasPermission(perm, explicit);
+			};
 
-		return {
-			// general
-			createInstantInvite: hp(Permissions.createInstantInvite),
-			kickMembers: hp(Permissions.kickMembers),
-			banMembers: hp(Permissions.banMembers),
-			manageRoles: hp(Permissions.manageRoles),
-			manageChannels: hp(Permissions.manageChannels),
-			manageServer: hp(Permissions.manageServer),
-			// text
-			readMessages: hp(Permissions.readMessages),
-			sendMessages: hp(Permissions.sendMessages),
-			sendTTSMessages: hp(Permissions.sendTTSMessages),
-			manageMessages: hp(Permissions.manageMessages),
-			embedLinks: hp(Permissions.embedLinks),
-			attachFiles: hp(Permissions.attachFiles),
-			readMessageHistory: hp(Permissions.readMessageHistory),
-			mentionEveryone: hp(Permissions.mentionEveryone),
-			// voice
-			voiceConnect: hp(Permissions.voiceConnect),
-			voiceSpeak: hp(Permissions.voiceSpeak),
-			voiceMuteMembers: hp(Permissions.voiceMuteMembers),
-			voiceDeafenMembers: hp(Permissions.voiceDeafenMembers),
-			voiceMoveMembers: hp(Permissions.voiceMoveMembers),
-			voiceUseVAD: hp(Permissions.voiceUseVAD)
-		};
-	}
-
-	serialize() {
-		// ;n;
-		return this.serialise();
-	}
-
-	hasPermission(perm, explicit = false) {
-		if (perm instanceof String || typeof perm === "string") {
-			perm = Permissions[perm];
+			return {
+				// general
+				createInstantInvite: hp(Permissions.createInstantInvite),
+				kickMembers: hp(Permissions.kickMembers),
+				banMembers: hp(Permissions.banMembers),
+				manageRoles: hp(Permissions.manageRoles),
+				manageChannels: hp(Permissions.manageChannels),
+				manageServer: hp(Permissions.manageServer),
+				// text
+				readMessages: hp(Permissions.readMessages),
+				sendMessages: hp(Permissions.sendMessages),
+				sendTTSMessages: hp(Permissions.sendTTSMessages),
+				manageMessages: hp(Permissions.manageMessages),
+				embedLinks: hp(Permissions.embedLinks),
+				attachFiles: hp(Permissions.attachFiles),
+				readMessageHistory: hp(Permissions.readMessageHistory),
+				mentionEveryone: hp(Permissions.mentionEveryone),
+				// voice
+				voiceConnect: hp(Permissions.voiceConnect),
+				voiceSpeak: hp(Permissions.voiceSpeak),
+				voiceMuteMembers: hp(Permissions.voiceMuteMembers),
+				voiceDeafenMembers: hp(Permissions.voiceDeafenMembers),
+				voiceMoveMembers: hp(Permissions.voiceMoveMembers),
+				voiceUseVAD: hp(Permissions.voiceUseVAD)
+			};
 		}
-		if (!perm) {
-			return false;
+	}, {
+		key: "serialize",
+		value: function serialize() {
+			// ;n;
+			return this.serialise();
 		}
-		if (!explicit) {
-			// implicit permissions allowed
-			if (!!(this.permissions & Permissions.manageRoles)) {
-				// manageRoles allowed, they have all permissions
-				return true;
+	}, {
+		key: "hasPermission",
+		value: function hasPermission(perm) {
+			var explicit = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
+
+			if (perm instanceof String || typeof perm === "string") {
+				perm = Permissions[perm];
 			}
-		}
-		// e.g.
-		// !!(36953089 & Permissions.manageRoles) = not allowed to manage roles
-		// !!(36953089 & (1 << 21)) = voice speak allowed
-
-		return !!(this.permissions & perm);
-	}
-
-	setPermission(permission, value) {
-		if (permission instanceof String || typeof permission === "string") {
-			permission = Permissions[permission];
-		}
-		if (permission) {
-			// valid permission
-			if (value) {
-				this.permissions |= permission;
-			} else {
-				this.permissions &= ~permission;
+			if (!perm) {
+				return false;
 			}
-		}
-	}
+			if (!explicit) {
+				// implicit permissions allowed
+				if (!!(this.permissions & 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
 
-	setPermissions(obj) {
-		obj.forEach((value, permission) => {
+			return !!(this.permissions & perm);
+		}
+	}, {
+		key: "setPermission",
+		value: function setPermission(permission, value) {
 			if (permission instanceof String || typeof permission === "string") {
 				permission = Permissions[permission];
 			}
 			if (permission) {
 				// valid permission
-				this.setPermission(permission, value);
+				if (value) {
+					this.permissions |= permission;
+				} else {
+					this.permissions &= ~permission;
+				}
 			}
-		});
-	}
-
-	colorAsHex() {
-		var val = this.color.toString();
-		while (val.length < 6) {
-			val = "0" + val;
 		}
-		return "#" + val;
-	}
-}
+	}, {
+		key: "setPermissions",
+		value: function setPermissions(obj) {
+			var _this2 = this;
+
+			obj.forEach(function (value, permission) {
+				if (permission instanceof String || typeof permission === "string") {
+					permission = Permissions[permission];
+				}
+				if (permission) {
+					// valid permission
+					_this2.setPermission(permission, value);
+				}
+			});
+		}
+	}, {
+		key: "colorAsHex",
+		value: function colorAsHex() {
+			var val = this.color.toString();
+			while (val.length < 6) {
+				val = "0" + val;
+			}
+			return "#" + val;
+		}
+	}]);
+
+	return Role;
+})();
 
 module.exports = Role;
\ No newline at end of file
diff --git a/lib/Structures/Server.js b/lib/Structures/Server.js
index cdbce7653..8613a67ee 100644
--- a/lib/Structures/Server.js
+++ b/lib/Structures/Server.js
@@ -1,5 +1,13 @@
 "use strict";
 
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 Equality = require("../Util/Equality.js");
 var Endpoints = require("../Constants.js").Endpoints;
 var Cache = require("../Util/Cache.js");
@@ -10,114 +18,173 @@ var Role = require("./Role.js");
 
 var strictKeys = ["region", "ownerID", "name", "id", "icon", "afkTimeout", "afkChannelID"];
 
-class Server extends Equality {
-	constructor(data, client) {
+var Server = (function (_Equality) {
+	_inherits(Server, _Equality);
 
-		super();
+	function Server(data, client) {
+		_classCallCheck(this, Server);
 
-		var self = this;
-		this.client = client;
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Server).call(this));
 
-		this.region = data.region;
-		this.ownerID = data.owner_id;
-		this.name = data.name;
-		this.id = data.id;
-		this.members = new Cache();
-		this.channels = new Cache();
-		this.roles = new Cache();
-		this.icon = data.icon;
-		this.afkTimeout = data.afkTimeout;
-		this.afkChannelID = data.afk_channel_id;
-		this.memberMap = {};
+		var self = _this;
+		_this.client = client;
 
-		var self = this;
+		_this.region = data.region;
+		_this.ownerID = data.owner_id;
+		_this.name = data.name;
+		_this.id = data.id;
+		_this.members = new Cache();
+		_this.channels = new Cache();
+		_this.roles = new Cache();
+		_this.icon = data.icon;
+		_this.afkTimeout = data.afkTimeout;
+		_this.afkChannelID = data.afk_channel_id;
+		_this.memberMap = {};
 
-		data.roles.forEach(dataRole => {
-			this.roles.add(new Role(dataRole, this, client));
+		var self = _this;
+
+		data.roles.forEach(function (dataRole) {
+			_this.roles.add(new Role(dataRole, _this, client));
 		});
 
-		data.members.forEach(dataUser => {
-			this.memberMap[dataUser.user.id] = {
-				roles: dataUser.roles.map(pid => self.roles.get("id", pid)),
+		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 User(dataUser.user, client));
-			this.members.add(user);
+			_this.members.add(user);
 		});
 
-		data.channels.forEach(dataChannel => {
+		data.channels.forEach(function (dataChannel) {
 			if (dataChannel.type === "text") {
-				var channel = client.internal.channels.add(new TextChannel(dataChannel, client, this));
-				this.channels.add(channel);
+				var channel = client.internal.channels.add(new TextChannel(dataChannel, client, _this));
+				_this.channels.add(channel);
 			} else {
-				var channel = client.internal.channels.add(new VoiceChannel(dataChannel, client, this));
-				this.channels.add(channel);
+				var channel = client.internal.channels.add(new VoiceChannel(dataChannel, client, _this));
+				_this.channels.add(channel);
 			}
 		});
 
 		if (data.presences) {
-			for (var presence of data.presences) {
-				var user = client.internal.users.get("id", presence.user.id);
-				if (user) {
-					user.status = presence.status;
-					user.gameID = presence.game_id;
+			var _iteratorNormalCompletion = true;
+			var _didIteratorError = false;
+			var _iteratorError = undefined;
+
+			try {
+				for (var _iterator = data.presences[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+					var presence = _step.value;
+
+					var user = client.internal.users.get("id", presence.user.id);
+					if (user) {
+						user.status = presence.status;
+						user.gameID = presence.game_id;
+					}
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion && _iterator.return) {
+						_iterator.return();
+					}
+				} finally {
+					if (_didIteratorError) {
+						throw _iteratorError;
+					}
 				}
 			}
 		}
+		return _this;
 	}
 
-	rolesOfUser(user) {
-		user = this.client.internal.resolver.resolveUser(user);
-		if (user) {
-			return this.memberMap[user.id] ? this.memberMap[user.id].roles : [];
-		} else {
-			return null;
-		}
-	}
-
-	rolesOf(user) {
-		return this.rolesOfUser(user);
-	}
-
-	get iconURL() {
-		if (!this.icon) {
-			return null;
-		} else {
-			return Endpoints.SERVER_ICON(this.id, this.icon);
-		}
-	}
-
-	get afkChannel() {
-		return this.channels.get("id", this.afkChannelID);
-	}
-
-	get defaultChannel() {
-		return this.channels.get("id", this.id);
-	}
-
-	get owner() {
-		return this.members.get("id", this.ownerID);
-	}
-
-	toString() {
-		return this.name;
-	}
-
-	equalsStrict(obj) {
-		if (obj instanceof Server) {
-			for (var key of strictKeys) {
-				if (obj[key] !== this[key]) {
-					return false;
-				}
+	_createClass(Server, [{
+		key: "rolesOfUser",
+		value: 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;
 			}
-		} else {
-			return false;
 		}
-		return true;
-	}
+	}, {
+		key: "rolesOf",
+		value: function rolesOf(user) {
+			return this.rolesOfUser(user);
+		}
+	}, {
+		key: "toString",
+		value: function toString() {
+			return this.name;
+		}
+	}, {
+		key: "equalsStrict",
+		value: function equalsStrict(obj) {
+			if (obj instanceof Server) {
+				var _iteratorNormalCompletion2 = true;
+				var _didIteratorError2 = false;
+				var _iteratorError2 = undefined;
 
-}
+				try {
+					for (var _iterator2 = strictKeys[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+						var key = _step2.value;
+
+						if (obj[key] !== this[key]) {
+							return false;
+						}
+					}
+				} catch (err) {
+					_didIteratorError2 = true;
+					_iteratorError2 = err;
+				} finally {
+					try {
+						if (!_iteratorNormalCompletion2 && _iterator2.return) {
+							_iterator2.return();
+						}
+					} finally {
+						if (_didIteratorError2) {
+							throw _iteratorError2;
+						}
+					}
+				}
+			} else {
+				return false;
+			}
+			return true;
+		}
+	}, {
+		key: "iconURL",
+		get: function get() {
+			if (!this.icon) {
+				return null;
+			} else {
+				return 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;
+})(Equality);
 
 module.exports = Server;
\ No newline at end of file
diff --git a/lib/Structures/ServerChannel.js b/lib/Structures/ServerChannel.js
index b3d84b732..baf69892b 100644
--- a/lib/Structures/ServerChannel.js
+++ b/lib/Structures/ServerChannel.js
@@ -1,77 +1,144 @@
 "use strict";
 
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 Channel = require("./Channel.js");
 var Cache = require("../Util/Cache.js");
 var PermissionOverwrite = require("./PermissionOverwrite.js");
 var ChannelPermissions = require("./ChannelPermissions.js");
 var reg = require("../Util/ArgumentRegulariser.js").reg;
 
-class ServerChannel extends Channel {
-	constructor(data, client, server) {
-		super(data, client);
-		this.name = data.name;
-		this.type = data.type;
-		this.position = data.position;
-		this.permissionOverwrites = new Cache();
-		this.server = server;
-		data.permission_overwrites.forEach(permission => {
-			this.permissionOverwrites.add(new PermissionOverwrite(permission));
+var ServerChannel = (function (_Channel) {
+	_inherits(ServerChannel, _Channel);
+
+	function ServerChannel(data, client, server) {
+		_classCallCheck(this, ServerChannel);
+
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(ServerChannel).call(this, data, client));
+
+		_this.name = data.name;
+		_this.type = data.type;
+		_this.position = data.position;
+		_this.permissionOverwrites = new Cache();
+		_this.server = server;
+		data.permission_overwrites.forEach(function (permission) {
+			_this.permissionOverwrites.add(new PermissionOverwrite(permission));
 		});
+		return _this;
 	}
 
-	permissionsOf(user) {
-		user = this.client.internal.resolver.resolveUser(user);
-		if (user) {
-			if (this.server.owner.equals(user)) {
-				return new ChannelPermissions(4294967295);
-			}
-			var everyoneRole = this.server.roles.get("name", "@everyone");
-
-			var userRoles = [everyoneRole].concat(this.server.rolesOf(user) || []);
-			var userRolesID = userRoles.map(v => v.id);
-			var roleOverwrites = [],
-			    memberOverwrites = [];
-
-			this.permissionOverwrites.forEach(overwrite => {
-				if (overwrite.type === "member" && overwrite.id === user.id) {
-					memberOverwrites.push(overwrite);
-				} else if (overwrite.type === "role" && overwrite.id in userRolesID) {
-					roleOverwrites.push(overwrite);
+	_createClass(ServerChannel, [{
+		key: "permissionsOf",
+		value: function permissionsOf(user) {
+			user = this.client.internal.resolver.resolveUser(user);
+			if (user) {
+				if (this.server.owner.equals(user)) {
+					return new ChannelPermissions(4294967295);
 				}
-			});
+				var everyoneRole = this.server.roles.get("name", "@everyone");
 
-			var permissions = 0;
+				var userRoles = [everyoneRole].concat(this.server.rolesOf(user) || []);
+				var userRolesID = userRoles.map(function (v) {
+					return v.id;
+				});
+				var roleOverwrites = [],
+				    memberOverwrites = [];
 
-			for (var serverRole of userRoles) {
-				permissions |= serverRole.permissions;
+				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;
+
+				var _iteratorNormalCompletion = true;
+				var _didIteratorError = false;
+				var _iteratorError = undefined;
+
+				try {
+					for (var _iterator = userRoles[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+						var serverRole = _step.value;
+
+						permissions |= serverRole.permissions;
+					}
+				} catch (err) {
+					_didIteratorError = true;
+					_iteratorError = err;
+				} finally {
+					try {
+						if (!_iteratorNormalCompletion && _iterator.return) {
+							_iterator.return();
+						}
+					} finally {
+						if (_didIteratorError) {
+							throw _iteratorError;
+						}
+					}
+				}
+
+				var _iteratorNormalCompletion2 = true;
+				var _didIteratorError2 = false;
+				var _iteratorError2 = undefined;
+
+				try {
+					for (var _iterator2 = roleOverwrites.concat(memberOverwrites)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+						var overwrite = _step2.value;
+
+						permissions = permissions & ~overwrite.deny;
+						permissions = permissions | overwrite.allow;
+					}
+				} catch (err) {
+					_didIteratorError2 = true;
+					_iteratorError2 = err;
+				} finally {
+					try {
+						if (!_iteratorNormalCompletion2 && _iterator2.return) {
+							_iterator2.return();
+						}
+					} finally {
+						if (_didIteratorError2) {
+							throw _iteratorError2;
+						}
+					}
+				}
+
+				return new ChannelPermissions(permissions);
+			} else {
+				return null;
 			}
-
-			for (var overwrite of roleOverwrites.concat(memberOverwrites)) {
-				permissions = permissions & ~overwrite.deny;
-				permissions = permissions | overwrite.allow;
-			}
-
-			return new ChannelPermissions(permissions);
-		} else {
-			return null;
 		}
-	}
+	}, {
+		key: "permsOf",
+		value: function permsOf(user) {
+			return this.permissionsOf(user);
+		}
+	}, {
+		key: "mention",
+		value: function mention() {
+			return "<#" + this.id + ">";
+		}
+	}, {
+		key: "toString",
+		value: function toString() {
+			return this.mention();
+		}
+	}, {
+		key: "setName",
+		value: function setName() {
+			return this.client.setChannelName.apply(this.client, reg(this, arguments));
+		}
+	}]);
 
-	permsOf(user) {
-		return this.permissionsOf(user);
-	}
-
-	mention() {
-		return `<#${ this.id }>`;
-	}
-
-	toString() {
-		return this.mention();
-	}
-
-	setName() {
-		return this.client.setChannelName.apply(this.client, reg(this, arguments));
-	}
-}
+	return ServerChannel;
+})(Channel);
 
 module.exports = ServerChannel;
\ No newline at end of file
diff --git a/lib/Structures/TextChannel.js b/lib/Structures/TextChannel.js
index 81c48dfc2..e90eecc4c 100644
--- a/lib/Structures/TextChannel.js
+++ b/lib/Structures/TextChannel.js
@@ -1,42 +1,66 @@
 "use strict";
 
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 ServerChannel = require("./ServerChannel.js");
 var Cache = require("../Util/Cache.js");
 var reg = require("../Util/ArgumentRegulariser.js").reg;
 
-class TextChannel extends ServerChannel {
-	constructor(data, client, server) {
-		super(data, client, server);
+var TextChannel = (function (_ServerChannel) {
+	_inherits(TextChannel, _ServerChannel);
 
-		this.topic = data.topic;
-		this.lastMessageID = data.last_message_id;
-		this.messages = new Cache("id", client.options.maximumMessages);
+	function TextChannel(data, client, server) {
+		_classCallCheck(this, TextChannel);
+
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(TextChannel).call(this, data, client, server));
+
+		_this.topic = data.topic;
+		_this.lastMessageID = data.last_message_id;
+		_this.messages = new Cache("id", client.options.maximumMessages);
+		return _this;
 	}
 
 	/* warning! may return null */
-	get lastMessage() {
-		return this.messages.get("id", this.lastMessageID);
-	}
 
-	setTopic() {
-		return this.client.setTopic.apply(this.client, reg(this, arguments));
-	}
+	_createClass(TextChannel, [{
+		key: "setTopic",
+		value: function setTopic() {
+			return this.client.setTopic.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "setNameAndTopic",
+		value: function setNameAndTopic() {
+			return this.client.setChannelNameAndTopic.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "update",
+		value: function update() {
+			return this.client.updateChannel.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "sendMessage",
+		value: function sendMessage() {
+			return this.client.sendMessage.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "sendTTSMessage",
+		value: function sendTTSMessage() {
+			return this.client.sendTTSMessage.apply(this.client, reg(this, arguments));
+		}
+	}, {
+		key: "lastMessage",
+		get: function get() {
+			return this.messages.get("id", this.lastMessageID);
+		}
+	}]);
 
-	setNameAndTopic() {
-		return this.client.setChannelNameAndTopic.apply(this.client, reg(this, arguments));
-	}
-
-	update() {
-		return this.client.updateChannel.apply(this.client, reg(this, arguments));
-	}
-
-	sendMessage() {
-		return this.client.sendMessage.apply(this.client, reg(this, arguments));
-	}
-
-	sendTTSMessage() {
-		return this.client.sendTTSMessage.apply(this.client, reg(this, arguments));
-	}
-}
+	return TextChannel;
+})(ServerChannel);
 
 module.exports = TextChannel;
\ No newline at end of file
diff --git a/lib/Structures/User.js b/lib/Structures/User.js
index 3a5e2a03d..cd9fe5b47 100644
--- a/lib/Structures/User.js
+++ b/lib/Structures/User.js
@@ -1,43 +1,65 @@
 "use strict";
 
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 Equality = require("../Util/Equality.js");
 var Endpoints = require("../Constants.js").Endpoints;
 
-class User extends Equality {
-	constructor(data, client) {
-		super();
-		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 = {
+var User = (function (_Equality) {
+	_inherits(User, _Equality);
+
+	function User(data, client) {
+		_classCallCheck(this, User);
+
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(User).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
 		};
+		return _this;
 	}
 
-	get avatarURL() {
-		if (!this.avatar) {
-			return null;
-		} else {
-			return Endpoints.AVATAR(this.id, this.avatar);
+	_createClass(User, [{
+		key: "mention",
+		value: function mention() {
+			return "<@" + this.id + ">";
 		}
-	}
+	}, {
+		key: "toString",
+		value: function toString() {
+			return this.mention();
+		}
+	}, {
+		key: "equalsStrict",
+		value: 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;
+		}
+	}, {
+		key: "avatarURL",
+		get: function get() {
+			if (!this.avatar) {
+				return null;
+			} else {
+				return Endpoints.AVATAR(this.id, this.avatar);
+			}
+		}
+	}]);
 
-	mention() {
-		return `<@${ this.id }>`;
-	}
-
-	toString() {
-		return this.mention();
-	}
-
-	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;
-	}
-}
+	return User;
+})(Equality);
 
 module.exports = User;
\ No newline at end of file
diff --git a/lib/Structures/VoiceChannel.js b/lib/Structures/VoiceChannel.js
index 482924544..92eed4f7c 100644
--- a/lib/Structures/VoiceChannel.js
+++ b/lib/Structures/VoiceChannel.js
@@ -1,11 +1,23 @@
 "use strict";
 
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 ServerChannel = require("./ServerChannel.js");
 
-class VoiceChannel extends ServerChannel {
-	constructor(data, client, server) {
-		super(data, client, server);
+var VoiceChannel = (function (_ServerChannel) {
+	_inherits(VoiceChannel, _ServerChannel);
+
+	function VoiceChannel(data, client, server) {
+		_classCallCheck(this, VoiceChannel);
+
+		return _possibleConstructorReturn(this, Object.getPrototypeOf(VoiceChannel).call(this, data, client, server));
 	}
-}
+
+	return VoiceChannel;
+})(ServerChannel);
 
 module.exports = VoiceChannel;
\ No newline at end of file
diff --git a/lib/Util/ArgumentRegulariser.js b/lib/Util/ArgumentRegulariser.js
index 81e683582..9c98ddb39 100644
--- a/lib/Util/ArgumentRegulariser.js
+++ b/lib/Util/ArgumentRegulariser.js
@@ -1,3 +1,5 @@
+"use strict";
+
 exports.reg = function (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 9bff343af..b3d3547ad 100644
--- a/lib/Util/Cache.js
+++ b/lib/Util/Cache.js
@@ -1,83 +1,130 @@
 "use strict";
 
-class Cache extends Array {
-	constructor(discrim, limit) {
-		super();
-		this.discrim = discrim || "id";
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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);
+
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(Cache).call(this));
+
+		_this.discrim = discrim || "id";
+		return _this;
 	}
 
-	get(key, value) {
-		var found = null;
-		this.forEach((val, index, array) => {
-			if (val.hasOwnProperty(key) && val[key] == value) {
-				found = val;
-				return;
+	_createClass(Cache, [{
+		key: "get",
+		value: 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;
+		}
+	}, {
+		key: "has",
+		value: function has(key, value) {
+			return !!this.get(key, value);
+		}
+	}, {
+		key: "getAll",
+		value: 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;
+		}
+	}, {
+		key: "add",
+		value: function add(data) {
+			var exit = false;
+			var _iteratorNormalCompletion = true;
+			var _didIteratorError = false;
+			var _iteratorError = undefined;
+
+			try {
+				for (var _iterator = this[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+					var item = _step.value;
+
+					if (item[this.discrim] === data[this.discrim]) {
+						exit = item;
+						break;
+					}
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion && _iterator.return) {
+						_iterator.return();
+					}
+				} finally {
+					if (_didIteratorError) {
+						throw _iteratorError;
+					}
+				}
 			}
-		});
-		return found;
-	}
 
-	has(key, value) {
-		return !!this.get(key, value);
-	}
-
-	getAll(key, value) {
-		var found = new Cache(this.discrim);
-		this.forEach((val, index, array) => {
-			if (val.hasOwnProperty(key) && val[key] == value) {
-				found.push(val);
-				return;
-			}
-		});
-		return found;
-	}
-
-	add(data) {
-		var exit = false;
-		for (var item of this) {
-			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;
 			}
 		}
-		if (exit) {
-			return exit;
-		} else {
-			if (this.limit && this.length >= this.limit) {
-				this.splice(0, 1);
+	}, {
+		key: "update",
+		value: 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;
 			}
-			this.push(data);
-			return data;
 		}
-	}
-
-	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 {
+	}, {
+		key: "random",
+		value: function random() {
+			return this[Math.floor(Math.random() * this.length)];
+		}
+	}, {
+		key: "remove",
+		value: 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;
 		}
-	}
+	}]);
 
-	random() {
-		return this[Math.floor(Math.random() * this.length)];
-	}
-
-	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);
 
 module.exports = Cache;
\ No newline at end of file
diff --git a/lib/Util/Equality.js b/lib/Util/Equality.js
index c1fa19284..145d3dbe7 100644
--- a/lib/Util/Equality.js
+++ b/lib/Util/Equality.js
@@ -1,3 +1,9 @@
+"use strict";
+
+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"); } }
+
 /*
 	The Equality Class is just used to show
 	that a Class has an ID that can be used to
@@ -9,24 +15,34 @@
 
 	Instead, use objectThatExtendsEquality.equals()
 */
-class Equality {
-	constructor() {}
 
-	get eqDiscriminator() {
-		return "id";
+var Equality = (function () {
+	function Equality() {
+		_classCallCheck(this, Equality);
 	}
 
-	equals(object) {
-		if (object && object[this.eqDiscriminator] == this[this.eqDiscriminator]) {
-			return true;
+	_createClass(Equality, [{
+		key: "equals",
+		value: function equals(object) {
+			if (object && object[this.eqDiscriminator] == this[this.eqDiscriminator]) {
+				return true;
+			}
+			return false;
 		}
-		return false;
-	}
+	}, {
+		key: "equalsStrict",
+		value: function equalsStrict(object) {
+			// override per class type
+			return;
+		}
+	}, {
+		key: "eqDiscriminator",
+		get: function get() {
+			return "id";
+		}
+	}]);
 
-	equalsStrict(object) {
-		// override per class type
-		return;
-	}
-}
+	return Equality;
+})();
 
 module.exports = Equality;
\ No newline at end of file
diff --git a/lib/Voice/AudioEncoder.js b/lib/Voice/AudioEncoder.js
index 33d444614..976ae2e37 100644
--- a/lib/Voice/AudioEncoder.js
+++ b/lib/Voice/AudioEncoder.js
@@ -1,5 +1,9 @@
 "use strict";
 
+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 cpoc = require("child_process");
 
 var opus;
@@ -10,97 +14,132 @@ try {
 }
 var VoicePacket = require("./VoicePacket.js");
 
-class AudioEncoder {
-	constructor() {
+var AudioEncoder = (function () {
+	function AudioEncoder() {
+		_classCallCheck(this, AudioEncoder);
+
 		if (opus) {
 			this.opus = new opus.OpusEncoder(48000, 1);
 		}
 		this.choice = false;
 	}
 
-	opusBuffer(buffer) {
+	_createClass(AudioEncoder, [{
+		key: "opusBuffer",
+		value: function opusBuffer(buffer) {
 
-		return this.opus.encode(buffer, 1920);
-	}
-
-	getCommand(force) {
-
-		if (this.choice && force) return choice;
-
-		var choices = ["avconv", "ffmpeg"];
-
-		for (var choice of choices) {
-			var p = cpoc.spawnSync(choice);
-			if (!p.error) {
-				this.choice = choice;
-				return choice;
-			}
+			return this.opus.encode(buffer, 1920);
 		}
+	}, {
+		key: "getCommand",
+		value: function getCommand(force) {
 
-		return "help";
-	}
+			if (this.choice && force) return choice;
 
-	encodeStream(stream, callback = function (err, buffer) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			var enc = cpoc.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", "-"]);
+			var choices = ["avconv", "ffmpeg"];
 
-			stream.pipe(enc.stdin);
+			var _iteratorNormalCompletion = true;
+			var _didIteratorError = false;
+			var _iteratorError = undefined;
 
-			enc.stdout.once("readable", function () {
-				callback(null, {
-					proc: enc,
-					stream: enc.stdout,
-					instream: stream
+			try {
+				for (var _iterator = choices[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+					var choice = _step.value;
+
+					var p = cpoc.spawnSync(choice);
+					if (!p.error) {
+						this.choice = choice;
+						return choice;
+					}
+				}
+			} catch (err) {
+				_didIteratorError = true;
+				_iteratorError = err;
+			} finally {
+				try {
+					if (!_iteratorNormalCompletion && _iterator.return) {
+						_iterator.return();
+					}
+				} finally {
+					if (_didIteratorError) {
+						throw _iteratorError;
+					}
+				}
+			}
+
+			return "help";
+		}
+	}, {
+		key: "encodeStream",
+		value: 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 = cpoc.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
+					});
 				});
-				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");
 				});
 			});
+		}
+	}, {
+		key: "encodeFile",
+		value: function encodeFile(file) {
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, buffer) {} : arguments[1];
 
-			enc.stdout.on("end", function () {
-				callback("end");
-				reject("end");
-			});
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				var enc = cpoc.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.on("close", function () {
-				callback("close");
-				reject("close");
-			});
-		});
-	}
-
-	encodeFile(file, callback = function (err, buffer) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			var enc = cpoc.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
+				enc.stdout.once("readable", function () {
+					callback(null, {
+						proc: enc,
+						stream: enc.stdout
+					});
+					resolve({
+						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");
 				});
 			});
+		}
+	}]);
 
-			enc.stdout.on("end", function () {
-				callback("end");
-				reject("end");
-			});
-
-			enc.stdout.on("close", function () {
-				callback("close");
-				reject("close");
-			});
-		});
-	}
-}
+	return AudioEncoder;
+})();
 
 module.exports = AudioEncoder;
\ No newline at end of file
diff --git a/lib/Voice/StreamIntent.js b/lib/Voice/StreamIntent.js
index 63d153312..f77ecb54f 100644
--- a/lib/Voice/StreamIntent.js
+++ b/lib/Voice/StreamIntent.js
@@ -1,12 +1,25 @@
 "use strict"
 // represents an intent of streaming music
 ;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 EventEmitter = require("events");
 
-class StreamIntent extends EventEmitter {
-	constructor() {
-		super();
+var StreamIntent = (function (_EventEmitter) {
+	_inherits(StreamIntent, _EventEmitter);
+
+	function StreamIntent() {
+		_classCallCheck(this, StreamIntent);
+
+		return _possibleConstructorReturn(this, Object.getPrototypeOf(StreamIntent).call(this));
 	}
-}
+
+	return StreamIntent;
+})(EventEmitter);
 
 module.exports = StreamIntent;
\ No newline at end of file
diff --git a/lib/Voice/VoiceConnection.js b/lib/Voice/VoiceConnection.js
index 3cde64d59..14faa5c0b 100644
--- a/lib/Voice/VoiceConnection.js
+++ b/lib/Voice/VoiceConnection.js
@@ -8,6 +8,15 @@
 */
 
 ;
+
+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"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+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 WebSocket = require("ws");
 var dns = require("dns");
 var udp = require("dgram");
@@ -17,291 +26,328 @@ var VoicePacket = require("./VoicePacket.js");
 var StreamIntent = require("./StreamIntent.js");
 var EventEmitter = require("events");
 
-class VoiceConnection extends EventEmitter {
-	constructor(channel, client, session, token, server, endpoint) {
-		super();
-		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 AudioEncoder();
-		this.udp = null;
-		this.playingIntent = null;
-		this.playing = false;
-		this.streamTime = 0;
-		this.streamProc = null;
-		this.KAI = null;
-		this.init();
+var VoiceConnection = (function (_EventEmitter) {
+	_inherits(VoiceConnection, _EventEmitter);
+
+	function VoiceConnection(channel, client, session, token, server, endpoint) {
+		_classCallCheck(this, VoiceConnection);
+
+		var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(VoiceConnection).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 AudioEncoder();
+		_this.udp = null;
+		_this.playingIntent = null;
+		_this.playing = false;
+		_this.streamTime = 0;
+		_this.streamProc = null;
+		_this.KAI = null;
+		_this.init();
+		return _this;
 	}
 
-	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
-			}
-		});
-	}
-
-	stopPlaying() {
-		this.playing = false;
-		this.playingIntent = null;
-		if (this.instream) {
-			this.instream.end();
-			this.instream.destroy();
+	_createClass(VoiceConnection, [{
+		key: "destroy",
+		value: 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
+				}
+			});
 		}
-	}
-
-	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 StreamIntent();
-		var onWarning = false;
-		self.playingIntent = retStream;
-
-		function send() {
-
-			if (!self.playingIntent || !self.playing) {
-				self.setSpeaking(false);
-				retStream.emit("end");
-				self;
-				return;
+	}, {
+		key: "stopPlaying",
+		value: function stopPlaying() {
+			this.playing = false;
+			this.playingIntent = null;
+			if (this.instream) {
+				this.instream.end();
+				this.instream.destroy();
 			}
-			try {
-				var buffer = stream.read(1920);
-				if (!buffer) {
-					setTimeout(send, length * 10); // give chance for some data in 200ms to appear
+		}
+	}, {
+		key: "playStream",
+		value: 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 StreamIntent();
+			var onWarning = false;
+			self.playingIntent = retStream;
+
+			function send() {
+
+				if (!self.playingIntent || !self.playing) {
+					self.setSpeaking(false);
+					retStream.emit("end");
+					self;
 					return;
 				}
-
-				if (buffer.length !== 1920) {
-					if (onWarning) {
-						retStream.emit("end");
-						stream.destroy();
-						self.setSpeaking(false);
-						return;
-					} else {
-						onWarning = true;
+				try {
+					var buffer = stream.read(1920);
+					if (!buffer) {
 						setTimeout(send, length * 10); // give chance for some data in 200ms to appear
 						return;
 					}
-				}
 
-				count++;
-				sequence + 10 < 65535 ? sequence += 1 : sequence = 0;
-				time + 9600 < 4294967295 ? time += 960 : time = 0;
-
-				self.sendBuffer(buffer, sequence, time, 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;
-	}
-
-	setSpeaking(value) {
-		this.playing = value;
-		if (this.vWS.readyState === WebSocket.OPEN) this.vWS.send(JSON.stringify({
-			op: 5,
-			d: {
-				speaking: value,
-				delay: 0
-			}
-		}));
-	}
-
-	sendPacket(packet, callback = function (err) {}) {
-		var self = this;
-		self.playing = true;
-		try {
-			if (self.vWS.readyState === WebSocket.OPEN) self.udp.send(packet, 0, packet.length, self.vWSData.port, self.endpoint, callback);
-		} catch (e) {
-			self.playing = false;
-			callback(e);
-			return false;
-		}
-	}
-
-	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 VoicePacket(buffer, sequence, timestamp, self.vWSData.ssrc);
-			return self.sendPacket(packet, callback);
-		} catch (e) {
-			self.playing = false;
-			self.emit("error", e);
-			return false;
-		}
-	}
-
-	test() {
-		this.playFile("C:/users/amish/desktop/audio.mp3").then(stream => {
-			stream.on("time", time => {
-				console.log("Time", time);
-			});
-		});
-	}
-
-	playFile(stream, callback = function (err, str) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			this.encoder.encodeFile(stream).catch(error).then(data => {
-				self.streamProc = data.proc;
-				var intent = self.playStream(data.stream);
-				resolve(intent);
-				callback(null, intent);
-			});
-			function error(e = true) {
-				reject(e);
-				callback(e);
-			}
-		});
-	}
-
-	playRawStream(stream, callback = function (err, str) {}) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			this.encoder.encodeStream(stream).catch(error).then(data => {
-				self.streamProc = data.proc;
-				self.instream = data.instream;
-				var intent = self.playStream(data.stream);
-				resolve(intent);
-				callback(null, intent);
-			});
-			function error(e = true) {
-				reject(e);
-				callback(e);
-			}
-		});
-	}
-
-	init() {
-		var self = this;
-		dns.lookup(this.endpoint, (err, address, family) => {
-			self.endpoint = address;
-			var vWS = self.vWS = new WebSocket("wss://" + this.endpoint, null, { rejectUnauthorized: false });
-			var udpClient = self.udp = udp.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
-							}
+					if (buffer.length !== 1920) {
+						if (onWarning) {
+							retStream.emit("end");
+							stream.destroy();
+							self.setSpeaking(false);
+							return;
+						} else {
+							onWarning = true;
+							setTimeout(send, length * 10); // give chance for some data in 200ms to appear
+							return;
 						}
-					};
-					vWS.send(JSON.stringify(wsDiscPayload));
-					firstPacket = false;
-				}
-			});
-
-			vWS.on("open", () => {
-				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
 					}
-				}));
+
+					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;
+		}
+	}, {
+		key: "setSpeaking",
+		value: function setSpeaking(value) {
+			this.playing = value;
+			if (this.vWS.readyState === WebSocket.OPEN) this.vWS.send(JSON.stringify({
+				op: 5,
+				d: {
+					speaking: value,
+					delay: 0
+				}
+			}));
+		}
+	}, {
+		key: "sendPacket",
+		value: 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 === WebSocket.OPEN) self.udp.send(packet, 0, packet.length, self.vWSData.port, self.endpoint, callback);
+			} catch (e) {
+				self.playing = false;
+				callback(e);
+				return false;
+			}
+		}
+	}, {
+		key: "sendBuffer",
+		value: 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 VoicePacket(buffer, sequence, timestamp, self.vWSData.ssrc);
+				return self.sendPacket(packet, callback);
+			} catch (e) {
+				self.playing = false;
+				self.emit("error", e);
+				return false;
+			}
+		}
+	}, {
+		key: "test",
+		value: function test() {
+			this.playFile("C:/users/amish/desktop/audio.mp3").then(function (stream) {
+				stream.on("time", function (time) {
+					console.log("Time", time);
+				});
 			});
+		}
+	}, {
+		key: "playFile",
+		value: function playFile(stream) {
+			var _this2 = this;
 
-			var KAI;
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, str) {} : arguments[1];
 
-			vWS.on("message", msg => {
-				var data = JSON.parse(msg);
-				switch (data.op) {
-					case 2:
-						self.vWSData = data.d;
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				_this2.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];
 
-						KAI = setInterval(() => {
-							if (vWS && vWS.readyState === WebSocket.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, err => {
-							if (err) self.emit("error", err);
-						});
-						break;
-					case 4:
-
-						self.ready = true;
-						self.mode = data.d.mode;
-						self.emit("ready", self);
-
-						break;
+					reject(e);
+					callback(e);
 				}
 			});
-		});
-	}
-}
+		}
+	}, {
+		key: "playRawStream",
+		value: function playRawStream(stream) {
+			var _this3 = this;
+
+			var callback = arguments.length <= 1 || arguments[1] === undefined ? function (err, str) {} : arguments[1];
+
+			var self = this;
+			return new Promise(function (resolve, reject) {
+				_this3.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);
+				}
+			});
+		}
+	}, {
+		key: "init",
+		value: function init() {
+			var _this4 = this;
+
+			var self = this;
+			dns.lookup(this.endpoint, function (err, address, family) {
+				self.endpoint = address;
+				var vWS = self.vWS = new WebSocket("wss://" + _this4.endpoint, null, { rejectUnauthorized: false });
+				var udpClient = self.udp = udp.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 === WebSocket.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;
+})(EventEmitter);
 
 module.exports = VoiceConnection;
\ No newline at end of file
diff --git a/lib/Voice/VoicePacket.js b/lib/Voice/VoicePacket.js
index 3548296b1..8fa32d5f6 100644
--- a/lib/Voice/VoicePacket.js
+++ b/lib/Voice/VoicePacket.js
@@ -1,25 +1,26 @@
 "use strict";
 
-class VoicePacket {
-		constructor(data, sequence, time, ssrc) {
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-				var audioBuffer = data,
-				    returnBuffer = new Buffer(audioBuffer.length + 12);
+var VoicePacket = function VoicePacket(data, sequence, time, ssrc) {
+		_classCallCheck(this, VoicePacket);
 
-				returnBuffer.fill(0);
-				returnBuffer[0] = 0x80;
-				returnBuffer[1] = 0x78;
+		var audioBuffer = data,
+		    returnBuffer = new Buffer(audioBuffer.length + 12);
 
-				returnBuffer.writeUIntBE(sequence, 2, 2);
-				returnBuffer.writeUIntBE(time, 4, 4);
-				returnBuffer.writeUIntBE(ssrc, 8, 4);
+		returnBuffer.fill(0);
+		returnBuffer[0] = 0x80;
+		returnBuffer[1] = 0x78;
 
-				for (var i = 0; i < audioBuffer.length; i++) {
-						returnBuffer[i + 12] = audioBuffer[i];
-				}
+		returnBuffer.writeUIntBE(sequence, 2, 2);
+		returnBuffer.writeUIntBE(time, 4, 4);
+		returnBuffer.writeUIntBE(ssrc, 8, 4);
 
-				return returnBuffer;
+		for (var i = 0; i < audioBuffer.length; i++) {
+				returnBuffer[i + 12] = audioBuffer[i];
 		}
-}
+
+		return returnBuffer;
+};
 
 module.exports = VoicePacket;
\ No newline at end of file
diff --git a/lib/index.js b/lib/index.js
index 4d5a58e3e..29c9cc6a3 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -1,3 +1,5 @@
+"use strict";
+
 module.exports = {
 	Client: require("./Client/Client"),
 	Channel: require("./Structures/Channel"),
diff --git a/src/Voice/VoiceConnection.js b/src/Voice/VoiceConnection.js
index a90337adc..5aded0e70 100644
--- a/src/Voice/VoiceConnection.js
+++ b/src/Voice/VoiceConnection.js
@@ -125,6 +125,7 @@ class VoiceConnection extends EventEmitter {
 				self.streamTime = count * length;
 
 				setTimeout(send, length + (nextTime - Date.now()));
+				
 				if (!self.playing)
 					self.setSpeaking(true);