diff --git a/src/util/Voice.js b/src/util/Voice.js
index 99a0250..3f1e906 100644
--- a/src/util/Voice.js
+++ b/src/util/Voice.js
@@ -6,125 +6,123 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
+var __name = (target, value) => __defProp(target, 'name', { value, configurable: true });
+var __commonJS = (cb, mod) =>
+  function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name in all) __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  if ((from && typeof from === 'object') || typeof from === 'function') {
+    for (let key of __getOwnPropNames(from)) {
+      if (!__hasOwnProp.call(to, key) && key !== except) {
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+      }
+    }
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, 'default', { value: mod, enumerable: true }) : target,
+    mod,
+  )
+);
+var __toCommonJS = mod => __copyProps(__defProp({}, '__esModule', { value: true }), mod);
 
-// package.json
+// Package.json
 var require_package = __commonJS({
-  "package.json"(exports, module2) {
+  'package.json'(exports, module2) {
     module2.exports = {
-      name: "@discordjs/voice",
-      version: "0.10.0-dev",
-      description: "Implementation of the Discord Voice API for node.js",
+      name: '@discordjs/voice',
+      version: '0.10.0-dev',
+      description: 'Implementation of the Discord Voice API for node.js',
       scripts: {
-        build: "tsup && node scripts/postbuild.mjs",
-        test: "jest --pass-with-no-tests --collect-coverage",
-        lint: "prettier --check . && eslint src __tests__ --ext mjs,js,ts",
-        format: "prettier --write . && eslint src __tests__ --ext mjs,js,ts --fix",
-        docs: "typedoc --json docs/typedoc-out.json src/index.ts && node scripts/docs.mjs",
-        prepublishOnly: "yarn build && yarn lint && yarn test",
-        changelog: "git cliff --prepend ./CHANGELOG.md -l -c ./cliff.toml -r ../../ --include-path 'packages/voice/*'"
+        build: 'tsup && node scripts/postbuild.mjs',
+        test: 'jest --pass-with-no-tests --collect-coverage',
+        lint: 'prettier --check . && eslint src __tests__ --ext mjs,js,ts',
+        format: 'prettier --write . && eslint src __tests__ --ext mjs,js,ts --fix',
+        docs: 'typedoc --json docs/typedoc-out.json src/index.ts && node scripts/docs.mjs',
+        prepublishOnly: 'yarn build && yarn lint && yarn test',
+        changelog: "git cliff --prepend ./CHANGELOG.md -l -c ./cliff.toml -r ../../ --include-path 'packages/voice/*'",
       },
-      main: "./dist/index.js",
-      module: "./dist/index.mjs",
-      typings: "./dist/index.d.ts",
+      main: './dist/index.js',
+      module: './dist/index.mjs',
+      typings: './dist/index.d.ts',
       exports: {
-        import: "./dist/index.mjs",
-        require: "./dist/index.js",
-        types: "./dist/index.d.ts"
+        import: './dist/index.mjs',
+        require: './dist/index.js',
+        types: './dist/index.d.ts',
       },
       directories: {
-        lib: "src",
-        test: "__tests__"
+        lib: 'src',
+        test: '__tests__',
       },
-      files: [
-        "dist"
-      ],
+      files: ['dist'],
       contributors: [
-        "Crawl <icrawltogo@gmail.com>",
-        "Amish Shah <amishshah.2k@gmail.com>",
-        "SpaceEEC <spaceeec@yahoo.com>",
-        "Vlad Frangu <kingdgrizzle@gmail.com>",
-        "Antonio Roman <kyradiscord@gmail.com>"
-      ],
-      license: "Apache-2.0",
-      keywords: [
-        "discord",
-        "discord.js",
-        "audio",
-        "voice",
-        "streaming"
+        'Crawl <icrawltogo@gmail.com>',
+        'Amish Shah <amishshah.2k@gmail.com>',
+        'SpaceEEC <spaceeec@yahoo.com>',
+        'Vlad Frangu <kingdgrizzle@gmail.com>',
+        'Antonio Roman <kyradiscord@gmail.com>',
       ],
+      license: 'Apache-2.0',
+      keywords: ['discord', 'discord.js', 'audio', 'voice', 'streaming'],
       repository: {
-        type: "git",
-        url: "git+https://github.com/discordjs/discord.js.git"
+        type: 'git',
+        url: 'git+https://github.com/discordjs/discord.js.git',
       },
       bugs: {
-        url: "https://github.com/discordjs/discord.js/issues"
+        url: 'https://github.com/discordjs/discord.js/issues',
       },
-      homepage: "https://discord.js.org",
+      homepage: 'https://discord.js.org',
       dependencies: {
-        "@types/ws": "^8.5.3",
-        "discord-api-types": "^0.33.3",
-        "prism-media": "^1.3.2",
-        "tiny-typed-emitter": "^2.1.0",
-        tslib: "^2.4.0",
-        ws: "^8.7.0"
+        '@types/ws': '^8.5.3',
+        'discord-api-types': '^0.33.0',
+        'prism-media': '^1.3.2',
+        'tiny-typed-emitter': '^2.1.0',
+        tslib: '^2.3.1',
+        ws: '^8.5.0',
       },
       devDependencies: {
-        "@babel/core": "^7.18.2",
-        "@babel/preset-env": "^7.18.2",
-        "@babel/preset-typescript": "^7.17.12",
-        "@discordjs/ts-docgen": "^0.4.1",
-        "@types/jest": "^28.1.0",
-        "@types/node": "^16.11.38",
-        "@typescript-eslint/eslint-plugin": "^5.27.0",
-        "@typescript-eslint/parser": "^5.27.0",
-        eslint: "^8.17.0",
-        "eslint-config-marine": "^9.4.1",
-        "eslint-config-prettier": "^8.5.0",
-        "eslint-plugin-import": "^2.26.0",
-        jest: "^28.1.0",
-        "jest-websocket-mock": "^2.3.0",
-        "mock-socket": "^9.1.4",
-        prettier: "^2.6.2",
-        tsup: "^6.0.1",
-        tweetnacl: "^1.0.3",
-        typedoc: "^0.22.17",
-        typescript: "^4.7.3"
+        '@babel/core': '^7.17.9',
+        '@babel/preset-env': '^7.16.11',
+        '@babel/preset-typescript': '^7.16.7',
+        '@discordjs/ts-docgen': '^0.4.1',
+        '@types/jest': '^27.4.1',
+        '@types/node': '^16.11.27',
+        '@typescript-eslint/eslint-plugin': '^5.19.0',
+        '@typescript-eslint/parser': '^5.19.0',
+        eslint: '^8.13.0',
+        'eslint-config-marine': '^9.4.1',
+        'eslint-config-prettier': '^8.5.0',
+        'eslint-plugin-import': '^2.26.0',
+        jest: '^27.5.1',
+        'jest-websocket-mock': '^2.3.0',
+        'mock-socket': '^9.1.2',
+        prettier: '^2.6.2',
+        tsup: '^5.12.5',
+        tweetnacl: '^1.0.3',
+        typedoc: '^0.22.15',
+        typescript: '^4.6.3',
       },
       engines: {
-        node: ">=16.9.0"
+        node: '>=16.9.0',
       },
       publishConfig: {
-        access: "public"
-      }
+        access: 'public',
+      },
     };
-  }
+  },
 });
 
