From 547f9ca7c63ac36dfb4f843363cdb6c8343dc0ea Mon Sep 17 00:00:00 2001
From: Elysia <71698422+aiko-chan-ai@users.noreply.github.com>
Date: Sun, 7 Jan 2024 20:06:23 +0700
Subject: [PATCH] remove 2

---
 src/util/Voice.js | 1456 ---------------------------------------------
 1 file changed, 1456 deletions(-)
 delete mode 100644 src/util/Voice.js

diff --git a/src/util/Voice.js b/src/util/Voice.js
deleted file mode 100644
index 8861b88..00000000
--- a/src/util/Voice.js
+++ /dev/null
@@ -1,1456 +0,0 @@
-'use strict';
-var NoSubscriberBehavior2,
-  AudioPlayerStatus2,
-  EndBehaviorType2,
-  VoiceConnectionStatus2,
-  VoiceConnectionDisconnectReason2,
-  StreamType2,
-  audioCycleInterval,
-  __create = Object.create,
-  __defProp = Object.defineProperty,
-  __getOwnPropDesc = Object.getOwnPropertyDescriptor,
-  __getOwnPropNames = Object.getOwnPropertyNames,
-  __getProtoOf = Object.getPrototypeOf,
-  __hasOwnProp = Object.prototype.hasOwnProperty,
-  __defNormalProp = (e, t, s) =>
-    t in e ? __defProp(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : (e[t] = s),
-  __name = (e, t) => __defProp(e, 'name', { value: t, configurable: !0 }),
-  __export = (e, t) => {
-    for (var s in t) __defProp(e, s, { get: t[s], enumerable: !0 });
-  },
-  __copyProps = (e, t, s, i) => {
-    if ((t && 'object' == typeof t) || 'function' == typeof t)
-      for (let o of __getOwnPropNames(t))
-        __hasOwnProp.call(e, o) ||
-          o === s ||
-          __defProp(e, o, { get: () => t[o], enumerable: !(i = __getOwnPropDesc(t, o)) || i.enumerable });
-    return e;
-  },
-  __toESM = (e, t, s) => (
-    (s = null != e ? __create(__getProtoOf(e)) : {}),
-    __copyProps(!t && e && e.__esModule ? s : __defProp(s, 'default', { value: e, enumerable: !0 }), e)
-  ),
-  __toCommonJS = e => __copyProps(__defProp({}, '__esModule', { value: !0 }), e),
-  __publicField = (e, t, s) => (__defNormalProp(e, 'symbol' != typeof t ? t + '' : t, s), s),
-  src_exports = {};
-__export(src_exports, {
-  AudioPlayer: () => AudioPlayer,
-  AudioPlayerError: () => AudioPlayerError,
-  AudioPlayerStatus: () => AudioPlayerStatus,
-  AudioReceiveStream: () => AudioReceiveStream,
-  AudioResource: () => AudioResource,
-  EndBehaviorType: () => EndBehaviorType,
-  NoSubscriberBehavior: () => NoSubscriberBehavior,
-  PlayerSubscription: () => PlayerSubscription,
-  SSRCMap: () => SSRCMap,
-  SpeakingMap: () => SpeakingMap,
-  StreamType: () => StreamType,
-  VoiceConnection: () => VoiceConnection,
-  VoiceConnectionDisconnectReason: () => VoiceConnectionDisconnectReason,
-  VoiceConnectionStatus: () => VoiceConnectionStatus,
-  VoiceReceiver: () => VoiceReceiver,
-  createAudioPlayer: () => createAudioPlayer,
-  createAudioResource: () => createAudioResource,
-  createDefaultAudioReceiveStreamOptions: () => createDefaultAudioReceiveStreamOptions,
-  demuxProbe: () => demuxProbe,
-  entersState: () => entersState,
-  generateDependencyReport: () => generateDependencyReport,
-  getGroups: () => getGroups,
-  getVoiceConnection: () => getVoiceConnection,
-  getVoiceConnections: () => getVoiceConnections,
-  joinVoiceChannel: () => joinVoiceChannel,
-  validateDiscordOpusHead: () => validateDiscordOpusHead,
-  version: () => version2,
-}),
-  (module.exports = __toCommonJS(src_exports));
-var import_node_events7 = require('events'),
-  import_v10 = require('discord-api-types/v10');
-function createJoinVoiceChannelPayload(e) {
-  return {
-    op: import_v10.GatewayOpcodes.VoiceStateUpdate,
-    d: { guild_id: e.guildId, channel_id: e.channelId, self_deaf: e.selfDeaf, self_mute: e.selfMute },
-  };
-}
-__name(createJoinVoiceChannelPayload, 'createJoinVoiceChannelPayload');
-var groups = new Map();
-function getOrCreateGroup(e) {
-  let t = groups.get(e);
-  if (t) return t;
-  let s = new Map();
-  return groups.set(e, s), s;
-}
-function getGroups() {
-  return groups;
-}
-function getVoiceConnections(e = 'default') {
-  return groups.get(e);
-}
-function getVoiceConnection(e, t = 'default') {
-  return getVoiceConnections(t)?.get(e);
-}
-function untrackVoiceConnection(e) {
-  return getVoiceConnections(e.joinConfig.group)?.delete(e.joinConfig.guildId);
-}
-function trackVoiceConnection(e) {
-  return getOrCreateGroup(e.joinConfig.group).set(e.joinConfig.guildId, e);
-}
-groups.set('default', new Map()),
-  __name(getOrCreateGroup, 'getOrCreateGroup'),
-  __name(getGroups, 'getGroups'),
-  __name(getVoiceConnections, 'getVoiceConnections'),
-  __name(getVoiceConnection, 'getVoiceConnection'),
-  __name(untrackVoiceConnection, 'untrackVoiceConnection'),
-  __name(trackVoiceConnection, 'trackVoiceConnection');
-var FRAME_LENGTH = 20,
-  nextTime = -1,
-  audioPlayers = [];
-function audioCycleStep() {
-  if (-1 === nextTime) return;
-  nextTime += FRAME_LENGTH;
-  let e = audioPlayers.filter(e => e.checkPlayable());
-  for (let t of e) t._stepDispatch();
-  prepareNextAudioFrame(e);
-}
-function prepareNextAudioFrame(e) {
-  let t = e.shift();
-  if (!t) {
-    -1 !== nextTime && (audioCycleInterval = setTimeout(() => audioCycleStep(), nextTime - Date.now()));
-    return;
-  }
-  t._stepPrepare(), setImmediate(() => prepareNextAudioFrame(e));
-}
-function hasAudioPlayer(e) {
-  return audioPlayers.includes(e);
-}
-function addAudioPlayer(e) {
-  return (
-    hasAudioPlayer(e) ||
-      (audioPlayers.push(e),
-      1 === audioPlayers.length && ((nextTime = Date.now()), setImmediate(() => audioCycleStep()))),
-    e
-  );
-}
-function deleteAudioPlayer(e) {
-  let t = audioPlayers.indexOf(e);
-  -1 !== t &&
-    (audioPlayers.splice(t, 1),
-    0 === audioPlayers.length && ((nextTime = -1), void 0 !== audioCycleInterval && clearTimeout(audioCycleInterval)));
-}
-__name(audioCycleStep, 'audioCycleStep'),
-  __name(prepareNextAudioFrame, 'prepareNextAudioFrame'),
-  __name(hasAudioPlayer, 'hasAudioPlayer'),
-  __name(addAudioPlayer, 'addAudioPlayer'),
-  __name(deleteAudioPlayer, 'deleteAudioPlayer');
-var import_node_buffer3 = require('buffer'),
-  import_node_events3 = require('events'),
-  import_v42 = require('discord-api-types/voice/v4'),
-  import_node_buffer = require('buffer'),
-  libs = {
-    'sodium-native': e => ({
-      open(t, s, i) {
-        if (t) {
-          let o = import_node_buffer.Buffer.allocUnsafe(t.length - e.crypto_box_MACBYTES);
-          if (e.crypto_secretbox_open_easy(o, t, s, i)) return o;
-        }
-        return null;
-      },
-      close(t, s, i) {
-        let o = import_node_buffer.Buffer.allocUnsafe(t.length + e.crypto_box_MACBYTES);
-        return e.crypto_secretbox_easy(o, t, s, i), o;
-      },
-      random: (t, s = import_node_buffer.Buffer.allocUnsafe(t)) => (e.randombytes_buf(s), s),
-    }),
-    sodium: e => ({
-      open: e.api.crypto_secretbox_open_easy,
-      close: e.api.crypto_secretbox_easy,
-      random: (t, s = import_node_buffer.Buffer.allocUnsafe(t)) => (e.api.randombytes_buf(s), s),
-    }),
-    'libsodium-wrappers': e => ({
-      open: e.crypto_secretbox_open_easy,
-      close: e.crypto_secretbox_easy,
-      random: e.randombytes_buf,
-    }),
-    tweetnacl: e => ({ open: e.secretbox.open, close: e.secretbox, random: e.randomBytes }),
-  },
-  fallbackError = __name(() => {
-    throw 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'),
-  methods = { open: fallbackError, close: fallbackError, random: fallbackError };
-(async () => {
-  for (let e of Object.keys(libs))
-    try {
-      let t = require(e);
-      'libsodium-wrappers' === e && t.ready && (await t.ready), Object.assign(methods, libs[e](t));
-      break;
-    } catch {}
-})();
-var noop = __name(() => {}, 'noop'),
-  import_node_buffer2 = require('buffer'),
-  import_node_dgram = require('dgram'),
-  import_node_events = require('events'),
-  import_node_net = require('net');
-function parseLocalPacket(e) {
-  let t = import_node_buffer2.Buffer.from(e),
-    s = t.slice(8, t.indexOf(0, 8)).toString('utf8');
-  if (!(0, import_node_net.isIPv4)(s)) throw Error('Malformed IP address');
-  let i = t.readUInt16BE(t.length - 2);
-  return { ip: s, port: i };
-}
-__name(parseLocalPacket, 'parseLocalPacket');
-var KEEP_ALIVE_INTERVAL = 5e3,
-  MAX_COUNTER_VALUE = 4294967296 - 1,
-  VoiceUDPSocket = class extends import_node_events.EventEmitter {
-    socket;
-    remote;
-    keepAliveCounter = 0;
-    keepAliveBuffer;
-    keepAliveInterval;
-    ping;
-    constructor(e) {
-      super(),
-        (this.socket = (0, import_node_dgram.createSocket)('udp4')),
-        this.socket.on('error', e => this.emit('error', e)),
-        this.socket.on('message', e => this.onMessage(e)),
-        this.socket.on('close', () => this.emit('close')),
-        (this.remote = e),
-        (this.keepAliveBuffer = import_node_buffer2.Buffer.alloc(8)),
-        (this.keepAliveInterval = setInterval(() => this.keepAlive(), KEEP_ALIVE_INTERVAL)),
-        setImmediate(() => this.keepAlive());
-    }
-    onMessage(e) {
-      this.emit('message', e);
-    }
-    keepAlive() {
-      this.keepAliveBuffer.writeUInt32LE(this.keepAliveCounter, 0),
-        this.send(this.keepAliveBuffer),
-        this.keepAliveCounter++,
-        this.keepAliveCounter > MAX_COUNTER_VALUE && (this.keepAliveCounter = 0);
-    }
-    send(e) {
-      this.socket.send(e, this.remote.port, this.remote.ip);
-    }
-    destroy() {
-      try {
-        this.socket.close();
-      } catch {}
-      clearInterval(this.keepAliveInterval);
-    }
-    async performIPDiscovery(e) {
-      return new Promise((t, s) => {
-        let i = __name(e => {
-          try {
-            if (2 !== e.readUInt16BE(0)) return;
-            let s = parseLocalPacket(e);
-            this.socket.off('message', i), t(s);
-          } catch {}
-        }, 'listener');
-        this.socket.on('message', i),
-          this.socket.once('close', () => s(Error('Cannot perform IP discovery - socket closed')));
-        let o = import_node_buffer2.Buffer.alloc(74);
-        o.writeUInt16BE(1, 0), o.writeUInt16BE(70, 2), o.writeUInt32BE(e, 4), this.send(o);
-      });
-    }
-  };
-__name(VoiceUDPSocket, 'VoiceUDPSocket');
-var import_node_events2 = require('events'),
-  import_v4 = require('discord-api-types/voice/v4'),
-  import_ws = __toESM(require('ws')),
-  VoiceWebSocket = class extends import_node_events2.EventEmitter {
-    heartbeatInterval;
-    lastHeartbeatAck;
-    lastHeartbeatSend;
-    missedHeartbeats = 0;
-    ping;
-    debug;
-    ws;
-    constructor(e, t) {
-      super(),
-        (this.ws = new import_ws.default(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 = t ? e => this.emit('debug', e) : null);
-    }
-    destroy() {
-      try {
-        this.debug?.('destroyed'), this.setHeartbeatInterval(-1), this.ws.close(1e3);
-      } catch (e) {
-        this.emit('error', e);
-      }
-    }
-    onMessage(e) {
-      if ('string' != typeof e.data) return;
-      this.debug?.(`<< ${e.data}`);
-      let t;
-      try {
-        t = JSON.parse(e.data);
-      } catch (s) {
-        this.emit('error', s);
-        return;
-      }
-      t.op === import_v4.VoiceOpcodes.HeartbeatAck &&
-        ((this.lastHeartbeatAck = Date.now()),
-        (this.missedHeartbeats = 0),
-        (this.ping = this.lastHeartbeatAck - this.lastHeartbeatSend)),
-        this.emit('packet', t);
-    }
-    sendPacket(e) {
-      try {
-        let t = JSON.stringify(e);
-        this.debug?.(`>> ${t}`), this.ws.send(t);
-        return;
-      } catch (s) {
-        this.emit('error', s);
-      }
-    }
-    sendHeartbeat() {
-      (this.lastHeartbeatSend = Date.now()), this.missedHeartbeats++;
-      let e = this.lastHeartbeatSend;
-      this.sendPacket({ op: import_v4.VoiceOpcodes.Heartbeat, d: e });
-    }
-    setHeartbeatInterval(e) {
-      void 0 !== this.heartbeatInterval && clearInterval(this.heartbeatInterval),
-        e > 0 &&
-          (this.heartbeatInterval = setInterval(() => {
-            0 !== this.lastHeartbeatSend &&
-              this.missedHeartbeats >= 3 &&
-              (this.ws.close(), this.setHeartbeatInterval(-1)),
-              this.sendHeartbeat();
-          }, e));
-    }
-  };
-__name(VoiceWebSocket, 'VoiceWebSocket');
-var CHANNELS = 2,
-  TIMESTAMP_INC = 480 * CHANNELS,
-  MAX_NONCE_SIZE = 4294967296 - 1,
-  SUPPORTED_ENCRYPTION_MODES = ['xsalsa20_poly1305_lite', 'xsalsa20_poly1305_suffix', 'xsalsa20_poly1305'],
-  nonce = import_node_buffer3.Buffer.alloc(24);
-function stringifyState(e) {
-  return JSON.stringify({ ...e, ws: Reflect.has(e, 'ws'), udp: Reflect.has(e, 'udp') });
-}
-function chooseEncryptionMode(e) {
-  let t = e.find(e => SUPPORTED_ENCRYPTION_MODES.includes(e));
-  if (!t) throw Error(`No compatible encryption modes. Available include: ${e.join(', ')}`);
-  return t;
-}
-function randomNBit(e) {
-  return Math.floor(Math.random() * 2 ** e);
-}
-__name(stringifyState, 'stringifyState'),
-  __name(chooseEncryptionMode, 'chooseEncryptionMode'),
-  __name(randomNBit, 'randomNBit');
-var Networking = class extends import_node_events3.EventEmitter {
-  _state;
-  debug;
-  constructor(e, t) {
-    super(),
-      (this.onWsOpen = this.onWsOpen.bind(this)),
-      (this.onChildError = this.onChildError.bind(this)),
-      (this.onWsPacket = this.onWsPacket.bind(this)),
-      (this.onWsClose = this.onWsClose.bind(this)),
-      (this.onWsDebug = this.onWsDebug.bind(this)),
-      (this.onUdpDebug = this.onUdpDebug.bind(this)),
-      (this.onUdpClose = this.onUdpClose.bind(this)),
-      (this.debug = t ? e => this.emit('debug', e) : null),
-      (this._state = { code: 0, ws: this.createWebSocket(e.endpoint), connectionOptions: e });
-  }
-  destroy() {
-    this.state = { code: 6 };
-  }
-  get state() {
-    return this._state;
-  }
-  set state(e) {
-    let t = Reflect.get(this._state, 'ws'),
-      s = Reflect.get(e, 'ws');
-    t &&
-      t !== s &&
-      (t.off('debug', this.onWsDebug),
-      t.on('error', noop),
-      t.off('error', this.onChildError),
-      t.off('open', this.onWsOpen),
-      t.off('packet', this.onWsPacket),
-      t.off('close', this.onWsClose),
-      t.destroy());
-    let i = Reflect.get(this._state, 'udp'),
-      o = Reflect.get(e, 'udp');
-    i &&
-      i !== o &&
-      (i.on('error', noop),
-      i.off('error', this.onChildError),
-      i.off('close', this.onUdpClose),
-      i.off('debug', this.onUdpDebug),
-      i.destroy());
-    let n = this._state;
-    (this._state = e),
-      this.emit('stateChange', n, e),
-      this.debug?.(`state change:
-from ${stringifyState(n)}
-to ${stringifyState(e)}`);
-  }
-  createWebSocket(e) {
-    let t = new VoiceWebSocket(`wss://${e}?v=4`, Boolean(this.debug));
-    return (
-      t.on('error', this.onChildError),
-      t.once('open', this.onWsOpen),
-      t.on('packet', this.onWsPacket),
-      t.once('close', this.onWsClose),
-      t.on('debug', this.onWsDebug),
-      t
-    );
-  }
-  onChildError(e) {
-    this.emit('error', e);
-  }
-  onWsOpen() {
-    if (0 === this.state.code) {
-      let e = {
-        op: import_v42.VoiceOpcodes.Identify,
-        d: {
-          server_id: this.state.connectionOptions.serverId,
-          user_id: this.state.connectionOptions.userId,
-          session_id: this.state.connectionOptions.sessionId,
-          token: this.state.connectionOptions.token,
-        },
-      };
-      this.state.ws.sendPacket(e), (this.state = { ...this.state, code: 1 });
-    } else if (5 === this.state.code) {
-      let t = {
-        op: import_v42.VoiceOpcodes.Resume,
-        d: {
-          server_id: this.state.connectionOptions.serverId,
-          session_id: this.state.connectionOptions.sessionId,
-          token: this.state.connectionOptions.token,
-        },
-      };
-      this.state.ws.sendPacket(t);
-    }
-  }
-  onWsClose({ code: e }) {
-    (4015 === e || e < 4e3) && 4 === this.state.code
-      ? (this.state = { ...this.state, code: 5, ws: this.createWebSocket(this.state.connectionOptions.endpoint) })
-      : 6 !== this.state.code && (this.destroy(), this.emit('close', e));
-  }
-  onUdpClose() {
-    4 === this.state.code &&
-      (this.state = { ...this.state, code: 5, ws: this.createWebSocket(this.state.connectionOptions.endpoint) });
-  }
-  onWsPacket(e) {
-    if (e.op === import_v42.VoiceOpcodes.Hello && 6 !== this.state.code)
-      this.state.ws.setHeartbeatInterval(e.d.heartbeat_interval);
-    else if (e.op === import_v42.VoiceOpcodes.Ready && 1 === this.state.code) {
-      let { ip: t, port: s, ssrc: i, modes: o } = e.d,
-        n = new VoiceUDPSocket({ ip: t, port: s });
-      n.on('error', this.onChildError),
-        n.on('debug', this.onUdpDebug),
-        n.once('close', this.onUdpClose),
-        n
-          .performIPDiscovery(i)
-          .then(e => {
-            2 === this.state.code &&
-              (this.state.ws.sendPacket({
-                op: import_v42.VoiceOpcodes.SelectProtocol,
-                d: { protocol: 'udp', data: { address: e.ip, port: e.port, mode: chooseEncryptionMode(o) } },
-              }),
-              (this.state = { ...this.state, code: 3 }));
-          })
-          .catch(e => this.emit('error', e)),
-        (this.state = { ...this.state, code: 2, udp: n, connectionData: { ssrc: i } });
-    } else if (e.op === import_v42.VoiceOpcodes.SessionDescription && 3 === this.state.code) {
-      let { mode: r, secret_key: a } = e.d;
-      this.state = {
-        ...this.state,
-        code: 4,
-        connectionData: {
-          ...this.state.connectionData,
-          encryptionMode: r,
-          secretKey: new Uint8Array(a),
-          sequence: randomNBit(16),
-          timestamp: randomNBit(32),
-          nonce: 0,
-          nonceBuffer: import_node_buffer3.Buffer.alloc(24),
-          speaking: !1,
-          packetsPlayed: 0,
-        },
-      };
-    } else
-      e.op === import_v42.VoiceOpcodes.Resumed &&
-        5 === this.state.code &&
-        ((this.state = { ...this.state, code: 4 }), (this.state.connectionData.speaking = !1));
-  }
-  onWsDebug(e) {
-    this.debug?.(`[WS] ${e}`);
-  }
-  onUdpDebug(e) {
-    this.debug?.(`[UDP] ${e}`);
-  }
-  prepareAudioPacket(e) {
-    let t = this.state;
-    if (4 === t.code) return (t.preparedPacket = this.createAudioPacket(e, t.connectionData)), t.preparedPacket;
-  }
-  dispatchAudio() {
-    let e = this.state;
-    return (
-      4 === e.code &&
-      void 0 !== e.preparedPacket &&
-      (this.playAudioPacket(e.preparedPacket), (e.preparedPacket = void 0), !0)
-    );
-  }
-  playAudioPacket(e) {
-    let t = this.state;
-    if (4 !== t.code) return;
-    let { connectionData: s } = t;
-    s.packetsPlayed++,
-      s.sequence++,
-      (s.timestamp += TIMESTAMP_INC),
-      s.sequence >= 65536 && (s.sequence = 0),
-      s.timestamp >= 4294967296 && (s.timestamp = 0),
-      this.setSpeaking(!0),
-      t.udp.send(e);
-  }
-  setSpeaking(e) {
-    let t = this.state;
-    4 === t.code &&
-      t.connectionData.speaking !== e &&
-      ((t.connectionData.speaking = e),
-      t.ws.sendPacket({
-        op: import_v42.VoiceOpcodes.Speaking,
-        d: { speaking: e ? 1 : 0, delay: 0, ssrc: t.connectionData.ssrc },
-      }));
-  }
-  createAudioPacket(e, t) {
-    let s = import_node_buffer3.Buffer.alloc(12);
-    (s[0] = 128), (s[1] = 120);
-    let { sequence: i, timestamp: o, ssrc: n } = t;
-    return (
-      s.writeUIntBE(i, 2, 2),
-      s.writeUIntBE(o, 4, 4),
-      s.writeUIntBE(n, 8, 4),
-      s.copy(nonce, 0, 0, 12),
-      import_node_buffer3.Buffer.concat([s, ...this.encryptOpusPacket(e, t)])
-    );
-  }
-  encryptOpusPacket(e, t) {
-    let { secretKey: s, encryptionMode: i } = t;
-    if ('xsalsa20_poly1305_lite' === i)
-      return (
-        t.nonce++,
-        t.nonce > MAX_NONCE_SIZE && (t.nonce = 0),
-        t.nonceBuffer.writeUInt32BE(t.nonce, 0),
-        [methods.close(e, t.nonceBuffer, s), t.nonceBuffer.slice(0, 4)]
-      );
-    if ('xsalsa20_poly1305_suffix' === i) {
-      let o = methods.random(24, t.nonceBuffer);
-      return [methods.close(e, o, s), o];
-    }
-    return [methods.close(e, nonce, s)];
-  }
-};
-__name(Networking, 'Networking');
-var import_node_buffer5 = require('buffer'),
-  import_v43 = require('discord-api-types/voice/v4'),
-  import_node_stream = require('stream'),
-  import_node_buffer4 = require('buffer'),
-  import_node_events4 = require('events'),
-  AudioPlayerError = class extends Error {
-    resource;
-    constructor(e, t) {
-      super(e.message), (this.resource = t), (this.name = e.name), (this.stack = e.stack);
-    }
-  };
-__name(AudioPlayerError, 'AudioPlayerError');
-var PlayerSubscription = class {
-  connection;
-  player;
-  constructor(e, t) {
-    (this.connection = e), (this.player = t);
-  }
-  unsubscribe() {
-    this.connection.onSubscriptionRemoved(this), this.player.unsubscribe(this);
-  }
-};
-__name(PlayerSubscription, 'PlayerSubscription');
-var SILENCE_FRAME = import_node_buffer4.Buffer.from([248, 255, 254]),
-  NoSubscriberBehavior =
-    (((NoSubscriberBehavior2 = NoSubscriberBehavior || {}).Pause = 'pause'),
-    (NoSubscriberBehavior2.Play = 'play'),
-    (NoSubscriberBehavior2.Stop = 'stop'),
-    NoSubscriberBehavior2),
-  AudioPlayerStatus =
-    (((AudioPlayerStatus2 = AudioPlayerStatus || {}).AutoPaused = 'autopaused'),
-    (AudioPlayerStatus2.Buffering = 'buffering'),
-    (AudioPlayerStatus2.Idle = 'idle'),
-    (AudioPlayerStatus2.Paused = 'paused'),
-    (AudioPlayerStatus2.Playing = 'playing'),
-    AudioPlayerStatus2);
-function stringifyState2(e) {
-  return JSON.stringify({ ...e, resource: Reflect.has(e, 'resource'), stepTimeout: Reflect.has(e, 'stepTimeout') });
-}
-__name(stringifyState2, 'stringifyState');
-var AudioPlayer = class extends import_node_events4.EventEmitter {
-  _state;
-  subscribers = [];
-  behaviors;
-  debug;
-  constructor(e = {}) {
-    super(),
-      (this._state = { status: 'idle' }),
-      (this.behaviors = { noSubscriber: 'pause', maxMissedFrames: 5, ...e.behaviors }),
-      (this.debug = !1 === e.debug ? null : e => this.emit('debug', e));
-  }
-  get playable() {
-    return this.subscribers.filter(({ connection: e }) => 'ready' === e.state.status).map(({ connection: e }) => e);
-  }
-  subscribe(e) {
-    let t = this.subscribers.find(t => t.connection === e);
-    if (!t) {
-      let s = new PlayerSubscription(e, this);
-      return this.subscribers.push(s), setImmediate(() => this.emit('subscribe', s)), s;
-    }
-    return t;
-  }
-  unsubscribe(e) {
-    let t = this.subscribers.indexOf(e),
-      s = -1 !== t;
-    return s && (this.subscribers.splice(t, 1), e.connection.setSpeaking(!1), this.emit('unsubscribe', e)), s;
-  }
-  get state() {
-    return this._state;
-  }
-  set state(e) {
-    let t = this._state,
-      s = Reflect.get(e, 'resource');
-    'idle' !== t.status &&
-      t.resource !== s &&
-      (t.resource.playStream.on('error', noop),
-      t.resource.playStream.off('error', t.onStreamError),
-      (t.resource.audioPlayer = void 0),
-      t.resource.playStream.destroy(),
-      t.resource.playStream.read()),
-      'buffering' === t.status &&
-        ('buffering' !== e.status || e.resource !== t.resource) &&
-        (t.resource.playStream.off('end', t.onFailureCallback),
-        t.resource.playStream.off('close', t.onFailureCallback),
-        t.resource.playStream.off('finish', t.onFailureCallback),
-        t.resource.playStream.off('readable', t.onReadableCallback)),
-      'idle' === e.status && (this._signalStopSpeaking(), deleteAudioPlayer(this)),
-      s && addAudioPlayer(this);
-    let i = 'idle' !== t.status && 'playing' === e.status && t.resource !== e.resource;
-    (this._state = e),
-      this.emit('stateChange', t, this._state),
-      (t.status !== e.status || i) && this.emit(e.status, t, this._state),
-      this.debug?.(`state change:
-from ${stringifyState2(t)}
-to ${stringifyState2(e)}`);
-  }
-  play(e) {
-    if (e.ended) throw Error('Cannot play a resource that has already ended.');
-    if (e.audioPlayer) {
-      if (e.audioPlayer === this) return;
-      throw Error('Resource is already being played by another audio player.');
-    }
-    e.audioPlayer = this;
-    let t = __name(t => {
-      'idle' !== this.state.status && this.emit('error', new AudioPlayerError(t, this.state.resource)),
-        'idle' !== this.state.status && this.state.resource === e && (this.state = { status: 'idle' });
-    }, 'onStreamError');
-    if ((e.playStream.once('error', t), e.started))
-      this.state = { status: 'playing', missedFrames: 0, playbackDuration: 0, resource: e, onStreamError: t };
-    else {
-      let s = __name(() => {
-          'buffering' === this.state.status &&
-            this.state.resource === e &&
-            (this.state = { status: 'playing', missedFrames: 0, playbackDuration: 0, resource: e, onStreamError: t });
-        }, 'onReadableCallback'),
-        i = __name(() => {
-          'buffering' === this.state.status && this.state.resource === e && (this.state = { status: 'idle' });
-        }, 'onFailureCallback');
-      e.playStream.once('readable', s),
-        e.playStream.once('end', i),
-        e.playStream.once('close', i),
-        e.playStream.once('finish', i),
-        (this.state = {
-          status: 'buffering',
-          resource: e,
-          onReadableCallback: s,
-          onFailureCallback: i,
-          onStreamError: t,
-        });
-    }
-  }
-  pause(e = !0) {
-    return (
-      'playing' === this.state.status &&
-      ((this.state = { ...this.state, status: 'paused', silencePacketsRemaining: e ? 5 : 0 }), !0)
-    );
-  }
-  unpause() {
-    return 'paused' === this.state.status && ((this.state = { ...this.state, status: 'playing', missedFrames: 0 }), !0);
-  }
-  stop(e = !1) {
-    return (
-      'idle' !== this.state.status &&
-      (e || 0 === this.state.resource.silencePaddingFrames
-        ? (this.state = { status: 'idle' })
-        : -1 === this.state.resource.silenceRemaining &&
-          (this.state.resource.silenceRemaining = this.state.resource.silencePaddingFrames),
-      !0)
-    );
-  }
-  checkPlayable() {
-    let e = this._state;
-    return (
-      'idle' !== e.status &&
-      'buffering' !== e.status &&
-      (!!e.resource.readable || ((this.state = { status: 'idle' }), !1))
-    );
-  }
-  _stepDispatch() {
-    let e = this._state;
-    if ('idle' !== e.status && 'buffering' !== e.status) for (let t of this.playable) t.dispatchAudio();
-  }
-  _stepPrepare() {
-    let e = this._state;
-    if ('idle' === e.status || 'buffering' === e.status) return;
-    let t = this.playable;
-    if (
-      ('autopaused' === e.status && t.length > 0 && (this.state = { ...e, status: 'playing', missedFrames: 0 }),
-      'paused' === e.status || 'autopaused' === e.status)
-    ) {
-      e.silencePacketsRemaining > 0 &&
-        (e.silencePacketsRemaining--,
-        this._preparePacket(SILENCE_FRAME, t, e),
-        0 === e.silencePacketsRemaining && this._signalStopSpeaking());
-      return;
-    }
-    if (0 === t.length) {
-      if ('pause' === this.behaviors.noSubscriber) {
-        this.state = { ...e, status: 'autopaused', silencePacketsRemaining: 5 };
-        return;
-      }
-      'stop' === this.behaviors.noSubscriber && this.stop(!0);
-    }
-    let s = e.resource.read();
-    'playing' === e.status &&
-      (s
-        ? (this._preparePacket(s, t, e), (e.missedFrames = 0))
-        : (this._preparePacket(SILENCE_FRAME, t, e),
-          e.missedFrames++,
-          e.missedFrames >= this.behaviors.maxMissedFrames && this.stop()));
-  }
-  _signalStopSpeaking() {
-    for (let { connection: e } of this.subscribers) e.setSpeaking(!1);
-  }
-  _preparePacket(e, t, s) {
-    for (let i of ((s.playbackDuration += 20), t)) i.prepareAudioPacket(e);
-  }
-};
-function createAudioPlayer(e) {
-  return new AudioPlayer(e);
-}
-__name(AudioPlayer, 'AudioPlayer'), __name(createAudioPlayer, 'createAudioPlayer');
-var EndBehaviorType =
-  (((EndBehaviorType2 = EndBehaviorType || {})[(EndBehaviorType2.Manual = 0)] = 'Manual'),
-  (EndBehaviorType2[(EndBehaviorType2.AfterSilence = 1)] = 'AfterSilence'),
-  (EndBehaviorType2[(EndBehaviorType2.AfterInactivity = 2)] = 'AfterInactivity'),
-  EndBehaviorType2);
-function createDefaultAudioReceiveStreamOptions() {
-  return { end: { behavior: 0 } };
-}
-__name(createDefaultAudioReceiveStreamOptions, 'createDefaultAudioReceiveStreamOptions');
-var AudioReceiveStream = class extends import_node_stream.Readable {
-  end;
-  endTimeout;
-  constructor({ end: e, ...t }) {
-    super({ ...t, objectMode: !0 }), (this.end = e);
-  }
-  push(e) {
-    return (
-      e &&
-        (2 === this.end.behavior ||
-          (1 === this.end.behavior && (0 !== e.compare(SILENCE_FRAME) || void 0 === this.endTimeout))) &&
-        this.renewEndTimeout(this.end),
-      super.push(e)
-    );
-  }
-  renewEndTimeout(e) {
-    this.endTimeout && clearTimeout(this.endTimeout), (this.endTimeout = setTimeout(() => this.push(null), e.duration));
-  }
-  _read() {}
-};
-__name(AudioReceiveStream, 'AudioReceiveStream');
-var import_node_events5 = require('events'),
-  SSRCMap = class extends import_node_events5.EventEmitter {
-    map;
-    constructor() {
-      super(), (this.map = new Map());
-    }
-    update(e) {
-      let t = this.map.get(e.audioSSRC),
-        s = { ...this.map.get(e.audioSSRC), ...e };
-      this.map.set(e.audioSSRC, s), t || this.emit('create', s), this.emit('update', t, s);
-    }
-    get(e) {
-      if ('number' == typeof e) return this.map.get(e);
-      for (let t of this.map.values()) if (t.userId === e) return t;
-    }
-    delete(e) {
-      if ('number' == typeof e) {
-        let t = this.map.get(e);
-        return t && (this.map.delete(e), this.emit('delete', t)), t;
-      }
-      for (let [s, i] of this.map.entries()) if (i.userId === e) return this.map.delete(s), this.emit('delete', i), i;
-    }
-  };
-__name(SSRCMap, 'SSRCMap');
-var import_node_events6 = require('events'),
-  _SpeakingMap = class extends import_node_events6.EventEmitter {
-    users;
-    speakingTimeouts;
-    constructor() {
-      super(), (this.users = new Map()), (this.speakingTimeouts = new Map());
-    }
-    onPacket(e) {
-      let t = this.speakingTimeouts.get(e);
-      t ? clearTimeout(t) : (this.users.set(e, Date.now()), this.emit('start', e)), this.startTimeout(e);
-    }
-    startTimeout(e) {
-      this.speakingTimeouts.set(
-        e,
-        setTimeout(() => {
-          this.emit('end', e), this.speakingTimeouts.delete(e), this.users.delete(e);
-        }, _SpeakingMap.DELAY),
-      );
-    }
-  },
-  SpeakingMap = _SpeakingMap;
-__name(SpeakingMap, 'SpeakingMap'), __publicField(SpeakingMap, 'DELAY', 100);
-var VoiceReceiver = class {
-  voiceConnection;
-  ssrcMap;
-  subscriptions;
-  connectionData;
-  speaking;
-  constructor(e) {
-    (this.voiceConnection = e),
-      (this.ssrcMap = new SSRCMap()),
-      (this.speaking = new SpeakingMap()),
-      (this.subscriptions = new Map()),
-      (this.connectionData = {}),
-      (this.onWsPacket = this.onWsPacket.bind(this)),
-      (this.onUdpMessage = this.onUdpMessage.bind(this));
-  }
-  onWsPacket(e) {
-    e.op === import_v43.VoiceOpcodes.ClientDisconnect && 'string' == typeof e.d?.user_id
-      ? this.ssrcMap.delete(e.d.user_id)
-      : e.op === import_v43.VoiceOpcodes.Speaking && 'string' == typeof e.d?.user_id && 'number' == typeof e.d?.ssrc
-      ? this.ssrcMap.update({ userId: e.d.user_id, audioSSRC: e.d.ssrc })
-      : e.op === import_v43.VoiceOpcodes.ClientConnect &&
-        'string' == typeof e.d?.user_id &&
-        'number' == typeof e.d?.audio_ssrc &&
-        this.ssrcMap.update({
-          userId: e.d.user_id,
-          audioSSRC: e.d.audio_ssrc,
-          videoSSRC: 0 === e.d.video_ssrc ? void 0 : e.d.video_ssrc,
-        });
-  }
-  decrypt(e, t, s, i) {
-    let o;
-    'xsalsa20_poly1305_lite' === t
-      ? (e.copy(s, 0, e.length - 4), (o = e.length - 4))
-      : 'xsalsa20_poly1305_suffix' === t
-      ? (e.copy(s, 0, e.length - 24), (o = e.length - 24))
-      : e.copy(s, 0, 0, 12);
-    let n = methods.open(e.slice(12, o), s, i);
-    if (n) return import_node_buffer5.Buffer.from(n);
-  }
-  parsePacket(e, t, s, i) {
-    let o = this.decrypt(e, t, s, i);
-    if (o) {
-      if (190 === o[0] && 222 === o[1]) {
-        let n = o.readUInt16BE(2);
-        o = o.subarray(4 + 4 * n);
-      }
-      return o;
-    }
-  }
-  onUdpMessage(e) {
-    if (e.length <= 8) return;
-    let t = e.readUInt32BE(8),
-      s = this.ssrcMap.get(t);
-    if (!s) return;
-    this.speaking.onPacket(s.userId);
-    let i = this.subscriptions.get(s.userId);
-    if (i && this.connectionData.encryptionMode && this.connectionData.nonceBuffer && this.connectionData.secretKey) {
-      let o = this.parsePacket(
-        e,
-        this.connectionData.encryptionMode,
-        this.connectionData.nonceBuffer,
-        this.connectionData.secretKey,
-      );
-      o ? i.push(o) : i.destroy(Error('Failed to parse packet'));
-    }
-  }
-  subscribe(e, t) {
-    let s = this.subscriptions.get(e);
-    if (s) return s;
-    let i = new AudioReceiveStream({ ...createDefaultAudioReceiveStreamOptions(), ...t });
-    return i.once('close', () => this.subscriptions.delete(e)), this.subscriptions.set(e, i), i;
-  }
-};
-__name(VoiceReceiver, 'VoiceReceiver');
-var VoiceConnectionStatus =
-    (((VoiceConnectionStatus2 = VoiceConnectionStatus || {}).Connecting = 'connecting'),
-    (VoiceConnectionStatus2.Destroyed = 'destroyed'),
-    (VoiceConnectionStatus2.Disconnected = 'disconnected'),
-    (VoiceConnectionStatus2.Ready = 'ready'),
-    (VoiceConnectionStatus2.Signalling = 'signalling'),
-    VoiceConnectionStatus2),
-  VoiceConnectionDisconnectReason =
-    (((VoiceConnectionDisconnectReason2 = VoiceConnectionDisconnectReason || {})[
-      (VoiceConnectionDisconnectReason2.WebSocketClose = 0)
-    ] = 'WebSocketClose'),
-    (VoiceConnectionDisconnectReason2[(VoiceConnectionDisconnectReason2.AdapterUnavailable = 1)] =
-      'AdapterUnavailable'),
-    (VoiceConnectionDisconnectReason2[(VoiceConnectionDisconnectReason2.EndpointRemoved = 2)] = 'EndpointRemoved'),
-    (VoiceConnectionDisconnectReason2[(VoiceConnectionDisconnectReason2.Manual = 3)] = 'Manual'),
-    VoiceConnectionDisconnectReason2),
-  VoiceConnection = class extends import_node_events7.EventEmitter {
-    rejoinAttempts;
-    _state;
-    joinConfig;
-    packets;
-    receiver;
-    debug;
-    constructor(e, t) {
-      super(),
-        (this.debug = t.debug ? e => this.emit('debug', e) : null),
-        (this.rejoinAttempts = 0),
-        (this.receiver = new VoiceReceiver(this)),
-        (this.onNetworkingClose = this.onNetworkingClose.bind(this)),
-        (this.onNetworkingStateChange = this.onNetworkingStateChange.bind(this)),
-        (this.onNetworkingError = this.onNetworkingError.bind(this)),
-        (this.onNetworkingDebug = this.onNetworkingDebug.bind(this));
-      let s = t.adapterCreator({
-        onVoiceServerUpdate: e => this.addServerPacket(e),
-        onVoiceStateUpdate: e => this.addStatePacket(e),
-        destroy: () => this.destroy(!1),
-      });
-      (this._state = { status: 'signalling', adapter: s }),
-        (this.packets = { server: void 0, state: void 0 }),
-        (this.joinConfig = e);
-    }
-    get state() {
-      return this._state;
-    }
-    set state(e) {
-      let t = this._state,
-        s = Reflect.get(t, 'networking'),
-        i = Reflect.get(e, 'networking'),
-        o = Reflect.get(t, 'subscription'),
-        n = Reflect.get(e, 'subscription');
-      if (
-        (s !== i &&
-          (s &&
-            (s.on('error', noop),
-            s.off('debug', this.onNetworkingDebug),
-            s.off('error', this.onNetworkingError),
-            s.off('close', this.onNetworkingClose),
-            s.off('stateChange', this.onNetworkingStateChange),
-            s.destroy()),
-          i && this.updateReceiveBindings(i.state, s?.state)),
-        'ready' === e.status)
-      )
-        this.rejoinAttempts = 0;
-      else if ('destroyed' === e.status) for (let r of this.receiver.subscriptions.values()) r.destroyed || r.destroy();
-      'destroyed' !== t.status && 'destroyed' === e.status && t.adapter.destroy(),
-        (this._state = e),
-        o && o !== n && o.unsubscribe(),
-        this.emit('stateChange', t, e),
-        t.status !== e.status && this.emit(e.status, t, e);
-    }
-    addServerPacket(e) {
-      (this.packets.server = e),
-        e.endpoint
-          ? this.configureNetworking()
-          : 'destroyed' !== this.state.status && (this.state = { ...this.state, status: 'disconnected', reason: 2 });
-    }
-    addStatePacket(e) {
-      (this.packets.state = e),
-        void 0 !== e.self_deaf && (this.joinConfig.selfDeaf = e.self_deaf),
-        void 0 !== e.self_mute && (this.joinConfig.selfMute = e.self_mute),
-        e.channel_id && (this.joinConfig.channelId = e.channel_id);
-    }
-    updateReceiveBindings(e, t) {
-      let s = Reflect.get(t ?? {}, 'ws'),
-        i = Reflect.get(e, 'ws'),
-        o = Reflect.get(t ?? {}, 'udp'),
-        n = Reflect.get(e, 'udp');
-      s !== i && (s?.off('packet', this.receiver.onWsPacket), i?.on('packet', this.receiver.onWsPacket)),
-        o !== n && (o?.off('message', this.receiver.onUdpMessage), n?.on('message', this.receiver.onUdpMessage)),
-        (this.receiver.connectionData = Reflect.get(e, 'connectionData') ?? {});
-    }
-    configureNetworking() {
-      let { server: e, state: t } = this.packets;
-      if (!e || !t || 'destroyed' === this.state.status || !e.endpoint) return;
-      let s = new Networking(
-        {
-          endpoint: e.endpoint,
-          serverId: e.guild_id ?? e.channel_id,
-          token: e.token,
-          sessionId: t.session_id,
-          userId: t.user_id,
-        },
-        Boolean(this.debug),
-      );
-      s.once('close', this.onNetworkingClose),
-        s.on('stateChange', this.onNetworkingStateChange),
-        s.on('error', this.onNetworkingError),
-        s.on('debug', this.onNetworkingDebug),
-        (this.state = { ...this.state, status: 'connecting', networking: s });
-    }
-    onNetworkingClose(e) {
-      'destroyed' === this.state.status ||
-        (4014 === e
-          ? (this.state = { ...this.state, status: 'disconnected', reason: 0, closeCode: e })
-          : ((this.state = { ...this.state, status: 'signalling' }),
-            this.rejoinAttempts++,
-            this.state.adapter.sendPayload(createJoinVoiceChannelPayload(this.joinConfig)) ||
-              (this.state = { ...this.state, status: 'disconnected', reason: 1 })));
-    }
-    onNetworkingStateChange(e, t) {
-      this.updateReceiveBindings(t, e),
-        e.code !== t.code &&
-          ('connecting' === this.state.status || 'ready' === this.state.status) &&
-          (4 === t.code
-            ? (this.state = { ...this.state, status: 'ready' })
-            : 6 !== t.code && (this.state = { ...this.state, status: 'connecting' }));
-    }
-    onNetworkingError(e) {
-      this.emit('error', e);
-    }
-    onNetworkingDebug(e) {
-      this.debug?.(`[NW] ${e}`);
-    }
-    prepareAudioPacket(e) {
-      let t = this.state;
-      if ('ready' === t.status) return t.networking.prepareAudioPacket(e);
-    }
-    dispatchAudio() {
-      let e = this.state;
-      if ('ready' === e.status) return e.networking.dispatchAudio();
-    }
-    playOpusPacket(e) {
-      let t = this.state;
-      if ('ready' === t.status) return t.networking.prepareAudioPacket(e), t.networking.dispatchAudio();
-    }
-    destroy(e = !0) {
-      if ('destroyed' === this.state.status)
-        throw Error('Cannot destroy VoiceConnection - it has already been destroyed');
-      getVoiceConnection(this.joinConfig.guildId, this.joinConfig.group) === this && untrackVoiceConnection(this),
-        e && this.state.adapter.sendPayload(createJoinVoiceChannelPayload({ ...this.joinConfig, channelId: null })),
-        (this.state = { status: 'destroyed' });
-    }
-    disconnect() {
-      return (
-        'destroyed' !== this.state.status &&
-        'signalling' !== this.state.status &&
-        (((this.joinConfig.channelId = null),
-        this.state.adapter.sendPayload(createJoinVoiceChannelPayload(this.joinConfig)))
-          ? ((this.state = { adapter: this.state.adapter, reason: 3, status: 'disconnected' }), !0)
-          : ((this.state = {
-              adapter: this.state.adapter,
-              subscription: this.state.subscription,
-              status: 'disconnected',
-              reason: 1,
-            }),
-            !1))
-      );
-    }
-    rejoin(e) {
-      if ('destroyed' === this.state.status) return !1;
-      let t = 'ready' !== this.state.status;
-      return (t && this.rejoinAttempts++,
-      Object.assign(this.joinConfig, e),
-      this.state.adapter.sendPayload(createJoinVoiceChannelPayload(this.joinConfig)))
-        ? (t && (this.state = { ...this.state, status: 'signalling' }), !0)
-        : ((this.state = {
-            adapter: this.state.adapter,
-            subscription: this.state.subscription,
-            status: 'disconnected',
-            reason: 1,
-          }),
-          !1);
-    }
-    setSpeaking(e) {
-      return 'ready' === this.state.status && this.state.networking.setSpeaking(e);
-    }
-    subscribe(e) {
-      if ('destroyed' === this.state.status) return;
-      let t = e.subscribe(this);
-      return (this.state = { ...this.state, subscription: t }), t;
-    }
-    get ping() {
-      return 'ready' === this.state.status && 4 === this.state.networking.state.code
-        ? { ws: this.state.networking.state.ws.ping, udp: this.state.networking.state.udp.ping }
-        : { ws: void 0, udp: void 0 };
-    }
-    onSubscriptionRemoved(e) {
-      'destroyed' !== this.state.status &&
-        this.state.subscription === e &&
-        (this.state = { ...this.state, subscription: void 0 });
-    }
-  };
-function createVoiceConnection(e, t) {
-  let s = createJoinVoiceChannelPayload(e),
-    i = getVoiceConnection(e.guildId, e.group);
-  if (i && 'destroyed' !== i.state.status)
-    return (
-      'disconnected' === i.state.status
-        ? i.rejoin({ channelId: e.channelId, selfDeaf: e.selfDeaf, selfMute: e.selfMute })
-        : i.state.adapter.sendPayload(s) || (i.state = { ...i.state, status: 'disconnected', reason: 1 }),
-      i
-    );
-  let o = new VoiceConnection(e, t);
-  return (
-    trackVoiceConnection(o),
-    'destroyed' === o.state.status ||
-      o.state.adapter.sendPayload(s) ||
-      (o.state = { ...o.state, status: 'disconnected', reason: 1 }),
-    o
-  );
-}
-function joinVoiceChannel(e) {
-  let t = { selfDeaf: !0, selfMute: !1, group: 'default', ...e };
-  return createVoiceConnection(t, { adapterCreator: e.adapterCreator, debug: e.debug });
-}
-__name(VoiceConnection, 'VoiceConnection'),
-  __name(createVoiceConnection, 'createVoiceConnection'),
-  __name(joinVoiceChannel, 'joinVoiceChannel');
-var import_node_stream2 = require('stream'),
-  import_prism_media2 = __toESM(require('prism-media')),
-  import_prism_media = __toESM(require('prism-media')),
-  FFMPEG_PCM_ARGUMENTS = ['-analyzeduration', '0', '-loglevel', '0', '-f', 's16le', '-ar', '48000', '-ac', '2'],
-  FFMPEG_OPUS_ARGUMENTS = [
-    '-analyzeduration',
-    '0',
-    '-loglevel',
-    '0',
-    '-acodec',
-    'libopus',
-    '-f',
-    'opus',
-    '-ar',
-    '48000',
-    '-ac',
-    '2',
-  ],
-  StreamType =
-    (((StreamType2 = StreamType || {}).Arbitrary = 'arbitrary'),
-    (StreamType2.OggOpus = 'ogg/opus'),
-    (StreamType2.Opus = 'opus'),
-    (StreamType2.Raw = 'raw'),
-    (StreamType2.WebmOpus = 'webm/opus'),
-    StreamType2),
-  Node = class {
-    edges = [];
-    type;
-    constructor(e) {
-      this.type = e;
-    }
-    addEdge(e) {
-      this.edges.push({ ...e, from: this });
-    }
-  };
-__name(Node, 'Node');
-var NODES = new Map();
-for (const streamType of Object.values(StreamType)) NODES.set(streamType, new Node(streamType));
-function getNode(e) {
-  let t = NODES.get(e);
-  if (!t) throw Error(`Node type '${e}' does not exist!`);
-  return t;
-}
-__name(getNode, 'getNode'),
-  getNode('raw').addEdge({
-    type: 'opus encoder',
-    to: getNode('opus'),
-    cost: 1.5,
-    transformer: () => new import_prism_media.default.opus.Encoder({ rate: 48e3, channels: 2, frameSize: 960 }),
-  }),
-  getNode('opus').addEdge({
-    type: 'opus decoder',
-    to: getNode('raw'),
-    cost: 1.5,
-    transformer: () => new import_prism_media.default.opus.Decoder({ rate: 48e3, channels: 2, frameSize: 960 }),
-  }),
-  getNode('ogg/opus').addEdge({
-    type: 'ogg/opus demuxer',
-    to: getNode('opus'),
-    cost: 1,
-    transformer: () => new import_prism_media.default.opus.OggDemuxer(),
-  }),
-  getNode('webm/opus').addEdge({
-    type: 'webm/opus demuxer',
-    to: getNode('opus'),
-    cost: 1,
-    transformer: () => new import_prism_media.default.opus.WebmDemuxer(),
-  });
-var FFMPEG_PCM_EDGE = {
-  type: 'ffmpeg pcm',
-  to: getNode('raw'),
-  cost: 2,
-  transformer: e =>
-    new import_prism_media.default.FFmpeg({
-      args: 'string' == typeof e ? ['-i', e, ...FFMPEG_PCM_ARGUMENTS] : FFMPEG_PCM_ARGUMENTS,
-    }),
-};
-function canEnableFFmpegOptimizations() {
-  try {
-    return import_prism_media.default.FFmpeg.getInfo().output.includes('--enable-libopus');
-  } catch {}
-  return !1;
-}
-if (
-  (getNode('arbitrary').addEdge(FFMPEG_PCM_EDGE),
-  getNode('ogg/opus').addEdge(FFMPEG_PCM_EDGE),
-  getNode('webm/opus').addEdge(FFMPEG_PCM_EDGE),
-  getNode('raw').addEdge({
-    type: 'volume transformer',
-    to: getNode('raw'),
-    cost: 0.5,
-    transformer: () => new import_prism_media.default.VolumeTransformer({ type: 's16le' }),
-  }),
-  __name(canEnableFFmpegOptimizations, 'canEnableFFmpegOptimizations'),
-  canEnableFFmpegOptimizations())
-) {
-  let e = {
-    type: 'ffmpeg ogg',
-    to: getNode('ogg/opus'),
-    cost: 2,
-    transformer: e =>
-      new import_prism_media.default.FFmpeg({
-        args: 'string' == typeof e ? ['-i', e, ...FFMPEG_OPUS_ARGUMENTS] : FFMPEG_OPUS_ARGUMENTS,
-      }),
-  };
-  getNode('arbitrary').addEdge(e), getNode('ogg/opus').addEdge(e), getNode('webm/opus').addEdge(e);
-}
-function findPath(e, t, s = getNode('opus'), i = [], o = 5) {
-  if (e === s && t(i)) return { cost: 0 };
-  if (0 === o) return { cost: Number.POSITIVE_INFINITY };
-  let n;
-  for (let r of e.edges) {
-    if (n && r.cost > n.cost) continue;
-    let a = findPath(r.to, t, s, [...i, r], o - 1),
-      c = r.cost + a.cost;
-    (!n || c < n.cost) && (n = { cost: c, edge: r, next: a });
-  }
-  return n ?? { cost: Number.POSITIVE_INFINITY };
-}
-function constructPipeline(e) {
-  let t = [],
-    s = e;
-  for (; s?.edge; ) t.push(s.edge), (s = s.next);
-  return t;
-}
-function findPipeline(e, t) {
-  return constructPipeline(findPath(getNode(e), t));
-}
-__name(findPath, 'findPath'), __name(constructPipeline, 'constructPipeline'), __name(findPipeline, 'findPipeline');
-var AudioResource = class {
-  playStream;
-  edges;
-  metadata;
-  volume;
-  encoder;
-  audioPlayer;
-  playbackDuration = 0;
-  started = !1;
-  silencePaddingFrames;
-  silenceRemaining = -1;
-  constructor(e, t, s, i) {
-    for (let o of ((this.edges = e),
-    (this.playStream = t.length > 1 ? (0, import_node_stream2.pipeline)(t, noop) : t[0]),
-    (this.metadata = s),
-    (this.silencePaddingFrames = i),
-    t))
-      o instanceof import_prism_media2.default.VolumeTransformer
-        ? (this.volume = o)
-        : o instanceof import_prism_media2.default.opus.Encoder && (this.encoder = o);
-    this.playStream.once('readable', () => (this.started = !0));
-  }
-  get readable() {
-    if (0 === this.silenceRemaining) return !1;
-    let e = this.playStream.readable;
-    return (
-      e ||
-      (-1 === this.silenceRemaining && (this.silenceRemaining = this.silencePaddingFrames), 0 !== this.silenceRemaining)
-    );
-  }
-  get ended() {
-    return this.playStream.readableEnded || this.playStream.destroyed || 0 === this.silenceRemaining;
-  }
-  read() {
-    if (0 === this.silenceRemaining) return null;
-    if (this.silenceRemaining > 0) return this.silenceRemaining--, SILENCE_FRAME;
-    let e = this.playStream.read();
-    return e && (this.playbackDuration += 20), e;
-  }
-};
-__name(AudioResource, 'AudioResource');
-var VOLUME_CONSTRAINT = __name(e => e.some(e => 'volume transformer' === e.type), 'VOLUME_CONSTRAINT'),
-  NO_CONSTRAINT = __name(() => !0, 'NO_CONSTRAINT');
-function inferStreamType(e) {
-  if (e instanceof import_prism_media2.default.opus.Encoder) return { streamType: 'opus', hasVolume: !1 };
-  if (e instanceof import_prism_media2.default.opus.Decoder) return { streamType: 'raw', hasVolume: !1 };
-  if (e instanceof import_prism_media2.default.VolumeTransformer) return { streamType: 'raw', hasVolume: !0 };
-  if (e instanceof import_prism_media2.default.opus.OggDemuxer) return { streamType: 'opus', hasVolume: !1 };
-  if (e instanceof import_prism_media2.default.opus.WebmDemuxer) return { streamType: 'opus', hasVolume: !1 };
-  return { streamType: 'arbitrary', hasVolume: !1 };
-}
-function createAudioResource(e, t = {}) {
-  let s = t.inputType,
-    i = Boolean(t.inlineVolume);
-  if ('string' == typeof e) s = 'arbitrary';
-  else if (void 0 === s) {
-    let o = inferStreamType(e);
-    (s = o.streamType), (i = i && !o.hasVolume);
-  }
-  let n = findPipeline(s, i ? VOLUME_CONSTRAINT : NO_CONSTRAINT);
-  if (0 === n.length) {
-    if ('string' == typeof e) throw Error(`Invalid pipeline constructed for string resource '${e}'`);
-    return new AudioResource([], [e], t.metadata ?? null, t.silencePaddingFrames ?? 5);
-  }
-  let r = n.map(t => t.transformer(e));
-  return 'string' != typeof e && r.unshift(e), new AudioResource(n, r, t.metadata ?? null, t.silencePaddingFrames ?? 5);
-}
-__name(inferStreamType, 'inferStreamType'), __name(createAudioResource, 'createAudioResource');
-var import_node_path = require('path'),
-  import_prism_media3 = __toESM(require('prism-media'));
-function findPackageJSON(e, t, s) {
-  if (0 === s) return;
-  let i = (0, import_node_path.resolve)(e, './package.json');
-  try {
-    let o = require(i);
-    if (o.name !== t) throw Error('package.json does not match');
-    return o;
-  } catch {
-    return findPackageJSON((0, import_node_path.resolve)(e, '..'), t, s - 1);
-  }
-}
-function version(e) {
-  try {
-    if ('@discordjs/voice' === e) return '0.16.0';
-    let t = findPackageJSON((0, import_node_path.dirname)(require.resolve(e)), e, 3);
-    return t?.version ?? 'not found';
-  } catch {
-    return 'not found';
-  }
-}
-function generateDependencyReport() {
-  let e = [],
-    t = __name(t => e.push(`- ${t}: ${version(t)}`), 'addVersion');
-  e.push('Core Dependencies'),
-    t('@discordjs/voice'),
-    t('prism-media'),
-    e.push(''),
-    e.push('Opus Libraries'),
-    t('@discordjs/opus'),
-    t('opusscript'),
-    e.push(''),
-    e.push('Encryption Libraries'),
-    t('sodium-native'),
-    t('sodium'),
-    t('libsodium-wrappers'),
-    t('tweetnacl'),
-    e.push(''),
-    e.push('FFmpeg');
-  try {
-    let s = import_prism_media3.default.FFmpeg.getInfo();
-    e.push(`- version: ${s.version}`), e.push(`- libopus: ${s.output.includes('--enable-libopus') ? 'yes' : 'no'}`);
-  } catch {
-    e.push('- not found');
-  }
-  return ['-'.repeat(50), ...e, '-'.repeat(50)].join('\n');
-}
-__name(findPackageJSON, 'findPackageJSON'),
-  __name(version, 'version'),
-  __name(generateDependencyReport, 'generateDependencyReport');
-var import_node_events8 = require('events');
-function abortAfter(e) {
-  let t = new AbortController(),
-    s = setTimeout(() => t.abort(), e);
-  return t.signal.addEventListener('abort', () => clearTimeout(s)), [t, t.signal];
-}
-async function entersState(e, t, s) {
-  if (e.state.status !== t) {
-    let [i, o] = 'number' == typeof s ? abortAfter(s) : [void 0, s];
-    try {
-      await (0, import_node_events8.once)(e, t, { signal: o });
-    } finally {
-      i?.abort();
-    }
-  }
-  return e;
-}
-__name(abortAfter, 'abortAfter'), __name(entersState, 'entersState');
-var import_node_buffer6 = require('buffer'),
-  import_node_process = __toESM(require('process')),
-  import_node_stream3 = require('stream'),
-  import_prism_media4 = __toESM(require('prism-media'));
-function validateDiscordOpusHead(e) {
-  let t = e.readUInt8(9),
-    s = e.readUInt32LE(12);
-  return 2 === t && 48e3 === s;
-}
-async function demuxProbe(e, t = 1024, s = validateDiscordOpusHead) {
-  return new Promise((i, o) => {
-    if (e.readableObjectMode) {
-      o(Error('Cannot probe a readable stream in object mode'));
-      return;
-    }
-    if (e.readableEnded) {
-      o(Error('Cannot probe a stream that has ended'));
-      return;
-    }
-    let n = import_node_buffer6.Buffer.alloc(0),
-      r,
-      a = __name(t => {
-        e.off('data', l),
-          e.off('close', p),
-          e.off('end', p),
-          e.pause(),
-          (r = t),
-          e.readableEnded
-            ? i({ stream: import_node_stream3.Readable.from(n), type: t })
-            : (n.length > 0 && e.push(n), i({ stream: e, type: t }));
-      }, 'finish'),
-      c = __name(
-        e => t => {
-          s(t) && a(e);
-        },
-        'foundHead',
-      ),
-      d = new import_prism_media4.default.opus.WebmDemuxer();
-    d.once('error', noop), d.on('head', c('webm/opus'));
-    let u = new import_prism_media4.default.opus.OggDemuxer();
-    u.once('error', noop), u.on('head', c('ogg/opus'));
-    let p = __name(() => {
-        r || a('arbitrary');
-      }, 'onClose'),
-      l = __name(s => {
-        (n = import_node_buffer6.Buffer.concat([n, s])),
-          d.write(s),
-          u.write(s),
-          n.length >= t && (e.off('data', l), e.pause(), import_node_process.default.nextTick(p));
-      }, 'onData');
-    e.once('error', o), e.on('data', l), e.once('close', p), e.once('end', p);
-  });
-}
-__name(validateDiscordOpusHead, 'validateDiscordOpusHead'), __name(demuxProbe, 'demuxProbe');
-var version2 = '0.16.0';