-// src/index.ts
+// Src/index.ts
 var src_exports = {};
 __export(src_exports, {
   AudioPlayer: () => AudioPlayer,
@@ -142,6 +140,7 @@ __export(src_exports, {
   VoiceConnectionDisconnectReason: () => VoiceConnectionDisconnectReason,
   VoiceConnectionStatus: () => VoiceConnectionStatus,
   VoiceReceiver: () => VoiceReceiver,
+  Networking: () => Networking,
   createAudioPlayer: () => createAudioPlayer,
   createAudioResource: () => createAudioResource,
   createDefaultAudioReceiveStreamOptions: () => createDefaultAudioReceiveStreamOptions,
@@ -152,15 +151,19 @@ __export(src_exports, {
   getVoiceConnection: () => getVoiceConnection,
   getVoiceConnections: () => getVoiceConnections,
   joinVoiceChannel: () => joinVoiceChannel,
-  validateDiscordOpusHead: () => validateDiscordOpusHead
+  validateDiscordOpusHead: () => validateDiscordOpusHead,
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/VoiceConnection.ts
-var import_tiny_typed_emitter7 = require("tiny-typed-emitter");
+// Src/VoiceConnection.ts
+var import_node_events = require('events');
+var import_node_path = require('path');
+var import_node_stream2 = require('stream');
+var import_node_stream3 = require('stream');
+var import_v10 = require('discord-api-types/v9');
+var import_tiny_typed_emitter7 = require('tiny-typed-emitter');
 
-// src/DataStore.ts
-var import_v10 = require("discord-api-types/v10");
+// Src/DataStore.ts
 function createJoinVoiceChannelPayload(config) {
   return {
     op: import_v10.GatewayOpcodes.VoiceStateUpdate,
@@ -168,55 +171,53 @@ function createJoinVoiceChannelPayload(config) {
       guild_id: config.guildId,
       channel_id: config.channelId,
       self_deaf: config.selfDeaf,
-      self_mute: config.selfMute
-    }
+      self_mute: config.selfMute,
+    },
   };
 }
-__name(createJoinVoiceChannelPayload, "createJoinVoiceChannelPayload");
+__name(createJoinVoiceChannelPayload, 'createJoinVoiceChannelPayload');
 var groups = /* @__PURE__ */ new Map();
-groups.set("default", /* @__PURE__ */ new Map());
+groups.set('default', /* @__PURE__ */ new Map());
 function getOrCreateGroup(group) {
   const existing = groups.get(group);
-  if (existing)
-    return existing;
+  if (existing) return existing;
   const map = /* @__PURE__ */ new Map();
   groups.set(group, map);
   return map;
 }
-__name(getOrCreateGroup, "getOrCreateGroup");
+__name(getOrCreateGroup, 'getOrCreateGroup');
 function getGroups() {
   return groups;
 }
-__name(getGroups, "getGroups");
-function getVoiceConnections(group = "default") {
+__name(getGroups, 'getGroups');
+function getVoiceConnections(group = 'default') {
   return groups.get(group);
 }
-__name(getVoiceConnections, "getVoiceConnections");
-function getVoiceConnection(guildId, group = "default") {
+__name(getVoiceConnections, 'getVoiceConnections');
+function getVoiceConnection(guildId, group = 'default') {
   return getVoiceConnections(group)?.get(guildId);
 }
-__name(getVoiceConnection, "getVoiceConnection");
+__name(getVoiceConnection, 'getVoiceConnection');
 function untrackVoiceConnection(voiceConnection) {
   return getVoiceConnections(voiceConnection.joinConfig.group)?.delete(voiceConnection.joinConfig.guildId);
 }
-__name(untrackVoiceConnection, "untrackVoiceConnection");
+__name(untrackVoiceConnection, 'untrackVoiceConnection');
 function trackVoiceConnection(voiceConnection) {
   return getOrCreateGroup(voiceConnection.joinConfig.group).set(voiceConnection.joinConfig.guildId, voiceConnection);
 }
-__name(trackVoiceConnection, "trackVoiceConnection");
+__name(trackVoiceConnection, 'trackVoiceConnection');
 var FRAME_LENGTH = 20;
 var audioCycleInterval;
 var nextTime = -1;
 var audioPlayers = [];
 function audioCycleStep() {
-  if (nextTime === -1)
-    return;
+  if (nextTime === -1) return;
   nextTime += FRAME_LENGTH;
-  const available = audioPlayers.filter((player) => player.checkPlayable());
-  available.forEach((player) => player["_stepDispatch"]());
+  const available = audioPlayers.filter(player => player.checkPlayable());
+  available.forEach(player => player._stepDispatch());
   prepareNextAudioFrame(available);
 }
-__name(audioCycleStep, "audioCycleStep");
+__name(audioCycleStep, 'audioCycleStep');
 function prepareNextAudioFrame(players) {
   const nextPlayer = players.shift();
   if (!nextPlayer) {
@@ -225,17 +226,16 @@ function prepareNextAudioFrame(players) {
     }
     return;
   }
-  nextPlayer["_stepPrepare"]();
+  nextPlayer._stepPrepare();
   setImmediate(() => prepareNextAudioFrame(players));
 }
-__name(prepareNextAudioFrame, "prepareNextAudioFrame");
+__name(prepareNextAudioFrame, 'prepareNextAudioFrame');
 function hasAudioPlayer(target) {
   return audioPlayers.includes(target);
 }
-__name(hasAudioPlayer, "hasAudioPlayer");
+__name(hasAudioPlayer, 'hasAudioPlayer');
 function addAudioPlayer(player) {
-  if (hasAudioPlayer(player))
-    return player;
+  if (hasAudioPlayer(player)) return player;
   audioPlayers.push(player);
   if (audioPlayers.length === 1) {
     nextTime = Date.now();
@@ -243,77 +243,67 @@ function addAudioPlayer(player) {
   }
   return player;
 }
-__name(addAudioPlayer, "addAudioPlayer");
+__name(addAudioPlayer, 'addAudioPlayer');
 function deleteAudioPlayer(player) {
   const index = audioPlayers.indexOf(player);
-  if (index === -1)
-    return;
+  if (index === -1) return;
   audioPlayers.splice(index, 1);
   if (audioPlayers.length === 0) {
     nextTime = -1;
-    if (typeof audioCycleInterval !== "undefined")
-      clearTimeout(audioCycleInterval);
+    if (typeof audioCycleInterval !== 'undefined') clearTimeout(audioCycleInterval);
   }
 }
-__name(deleteAudioPlayer, "deleteAudioPlayer");
+__name(deleteAudioPlayer, 'deleteAudioPlayer');
 
-// src/networking/Networking.ts
-var import_v42 = require("discord-api-types/voice/v4");
-var import_tiny_typed_emitter3 = require("tiny-typed-emitter");
+// Src/networking/Networking.ts
+var import_v42 = require('discord-api-types/voice/v4');
+var import_tiny_typed_emitter3 = require('tiny-typed-emitter');
 
-// src/networking/VoiceUDPSocket.ts
-var import_node_dgram = require("dgram");
-var import_node_net = require("net");
-var import_tiny_typed_emitter = require("tiny-typed-emitter");
+// Src/networking/VoiceUDPSocket.ts
+var import_node_dgram = require('dgram');
+var import_node_net = require('net');
+var import_tiny_typed_emitter = require('tiny-typed-emitter');
 function parseLocalPacket(message) {
   const packet = Buffer.from(message);
-  const ip = packet.slice(8, packet.indexOf(0, 8)).toString("utf-8");
+  const ip = packet.slice(8, packet.indexOf(0, 8)).toString('utf-8');
   if (!(0, import_node_net.isIPv4)(ip)) {
-    throw new Error("Malformed IP address");
+    throw new Error('Malformed IP address');
   }
   const port = packet.readUInt16BE(packet.length - 2);
   return { ip, port };
 }
-__name(parseLocalPacket, "parseLocalPacket");
+__name(parseLocalPacket, 'parseLocalPacket');
 var KEEP_ALIVE_INTERVAL = 5e3;
 var KEEP_ALIVE_LIMIT = 12;
 var MAX_COUNTER_VALUE = 2 ** 32 - 1;
 var VoiceUDPSocket = class extends import_tiny_typed_emitter.TypedEmitter {
   constructor(remote, debug = false) {
     super();
-    __publicField(this, "socket");
-    __publicField(this, "remote");
-    __publicField(this, "keepAlives");
-    __publicField(this, "keepAliveCounter", 0);
-    __publicField(this, "keepAliveBuffer");
-    __publicField(this, "keepAliveInterval");
-    __publicField(this, "ping");
-    __publicField(this, "debug");
-    this.socket = (0, import_node_dgram.createSocket)("udp4");
-    this.socket.on("error", (error) => this.emit("error", error));
-    this.socket.on("message", (buffer) => this.onMessage(buffer));
-    this.socket.on("close", () => this.emit("close"));
+    this.keepAliveCounter = 0;
+    this.socket = (0, import_node_dgram.createSocket)('udp4');
+    this.socket.on('error', error => this.emit('error', error));
+    this.socket.on('message', buffer => this.onMessage(buffer));
+    this.socket.on('close', () => this.emit('close'));
     this.remote = remote;
     this.keepAlives = [];
     this.keepAliveBuffer = Buffer.alloc(8);
     this.keepAliveInterval = setInterval(() => this.keepAlive(), KEEP_ALIVE_INTERVAL);
     setImmediate(() => this.keepAlive());
-    this.debug = debug ? (message) => this.emit("debug", message) : null;
+    this.debug = debug ? message => this.emit('debug', message) : null;
   }
   onMessage(buffer) {
     if (buffer.length === 8) {
       const counter = buffer.readUInt32LE(0);
       const index = this.keepAlives.findIndex(({ value }) => value === counter);
-      if (index === -1)
-        return;
+      if (index === -1) return;
       this.ping = Date.now() - this.keepAlives[index].timestamp;
       this.keepAlives.splice(0, index);
     }
-    this.emit("message", buffer);
+    this.emit('message', buffer);
   }
   keepAlive() {
     if (this.keepAlives.length >= KEEP_ALIVE_LIMIT) {
-      this.debug?.("UDP socket has not received enough responses from Discord - closing socket");
+      this.debug?.('UDP socket has not received enough responses from Discord - closing socket');
       this.destroy();
       return;
     }
@@ -321,7 +311,7 @@ var VoiceUDPSocket = class extends import_tiny_typed_emitter.TypedEmitter {
     this.send(this.keepAliveBuffer);
     this.keepAlives.push({
       value: this.keepAliveCounter,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     });
     this.keepAliveCounter++;
     if (this.keepAliveCounter > MAX_COUNTER_VALUE) {
@@ -334,24 +324,21 @@ var VoiceUDPSocket = class extends import_tiny_typed_emitter.TypedEmitter {
   destroy() {
     try {
       this.socket.close();
-    } catch {
-    }
+    } catch {}
     clearInterval(this.keepAliveInterval);
   }
   performIPDiscovery(ssrc) {
     return new Promise((resolve2, reject) => {
-      const listener = /* @__PURE__ */ __name((message) => {
+      const listener = /* @__PURE__ */ __name(message => {
         try {
-          if (message.readUInt16BE(0) !== 2)
-            return;
+          if (message.readUInt16BE(0) !== 2) return;
           const packet = parseLocalPacket(message);
-          this.socket.off("message", listener);
+          this.socket.off('message', listener);
           resolve2(packet);
-        } catch {
-        }
-      }, "listener");
-      this.socket.on("message", listener);
-      this.socket.once("close", () => reject(new Error("Cannot perform IP discovery - socket closed")));
+        } catch {}
+      }, 'listener');
+      this.socket.on('message', listener);
+      this.socket.once('close', () => reject(new Error('Cannot perform IP discovery - socket closed')));
       const discoveryBuffer = Buffer.alloc(74);
       discoveryBuffer.writeUInt16BE(1, 0);
       discoveryBuffer.writeUInt16BE(70, 2);
@@ -360,51 +347,44 @@ var VoiceUDPSocket = class extends import_tiny_typed_emitter.TypedEmitter {
     });
   }
 };
-__name(VoiceUDPSocket, "VoiceUDPSocket");
+__name(VoiceUDPSocket, 'VoiceUDPSocket');
 
-// src/networking/VoiceWebSocket.ts
-var import_v4 = require("discord-api-types/voice/v4");
-var import_tiny_typed_emitter2 = require("tiny-typed-emitter");
-var import_ws = __toESM(require("ws"));
+// Src/networking/VoiceWebSocket.ts
+var import_v4 = require('discord-api-types/voice/v4');
+var import_tiny_typed_emitter2 = require('tiny-typed-emitter');
+var import_ws = __toESM(require('ws'));
 var VoiceWebSocket = class extends import_tiny_typed_emitter2.TypedEmitter {
   constructor(address, debug) {
     super();
-    __publicField(this, "heartbeatInterval");
-    __publicField(this, "lastHeartbeatAck");
-    __publicField(this, "lastHeartbeatSend");
-    __publicField(this, "missedHeartbeats", 0);
-    __publicField(this, "ping");
-    __publicField(this, "debug");
-    __publicField(this, "ws");
+    this.missedHeartbeats = 0;
     this.ws = new import_ws.default(address);
-    this.ws.onmessage = (e) => this.onMessage(e);
-    this.ws.onopen = (e) => this.emit("open", e);
-    this.ws.onerror = (e) => this.emit("error", e instanceof Error ? e : e.error);
-    this.ws.onclose = (e) => this.emit("close", e);
+    this.ws.onmessage = e => this.onMessage(e);
+    this.ws.onopen = e => this.emit('open', e);
+    this.ws.onerror = e => this.emit('error', e instanceof Error ? e : e.error);
+    this.ws.onclose = e => this.emit('close', e);
     this.lastHeartbeatAck = 0;
     this.lastHeartbeatSend = 0;
-    this.debug = debug ? (message) => this.emit("debug", message) : null;
+    this.debug = debug ? message => this.emit('debug', message) : null;
   }
   destroy() {
     try {
-      this.debug?.("destroyed");
+      this.debug?.('destroyed');
       this.setHeartbeatInterval(-1);
       this.ws.close(1e3);
     } catch (error) {
       const e = error;
-      this.emit("error", e);
+      this.emit('error', e);
     }
   }
   onMessage(event) {
-    if (typeof event.data !== "string")
-      return;
+    if (typeof event.data !== 'string') return;
     this.debug?.(`<< ${event.data}`);
     let packet;
     try {
       packet = JSON.parse(event.data);
     } catch (error) {
       const e = error;
-      this.emit("error", e);
+      this.emit('error', e);
       return;
     }
     if (packet.op === import_v4.VoiceOpcodes.HeartbeatAck) {
@@ -412,7 +392,7 @@ var VoiceWebSocket = class extends import_tiny_typed_emitter2.TypedEmitter {
       this.missedHeartbeats = 0;
       this.ping = this.lastHeartbeatAck - this.lastHeartbeatSend;
     }
-    this.emit("packet", packet);
+    this.emit('packet', packet);
   }
   sendPacket(packet) {
     try {
@@ -421,7 +401,7 @@ var VoiceWebSocket = class extends import_tiny_typed_emitter2.TypedEmitter {
       return this.ws.send(stringified);
     } catch (error) {
       const e = error;
-      this.emit("error", e);
+      this.emit('error', e);
     }
   }
   sendHeartbeat() {
@@ -430,12 +410,11 @@ var VoiceWebSocket = class extends import_tiny_typed_emitter2.TypedEmitter {
     const nonce2 = this.lastHeartbeatSend;
     return this.sendPacket({
       op: import_v4.VoiceOpcodes.Heartbeat,
-      d: nonce2
+      d: nonce2,
     });
   }
   setHeartbeatInterval(ms) {
-    if (typeof this.heartbeatInterval !== "undefined")
-      clearInterval(this.heartbeatInterval);
+    if (typeof this.heartbeatInterval !== 'undefined') clearInterval(this.heartbeatInterval);
     if (ms > 0) {
       this.heartbeatInterval = setInterval(() => {
         if (this.lastHeartbeatSend !== 0 && this.missedHeartbeats >= 3) {
@@ -447,16 +426,15 @@ var VoiceWebSocket = class extends import_tiny_typed_emitter2.TypedEmitter {
     }
   }
 };
-__name(VoiceWebSocket, "VoiceWebSocket");
+__name(VoiceWebSocket, 'VoiceWebSocket');
 
-// src/util/Secretbox.ts
+// Src/util/Secretbox.ts
 var libs = {
-  "sodium-native": (sodium) => ({
+  'sodium-native': sodium => ({
     open: (buffer, nonce2, secretKey) => {
       if (buffer) {
         const output = Buffer.allocUnsafe(buffer.length - sodium.crypto_box_MACBYTES);
-        if (sodium.crypto_secretbox_open_easy(output, buffer, nonce2, secretKey))
-          return output;
+        if (sodium.crypto_secretbox_open_easy(output, buffer, nonce2, secretKey)) return output;
       }
       return null;
     },
@@ -468,86 +446,81 @@ var libs = {
     random: (n, buffer = Buffer.allocUnsafe(n)) => {
       sodium.randombytes_buf(buffer);
       return buffer;
-    }
+    },
   }),
-  sodium: (sodium) => ({
+  sodium: sodium => ({
     open: sodium.api.crypto_secretbox_open_easy,
     close: sodium.api.crypto_secretbox_easy,
     random: (n, buffer = Buffer.allocUnsafe(n)) => {
       sodium.api.randombytes_buf(buffer);
       return buffer;
-    }
+    },
   }),
-  "libsodium-wrappers": (sodium) => ({
+  'libsodium-wrappers': sodium => ({
     open: sodium.crypto_secretbox_open_easy,
     close: sodium.crypto_secretbox_easy,
-    random: sodium.randombytes_buf
+    random: sodium.randombytes_buf,
   }),
-  tweetnacl: (tweetnacl) => ({
+  tweetnacl: tweetnacl => ({
     open: tweetnacl.secretbox.open,
     close: tweetnacl.secretbox,
-    random: tweetnacl.randomBytes
-  })
+    random: tweetnacl.randomBytes,
+  }),
 };
 var fallbackError = /* @__PURE__ */ __name(() => {
   throw new Error(`Cannot play audio as no valid encryption package is installed.
 - Install sodium, libsodium-wrappers, or tweetnacl.
 - Use the generateDependencyReport() function for more information.
 `);
-}, "fallbackError");
+}, 'fallbackError');
 var methods = {
   open: fallbackError,
   close: fallbackError,
-  random: fallbackError
+  random: fallbackError,
 };
 void (async () => {
   for (const libName of Object.keys(libs)) {
     try {
       const lib = require(libName);
-      if (libName === "libsodium-wrappers" && lib.ready)
-        await lib.ready;
+      if (libName === 'libsodium-wrappers' && lib.ready) await lib.ready;
       Object.assign(methods, libs[libName](lib));
       break;
-    } catch {
-    }
+    } catch {}
   }
 })();
 
-// src/util/util.ts
-var noop = /* @__PURE__ */ __name(() => {
-}, "noop");
+// Src/util/util.ts
+var noop = /* @__PURE__ */ __name(() => {}, 'noop');
 
-// src/networking/Networking.ts
+// Src/networking/Networking.ts
 var CHANNELS = 2;
-var TIMESTAMP_INC = 48e3 / 100 * CHANNELS;
+var TIMESTAMP_INC = (48e3 / 100) * CHANNELS;
 var MAX_NONCE_SIZE = 2 ** 32 - 1;
-var SUPPORTED_ENCRYPTION_MODES = ["xsalsa20_poly1305_lite", "xsalsa20_poly1305_suffix", "xsalsa20_poly1305"];
+var SUPPORTED_ENCRYPTION_MODES = ['xsalsa20_poly1305_lite', 'xsalsa20_poly1305_suffix', 'xsalsa20_poly1305'];
 var nonce = Buffer.alloc(24);
 function stringifyState(state) {
   return JSON.stringify({
     ...state,
-    ws: Reflect.has(state, "ws"),
-    udp: Reflect.has(state, "udp")
+    ws: Reflect.has(state, 'ws'),
+    udp: Reflect.has(state, 'udp'),
   });
 }
-__name(stringifyState, "stringifyState");
+__name(stringifyState, 'stringifyState');
 function chooseEncryptionMode(options) {
-  const option = options.find((option2) => SUPPORTED_ENCRYPTION_MODES.includes(option2));
+  const option = options.find(option2 => SUPPORTED_ENCRYPTION_MODES.includes(option2));
   if (!option) {
-    throw new Error(`No compatible encryption modes. Available include: ${options.join(", ")}`);
+    throw new Error(`No compatible encryption modes. Available include: ${options.join(', ')}`);
   }
   return option;
 }
-__name(chooseEncryptionMode, "chooseEncryptionMode");
+__name(chooseEncryptionMode, 'chooseEncryptionMode');
 function randomNBit(n) {
   return Math.floor(Math.random() * 2 ** n);
 }
-__name(randomNBit, "randomNBit");
+__name(randomNBit, 'randomNBit');
 var Networking = class extends import_tiny_typed_emitter3.TypedEmitter {
   constructor(options, debug) {
     super();
-    __publicField(this, "_state");
-    __publicField(this, "debug");
     this.onWsOpen = this.onWsOpen.bind(this);
     this.onChildError = this.onChildError.bind(this);
     this.onWsPacket = this.onWsPacket.bind(this);
@@ -555,60 +528,60 @@ var Networking = class extends import_tiny_typed_emitter3.TypedEmitter {
     this.onWsDebug = this.onWsDebug.bind(this);
     this.onUdpDebug = this.onUdpDebug.bind(this);
     this.onUdpClose = this.onUdpClose.bind(this);
-    this.debug = debug ? (message) => this.emit("debug", message) : null;
+    this.debug = debug ? message => this.emit('debug', message) : null;
     this._state = {
       code: 0 /* OpeningWs */,
       ws: this.createWebSocket(options.endpoint),
-      connectionOptions: options
+      connectionOptions: options,
     };
   }
   destroy() {
     this.state = {
-      code: 6 /* Closed */
+      code: 6 /* Closed */,
     };
   }
   get state() {
     return this._state;
   }
   set state(newState) {
-    const oldWs = Reflect.get(this._state, "ws");
-    const newWs = Reflect.get(newState, "ws");
+    const oldWs = Reflect.get(this._state, 'ws');
+    const newWs = Reflect.get(newState, 'ws');
     if (oldWs && oldWs !== newWs) {
-      oldWs.off("debug", this.onWsDebug);
-      oldWs.on("error", noop);
-      oldWs.off("error", this.onChildError);
-      oldWs.off("open", this.onWsOpen);
-      oldWs.off("packet", this.onWsPacket);
-      oldWs.off("close", this.onWsClose);
+      oldWs.off('debug', this.onWsDebug);
+      oldWs.on('error', noop);
+      oldWs.off('error', this.onChildError);
+      oldWs.off('open', this.onWsOpen);
+      oldWs.off('packet', this.onWsPacket);
+      oldWs.off('close', this.onWsClose);
       oldWs.destroy();
     }
-    const oldUdp = Reflect.get(this._state, "udp");
-    const newUdp = Reflect.get(newState, "udp");
+    const oldUdp = Reflect.get(this._state, 'udp');
+    const newUdp = Reflect.get(newState, 'udp');
     if (oldUdp && oldUdp !== newUdp) {
-      oldUdp.on("error", noop);
-      oldUdp.off("error", this.onChildError);
-      oldUdp.off("close", this.onUdpClose);
-      oldUdp.off("debug", this.onUdpDebug);
+      oldUdp.on('error', noop);
+      oldUdp.off('error', this.onChildError);
+      oldUdp.off('close', this.onUdpClose);
+      oldUdp.off('debug', this.onUdpDebug);
       oldUdp.destroy();
     }
     const oldState = this._state;
     this._state = newState;
-    this.emit("stateChange", oldState, newState);
+    this.emit('stateChange', oldState, newState);
     this.debug?.(`state change:
 from ${stringifyState(oldState)}
 to ${stringifyState(newState)}`);
   }
   createWebSocket(endpoint) {
     const ws = new VoiceWebSocket(`wss://${endpoint}?v=4`, Boolean(this.debug));
-    ws.on("error", this.onChildError);
-    ws.once("open", this.onWsOpen);
-    ws.on("packet", this.onWsPacket);
-    ws.once("close", this.onWsClose);
-    ws.on("debug", this.onWsDebug);
+    ws.on('error', this.onChildError);
+    ws.once('open', this.onWsOpen);
+    ws.on('packet', this.onWsPacket);
+    ws.once('close', this.onWsClose);
+    ws.on('debug', this.onWsDebug);
     return ws;
   }
   onChildError(error) {
-    this.emit("error", error);
+    this.emit('error', error);
   }
   onWsOpen() {
     if (this.state.code === 0 /* OpeningWs */) {
@@ -618,13 +591,13 @@ to ${stringifyState(newState)}`);
           server_id: this.state.connectionOptions.serverId,
           user_id: this.state.connectionOptions.userId,
           session_id: this.state.connectionOptions.sessionId,
-          token: this.state.connectionOptions.token
-        }
+          token: this.state.connectionOptions.token,
+        },
       };
       this.state.ws.sendPacket(packet);
       this.state = {
         ...this.state,
-        code: 1 /* Identifying */
+        code: 1 /* Identifying */,
       };
     } else if (this.state.code === 5 /* Resuming */) {
       const packet = {
@@ -632,8 +605,8 @@ to ${stringifyState(newState)}`);
         d: {
           server_id: this.state.connectionOptions.serverId,
           session_id: this.state.connectionOptions.sessionId,
-          token: this.state.connectionOptions.token
-        }
+          token: this.state.connectionOptions.token,
+        },
       };
       this.state.ws.sendPacket(packet);
     }
@@ -644,11 +617,11 @@ to ${stringifyState(newState)}`);
       this.state = {
         ...this.state,
         code: 5 /* Resuming */,
-        ws: this.createWebSocket(this.state.connectionOptions.endpoint)
+        ws: this.createWebSocket(this.state.connectionOptions.endpoint),
       };
     } else if (this.state.code !== 6 /* Closed */) {
       this.destroy();
-      this.emit("close", code);
+      this.emit('close', code);
     }
   }
   onUdpClose() {
@@ -656,7 +629,7 @@ to ${stringifyState(newState)}`);
       this.state = {
         ...this.state,
         code: 5 /* Resuming */,
-        ws: this.createWebSocket(this.state.connectionOptions.endpoint)
+        ws: this.createWebSocket(this.state.connectionOptions.endpoint),
       };
     }
   }
@@ -666,37 +639,42 @@ to ${stringifyState(newState)}`);
     } else if (packet.op === import_v42.VoiceOpcodes.Ready && this.state.code === 1 /* Identifying */) {
       const { ip, port, ssrc, modes } = packet.d;
       const udp = new VoiceUDPSocket({ ip, port });
-      udp.on("error", this.onChildError);
-      udp.on("debug", this.onUdpDebug);
-      udp.once("close", this.onUdpClose);
-      udp.performIPDiscovery(ssrc).then((localConfig) => {
-        if (this.state.code !== 2 /* UdpHandshaking */)
-          return;
-        this.state.ws.sendPacket({
-          op: import_v42.VoiceOpcodes.SelectProtocol,
-          d: {
-            protocol: "udp",
-            data: {
-              address: localConfig.ip,
-              port: localConfig.port,
-              mode: chooseEncryptionMode(modes)
-            }
-          }
-        });
-        this.state = {
-          ...this.state,
-          code: 3 /* SelectingProtocol */
-        };
-      }).catch((error) => this.emit("error", error));
+      udp.on('error', this.onChildError);
+      udp.on('debug', this.onUdpDebug);
+      udp.once('close', this.onUdpClose);
+      udp
+        .performIPDiscovery(ssrc)
+        .then(localConfig => {
+          if (this.state.code !== 2 /* UdpHandshaking */) return;
+          this.state.ws.sendPacket({
+            op: import_v42.VoiceOpcodes.SelectProtocol,
+            d: {
+              protocol: 'udp',
+              data: {
+                address: localConfig.ip,
+                port: localConfig.port,
+                mode: chooseEncryptionMode(modes),
+              },
+            },
+          });
+          this.state = {
+            ...this.state,
+            code: 3 /* SelectingProtocol */,
+          };
+        })
+        .catch(error => this.emit('error', error));
       this.state = {
         ...this.state,
         code: 2 /* UdpHandshaking */,
         udp,
         connectionData: {
-          ssrc
-        }
+          ssrc,
+        },
       };
-    } else if (packet.op === import_v42.VoiceOpcodes.SessionDescription && this.state.code === 3 /* SelectingProtocol */) {
+    } else if (
+      packet.op === import_v42.VoiceOpcodes.SessionDescription &&
+      this.state.code === 3 /* SelectingProtocol */
+    ) {
       const { mode: encryptionMode, secret_key: secretKey } = packet.d;
       this.state = {
         ...this.state,
@@ -710,13 +688,13 @@ to ${stringifyState(newState)}`);
           nonce: 0,
           nonceBuffer: Buffer.alloc(24),
           speaking: false,
-          packetsPlayed: 0
-        }
+          packetsPlayed: 0,
+        },
       };
     } else if (packet.op === import_v42.VoiceOpcodes.Resumed && this.state.code === 5 /* Resuming */) {
       this.state = {
         ...this.state,
-        code: 4 /* Ready */
+        code: 4 /* Ready */,
       };
       this.state.connectionData.speaking = false;
     }
@@ -729,16 +707,14 @@ to ${stringifyState(newState)}`);
   }
   prepareAudioPacket(opusPacket) {
     const state = this.state;
-    if (state.code !== 4 /* Ready */)
-      return;
+    if (state.code !== 4 /* Ready */) return;
     state.preparedPacket = this.createAudioPacket(opusPacket, state.connectionData);
     return state.preparedPacket;
   }
   dispatchAudio() {
     const state = this.state;
-    if (state.code !== 4 /* Ready */)
-      return false;
-    if (typeof state.preparedPacket !== "undefined") {
+    if (state.code !== 4 /* Ready */) return false;
+    if (typeof state.preparedPacket !== 'undefined') {
       this.playAudioPacket(state.preparedPacket);
       state.preparedPacket = void 0;
       return true;
@@ -747,33 +723,28 @@ to ${stringifyState(newState)}`);
   }
   playAudioPacket(audioPacket) {
     const state = this.state;
-    if (state.code !== 4 /* Ready */)
-      return;
+    if (state.code !== 4 /* Ready */) return;
     const { connectionData } = state;
     connectionData.packetsPlayed++;
     connectionData.sequence++;
     connectionData.timestamp += TIMESTAMP_INC;
-    if (connectionData.sequence >= 2 ** 16)
-      connectionData.sequence = 0;
-    if (connectionData.timestamp >= 2 ** 32)
-      connectionData.timestamp = 0;
+    if (connectionData.sequence >= 2 ** 16) connectionData.sequence = 0;
+    if (connectionData.timestamp >= 2 ** 32) connectionData.timestamp = 0;
     this.setSpeaking(true);
     state.udp.send(audioPacket);
   }
   setSpeaking(speaking) {
     const state = this.state;
-    if (state.code !== 4 /* Ready */)
-      return;
-    if (state.connectionData.speaking === speaking)
-      return;
+    if (state.code !== 4 /* Ready */) return;
+    if (state.connectionData.speaking === speaking) return;
     state.connectionData.speaking = speaking;
     state.ws.sendPacket({
       op: import_v42.VoiceOpcodes.Speaking,
       d: {
         speaking: speaking ? 1 : 0,
         delay: 0,
-        ssrc: state.connectionData.ssrc
-      }
+        ssrc: state.connectionData.ssrc,
+      },
     });
   }
   createAudioPacket(opusPacket, connectionData) {
@@ -789,108 +760,100 @@ to ${stringifyState(newState)}`);
   }
   encryptOpusPacket(opusPacket, connectionData) {
     const { secretKey, encryptionMode } = connectionData;
-    if (encryptionMode === "xsalsa20_poly1305_lite") {
+    if (encryptionMode === 'xsalsa20_poly1305_lite') {
       connectionData.nonce++;
-      if (connectionData.nonce > MAX_NONCE_SIZE)
-        connectionData.nonce = 0;
+      if (connectionData.nonce > MAX_NONCE_SIZE) connectionData.nonce = 0;
       connectionData.nonceBuffer.writeUInt32BE(connectionData.nonce, 0);
-      return [
-        methods.close(opusPacket, connectionData.nonceBuffer, secretKey),
-        connectionData.nonceBuffer.slice(0, 4)
-      ];
-    } else if (encryptionMode === "xsalsa20_poly1305_suffix") {
+      return [methods.close(opusPacket, connectionData.nonceBuffer, secretKey), connectionData.nonceBuffer.slice(0, 4)];
+    } else if (encryptionMode === 'xsalsa20_poly1305_suffix') {
       const random = methods.random(24, connectionData.nonceBuffer);
       return [methods.close(opusPacket, random, secretKey), random];
     }
     return [methods.close(opusPacket, nonce, secretKey)];
   }
 };
-__name(Networking, "Networking");
+__name(Networking, 'Networking');
 
-// src/receive/VoiceReceiver.ts
-var import_v43 = require("discord-api-types/voice/v4");
+// Src/receive/VoiceReceiver.ts
+var import_v43 = require('discord-api-types/voice/v4');
 
-// src/receive/AudioReceiveStream.ts
-var import_node_stream = require("stream");
+// Src/receive/AudioReceiveStream.ts
+var import_node_stream = require('stream');
 
-// src/audio/AudioPlayer.ts
-var import_tiny_typed_emitter4 = require("tiny-typed-emitter");
+// Src/audio/AudioPlayer.ts
+var import_tiny_typed_emitter4 = require('tiny-typed-emitter');
 
-// src/audio/AudioPlayerError.ts
+// Src/audio/AudioPlayerError.ts
 var AudioPlayerError = class extends Error {
   constructor(error, resource) {
     super(error.message);
-    __publicField(this, "resource");
     this.resource = resource;
     this.name = error.name;
     this.stack = error.stack;
   }
 };
-__name(AudioPlayerError, "AudioPlayerError");
+__name(AudioPlayerError, 'AudioPlayerError');
 
-// src/audio/PlayerSubscription.ts
+// Src/audio/PlayerSubscription.ts
 var PlayerSubscription = class {
   constructor(connection, player) {
-    __publicField(this, "connection");
-    __publicField(this, "player");
     this.connection = connection;
     this.player = player;
   }
   unsubscribe() {
-    this.connection["onSubscriptionRemoved"](this);
-    this.player["unsubscribe"](this);
+    this.connection.onSubscriptionRemoved(this);
+    this.player.unsubscribe(this);
   }
 };
-__name(PlayerSubscription, "PlayerSubscription");
+__name(PlayerSubscription, 'PlayerSubscription');
 
-// src/audio/AudioPlayer.ts
+// Src/audio/AudioPlayer.ts
 var SILENCE_FRAME = Buffer.from([248, 255, 254]);
-var NoSubscriberBehavior = /* @__PURE__ */ ((NoSubscriberBehavior2) => {
-  NoSubscriberBehavior2["Pause"] = "pause";
-  NoSubscriberBehavior2["Play"] = "play";
-  NoSubscriberBehavior2["Stop"] = "stop";
+var NoSubscriberBehavior = /* @__PURE__ */ (NoSubscriberBehavior2 => {
+  NoSubscriberBehavior2.Pause = 'pause';
+  NoSubscriberBehavior2.Play = 'play';
+  NoSubscriberBehavior2.Stop = 'stop';
   return NoSubscriberBehavior2;
 })(NoSubscriberBehavior || {});
-var AudioPlayerStatus = /* @__PURE__ */ ((AudioPlayerStatus2) => {
-  AudioPlayerStatus2["Idle"] = "idle";
-  AudioPlayerStatus2["Buffering"] = "buffering";
-  AudioPlayerStatus2["Paused"] = "paused";
-  AudioPlayerStatus2["Playing"] = "playing";
-  AudioPlayerStatus2["AutoPaused"] = "autopaused";
+var AudioPlayerStatus = /* @__PURE__ */ (AudioPlayerStatus2 => {
+  AudioPlayerStatus2.Idle = 'idle';
+  AudioPlayerStatus2.Buffering = 'buffering';
+  AudioPlayerStatus2.Paused = 'paused';
+  AudioPlayerStatus2.Playing = 'playing';
+  AudioPlayerStatus2.AutoPaused = 'autopaused';
   return AudioPlayerStatus2;
 })(AudioPlayerStatus || {});
 function stringifyState2(state) {
   return JSON.stringify({
     ...state,
-    resource: Reflect.has(state, "resource"),
-    stepTimeout: Reflect.has(state, "stepTimeout")
+    resource: Reflect.has(state, 'resource'),
+    stepTimeout: Reflect.has(state, 'stepTimeout'),
   });
 }
-__name(stringifyState2, "stringifyState");
+__name(stringifyState2, 'stringifyState');
 var AudioPlayer = class extends import_tiny_typed_emitter4.TypedEmitter {
   constructor(options = {}) {
     super();
-    __publicField(this, "_state");
-    __publicField(this, "subscribers", []);
-    __publicField(this, "behaviors");
-    __publicField(this, "debug");
-    this._state = { status: "idle" /* Idle */ };
+    this.subscribers = [];
+    this._state = { status: 'idle' /* Idle */ };
     this.behaviors = {
-      noSubscriber: "pause" /* Pause */,
+      noSubscriber: 'pause' /* Pause */,
       maxMissedFrames: 5,
-      ...options.behaviors
+      ...options.behaviors,
     };
-    this.debug = options.debug === false ? null : (message) => this.emit("debug", message);
+    this.debug = options.debug === false ? null : message => this.emit('debug', message);
   }
   get playable() {
-    return this.subscribers.filter(({ connection }) => connection.state.status === "ready" /* Ready */).map(({ connection }) => connection);
+    return this.subscribers
+      .filter(({ connection }) => connection.state.status === 'ready' /* Ready */)
+      .map(({ connection }) => connection);
   }
   subscribe(connection) {
-    const existingSubscription = this.subscribers.find((subscription) => subscription.connection === connection);
+    const existingSubscription = this.subscribers.find(subscription => subscription.connection === connection);
     if (!existingSubscription) {
       const subscription = new PlayerSubscription(connection, this);
       this.subscribers.push(subscription);
-      setImmediate(() => this.emit("subscribe", subscription));
+      setImmediate(() => this.emit('subscribe', subscription));
       return subscription;
     }
     return existingSubscription;
@@ -901,7 +864,7 @@ var AudioPlayer = class extends import_tiny_typed_emitter4.TypedEmitter {
     if (exists) {
       this.subscribers.splice(index, 1);
       subscription.connection.setSpeaking(false);
-      this.emit("unsubscribe", subscription);
+      this.emit('unsubscribe', subscription);
     }
     return exists;
   }
@@ -910,30 +873,36 @@ var AudioPlayer = class extends import_tiny_typed_emitter4.TypedEmitter {
   }
   set state(newState) {
     const oldState = this._state;
-    const newResource = Reflect.get(newState, "resource");
-    if (oldState.status !== "idle" /* Idle */ && oldState.resource !== newResource) {
-      oldState.resource.playStream.on("error", noop);
-      oldState.resource.playStream.off("error", oldState.onStreamError);
+    const newResource = Reflect.get(newState, 'resource');
+    if (oldState.status !== 'idle' /* Idle */ && oldState.resource !== newResource) {
+      oldState.resource.playStream.on('error', noop);
+      oldState.resource.playStream.off('error', oldState.onStreamError);
       oldState.resource.audioPlayer = void 0;
       oldState.resource.playStream.destroy();
       oldState.resource.playStream.read();
     }
-    if (oldState.status === "buffering" /* Buffering */ && (newState.status !== "buffering" /* Buffering */ || newState.resource !== oldState.resource)) {
-      oldState.resource.playStream.off("end", oldState.onFailureCallback);
-      oldState.resource.playStream.off("close", oldState.onFailureCallback);
-      oldState.resource.playStream.off("finish", oldState.onFailureCallback);
-      oldState.resource.playStream.off("readable", oldState.onReadableCallback);
+    if (
+      oldState.status === 'buffering' /* Buffering */ &&
+      (newState.status !== 'buffering' /* Buffering */ || newState.resource !== oldState.resource)
+    ) {
+      oldState.resource.playStream.off('end', oldState.onFailureCallback);
+      oldState.resource.playStream.off('close', oldState.onFailureCallback);
+      oldState.resource.playStream.off('finish', oldState.onFailureCallback);
+      oldState.resource.playStream.off('readable', oldState.onReadableCallback);
     }
-    if (newState.status === "idle" /* Idle */) {
+    if (newState.status === 'idle' /* Idle */) {
       this._signalStopSpeaking();
       deleteAudioPlayer(this);
     }
     if (newResource) {
       addAudioPlayer(this);
     }
-    const didChangeResources = oldState.status !== "idle" /* Idle */ && newState.status === "playing" /* Playing */ && oldState.resource !== newState.resource;
+    const didChangeResources =
+      oldState.status !== 'idle' /* Idle */ &&
+      newState.status === 'playing' /* Playing */ &&
+      oldState.resource !== newState.resource;
     this._state = newState;
-    this.emit("stateChange", oldState, this._state);
+    this.emit('stateChange', oldState, this._state);
     if (oldState.status !== newState.status || didChangeResources) {
       this.emit(newState.status, oldState, this._state);
     }
@@ -943,92 +912,89 @@ to ${stringifyState2(newState)}`);
   }
   play(resource) {
     if (resource.ended) {
-      throw new Error("Cannot play a resource that has already ended.");
+      throw new Error('Cannot play a resource that has already ended.');
     }
     if (resource.audioPlayer) {
       if (resource.audioPlayer === this) {
         return;
       }
-      throw new Error("Resource is already being played by another audio player.");
+      throw new Error('Resource is already being played by another audio player.');
     }
     resource.audioPlayer = this;
-    const onStreamError = /* @__PURE__ */ __name((error) => {
-      if (this.state.status !== "idle" /* Idle */) {
-        this.emit("error", new AudioPlayerError(error, this.state.resource));
+    const onStreamError = /* @__PURE__ */ __name(error => {
+      if (this.state.status !== 'idle' /* Idle */) {
+        this.emit('error', new AudioPlayerError(error, this.state.resource));
       }
-      if (this.state.status !== "idle" /* Idle */ && this.state.resource === resource) {
+      if (this.state.status !== 'idle' /* Idle */ && this.state.resource === resource) {
         this.state = {
-          status: "idle" /* Idle */
+          status: 'idle' /* Idle */,
         };
       }
-    }, "onStreamError");
-    resource.playStream.once("error", onStreamError);
+    }, 'onStreamError');
+    resource.playStream.once('error', onStreamError);
     if (resource.started) {
       this.state = {
-        status: "playing" /* Playing */,
+        status: 'playing' /* Playing */,
         missedFrames: 0,
         playbackDuration: 0,
         resource,
-        onStreamError
+        onStreamError,
       };
     } else {
       const onReadableCallback = /* @__PURE__ */ __name(() => {
-        if (this.state.status === "buffering" /* Buffering */ && this.state.resource === resource) {
+        if (this.state.status === 'buffering' /* Buffering */ && this.state.resource === resource) {
           this.state = {
-            status: "playing" /* Playing */,
+            status: 'playing' /* Playing */,
             missedFrames: 0,
             playbackDuration: 0,
             resource,
-            onStreamError
+            onStreamError,
           };
         }
-      }, "onReadableCallback");
+      }, 'onReadableCallback');
       const onFailureCallback = /* @__PURE__ */ __name(() => {
-        if (this.state.status === "buffering" /* Buffering */ && this.state.resource === resource) {
+        if (this.state.status === 'buffering' /* Buffering */ && this.state.resource === resource) {
           this.state = {
-            status: "idle" /* Idle */
+            status: 'idle' /* Idle */,
           };
         }
-      }, "onFailureCallback");
-      resource.playStream.once("readable", onReadableCallback);
-      resource.playStream.once("end", onFailureCallback);
-      resource.playStream.once("close", onFailureCallback);
-      resource.playStream.once("finish", onFailureCallback);
+      }, 'onFailureCallback');
+      resource.playStream.once('readable', onReadableCallback);
+      resource.playStream.once('end', onFailureCallback);
+      resource.playStream.once('close', onFailureCallback);
+      resource.playStream.once('finish', onFailureCallback);
       this.state = {
-        status: "buffering" /* Buffering */,
+        status: 'buffering' /* Buffering */,
         resource,
         onReadableCallback,
         onFailureCallback,
-        onStreamError
+        onStreamError,
       };
     }
   }
   pause(interpolateSilence = true) {
-    if (this.state.status !== "playing" /* Playing */)
-      return false;
+    if (this.state.status !== 'playing' /* Playing */) return false;
     this.state = {
       ...this.state,
-      status: "paused" /* Paused */,
-      silencePacketsRemaining: interpolateSilence ? 5 : 0
+      status: 'paused' /* Paused */,
+      silencePacketsRemaining: interpolateSilence ? 5 : 0,
     };
     return true;
   }
   unpause() {
-    if (this.state.status !== "paused" /* Paused */)
-      return false;
+    if (this.state.status !== 'paused' /* Paused */) return false;
     this.state = {
       ...this.state,
-      status: "playing" /* Playing */,
-      missedFrames: 0
+      status: 'playing' /* Playing */,
+      missedFrames: 0,
     };
     return true;
   }
   stop(force = false) {
-    if (this.state.status === "idle" /* Idle */)
-      return false;
+    if (this.state.status === 'idle' /* Idle */) return false;
     if (force || this.state.resource.silencePaddingFrames === 0) {
       this.state = {
-        status: "idle" /* Idle */
+        status: 'idle' /* Idle */,
       };
     } else if (this.state.resource.silenceRemaining === -1) {
       this.state.resource.silenceRemaining = this.state.resource.silencePaddingFrames;
@@ -1037,11 +1003,10 @@ to ${stringifyState2(newState)}`);
   }
   checkPlayable() {
     const state = this._state;
-    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */)
-      return false;
+    if (state.status === 'idle' /* Idle */ || state.status === 'buffering' /* Buffering */) return false;
     if (!state.resource.readable) {
       this.state = {
-        status: "idle" /* Idle */
+        status: 'idle' /* Idle */,
       };
       return false;
     }
@@ -1049,23 +1014,21 @@ to ${stringifyState2(newState)}`);
   }
   _stepDispatch() {
     const state = this._state;
-    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */)
-      return;
-    this.playable.forEach((connection) => connection.dispatchAudio());
+    if (state.status === 'idle' /* Idle */ || state.status === 'buffering' /* Buffering */) return;
+    this.playable.forEach(connection => connection.dispatchAudio());
   }
   _stepPrepare() {
     const state = this._state;
-    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */)
-      return;
+    if (state.status === 'idle' /* Idle */ || state.status === 'buffering' /* Buffering */) return;
     const playable = this.playable;
-    if (state.status === "autopaused" /* AutoPaused */ && playable.length > 0) {
+    if (state.status === 'autopaused' /* AutoPaused */ && playable.length > 0) {
       this.state = {
         ...state,
-        status: "playing" /* Playing */,
-        missedFrames: 0
+        status: 'playing' /* Playing */,
+        missedFrames: 0,
       };
     }
-    if (state.status === "paused" /* Paused */ || state.status === "autopaused" /* AutoPaused */) {
+    if (state.status === 'paused' /* Paused */ || state.status === 'autopaused' /* AutoPaused */) {
       if (state.silencePacketsRemaining > 0) {
         state.silencePacketsRemaining--;
         this._preparePacket(SILENCE_FRAME, playable, state);
@@ -1076,19 +1039,19 @@ to ${stringifyState2(newState)}`);
       return;
     }
     if (playable.length === 0) {
-      if (this.behaviors.noSubscriber === "pause" /* Pause */) {
+      if (this.behaviors.noSubscriber === 'pause' /* Pause */) {
         this.state = {
           ...state,
-          status: "autopaused" /* AutoPaused */,
-          silencePacketsRemaining: 5
+          status: 'autopaused' /* AutoPaused */,
+          silencePacketsRemaining: 5,
         };
         return;
-      } else if (this.behaviors.noSubscriber === "stop" /* Stop */) {
+      } else if (this.behaviors.noSubscriber === 'stop' /* Stop */) {
         this.stop(true);
       }
     }
     const packet = state.resource.read();
-    if (state.status === "playing" /* Playing */) {
+    if (state.status === 'playing' /* Playing */) {
       if (packet) {
         this._preparePacket(packet, playable, state);
         state.missedFrames = 0;
@@ -1106,43 +1069,45 @@ to ${stringifyState2(newState)}`);
   }
   _preparePacket(packet, receivers, state) {
     state.playbackDuration += 20;
-    receivers.forEach((connection) => connection.prepareAudioPacket(packet));
+    receivers.forEach(connection => connection.prepareAudioPacket(packet));
   }
 };
-__name(AudioPlayer, "AudioPlayer");
+__name(AudioPlayer, 'AudioPlayer');
 function createAudioPlayer(options) {
   return new AudioPlayer(options);
 }
-__name(createAudioPlayer, "createAudioPlayer");
+__name(createAudioPlayer, 'createAudioPlayer');
 
-// src/receive/AudioReceiveStream.ts
-var EndBehaviorType = /* @__PURE__ */ ((EndBehaviorType2) => {
-  EndBehaviorType2[EndBehaviorType2["Manual"] = 0] = "Manual";
-  EndBehaviorType2[EndBehaviorType2["AfterSilence"] = 1] = "AfterSilence";
-  EndBehaviorType2[EndBehaviorType2["AfterInactivity"] = 2] = "AfterInactivity";
+// Src/receive/AudioReceiveStream.ts
+var EndBehaviorType = /* @__PURE__ */ (EndBehaviorType2 => {
+  EndBehaviorType2[(EndBehaviorType2.Manual = 0)] = 'Manual';
+  EndBehaviorType2[(EndBehaviorType2.AfterSilence = 1)] = 'AfterSilence';
+  EndBehaviorType2[(EndBehaviorType2.AfterInactivity = 2)] = 'AfterInactivity';
   return EndBehaviorType2;
 })(EndBehaviorType || {});
 function createDefaultAudioReceiveStreamOptions() {
   return {
     end: {
-      behavior: 0 /* Manual */
-    }
+      behavior: 0 /* Manual */,
+    },
   };
 }
-__name(createDefaultAudioReceiveStreamOptions, "createDefaultAudioReceiveStreamOptions");
+__name(createDefaultAudioReceiveStreamOptions, 'createDefaultAudioReceiveStreamOptions');
 var AudioReceiveStream = class extends import_node_stream.Readable {
   constructor({ end, ...options }) {
     super({
       ...options,
-      objectMode: true
+      objectMode: true,
     });
-    __publicField(this, "end");
-    __publicField(this, "endTimeout");
     this.end = end;
   }
   push(buffer) {
     if (buffer) {
-      if (this.end.behavior === 2 /* AfterInactivity */ || this.end.behavior === 1 /* AfterSilence */ && (buffer.compare(SILENCE_FRAME) !== 0 || typeof this.endTimeout === "undefined")) {
+      if (
+        this.end.behavior === 2 /* AfterInactivity */ ||
+        (this.end.behavior === 1 /* AfterSilence */ &&
+          (buffer.compare(SILENCE_FRAME) !== 0 || typeof this.endTimeout === 'undefined'))
+      ) {
         this.renewEndTimeout(this.end);
       }
     }
@@ -1154,32 +1119,29 @@ var AudioReceiveStream = class extends import_node_stream.Readable {
     }
     this.endTimeout = setTimeout(() => this.push(null), end.duration);
   }
-  _read() {
-  }
+  _read() {}
 };
-__name(AudioReceiveStream, "AudioReceiveStream");
+__name(AudioReceiveStream, 'AudioReceiveStream');
 
-// src/receive/SSRCMap.ts
-var import_tiny_typed_emitter5 = require("tiny-typed-emitter");
+// Src/receive/SSRCMap.ts
+var import_tiny_typed_emitter5 = require('tiny-typed-emitter');
 var SSRCMap = class extends import_tiny_typed_emitter5.TypedEmitter {
   constructor() {
     super();
-    __publicField(this, "map");
     this.map = /* @__PURE__ */ new Map();
   }
   update(data) {
     const existing = this.map.get(data.audioSSRC);
     const newValue = {
       ...this.map.get(data.audioSSRC),
-      ...data
+      ...data,
     };
     this.map.set(data.audioSSRC, newValue);
-    if (!existing)
-      this.emit("create", newValue);
-    this.emit("update", existing, newValue);
+    if (!existing) this.emit('create', newValue);
+    this.emit('update', existing, newValue);
   }
   get(target) {
-    if (typeof target === "number") {
+    if (typeof target === 'number') {
       return this.map.get(target);
     }
     for (const data of this.map.values()) {
@@ -1190,33 +1152,31 @@ var SSRCMap = class extends import_tiny_typed_emitter5.TypedEmitter {
     return void 0;
   }
   delete(target) {
-    if (typeof target === "number") {
+    if (typeof target === 'number') {
       const existing = this.map.get(target);
       if (existing) {
         this.map.delete(target);
-        this.emit("delete", existing);
+        this.emit('delete', existing);
       }
       return existing;
     }
     for (const [audioSSRC, data] of this.map.entries()) {
       if (data.userId === target) {
         this.map.delete(audioSSRC);
-        this.emit("delete", data);
+        this.emit('delete', data);
         return data;
       }
     }
     return void 0;
   }
 };
-__name(SSRCMap, "SSRCMap");
+__name(SSRCMap, 'SSRCMap');
 
-// src/receive/SpeakingMap.ts
-var import_tiny_typed_emitter6 = require("tiny-typed-emitter");
+// Src/receive/SpeakingMap.ts
+var import_tiny_typed_emitter6 = require('tiny-typed-emitter');
 var _SpeakingMap = class extends import_tiny_typed_emitter6.TypedEmitter {
   constructor() {
     super();
-    __publicField(this, "users");
-    __publicField(this, "speakingTimeouts");
     this.users = /* @__PURE__ */ new Map();
     this.speakingTimeouts = /* @__PURE__ */ new Map();
   }
@@ -1226,30 +1186,28 @@ var _SpeakingMap = class extends import_tiny_typed_emitter6.TypedEmitter {
       clearTimeout(timeout);
     } else {
       this.users.set(userId, Date.now());
-      this.emit("start", userId);
+      this.emit('start', userId);
     }
     this.startTimeout(userId);
   }
   startTimeout(userId) {
-    this.speakingTimeouts.set(userId, setTimeout(() => {
-      this.emit("end", userId);
-      this.speakingTimeouts.delete(userId);
-      this.users.delete(userId);
-    }, _SpeakingMap.DELAY));
+    this.speakingTimeouts.set(
+      userId,
+      setTimeout(() => {
+        this.emit('end', userId);
+        this.speakingTimeouts.delete(userId);
+        this.users.delete(userId);
+      }, _SpeakingMap.DELAY),
+    );
   }
 };
 var SpeakingMap = _SpeakingMap;
-__name(SpeakingMap, "SpeakingMap");
-__publicField(SpeakingMap, "DELAY", 100);
+__name(SpeakingMap, 'SpeakingMap');
+SpeakingMap.DELAY = 100;
 
-// src/receive/VoiceReceiver.ts
+// Src/receive/VoiceReceiver.ts
 var VoiceReceiver = class {
   constructor(voiceConnection) {
-    __publicField(this, "voiceConnection");
-    __publicField(this, "ssrcMap");
-    __publicField(this, "subscriptions");
-    __publicField(this, "connectionData");
-    __publicField(this, "speaking");
     this.voiceConnection = voiceConnection;
     this.ssrcMap = new SSRCMap();
     this.speaking = new SpeakingMap();
@@ -1259,116 +1217,115 @@ var VoiceReceiver = class {
     this.onUdpMessage = this.onUdpMessage.bind(this);
   }
   onWsPacket(packet) {
-    if (packet.op === import_v43.VoiceOpcodes.ClientDisconnect && typeof packet.d?.user_id === "string") {
+    if (packet.op === import_v43.VoiceOpcodes.ClientDisconnect && typeof packet.d?.user_id === 'string') {
       this.ssrcMap.delete(packet.d.user_id);
-    } else if (packet.op === import_v43.VoiceOpcodes.Speaking && typeof packet.d?.user_id === "string" && typeof packet.d?.ssrc === "number") {
+    } else if (
+      packet.op === import_v43.VoiceOpcodes.Speaking &&
+      typeof packet.d?.user_id === 'string' &&
+      typeof packet.d?.ssrc === 'number'
+    ) {
       this.ssrcMap.update({ userId: packet.d.user_id, audioSSRC: packet.d.ssrc });
-    } else if (packet.op === import_v43.VoiceOpcodes.ClientConnect && typeof packet.d?.user_id === "string" && typeof packet.d?.audio_ssrc === "number") {
+    } else if (
+      packet.op === import_v43.VoiceOpcodes.ClientConnect &&
+      typeof packet.d?.user_id === 'string' &&
+      typeof packet.d?.audio_ssrc === 'number'
+    ) {
       this.ssrcMap.update({
         userId: packet.d.user_id,
         audioSSRC: packet.d.audio_ssrc,
-        videoSSRC: packet.d.video_ssrc === 0 ? void 0 : packet.d.video_ssrc
+        videoSSRC: packet.d.video_ssrc === 0 ? void 0 : packet.d.video_ssrc,
       });
     }
   }
   decrypt(buffer, mode, nonce2, secretKey) {
     let end;
-    if (mode === "xsalsa20_poly1305_lite") {
+    if (mode === 'xsalsa20_poly1305_lite') {
       buffer.copy(nonce2, 0, buffer.length - 4);
       end = buffer.length - 4;
-    } else if (mode === "xsalsa20_poly1305_suffix") {
+    } else if (mode === 'xsalsa20_poly1305_suffix') {
       buffer.copy(nonce2, 0, buffer.length - 24);
       end = buffer.length - 24;
     } else {
       buffer.copy(nonce2, 0, 0, 12);
     }
     const decrypted = methods.open(buffer.slice(12, end), nonce2, secretKey);
-    if (!decrypted)
-      return;
+    if (!decrypted) return;
     return Buffer.from(decrypted);
   }
   parsePacket(buffer, mode, nonce2, secretKey) {
     let packet = this.decrypt(buffer, mode, nonce2, secretKey);
-    if (!packet)
-      return;
+    if (!packet) return;
     if (packet[0] === 190 && packet[1] === 222 && packet.length > 4) {
       const headerExtensionLength = packet.readUInt16BE(2);
       let offset = 4;
       for (let i = 0; i < headerExtensionLength; i++) {
         const byte2 = packet[offset];
         offset++;
-        if (byte2 === 0)
-          continue;
+        if (byte2 === 0) continue;
         offset += 1 + (byte2 >> 4);
       }
       const byte = packet.readUInt8(offset);
-      if (byte === 0 || byte === 2)
-        offset++;
+      if (byte === 0 || byte === 2) offset++;
       packet = packet.slice(offset);
     }
     return packet;
   }
   onUdpMessage(msg) {
-    if (msg.length <= 8)
-      return;
+    if (msg.length <= 8) return;
     const ssrc = msg.readUInt32BE(8);
     const userData = this.ssrcMap.get(ssrc);
-    if (!userData)
-      return;
+    if (!userData) return;
     this.speaking.onPacket(userData.userId);
     const stream = this.subscriptions.get(userData.userId);
-    if (!stream)
-      return;
+    if (!stream) return;
     if (this.connectionData.encryptionMode && this.connectionData.nonceBuffer && this.connectionData.secretKey) {
-      const packet = this.parsePacket(msg, this.connectionData.encryptionMode, this.connectionData.nonceBuffer, this.connectionData.secretKey);
+      const packet = this.parsePacket(
+        msg,
+        this.connectionData.encryptionMode,
+        this.connectionData.nonceBuffer,
+        this.connectionData.secretKey,
+      );
       if (packet) {
         stream.push(packet);
       } else {
-        stream.destroy(new Error("Failed to parse packet"));
+        stream.destroy(new Error('Failed to parse packet'));
       }
     }
   }
   subscribe(userId, options) {
     const existing = this.subscriptions.get(userId);
-    if (existing)
-      return existing;
+    if (existing) return existing;
     const stream = new AudioReceiveStream({
       ...createDefaultAudioReceiveStreamOptions(),
-      ...options
+      ...options,
     });
-    stream.once("close", () => this.subscriptions.delete(userId));
+    stream.once('close', () => this.subscriptions.delete(userId));
     this.subscriptions.set(userId, stream);
     return stream;
   }
 };
-__name(VoiceReceiver, "VoiceReceiver");
+__name(VoiceReceiver, 'VoiceReceiver');
 
-// src/VoiceConnection.ts
-var VoiceConnectionStatus = /* @__PURE__ */ ((VoiceConnectionStatus2) => {
-  VoiceConnectionStatus2["Signalling"] = "signalling";
-  VoiceConnectionStatus2["Connecting"] = "connecting";
-  VoiceConnectionStatus2["Ready"] = "ready";
-  VoiceConnectionStatus2["Disconnected"] = "disconnected";
-  VoiceConnectionStatus2["Destroyed"] = "destroyed";
+// Src/VoiceConnection.ts
+var VoiceConnectionStatus = /* @__PURE__ */ (VoiceConnectionStatus2 => {
+  VoiceConnectionStatus2.Signalling = 'signalling';
+  VoiceConnectionStatus2.Connecting = 'connecting';
+  VoiceConnectionStatus2.Ready = 'ready';
+  VoiceConnectionStatus2.Disconnected = 'disconnected';
+  VoiceConnectionStatus2.Destroyed = 'destroyed';
   return VoiceConnectionStatus2;
 })(VoiceConnectionStatus || {});
-var VoiceConnectionDisconnectReason = /* @__PURE__ */ ((VoiceConnectionDisconnectReason2) => {
-  VoiceConnectionDisconnectReason2[VoiceConnectionDisconnectReason2["WebSocketClose"] = 0] = "WebSocketClose";
-  VoiceConnectionDisconnectReason2[VoiceConnectionDisconnectReason2["AdapterUnavailable"] = 1] = "AdapterUnavailable";
-  VoiceConnectionDisconnectReason2[VoiceConnectionDisconnectReason2["EndpointRemoved"] = 2] = "EndpointRemoved";
-  VoiceConnectionDisconnectReason2[VoiceConnectionDisconnectReason2["Manual"] = 3] = "Manual";
+var VoiceConnectionDisconnectReason = /* @__PURE__ */ (VoiceConnectionDisconnectReason2 => {
+  VoiceConnectionDisconnectReason2[(VoiceConnectionDisconnectReason2.WebSocketClose = 0)] = 'WebSocketClose';
+  VoiceConnectionDisconnectReason2[(VoiceConnectionDisconnectReason2.AdapterUnavailable = 1)] = 'AdapterUnavailable';
+  VoiceConnectionDisconnectReason2[(VoiceConnectionDisconnectReason2.EndpointRemoved = 2)] = 'EndpointRemoved';
+  VoiceConnectionDisconnectReason2[(VoiceConnectionDisconnectReason2.Manual = 3)] = 'Manual';
   return VoiceConnectionDisconnectReason2;
 })(VoiceConnectionDisconnectReason || {});
 var VoiceConnection2 = class extends import_tiny_typed_emitter7.TypedEmitter {
   constructor(joinConfig, { debug, adapterCreator }) {
     super();
-    __publicField(this, "rejoinAttempts");
-    __publicField(this, "_state");
-    __publicField(this, "joinConfig");
-    __publicField(this, "packets");
-    __publicField(this, "receiver");
-    __publicField(this, "debug");
-    this.debug = debug ? (message) => this.emit("debug", message) : null;
+    this.debug = debug ? message => this.emit('debug', message) : null;
     this.rejoinAttempts = 0;
     this.receiver = new VoiceReceiver(this);
     this.onNetworkingClose = this.onNetworkingClose.bind(this);
@@ -1376,14 +1333,14 @@ var VoiceConnection2 = class extends import_tiny_typed_emitter7.TypedEmitter {
     this.onNetworkingError = this.onNetworkingError.bind(this);
     this.onNetworkingDebug = this.onNetworkingDebug.bind(this);
     const adapter = adapterCreator({
-      onVoiceServerUpdate: (data) => this.addServerPacket(data),
-      onVoiceStateUpdate: (data) => this.addStatePacket(data),
-      destroy: () => this.destroy(false)
+      onVoiceServerUpdate: data => this.addServerPacket(data),
+      onVoiceStateUpdate: data => this.addStatePacket(data),
+      destroy: () => this.destroy(false),
     });
-    this._state = { status: "signalling" /* Signalling */, adapter };
+    this._state = { status: 'signalling' /* Signalling */, adapter };
     this.packets = {
       server: void 0,
-      state: void 0
+      state: void 0,
     };
     this.joinConfig = joinConfig;
   }
@@ -1392,38 +1349,36 @@ var VoiceConnection2 = class extends import_tiny_typed_emitter7.TypedEmitter {
   }
   set state(newState) {
     const oldState = this._state;
-    const oldNetworking = Reflect.get(oldState, "networking");
-    const newNetworking = Reflect.get(newState, "networking");
-    const oldSubscription = Reflect.get(oldState, "subscription");
-    const newSubscription = Reflect.get(newState, "subscription");
+    const oldNetworking = Reflect.get(oldState, 'networking');
+    const newNetworking = Reflect.get(newState, 'networking');
+    const oldSubscription = Reflect.get(oldState, 'subscription');
+    const newSubscription = Reflect.get(newState, 'subscription');
     if (oldNetworking !== newNetworking) {
       if (oldNetworking) {
-        oldNetworking.on("error", noop);
-        oldNetworking.off("debug", this.onNetworkingDebug);
-        oldNetworking.off("error", this.onNetworkingError);
-        oldNetworking.off("close", this.onNetworkingClose);
-        oldNetworking.off("stateChange", this.onNetworkingStateChange);
+        oldNetworking.on('error', noop);
+        oldNetworking.off('debug', this.onNetworkingDebug);
+        oldNetworking.off('error', this.onNetworkingError);
+        oldNetworking.off('close', this.onNetworkingClose);
+        oldNetworking.off('stateChange', this.onNetworkingStateChange);
         oldNetworking.destroy();
       }
-      if (newNetworking)
-        this.updateReceiveBindings(newNetworking.state, oldNetworking?.state);
+      if (newNetworking) this.updateReceiveBindings(newNetworking.state, oldNetworking?.state);
     }
-    if (newState.status === "ready" /* Ready */) {
+    if (newState.status === 'ready' /* Ready */) {
       this.rejoinAttempts = 0;
-    } else if (newState.status === "destroyed" /* Destroyed */) {
+    } else if (newState.status === 'destroyed' /* Destroyed */) {
       for (const stream of this.receiver.subscriptions.values()) {
-        if (!stream.destroyed)
-          stream.destroy();
+        if (!stream.destroyed) stream.destroy();
       }
     }
-    if (oldState.status !== "destroyed" /* Destroyed */ && newState.status === "destroyed" /* Destroyed */) {
+    if (oldState.status !== 'destroyed' /* Destroyed */ && newState.status === 'destroyed' /* Destroyed */) {
       oldState.adapter.destroy();
     }
     this._state = newState;
     if (oldSubscription && oldSubscription !== newSubscription) {
       oldSubscription.unsubscribe();
     }
-    this.emit("stateChange", oldState, newState);
+    this.emit('stateChange', oldState, newState);
     if (oldState.status !== newState.status) {
       this.emit(newState.status, oldState, newState);
     }
@@ -1432,130 +1387,123 @@ var VoiceConnection2 = class extends import_tiny_typed_emitter7.TypedEmitter {
     this.packets.server = packet;
     if (packet.endpoint) {
       this.configureNetworking();
-    } else if (this.state.status !== "destroyed" /* Destroyed */) {
+    } else if (this.state.status !== 'destroyed' /* Destroyed */) {
       this.state = {
         ...this.state,
-        status: "disconnected" /* Disconnected */,
-        reason: 2 /* EndpointRemoved */
+        status: 'disconnected' /* Disconnected */,
+        reason: 2 /* EndpointRemoved */,
       };
     }
   }
   addStatePacket(packet) {
     this.packets.state = packet;
-    if (typeof packet.self_deaf !== "undefined")
-      this.joinConfig.selfDeaf = packet.self_deaf;
-    if (typeof packet.self_mute !== "undefined")
-      this.joinConfig.selfMute = packet.self_mute;
-    if (packet.channel_id)
-      this.joinConfig.channelId = packet.channel_id;
+    if (typeof packet.self_deaf !== 'undefined') this.joinConfig.selfDeaf = packet.self_deaf;
+    if (typeof packet.self_mute !== 'undefined') this.joinConfig.selfMute = packet.self_mute;
+    if (packet.channel_id) this.joinConfig.channelId = packet.channel_id;
   }
   updateReceiveBindings(newState, oldState) {
-    const oldWs = Reflect.get(oldState ?? {}, "ws");
-    const newWs = Reflect.get(newState, "ws");
-    const oldUdp = Reflect.get(oldState ?? {}, "udp");
-    const newUdp = Reflect.get(newState, "udp");
+    const oldWs = Reflect.get(oldState ?? {}, 'ws');
+    const newWs = Reflect.get(newState, 'ws');
+    const oldUdp = Reflect.get(oldState ?? {}, 'udp');
+    const newUdp = Reflect.get(newState, 'udp');
     if (oldWs !== newWs) {
-      oldWs?.off("packet", this.receiver.onWsPacket);
-      newWs?.on("packet", this.receiver.onWsPacket);
+      oldWs?.off('packet', this.receiver.onWsPacket);
+      newWs?.on('packet', this.receiver.onWsPacket);
     }
     if (oldUdp !== newUdp) {
-      oldUdp?.off("message", this.receiver.onUdpMessage);
-      newUdp?.on("message", this.receiver.onUdpMessage);
+      oldUdp?.off('message', this.receiver.onUdpMessage);
+      newUdp?.on('message', this.receiver.onUdpMessage);
     }
-    this.receiver.connectionData = Reflect.get(newState, "connectionData") ?? {};
+    this.receiver.connectionData = Reflect.get(newState, 'connectionData') ?? {};
   }
   configureNetworking() {
     const { server, state } = this.packets;
-    if (!server || !state || this.state.status === "destroyed" /* Destroyed */ || !server.endpoint)
-      return;
-    const networking = new Networking({
-      endpoint: server.endpoint,
-      serverId: server.guild_id,
-      token: server.token,
-      sessionId: state.session_id,
-      userId: state.user_id
-    }, Boolean(this.debug));
-    networking.once("close", this.onNetworkingClose);
-    networking.on("stateChange", this.onNetworkingStateChange);
-    networking.on("error", this.onNetworkingError);
-    networking.on("debug", this.onNetworkingDebug);
+    if (!server || !state || this.state.status === 'destroyed' /* Destroyed */ || !server.endpoint) return;
+    const networking = new Networking(
+      {
+        endpoint: server.endpoint,
+        serverId: server.guild_id,
+        token: server.token,
+        sessionId: state.session_id,
+        userId: state.user_id,
+      },
+      Boolean(this.debug),
+    );
+    networking.once('close', this.onNetworkingClose);
+    networking.on('stateChange', this.onNetworkingStateChange);
+    networking.on('error', this.onNetworkingError);
+    networking.on('debug', this.onNetworkingDebug);
     this.state = {
       ...this.state,
-      status: "connecting" /* Connecting */,
-      networking
+      status: 'connecting' /* Connecting */,
+      networking,
     };
   }
   onNetworkingClose(code) {
-    if (this.state.status === "destroyed" /* Destroyed */)
-      return;
+    if (this.state.status === 'destroyed' /* Destroyed */) return;
     if (code === 4014) {
       this.state = {
         ...this.state,
-        status: "disconnected" /* Disconnected */,
+        status: 'disconnected' /* Disconnected */,
         reason: 0 /* WebSocketClose */,
-        closeCode: code
+        closeCode: code,
       };
     } else {
       this.state = {
         ...this.state,
-        status: "signalling" /* Signalling */
+        status: 'signalling' /* Signalling */,
       };
       this.rejoinAttempts++;
       if (!this.state.adapter.sendPayload(createJoinVoiceChannelPayload(this.joinConfig))) {
         this.state = {
           ...this.state,
-          status: "disconnected" /* Disconnected */,
-          reason: 1 /* AdapterUnavailable */
+          status: 'disconnected' /* Disconnected */,
+          reason: 1 /* AdapterUnavailable */,
         };
       }
     }
   }
   onNetworkingStateChange(oldState, newState) {
     this.updateReceiveBindings(newState, oldState);
-    if (oldState.code === newState.code)
-      return;
-    if (this.state.status !== "connecting" /* Connecting */ && this.state.status !== "ready" /* Ready */)
-      return;
+    if (oldState.code === newState.code) return;
+    if (this.state.status !== 'connecting' /* Connecting */ && this.state.status !== 'ready' /* Ready */) return;
     if (newState.code === 4 /* Ready */) {
       this.state = {
         ...this.state,
-        status: "ready" /* Ready */
+        status: 'ready' /* Ready */,
       };
     } else if (newState.code !== 6 /* Closed */) {
       this.state = {
         ...this.state,
-        status: "connecting" /* Connecting */
+        status: 'connecting' /* Connecting */,
       };
     }
   }
   onNetworkingError(error) {
-    this.emit("error", error);
+    this.emit('error', error);
   }
   onNetworkingDebug(message) {
     this.debug?.(`[NW] ${message}`);
   }
   prepareAudioPacket(buffer) {
     const state = this.state;
-    if (state.status !== "ready" /* Ready */)
-      return;
+    if (state.status !== 'ready' /* Ready */) return;
     return state.networking.prepareAudioPacket(buffer);
   }
   dispatchAudio() {
     const state = this.state;
-    if (state.status !== "ready" /* Ready */)
-      return;
+    if (state.status !== 'ready' /* Ready */) return;
     return state.networking.dispatchAudio();
   }
   playOpusPacket(buffer) {
     const state = this.state;
-    if (state.status !== "ready" /* Ready */)
-      return;
+    if (state.status !== 'ready' /* Ready */) return;
     state.networking.prepareAudioPacket(buffer);
     return state.networking.dispatchAudio();
   }
   destroy(adapterAvailable = true) {
-    if (this.state.status === "destroyed" /* Destroyed */) {
-      throw new Error("Cannot destroy VoiceConnection - it has already been destroyed");
+    if (this.state.status === 'destroyed' /* Destroyed */) {
+      throw new Error('Cannot destroy VoiceConnection - it has already been destroyed');
     }
     if (getVoiceConnection(this.joinConfig.guildId, this.joinConfig.group) === this) {
       untrackVoiceConnection(this);
@@ -1564,11 +1512,11 @@ var VoiceConnection2 = class extends import_tiny_typed_emitter7.TypedEmitter {
       this.state.adapter.sendPayload(createJoinVoiceChannelPayload({ ...this.joinConfig, channelId: null }));
     }
     this.state = {
-      status: "destroyed" /* Destroyed */
+      status: 'destroyed' /* Destroyed */,
     };
   }
   disconnect() {
-    if (this.state.status === "destroyed" /* Destroyed */ || this.state.status === "signalling" /* Signalling */) {
+    if (this.state.status === 'destroyed' /* Destroyed */ || this.state.status === 'signalling' /* Signalling */) {
       return false;
     }
     this.joinConfig.channelId = null;
@@ -1576,31 +1524,30 @@ var VoiceConnection2 = class extends import_tiny_typed_emitter7.TypedEmitter {
       this.state = {
         adapter: this.state.adapter,
         subscription: this.state.subscription,
-        status: "disconnected" /* Disconnected */,
-        reason: 1 /* AdapterUnavailable */
+        status: 'disconnected' /* Disconnected */,
+        reason: 1 /* AdapterUnavailable */,
       };
       return false;
     }
     this.state = {
       adapter: this.state.adapter,
       reason: 3 /* Manual */,
-      status: "disconnected" /* Disconnected */
+      status: 'disconnected' /* Disconnected */,
     };
     return true;
   }
   rejoin(joinConfig) {
-    if (this.state.status === "destroyed" /* Destroyed */) {
+    if (this.state.status === 'destroyed' /* Destroyed */) {
       return false;
     }
-    const notReady = this.state.status !== "ready" /* Ready */;
-    if (notReady)
-      this.rejoinAttempts++;
+    const notReady = this.state.status !== 'ready'; /* Ready */
+    if (notReady) this.rejoinAttempts++;
     Object.assign(this.joinConfig, joinConfig);
     if (this.state.adapter.sendPayload(createJoinVoiceChannelPayload(this.joinConfig))) {
       if (notReady) {
         this.state = {
           ...this.state,
-          status: "signalling" /* Signalling */
+          status: 'signalling' /* Signalling */,
         };
       }
       return true;
@@ -1608,211 +1555,207 @@ var VoiceConnection2 = class extends import_tiny_typed_emitter7.TypedEmitter {
     this.state = {
       adapter: this.state.adapter,
       subscription: this.state.subscription,
-      status: "disconnected" /* Disconnected */,
-      reason: 1 /* AdapterUnavailable */
+      status: 'disconnected' /* Disconnected */,
+      reason: 1 /* AdapterUnavailable */,
     };
     return false;
   }
   setSpeaking(enabled) {
-    if (this.state.status !== "ready" /* Ready */)
-      return false;
+    if (this.state.status !== 'ready' /* Ready */) return false;
     return this.state.networking.setSpeaking(enabled);
   }
   subscribe(player) {
-    if (this.state.status === "destroyed" /* Destroyed */)
-      return;
-    const subscription = player["subscribe"](this);
+    if (this.state.status === 'destroyed' /* Destroyed */) return;
+    const subscription = player.subscribe(this);
     this.state = {
       ...this.state,
-      subscription
+      subscription,
     };
     return subscription;
   }
   get ping() {
-    if (this.state.status === "ready" /* Ready */ && this.state.networking.state.code === 4 /* Ready */) {
+    if (this.state.status === 'ready' /* Ready */ && this.state.networking.state.code === 4 /* Ready */) {
       return {
         ws: this.state.networking.state.ws.ping,
-        udp: this.state.networking.state.udp.ping
+        udp: this.state.networking.state.udp.ping,
       };
     }
     return {
       ws: void 0,
-      udp: void 0
+      udp: void 0,
     };
   }
   onSubscriptionRemoved(subscription) {
-    if (this.state.status !== "destroyed" /* Destroyed */ && this.state.subscription === subscription) {
+    if (this.state.status !== 'destroyed' /* Destroyed */ && this.state.subscription === subscription) {
       this.state = {
         ...this.state,
-        subscription: void 0
+        subscription: void 0,
       };
     }
   }
 };
-__name(VoiceConnection2, "VoiceConnection");
+__name(VoiceConnection2, 'VoiceConnection');
 function createVoiceConnection(joinConfig, options) {
   const payload = createJoinVoiceChannelPayload(joinConfig);
   const existing = getVoiceConnection(joinConfig.guildId, joinConfig.group);
-  if (existing && existing.state.status !== "destroyed" /* Destroyed */) {
-    if (existing.state.status === "disconnected" /* Disconnected */) {
+  if (existing && existing.state.status !== 'destroyed' /* Destroyed */) {
+    if (existing.state.status === 'disconnected' /* Disconnected */) {
       existing.rejoin({
         channelId: joinConfig.channelId,
         selfDeaf: joinConfig.selfDeaf,
-        selfMute: joinConfig.selfMute
+        selfMute: joinConfig.selfMute,
       });
     } else if (!existing.state.adapter.sendPayload(payload)) {
       existing.state = {
         ...existing.state,
-        status: "disconnected" /* Disconnected */,
-        reason: 1 /* AdapterUnavailable */
+        status: 'disconnected' /* Disconnected */,
+        reason: 1 /* AdapterUnavailable */,
       };
     }
     return existing;
   }
   const voiceConnection = new VoiceConnection2(joinConfig, options);
   trackVoiceConnection(voiceConnection);
-  if (voiceConnection.state.status !== "destroyed" /* Destroyed */) {
+  if (voiceConnection.state.status !== 'destroyed' /* Destroyed */) {
     if (!voiceConnection.state.adapter.sendPayload(payload)) {
       voiceConnection.state = {
         ...voiceConnection.state,
-        status: "disconnected" /* Disconnected */,
-        reason: 1 /* AdapterUnavailable */
+        status: 'disconnected' /* Disconnected */,
+        reason: 1 /* AdapterUnavailable */,
       };
     }
   }
   return voiceConnection;
 }
-__name(createVoiceConnection, "createVoiceConnection");
+__name(createVoiceConnection, 'createVoiceConnection');
 
-// src/joinVoiceChannel.ts
+// Src/joinVoiceChannel.ts
 function joinVoiceChannel(options) {
   const joinConfig = {
     selfDeaf: true,
     selfMute: false,
-    group: "default",
-    ...options
+    group: 'default',
+    ...options,
   };
   return createVoiceConnection(joinConfig, {
     adapterCreator: options.adapterCreator,
-    debug: options.debug
+    debug: options.debug,
   });
 }
-__name(joinVoiceChannel, "joinVoiceChannel");
+__name(joinVoiceChannel, 'joinVoiceChannel');
 
-// src/audio/AudioResource.ts
-var import_node_stream2 = require("stream");
-var import_prism_media2 = __toESM(require("prism-media"));
+// Src/audio/AudioResource.ts
+var import_prism_media2 = __toESM(require('prism-media'));
 
-// src/audio/TransformerGraph.ts
-var import_prism_media = __toESM(require("prism-media"));
-var FFMPEG_PCM_ARGUMENTS = ["-analyzeduration", "0", "-loglevel", "0", "-f", "s16le", "-ar", "48000", "-ac", "2"];
+// Src/audio/TransformerGraph.ts
+var import_prism_media = __toESM(require('prism-media'));
+var FFMPEG_PCM_ARGUMENTS = ['-analyzeduration', '0', '-loglevel', '0', '-f', 's16le', '-ar', '48000', '-ac', '2'];
 var FFMPEG_OPUS_ARGUMENTS = [
-  "-analyzeduration",
-  "0",
-  "-loglevel",
-  "0",
-  "-acodec",
-  "libopus",
-  "-f",
-  "opus",
-  "-ar",
-  "48000",
-  "-ac",
-  "2"
+  '-analyzeduration',
+  '0',
+  '-loglevel',
+  '0',
+  '-acodec',
+  'libopus',
+  '-f',
+  'opus',
+  '-ar',
+  '48000',
+  '-ac',
+  '2',
 ];
-var StreamType = /* @__PURE__ */ ((StreamType2) => {
-  StreamType2["Arbitrary"] = "arbitrary";
-  StreamType2["Raw"] = "raw";
-  StreamType2["OggOpus"] = "ogg/opus";
-  StreamType2["WebmOpus"] = "webm/opus";
-  StreamType2["Opus"] = "opus";
+var StreamType = /* @__PURE__ */ (StreamType2 => {
+  StreamType2.Arbitrary = 'arbitrary';
+  StreamType2.Raw = 'raw';
+  StreamType2.OggOpus = 'ogg/opus';
+  StreamType2.WebmOpus = 'webm/opus';
+  StreamType2.Opus = 'opus';
   return StreamType2;
 })(StreamType || {});
 var Node = class {
   constructor(type) {
-    __publicField(this, "edges", []);
-    __publicField(this, "type");
+    this.edges = [];
     this.type = type;
   }
   addEdge(edge) {
     this.edges.push({ ...edge, from: this });
   }
 };
-__name(Node, "Node");
+__name(Node, 'Node');
 var NODES = /* @__PURE__ */ new Map();
 for (const streamType of Object.values(StreamType)) {
   NODES.set(streamType, new Node(streamType));
 }
 function getNode(type) {
   const node = NODES.get(type);
-  if (!node)
-    throw new Error(`Node type '${type}' does not exist!`);
+  if (!node) throw new Error(`Node type '${type}' does not exist!`);
   return node;
 }
-__name(getNode, "getNode");
-getNode("raw" /* Raw */).addEdge({
-  type: "opus encoder" /* OpusEncoder */,
-  to: getNode("opus" /* Opus */),
+__name(getNode, 'getNode');
+getNode('raw' /* Raw */).addEdge({
+  type: 'opus encoder' /* OpusEncoder */,
+  to: getNode('opus' /* Opus */),
   cost: 1.5,
-  transformer: () => new import_prism_media.default.opus.Encoder({ rate: 48e3, channels: 2, frameSize: 960 })
+  transformer: () => new import_prism_media.default.opus.Encoder({ rate: 48e3, channels: 2, frameSize: 960 }),
 });
-getNode("opus" /* Opus */).addEdge({
-  type: "opus decoder" /* OpusDecoder */,
-  to: getNode("raw" /* Raw */),
+getNode('opus' /* Opus */).addEdge({
+  type: 'opus decoder' /* OpusDecoder */,
+  to: getNode('raw' /* Raw */),
   cost: 1.5,
-  transformer: () => new import_prism_media.default.opus.Decoder({ rate: 48e3, channels: 2, frameSize: 960 })
+  transformer: () => new import_prism_media.default.opus.Decoder({ rate: 48e3, channels: 2, frameSize: 960 }),
 });
-getNode("ogg/opus" /* OggOpus */).addEdge({
-  type: "ogg/opus demuxer" /* OggOpusDemuxer */,
-  to: getNode("opus" /* Opus */),
+getNode('ogg/opus' /* OggOpus */).addEdge({
+  type: 'ogg/opus demuxer' /* OggOpusDemuxer */,
+  to: getNode('opus' /* Opus */),
   cost: 1,
-  transformer: () => new import_prism_media.default.opus.OggDemuxer()
+  transformer: () => new import_prism_media.default.opus.OggDemuxer(),
 });
-getNode("webm/opus" /* WebmOpus */).addEdge({
-  type: "webm/opus demuxer" /* WebmOpusDemuxer */,
-  to: getNode("opus" /* Opus */),
+getNode('webm/opus' /* WebmOpus */).addEdge({
+  type: 'webm/opus demuxer' /* WebmOpusDemuxer */,
+  to: getNode('opus' /* Opus */),
   cost: 1,
-  transformer: () => new import_prism_media.default.opus.WebmDemuxer()
+  transformer: () => new import_prism_media.default.opus.WebmDemuxer(),
 });
 var FFMPEG_PCM_EDGE = {
-  type: "ffmpeg pcm" /* FFmpegPCM */,
-  to: getNode("raw" /* Raw */),
+  type: 'ffmpeg pcm' /* FFmpegPCM */,
+  to: getNode('raw' /* Raw */),
   cost: 2,
-  transformer: (input) => new import_prism_media.default.FFmpeg({
-    args: typeof input === "string" ? ["-i", input, ...FFMPEG_PCM_ARGUMENTS] : FFMPEG_PCM_ARGUMENTS
-  })
+  transformer: input =>
+    new import_prism_media.default.FFmpeg({
+      args: typeof input === 'string' ? ['-i', input, ...FFMPEG_PCM_ARGUMENTS] : FFMPEG_PCM_ARGUMENTS,
+    }),
 };
-getNode("arbitrary" /* Arbitrary */).addEdge(FFMPEG_PCM_EDGE);
-getNode("ogg/opus" /* OggOpus */).addEdge(FFMPEG_PCM_EDGE);
-getNode("webm/opus" /* WebmOpus */).addEdge(FFMPEG_PCM_EDGE);
-getNode("raw" /* Raw */).addEdge({
-  type: "volume transformer" /* InlineVolume */,
-  to: getNode("raw" /* Raw */),
+getNode('arbitrary' /* Arbitrary */).addEdge(FFMPEG_PCM_EDGE);
+getNode('ogg/opus' /* OggOpus */).addEdge(FFMPEG_PCM_EDGE);
+getNode('webm/opus' /* WebmOpus */).addEdge(FFMPEG_PCM_EDGE);
+getNode('raw' /* Raw */).addEdge({
+  type: 'volume transformer' /* InlineVolume */,
+  to: getNode('raw' /* Raw */),
   cost: 0.5,
-  transformer: () => new import_prism_media.default.VolumeTransformer({ type: "s16le" })
+  transformer: () => new import_prism_media.default.VolumeTransformer({ type: 's16le' }),
 });
 function canEnableFFmpegOptimizations() {
   try {
-    return import_prism_media.default.FFmpeg.getInfo().output.includes("--enable-libopus");
-  } catch {
-  }
+    return import_prism_media.default.FFmpeg.getInfo().output.includes('--enable-libopus');
+  } catch {}
   return false;
 }
-__name(canEnableFFmpegOptimizations, "canEnableFFmpegOptimizations");
+__name(canEnableFFmpegOptimizations, 'canEnableFFmpegOptimizations');
 if (canEnableFFmpegOptimizations()) {
   const FFMPEG_OGG_EDGE = {
-    type: "ffmpeg ogg" /* FFmpegOgg */,
-    to: getNode("ogg/opus" /* OggOpus */),
+    type: 'ffmpeg ogg' /* FFmpegOgg */,
+    to: getNode('ogg/opus' /* OggOpus */),
     cost: 2,
-    transformer: (input) => new import_prism_media.default.FFmpeg({
-      args: typeof input === "string" ? ["-i", input, ...FFMPEG_OPUS_ARGUMENTS] : FFMPEG_OPUS_ARGUMENTS
-    })
+    transformer: input =>
+      new import_prism_media.default.FFmpeg({
+        args: typeof input === 'string' ? ['-i', input, ...FFMPEG_OPUS_ARGUMENTS] : FFMPEG_OPUS_ARGUMENTS,
+      }),
   };
-  getNode("arbitrary" /* Arbitrary */).addEdge(FFMPEG_OGG_EDGE);
-  getNode("ogg/opus" /* OggOpus */).addEdge(FFMPEG_OGG_EDGE);
-  getNode("webm/opus" /* WebmOpus */).addEdge(FFMPEG_OGG_EDGE);
+  getNode('arbitrary' /* Arbitrary */).addEdge(FFMPEG_OGG_EDGE);
+  getNode('ogg/opus' /* OggOpus */).addEdge(FFMPEG_OGG_EDGE);
+  getNode('webm/opus' /* WebmOpus */).addEdge(FFMPEG_OGG_EDGE);
 }
-function findPath(from, constraints, goal = getNode("opus" /* Opus */), path = [], depth = 5) {
+function findPath(from, constraints, goal = getNode('opus' /* Opus */), path = [], depth = 5) {
   if (from === goal && constraints(path)) {
     return { cost: 0 };
   } else if (depth === 0) {
@@ -1820,8 +1763,7 @@ function findPath(from, constraints, goal = getNode("opus" /* Opus */), path = [
   }
   let currentBest = void 0;
   for (const edge of from.edges) {
-    if (currentBest && edge.cost > currentBest.cost)
-      continue;
+    if (currentBest && edge.cost > currentBest.cost) continue;
     const next = findPath(edge.to, constraints, goal, [...path, edge], depth - 1);
     const cost = edge.cost + next.cost;
     if (!currentBest || cost < currentBest.cost) {
@@ -1830,7 +1772,7 @@ function findPath(from, constraints, goal = getNode("opus" /* Opus */), path = [
   }
   return currentBest ?? { cost: Infinity };
 }
-__name(findPath, "findPath");
+__name(findPath, 'findPath');
 function constructPipeline(step) {
   const edges = [];
   let current = step;
@@ -1840,25 +1782,18 @@ function constructPipeline(step) {
   }
   return edges;
 }
-__name(constructPipeline, "constructPipeline");
+__name(constructPipeline, 'constructPipeline');
 function findPipeline(from, constraint) {
   return constructPipeline(findPath(getNode(from), constraint));
 }
-__name(findPipeline, "findPipeline");
+__name(findPipeline, 'findPipeline');
 
-// src/audio/AudioResource.ts
+// Src/audio/AudioResource.ts
 var AudioResource = class {
   constructor(edges, streams, metadata, silencePaddingFrames) {
-    __publicField(this, "playStream");
-    __publicField(this, "edges");
-    __publicField(this, "metadata");
-    __publicField(this, "volume");
-    __publicField(this, "encoder");
-    __publicField(this, "audioPlayer");
-    __publicField(this, "playbackDuration", 0);
-    __publicField(this, "started", false);
-    __publicField(this, "silencePaddingFrames");
-    __publicField(this, "silenceRemaining", -1);
+    this.playbackDuration = 0;
+    this.started = false;
+    this.silenceRemaining = -1;
     this.edges = edges;
     this.playStream = streams.length > 1 ? (0, import_node_stream2.pipeline)(streams, noop) : streams[0];
     this.metadata = metadata;
@@ -1870,15 +1805,13 @@ var AudioResource = class {
         this.encoder = stream;
       }
     }
-    this.playStream.once("readable", () => this.started = true);
+    this.playStream.once('readable', () => (this.started = true));
   }
   get readable() {
-    if (this.silenceRemaining === 0)
-      return false;
+    if (this.silenceRemaining === 0) return false;
     const real = this.playStream.readable;
     if (!real) {
-      if (this.silenceRemaining === -1)
-        this.silenceRemaining = this.silencePaddingFrames;
+      if (this.silenceRemaining === -1) this.silenceRemaining = this.silencePaddingFrames;
       return this.silenceRemaining !== 0;
     }
     return real;
@@ -1900,118 +1833,118 @@ var AudioResource = class {
     return packet;
   }
 };
-__name(AudioResource, "AudioResource");
-var VOLUME_CONSTRAINT = /* @__PURE__ */ __name((path) => path.some((edge) => edge.type === "volume transformer" /* InlineVolume */), "VOLUME_CONSTRAINT");
-var NO_CONSTRAINT = /* @__PURE__ */ __name(() => true, "NO_CONSTRAINT");
+__name(AudioResource, 'AudioResource');
+var VOLUME_CONSTRAINT = /* @__PURE__ */ __name(
+  path => path.some(edge => edge.type === 'volume transformer' /* InlineVolume */),
+  'VOLUME_CONSTRAINT',
+);
+var NO_CONSTRAINT = /* @__PURE__ */ __name(() => true, 'NO_CONSTRAINT');
 function inferStreamType(stream) {
   if (stream instanceof import_prism_media2.default.opus.Encoder) {
-    return { streamType: "opus" /* Opus */, hasVolume: false };
+    return { streamType: 'opus' /* Opus */, hasVolume: false };
   } else if (stream instanceof import_prism_media2.default.opus.Decoder) {
-    return { streamType: "raw" /* Raw */, hasVolume: false };
+    return { streamType: 'raw' /* Raw */, hasVolume: false };
   } else if (stream instanceof import_prism_media2.default.VolumeTransformer) {
-    return { streamType: "raw" /* Raw */, hasVolume: true };
+    return { streamType: 'raw' /* Raw */, hasVolume: true };
   } else if (stream instanceof import_prism_media2.default.opus.OggDemuxer) {
-    return { streamType: "opus" /* Opus */, hasVolume: false };
+    return { streamType: 'opus' /* Opus */, hasVolume: false };
   } else if (stream instanceof import_prism_media2.default.opus.WebmDemuxer) {
-    return { streamType: "opus" /* Opus */, hasVolume: false };
+    return { streamType: 'opus' /* Opus */, hasVolume: false };
   }
-  return { streamType: "arbitrary" /* Arbitrary */, hasVolume: false };
+  return { streamType: 'arbitrary' /* Arbitrary */, hasVolume: false };
 }
-__name(inferStreamType, "inferStreamType");
+__name(inferStreamType, 'inferStreamType');
 function createAudioResource(input, options = {}) {
   let inputType = options.inputType;
   let needsInlineVolume = Boolean(options.inlineVolume);
-  if (typeof input === "string") {
-    inputType = "arbitrary" /* Arbitrary */;
-  } else if (typeof inputType === "undefined") {
+  if (typeof input === 'string') {
+    inputType = 'arbitrary';
+  } else if (typeof inputType === 'undefined') {
     const analysis = inferStreamType(input);
     inputType = analysis.streamType;
     needsInlineVolume = needsInlineVolume && !analysis.hasVolume;
   }
   const transformerPipeline = findPipeline(inputType, needsInlineVolume ? VOLUME_CONSTRAINT : NO_CONSTRAINT);
   if (transformerPipeline.length === 0) {
-    if (typeof input === "string")
-      throw new Error(`Invalid pipeline constructed for string resource '${input}'`);
+    if (typeof input === 'string') throw new Error(`Invalid pipeline constructed for string resource '${input}'`);
     return new AudioResource([], [input], options.metadata ?? null, options.silencePaddingFrames ?? 5);
   }
-  const streams = transformerPipeline.map((edge) => edge.transformer(input));
-  if (typeof input !== "string")
-    streams.unshift(input);
+  const streams = transformerPipeline.map(edge => edge.transformer(input));
+  if (typeof input !== 'string') streams.unshift(input);
   return new AudioResource(transformerPipeline, streams, options.metadata ?? null, options.silencePaddingFrames ?? 5);
 }
-__name(createAudioResource, "createAudioResource");
+__name(createAudioResource, 'createAudioResource');
 
-// src/util/generateDependencyReport.ts
-var import_node_path = require("path");
-var import_prism_media3 = __toESM(require("prism-media"));
+// Src/util/generateDependencyReport.ts
+var import_prism_media3 = __toESM(require('prism-media'));
 function findPackageJSON(dir, packageName, depth) {
-  if (depth === 0)
-    return void 0;
-  const attemptedPath = (0, import_node_path.resolve)(dir, "./package.json");
+  if (depth === 0) return void 0;
+  const attemptedPath = (0, import_node_path.resolve)(dir, './package.json');
   try {
     const pkg = require(attemptedPath);
-    if (pkg.name !== packageName)
-      throw new Error("package.json does not match");
+    if (pkg.name !== packageName) throw new Error('package.json does not match');
     return pkg;
   } catch (err) {
-    return findPackageJSON((0, import_node_path.resolve)(dir, ".."), packageName, depth - 1);
+    return findPackageJSON((0, import_node_path.resolve)(dir, '..'), packageName, depth - 1);
   }
 }
-__name(findPackageJSON, "findPackageJSON");
+__name(findPackageJSON, 'findPackageJSON');
 function version(name) {
   try {
-    const pkg = name === "@discordjs/voice" ? require_package() : findPackageJSON((0, import_node_path.dirname)(require.resolve(name)), name, 3);
-    return pkg?.version ?? "not found";
+    const pkg =
+      name === '@discordjs/voice'
+        ? require_package()
+        : findPackageJSON((0, import_node_path.dirname)(require.resolve(name)), name, 3);
+    return pkg?.version ?? 'not found';
   } catch (err) {
-    return "not found";
+    return 'not found';
   }
 }
-__name(version, "version");
+__name(version, 'version');
 function generateDependencyReport() {
   const report = [];
-  const addVersion = /* @__PURE__ */ __name((name) => report.push(`- ${name}: ${version(name)}`), "addVersion");
-  report.push("Core Dependencies");
-  addVersion("@discordjs/voice");
-  addVersion("prism-media");
-  report.push("");
-  report.push("Opus Libraries");
-  addVersion("@discordjs/opus");
-  addVersion("opusscript");
-  report.push("");
-  report.push("Encryption Libraries");
-  addVersion("sodium-native");
-  addVersion("sodium");
-  addVersion("libsodium-wrappers");
-  addVersion("tweetnacl");
-  report.push("");
-  report.push("FFmpeg");
+  const addVersion = /* @__PURE__ */ __name(name => report.push(`- ${name}: ${version(name)}`), 'addVersion');
+  report.push('Core Dependencies');
+  addVersion('@discordjs/voice');
+  addVersion('prism-media');
+  report.push('');
+  report.push('Opus Libraries');
+  addVersion('@discordjs/opus');
+  addVersion('opusscript');
+  report.push('');
+  report.push('Encryption Libraries');
+  addVersion('sodium-native');
+  addVersion('sodium');
+  addVersion('libsodium-wrappers');
+  addVersion('tweetnacl');
+  report.push('');
+  report.push('FFmpeg');
   try {
     const info = import_prism_media3.default.FFmpeg.getInfo();
     report.push(`- version: ${info.version}`);
-    report.push(`- libopus: ${info.output.includes("--enable-libopus") ? "yes" : "no"}`);
+    report.push(`- libopus: ${info.output.includes('--enable-libopus') ? 'yes' : 'no'}`);
   } catch (err) {
-    report.push("- not found");
+    report.push('- not found');
   }
-  return ["-".repeat(50), ...report, "-".repeat(50)].join("\n");
+  return ['-'.repeat(50), ...report, '-'.repeat(50)].join('\n');
 }
-__name(generateDependencyReport, "generateDependencyReport");
+__name(generateDependencyReport, 'generateDependencyReport');
 
-// src/util/entersState.ts
-var import_node_events = require("events");
+// Src/util/entersState.ts
 
-// src/util/abortAfter.ts
+// Src/util/abortAfter.ts
 function abortAfter(delay) {
   const ac = new AbortController();
   const timeout = setTimeout(() => ac.abort(), delay);
-  ac.signal.addEventListener("abort", () => clearTimeout(timeout));
+  ac.signal.addEventListener('abort', () => clearTimeout(timeout));
   return [ac, ac.signal];
 }
-__name(abortAfter, "abortAfter");
+__name(abortAfter, 'abortAfter');
 
-// src/util/entersState.ts
+// Src/util/entersState.ts
 async function entersState(target, status, timeoutOrSignal) {
   if (target.state.status !== status) {
-    const [ac, signal] = typeof timeoutOrSignal === "number" ? abortAfter(timeoutOrSignal) : [void 0, timeoutOrSignal];
+    const [ac, signal] = typeof timeoutOrSignal === 'number' ? abortAfter(timeoutOrSignal) : [void 0, timeoutOrSignal];
     try {
       await (0, import_node_events.once)(target, status, { signal });
     } finally {
@@ -2020,35 +1953,32 @@ async function entersState(target, status, timeoutOrSignal) {
   }
   return target;
 }
-__name(entersState, "entersState");
+__name(entersState, 'entersState');
 
-// src/util/demuxProbe.ts
-var import_node_stream3 = require("stream");
-var import_prism_media4 = __toESM(require("prism-media"));
+// Src/util/demuxProbe.ts
+var import_prism_media4 = __toESM(require('prism-media'));
 function validateDiscordOpusHead(opusHead) {
   const channels = opusHead.readUInt8(9);
   const sampleRate = opusHead.readUInt32LE(12);
   return channels === 2 && sampleRate === 48e3;
 }
-__name(validateDiscordOpusHead, "validateDiscordOpusHead");
+__name(validateDiscordOpusHead, 'validateDiscordOpusHead');
 function demuxProbe(stream, probeSize = 1024, validator = validateDiscordOpusHead) {
   return new Promise((resolve2, reject) => {
-    if (stream.readableObjectMode)
-      return reject(new Error("Cannot probe a readable stream in object mode"));
-    if (stream.readableEnded)
-      return reject(new Error("Cannot probe a stream that has ended"));
+    if (stream.readableObjectMode) return reject(new Error('Cannot probe a readable stream in object mode'));
+    if (stream.readableEnded) return reject(new Error('Cannot probe a stream that has ended'));
     let readBuffer = Buffer.alloc(0);
     let resolved = void 0;
-    const finish = /* @__PURE__ */ __name((type) => {
-      stream.off("data", onData);
-      stream.off("close", onClose);
-      stream.off("end", onClose);
+    const finish = /* @__PURE__ */ __name(type => {
+      stream.off('data', onData);
+      stream.off('close', onClose);
+      stream.off('end', onClose);
       stream.pause();
       resolved = type;
       if (stream.readableEnded) {
         resolve2({
           stream: import_node_stream3.Readable.from(readBuffer),
-          type
+          type,
         });
       } else {
         if (readBuffer.length > 0) {
@@ -2056,70 +1986,75 @@ function demuxProbe(stream, probeSize = 1024, validator = validateDiscordOpusHea
         }
         resolve2({
           stream,
-          type
+          type,
         });
       }
-    }, "finish");
-    const foundHead = /* @__PURE__ */ __name((type) => (head) => {
-      if (validator(head)) {
-        finish(type);
-      }
-    }, "foundHead");
+    }, 'finish');
+    const foundHead = /* @__PURE__ */ __name(
+      type => head => {
+        if (validator(head)) {
+          finish(type);
+        }
+      },
+      'foundHead',
+    );
     const webm = new import_prism_media4.default.opus.WebmDemuxer();
-    webm.once("error", noop);
-    webm.on("head", foundHead("webm/opus" /* WebmOpus */));
+    webm.once('error', noop);
+    webm.on('head', foundHead('webm/opus' /* WebmOpus */));
     const ogg = new import_prism_media4.default.opus.OggDemuxer();
-    ogg.once("error", noop);
-    ogg.on("head", foundHead("ogg/opus" /* OggOpus */));
+    ogg.once('error', noop);
+    ogg.on('head', foundHead('ogg/opus' /* OggOpus */));
     const onClose = /* @__PURE__ */ __name(() => {
       if (!resolved) {
-        finish("arbitrary" /* Arbitrary */);
+        finish('arbitrary' /* Arbitrary */);
       }
-    }, "onClose");
-    const onData = /* @__PURE__ */ __name((buffer) => {
+    }, 'onClose');
+    const onData = /* @__PURE__ */ __name(buffer => {
       readBuffer = Buffer.concat([readBuffer, buffer]);
       webm.write(buffer);
       ogg.write(buffer);
       if (readBuffer.length >= probeSize) {
-        stream.off("data", onData);
+        stream.off('data', onData);
         stream.pause();
         process.nextTick(onClose);
       }
-    }, "onData");
-    stream.once("error", reject);
-    stream.on("data", onData);
-    stream.once("close", onClose);
-    stream.once("end", onClose);
+    }, 'onData');
+    stream.once('error', reject);
+    stream.on('data', onData);
+    stream.once('close', onClose);
+    stream.once('end', onClose);
   });
 }
-__name(demuxProbe, "demuxProbe");
+__name(demuxProbe, 'demuxProbe');
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AudioPlayer,
-  AudioPlayerError,
-  AudioPlayerStatus,
-  AudioReceiveStream,
-  AudioResource,
-  EndBehaviorType,
-  NoSubscriberBehavior,
-  PlayerSubscription,
-  SSRCMap,
-  SpeakingMap,
-  StreamType,
-  VoiceConnection,
-  VoiceConnectionDisconnectReason,
-  VoiceConnectionStatus,
-  VoiceReceiver,
-  createAudioPlayer,
-  createAudioResource,
-  createDefaultAudioReceiveStreamOptions,
-  demuxProbe,
-  entersState,
-  generateDependencyReport,
-  getGroups,
-  getVoiceConnection,
-  getVoiceConnections,
-  joinVoiceChannel,
-  validateDiscordOpusHead
-});
-//# sourceMappingURL=index.js.map
\ No newline at end of file
+0 &&
+  (module.exports = {
+    AudioPlayer,
+    AudioPlayerError,
+    AudioPlayerStatus,
+    AudioReceiveStream,
+    AudioResource,
+    EndBehaviorType,
+    NoSubscriberBehavior,
+    PlayerSubscription,
+    SSRCMap,
+    SpeakingMap,
+    StreamType,
+    VoiceConnection,
+    VoiceConnectionDisconnectReason,
+    VoiceConnectionStatus,
+    VoiceReceiver,
+    Networking,
+    createAudioPlayer,
+    createAudioResource,
+    createDefaultAudioReceiveStreamOptions,
+    demuxProbe,
+    entersState,
+    generateDependencyReport,
+    getGroups,
+    getVoiceConnection,
+    getVoiceConnections,
+    joinVoiceChannel,
+    validateDiscordOpusHead,
+  });
+// # sourceMappingURL=index.js.map