"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
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 __export = (target, all) => {
  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 });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  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);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  AudioPlayer: () => AudioPlayer,
  AudioPlayerError: () => AudioPlayerError,
  AudioPlayerStatus: () => AudioPlayerStatus,
  AudioResource: () => AudioResource,
  NoSubscriberBehavior: () => NoSubscriberBehavior,
  PlayerSubscription: () => PlayerSubscription,
  StreamType: () => StreamType,
  VoiceConnection: () => VoiceConnection,
  VoiceConnectionDisconnectReason: () => VoiceConnectionDisconnectReason,
  VoiceConnectionStatus: () => VoiceConnectionStatus,
  createAudioPlayer: () => createAudioPlayer,
  createAudioResource: () => createAudioResource,
  entersState: () => entersState,
  getGroups: () => getGroups,
  getVoiceConnection: () => getVoiceConnection,
  getVoiceConnections: () => getVoiceConnections,
  joinVoiceChannel: () => joinVoiceChannel,
  version: () => version
});
module.exports = __toCommonJS(src_exports);

// src/VoiceConnection.ts
var import_node_events6 = require("events");

// src/DataStore.ts
var import_v10 = require("discord-api-types/v10");
function createJoinVoiceChannelPayload(config) {
  return {
    op: import_v10.GatewayOpcodes.VoiceStateUpdate,
    // eslint-disable-next-line id-length
    d: {
      guild_id: config.guildId,
      channel_id: config.channelId,
      self_deaf: config.selfDeaf,
      self_mute: config.selfMute
    }
  };
}
__name(createJoinVoiceChannelPayload, "createJoinVoiceChannelPayload");
var groups = /* @__PURE__ */ new Map();
groups.set("default", /* @__PURE__ */ new Map());
function getOrCreateGroup(group) {
  const existing = groups.get(group);
  if (existing) return existing;
  const map = /* @__PURE__ */ new Map();
  groups.set(group, map);
  return map;
}
__name(getOrCreateGroup, "getOrCreateGroup");
function getGroups() {
  return groups;
}
__name(getGroups, "getGroups");
function getVoiceConnections(group = "default") {
  return groups.get(group);
}
__name(getVoiceConnections, "getVoiceConnections");
function getVoiceConnection(guildId, group = "default") {
  return getVoiceConnections(group)?.get(guildId);
}
__name(getVoiceConnection, "getVoiceConnection");
function untrackVoiceConnection(voiceConnection) {
  return getVoiceConnections(voiceConnection.joinConfig.group)?.delete(
    voiceConnection.joinConfig.guildId
  );
}
__name(untrackVoiceConnection, "untrackVoiceConnection");
function trackVoiceConnection(voiceConnection) {
  return getOrCreateGroup(voiceConnection.joinConfig.group).set(
    voiceConnection.joinConfig.guildId,
    voiceConnection
  );
}
__name(trackVoiceConnection, "trackVoiceConnection");
var FRAME_LENGTH = 20;
var audioCycleInterval;
var nextTime = -1;
var audioPlayers = [];
function audioCycleStep() {
  if (nextTime === -1) return;
  nextTime += FRAME_LENGTH;
  const available = audioPlayers.filter((player) => player.checkPlayable());
  for (const player of available) {
    player["_stepDispatch"]();
  }
  prepareNextAudioFrame(available);
}
__name(audioCycleStep, "audioCycleStep");
function prepareNextAudioFrame(players) {
  const nextPlayer = players.shift();
  if (!nextPlayer) {
    if (nextTime >= 0) {
      audioCycleInterval = setTimeout(
        () => audioCycleStep(),
        Math.max(nextTime - Date.now(), 1)
      );
    }
    return;
  }
  nextPlayer["_stepPrepare"]();
  setImmediate(() => prepareNextAudioFrame(players));
}
__name(prepareNextAudioFrame, "prepareNextAudioFrame");
function hasAudioPlayer(target) {
  return audioPlayers.includes(target);
}
__name(hasAudioPlayer, "hasAudioPlayer");
function addAudioPlayer(player) {
  if (hasAudioPlayer(player)) return player;
  audioPlayers.push(player);
  if (audioPlayers.length === 1) {
    nextTime = Date.now();
    setImmediate(() => audioCycleStep());
  }
  return player;
}
__name(addAudioPlayer, "addAudioPlayer");
function deleteAudioPlayer(player) {
  const index = audioPlayers.indexOf(player);
  if (index === -1) return;
  audioPlayers.splice(index, 1);
  if (audioPlayers.length === 0) {
    nextTime = -1;
    if (audioCycleInterval !== void 0) clearTimeout(audioCycleInterval);
  }
}
__name(deleteAudioPlayer, "deleteAudioPlayer");

// src/networking/Networking.ts
var import_node_buffer6 = require("buffer");
var import_node_crypto = __toESM(require("crypto"));
var import_node_events5 = require("events");
var import_v82 = require("discord-api-types/voice/v8");

// src/util/Secretbox.ts
var import_node_buffer = require("buffer");
var libs = {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  "sodium-native": /* @__PURE__ */ __name((sodium) => ({
    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => {
      const cipherText = import_node_buffer.Buffer.alloc(
        plaintext.length + sodium.crypto_aead_xchacha20poly1305_ietf_ABYTES
      );
      sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(
        cipherText,
        plaintext,
        additionalData,
        null,
        nonce2,
        key
      );
      return cipherText;
    }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
  }), "sodium-native"),
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  sodium: /* @__PURE__ */ __name((sodium) => ({
    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => {
      return sodium.api.crypto_aead_xchacha20poly1305_ietf_encrypt(
        plaintext,
        additionalData,
        null,
        nonce2,
        key
      );
    }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
  }), "sodium"),
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  "libsodium-wrappers": /* @__PURE__ */ __name((sodium) => ({
    crypto_aead_xchacha20poly1305_ietf_encrypt: /* @__PURE__ */ __name((plaintext, additionalData, nonce2, key) => {
      return sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(
        plaintext,
        additionalData,
        null,
        nonce2,
        key
      );
    }, "crypto_aead_xchacha20poly1305_ietf_encrypt")
  }), "libsodium-wrappers"),
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  "@stablelib/xchacha20poly1305": /* @__PURE__ */ __name((stablelib) => ({
    crypto_aead_xchacha20poly1305_ietf_encrypt(cipherText, additionalData, nonce2, key) {
      const crypto2 = new stablelib.XChaCha20Poly1305(key);
      return crypto2.seal(nonce2, cipherText, additionalData);
    }
  }), "@stablelib/xchacha20poly1305"),
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  "@noble/ciphers/chacha": /* @__PURE__ */ __name((noble) => ({
    crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, nonce2, key) {
      const chacha = noble.xchacha20poly1305(key, nonce2, additionalData);
      return chacha.encrypt(plaintext);
    }
  }), "@noble/ciphers/chacha")
};
libs["sodium-javascript"] = libs["sodium-native"];
var validLibs = Object.keys(libs);
var fallbackError = /* @__PURE__ */ __name(() => {
  throw new Error(
    `Cannot play audio as no valid encryption package is installed.
- Install one of the following packages: ${validLibs.join(", ")}
- Use the generateDependencyReport() function for more information.
`
  );
}, "fallbackError");
var methods = {
  crypto_aead_xchacha20poly1305_ietf_encrypt: fallbackError
};
void (async () => {
  for (const libName of Object.keys(libs)) {
    try {
      const lib = await import(libName);
      if (libName === "libsodium-wrappers" && lib.ready) await lib.ready;
      Object.assign(methods, libs[libName](lib));
      break;
    } catch {
    }
  }
})();

// src/util/util.ts
var noop = /* @__PURE__ */ __name(() => {
}, "noop");

// src/networking/DAVESession.ts
var import_node_buffer3 = require("buffer");
var import_node_events2 = require("events");

// src/audio/AudioPlayer.ts
var import_node_buffer2 = require("buffer");
var import_node_events = require("events");

// src/audio/AudioPlayerError.ts
var _AudioPlayerError = class _AudioPlayerError extends Error {
  constructor(error, resource) {
    super(error.message);
    /**
     * The resource associated with the audio player at the time the error was thrown.
     */
    __publicField(this, "resource");
    this.resource = resource;
    this.name = error.name;
    this.stack = error.stack;
  }
};
__name(_AudioPlayerError, "AudioPlayerError");
var AudioPlayerError = _AudioPlayerError;

// src/audio/PlayerSubscription.ts
var _PlayerSubscription = class _PlayerSubscription {
  constructor(connection, player) {
    /**
     * The voice connection of this subscription.
     */
    __publicField(this, "connection");
    /**
     * The audio player of this subscription.
     */
    __publicField(this, "player");
    this.connection = connection;
    this.player = player;
  }
  /**
   * Unsubscribes the connection from the audio player, meaning that the
   * audio player cannot stream audio to it until a new subscription is made.
   */
  unsubscribe() {
    this.connection["onSubscriptionRemoved"](this);
    this.player["unsubscribe"](this);
  }
};
__name(_PlayerSubscription, "PlayerSubscription");
var PlayerSubscription = _PlayerSubscription;

// src/audio/AudioPlayer.ts
var SILENCE_FRAME = import_node_buffer2.Buffer.from([248, 255, 254]);
var NoSubscriberBehavior = /* @__PURE__ */ ((NoSubscriberBehavior2) => {
  NoSubscriberBehavior2["Pause"] = "pause";
  NoSubscriberBehavior2["Play"] = "play";
  NoSubscriberBehavior2["Stop"] = "stop";
  return NoSubscriberBehavior2;
})(NoSubscriberBehavior || {});
var AudioPlayerStatus = /* @__PURE__ */ ((AudioPlayerStatus2) => {
  AudioPlayerStatus2["AutoPaused"] = "autopaused";
  AudioPlayerStatus2["Buffering"] = "buffering";
  AudioPlayerStatus2["Idle"] = "idle";
  AudioPlayerStatus2["Paused"] = "paused";
  AudioPlayerStatus2["Playing"] = "playing";
  return AudioPlayerStatus2;
})(AudioPlayerStatus || {});
function stringifyState(state) {
  return JSON.stringify({
    ...state,
    resource: Reflect.has(state, "resource"),
    stepTimeout: Reflect.has(state, "stepTimeout")
  });
}
__name(stringifyState, "stringifyState");
var _AudioPlayer = class _AudioPlayer extends import_node_events.EventEmitter {
  /**
   * Creates a new AudioPlayer.
   */
  constructor(options = {}) {
    super();
    /**
     * The state that the AudioPlayer is in.
     */
    __publicField(this, "_state");
    /**
     * A list of VoiceConnections that are registered to this AudioPlayer. The player will attempt to play audio
     * to the streams in this list.
     */
    __publicField(this, "subscribers", []);
    /**
     * The behavior that the player should follow when it enters certain situations.
     */
    __publicField(this, "behaviors");
    /**
     * The debug logger function, if debugging is enabled.
     */
    __publicField(this, "debug");
    this._state = { status: "idle" /* Idle */ };
    this.behaviors = {
      noSubscriber: "pause" /* Pause */,
      maxMissedFrames: 5,
      ...options.behaviors
    };
    this.debug = options.debug === false ? null : (message) => this.emit("debug", message);
  }
  /**
   * A list of subscribed voice connections that can currently receive audio to play.
   */
  get playable() {
    return this.subscribers.filter(
      ({ connection }) => connection.state.status === "ready" /* Ready */
    ).map(({ connection }) => connection);
  }
  /**
   * Subscribes a VoiceConnection to the audio player's play list. If the VoiceConnection is already subscribed,
   * then the existing subscription is used.
   *
   * @remarks
   * This method should not be directly called. Instead, use VoiceConnection#subscribe.
   * @param connection - The connection to subscribe
   * @returns The new subscription if the voice connection is not yet subscribed, otherwise the existing subscription
   */
  // @ts-ignore
  subscribe(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));
      return subscription;
    }
    return existingSubscription;
  }
  /**
   * Unsubscribes a subscription - i.e. removes a voice connection from the play list of the audio player.
   *
   * @remarks
   * This method should not be directly called. Instead, use PlayerSubscription#unsubscribe.
   * @param subscription - The subscription to remove
   * @returns Whether or not the subscription existed on the player and was removed
   */
  // @ts-ignore
  unsubscribe(subscription) {
    const index = this.subscribers.indexOf(subscription);
    const exists = index !== -1;
    if (exists) {
      this.subscribers.splice(index, 1);
      subscription.connection.setSpeaking(false);
      this.emit("unsubscribe", subscription);
    }
    return exists;
  }
  /**
   * The state that the player is in.
   */
  get state() {
    return this._state;
  }
  /**
   * Sets a new state for the player, performing clean-up operations where necessary.
   */
  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);
      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 (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;
    this._state = newState;
    this.emit("stateChange", oldState, this._state);
    if (oldState.status !== newState.status || didChangeResources) {
      this.emit(newState.status, oldState, this._state);
    }
    this.debug?.(
      `state change:
from ${stringifyState(oldState)}
to ${stringifyState(
        newState
      )}`
    );
  }
  /**
   * Plays a new resource on the player. If the player is already playing a resource, the existing resource is destroyed
   * (it cannot be reused, even in another player) and is replaced with the new resource.
   *
   * @remarks
   * The player will transition to the Playing state once playback begins, and will return to the Idle state once
   * playback is ended.
   *
   * If the player was previously playing a resource and this method is called, the player will not transition to the
   * Idle state during the swap over.
   * @param resource - The resource to play
   * @throws Will throw if attempting to play an audio resource that has already ended, or is being played by another player
   */
  play(resource) {
    if (resource.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."
      );
    }
    resource.audioPlayer = this;
    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) {
        this.state = {
          status: "idle" /* Idle */
        };
      }
    }, "onStreamError");
    resource.playStream.once("error", onStreamError);
    if (resource.started) {
      this.state = {
        status: "playing" /* Playing */,
        missedFrames: 0,
        playbackDuration: 0,
        resource,
        onStreamError
      };
    } else {
      const onReadableCallback = /* @__PURE__ */ __name(() => {
        if (this.state.status === "buffering" /* Buffering */ && this.state.resource === resource) {
          this.state = {
            status: "playing" /* Playing */,
            missedFrames: 0,
            playbackDuration: 0,
            resource,
            onStreamError
          };
        }
      }, "onReadableCallback");
      const onFailureCallback = /* @__PURE__ */ __name(() => {
        if (this.state.status === "buffering" /* Buffering */ && this.state.resource === resource) {
          this.state = {
            status: "idle" /* Idle */
          };
        }
      }, "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 */,
        resource,
        onReadableCallback,
        onFailureCallback,
        onStreamError
      };
    }
  }
  /**
   * Pauses playback of the current resource, if any.
   *
   * @param interpolateSilence - If true, the player will play 5 packets of silence after pausing to prevent audio glitches
   * @returns `true` if the player was successfully paused, otherwise `false`
   */
  pause(interpolateSilence = true) {
    if (this.state.status !== "playing" /* Playing */) return false;
    this.state = {
      ...this.state,
      status: "paused" /* Paused */,
      silencePacketsRemaining: interpolateSilence ? 5 : 0
    };
    return true;
  }
  /**
   * Unpauses playback of the current resource, if any.
   *
   * @returns `true` if the player was successfully unpaused, otherwise `false`
   */
  unpause() {
    if (this.state.status !== "paused" /* Paused */) return false;
    this.state = {
      ...this.state,
      status: "playing" /* Playing */,
      missedFrames: 0
    };
    return true;
  }
  /**
   * Stops playback of the current resource and destroys the resource. The player will either transition to the Idle state,
   * or remain in its current state until the silence padding frames of the resource have been played.
   *
   * @param force - If true, will force the player to enter the Idle state even if the resource has silence padding frames
   * @returns `true` if the player will come to a stop, otherwise `false`
   */
  stop(force = false) {
    if (this.state.status === "idle" /* Idle */) return false;
    if (force || this.state.resource.silencePaddingFrames === 0) {
      this.state = {
        status: "idle" /* Idle */
      };
    } else if (this.state.resource.silenceRemaining === -1) {
      this.state.resource.silenceRemaining = this.state.resource.silencePaddingFrames;
    }
    return true;
  }
  /**
   * Checks whether the underlying resource (if any) is playable (readable)
   *
   * @returns `true` if the resource is playable, otherwise `false`
   */
  checkPlayable() {
    const state = this._state;
    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */)
      return false;
    if (!state.resource.readable) {
      this.state = {
        status: "idle" /* Idle */
      };
      return false;
    }
    return true;
  }
  /**
   * Called roughly every 20ms by the global audio player timer. Dispatches any audio packets that are buffered
   * by the active connections of this audio player.
   */
  // @ts-ignore
  _stepDispatch() {
    const state = this._state;
    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */)
      return;
    for (const connection of this.playable) {
      connection.dispatchAudio();
    }
  }
  /**
   * Called roughly every 20ms by the global audio player timer. Attempts to read an audio packet from the
   * underlying resource of the stream, and then has all the active connections of the audio player prepare it
   * (encrypt it, append header data) so that it is ready to play at the start of the next cycle.
   */
  // @ts-ignore
  _stepPrepare() {
    const state = this._state;
    if (state.status === "idle" /* Idle */ || state.status === "buffering" /* Buffering */)
      return;
    const playable = this.playable;
    if (state.status === "autopaused" /* AutoPaused */ && playable.length > 0) {
      this.state = {
        ...state,
        status: "playing" /* Playing */,
        missedFrames: 0
      };
    }
    if (state.status === "paused" /* Paused */ || state.status === "autopaused" /* AutoPaused */) {
      if (state.silencePacketsRemaining > 0) {
        state.silencePacketsRemaining--;
        this._preparePacket(SILENCE_FRAME, playable, state);
        if (state.silencePacketsRemaining === 0) {
          this._signalStopSpeaking();
        }
      }
      return;
    }
    if (playable.length === 0) {
      if (this.behaviors.noSubscriber === "pause" /* Pause */) {
        this.state = {
          ...state,
          status: "autopaused" /* AutoPaused */,
          silencePacketsRemaining: 5
        };
        return;
      } else if (this.behaviors.noSubscriber === "stop" /* Stop */) {
        this.stop(true);
      }
    }
    const packet = state.resource.read();
    if (state.status === "playing" /* Playing */) {
      if (packet) {
        this._preparePacket(packet, playable, state);
        state.missedFrames = 0;
      } else {
        this._preparePacket(SILENCE_FRAME, playable, state);
        state.missedFrames++;
        if (state.missedFrames >= this.behaviors.maxMissedFrames) {
          this.stop();
        }
      }
    }
  }
  /**
   * Signals to all the subscribed connections that they should send a packet to Discord indicating
   * they are no longer speaking. Called once playback of a resource ends.
   */
  _signalStopSpeaking() {
    for (const { connection } of this.subscribers) {
      connection.setSpeaking(false);
    }
  }
  /**
   * Instructs the given connections to each prepare this packet to be played at the start of the
   * next cycle.
   *
   * @param packet - The Opus packet to be prepared by each receiver
   * @param receivers - The connections that should play this packet
   */
  _preparePacket(packet, receivers, state) {
    state.playbackDuration += 20;
    for (const connection of receivers) {
      connection.prepareAudioPacket(packet);
    }
  }
};
__name(_AudioPlayer, "AudioPlayer");
var AudioPlayer = _AudioPlayer;
function createAudioPlayer(options) {
  return new AudioPlayer(options);
}
__name(createAudioPlayer, "createAudioPlayer");

// src/networking/DAVESession.ts
var TRANSITION_EXPIRY = 10;
var TRANSITION_EXPIRY_PENDING_DOWNGRADE = 24;
var DEFAULT_DECRYPTION_FAILURE_TOLERANCE = 36;
var Davey;
try {
  Davey = require("@snazzah/davey");
} catch {
  Davey = new Proxy({}, {
    get(_, prop) {
      throw new Error(
        `DAVE protocol support requires the @snazzah/davey package. Please install it to use this feature.
Attempted to access property ${String(
          prop
        )} on the DAVESession (class), but Davey is not available.`
      );
    }
  });
}
function getMaxProtocolVersion() {
  return Davey.DAVE_PROTOCOL_VERSION;
}
__name(getMaxProtocolVersion, "getMaxProtocolVersion");
var _DAVESession = class _DAVESession extends import_node_events2.EventEmitter {
  constructor(protocolVersion, userId, channelId, options) {
    super();
    /**
     * The channel id represented by this session.
     */
    __publicField(this, "channelId");
    /**
     * The user id represented by this session.
     */
    __publicField(this, "userId");
    /**
     * The protocol version being used.
     */
    __publicField(this, "protocolVersion");
    /**
     * The last transition id executed.
     */
    __publicField(this, "lastTransitionId");
    /**
     * The pending transitions, mapped by their ID and the protocol version.
     */
    __publicField(this, "pendingTransitions", /* @__PURE__ */ new Map());
    /**
     * Whether this session was downgraded previously.
     */
    __publicField(this, "downgraded", false);
    /**
     * The amount of consecutive failures encountered when decrypting.
     */
    __publicField(this, "consecutiveFailures", 0);
    /**
     * The amount of consecutive failures needed to attempt to recover.
     */
    __publicField(this, "failureTolerance");
    /**
     * Whether this session is currently re-initializing due to an invalid transition.
     */
    __publicField(this, "reinitializing", false);
    /**
     * The underlying DAVE Session of this wrapper.
     */
    __publicField(this, "session");
    this.protocolVersion = protocolVersion;
    this.userId = userId;
    this.channelId = channelId;
    this.failureTolerance = options.decryptionFailureTolerance ?? DEFAULT_DECRYPTION_FAILURE_TOLERANCE;
  }
  /**
   * The current voice privacy code of the session. Will be `null` if there is no session.
   */
  get voicePrivacyCode() {
    if (this.protocolVersion === 0 || !this.session?.voicePrivacyCode) {
      return null;
    }
    return this.session.voicePrivacyCode;
  }
  /**
   * Gets the verification code for a user in the session.
   *
   * @throws Will throw if there is not an active session or the user id provided is invalid or not in the session.
   */
  async getVerificationCode(userId) {
    if (!this.session) throw new Error("Session not available");
    return this.session.getVerificationCode(userId);
  }
  /**
   * Re-initializes (or initializes) the underlying session.
   */
  reinit() {
    if (this.protocolVersion > 0) {
      if (this.session) {
        this.session.reinit(this.protocolVersion, this.userId, this.channelId);
        this.emit(
          "debug",
          `Session reinitialized for protocol version ${this.protocolVersion}`
        );
      } else {
        this.session = new Davey.DAVESession(
          this.protocolVersion,
          this.userId,
          this.channelId
        );
        this.emit(
          "debug",
          `Session initialized for protocol version ${this.protocolVersion}`
        );
      }
      this.emit("keyPackage", this.session.getSerializedKeyPackage());
    } else if (this.session) {
      this.session.reset();
      this.session.setPassthroughMode(true, TRANSITION_EXPIRY);
      this.emit("debug", "Session reset");
    }
  }
  /**
   * Set the external sender for this session.
   *
   * @param externalSender - The external sender
   */
  setExternalSender(externalSender) {
    if (!this.session) throw new Error("No session available");
    this.session.setExternalSender(externalSender);
    this.emit("debug", "Set MLS external sender");
  }
  /**
   * Prepare for a transition.
   *
   * @param data - The transition data
   * @returns Whether we should signal to the voice server that we are ready
   */
  prepareTransition(data) {
    this.emit(
      "debug",
      `Preparing for transition (${data.transition_id}, v${data.protocol_version})`
    );
    this.pendingTransitions.set(data.transition_id, data.protocol_version);
    if (data.transition_id === 0) {
      this.executeTransition(data.transition_id);
    } else {
      if (data.protocol_version === 0)
        this.session?.setPassthroughMode(
          true,
          TRANSITION_EXPIRY_PENDING_DOWNGRADE
        );
      return true;
    }
    return false;
  }
  /**
   * Execute a transition.
   *
   * @param transitionId - The transition id to execute on
   */
  executeTransition(transitionId) {
    this.emit("debug", `Executing transition (${transitionId})`);
    if (!this.pendingTransitions.has(transitionId)) {
      this.emit(
        "debug",
        `Received execute transition, but we don't have a pending transition for ${transitionId}`
      );
      return false;
    }
    const oldVersion = this.protocolVersion;
    this.protocolVersion = this.pendingTransitions.get(transitionId);
    if (oldVersion !== this.protocolVersion && this.protocolVersion === 0) {
      this.downgraded = true;
      this.emit("debug", "Session downgraded");
    } else if (transitionId > 0 && this.downgraded) {
      this.downgraded = false;
      this.session?.setPassthroughMode(true, TRANSITION_EXPIRY);
      this.emit("debug", "Session upgraded");
    }
    this.reinitializing = false;
    this.lastTransitionId = transitionId;
    this.emit(
      "debug",
      `Transition executed (v${oldVersion} -> v${this.protocolVersion}, id: ${transitionId})`
    );
    this.pendingTransitions.delete(transitionId);
    return true;
  }
  /**
   * Prepare for a new epoch.
   *
   * @param data - The epoch data
   */
  prepareEpoch(data) {
    this.emit("debug", `Preparing for epoch (${data.epoch})`);
    if (data.epoch === 1) {
      this.protocolVersion = data.protocol_version;
      this.reinit();
    }
  }
  /**
   * Recover from an invalid transition by re-initializing.
   *
   * @param transitionId - The transition id to invalidate
   */
  recoverFromInvalidTransition(transitionId) {
    if (this.reinitializing) return;
    this.emit("debug", `Invalidating transition ${transitionId}`);
    this.reinitializing = true;
    this.consecutiveFailures = 0;
    this.emit("invalidateTransition", transitionId);
    this.reinit();
  }
  /**
   * Processes proposals from the MLS group.
   *
   * @param payload - The binary message payload
   * @param connectedClients - The set of connected client IDs
   * @returns The payload to send back to the voice server, if there is one
   */
  processProposals(payload, connectedClients) {
    if (!this.session) throw new Error("No session available");
    const optype = payload.readUInt8(0);
    const { commit, welcome } = this.session.processProposals(
      optype,
      payload.subarray(1),
      Array.from(connectedClients)
    );
    this.emit("debug", "MLS proposals processed");
    if (!commit) return;
    return welcome ? import_node_buffer3.Buffer.concat([commit, welcome]) : commit;
  }
  /**
   * Processes a commit from the MLS group.
   *
   * @param payload - The payload
   * @returns The transaction id and whether it was successful
   */
  processCommit(payload) {
    if (!this.session) throw new Error("No session available");
    const transitionId = payload.readUInt16BE(0);
    try {
      this.session.processCommit(payload.subarray(2));
      if (transitionId === 0) {
        this.reinitializing = false;
        this.lastTransitionId = transitionId;
      } else {
        this.pendingTransitions.set(transitionId, this.protocolVersion);
      }
      this.emit(
        "debug",
        `MLS commit processed (transition id: ${transitionId})`
      );
      return { transitionId, success: true };
    } catch (error) {
      this.emit(
        "debug",
        `MLS commit errored from transition ${transitionId}: ${error}`
      );
      this.recoverFromInvalidTransition(transitionId);
      return { transitionId, success: false };
    }
  }
  /**
   * Processes a welcome from the MLS group.
   *
   * @param payload - The payload
   * @returns The transaction id and whether it was successful
   */
  processWelcome(payload) {
    if (!this.session) throw new Error("No session available");
    const transitionId = payload.readUInt16BE(0);
    try {
      this.session.processWelcome(payload.subarray(2));
      if (transitionId === 0) {
        this.reinitializing = false;
        this.lastTransitionId = transitionId;
      } else {
        this.pendingTransitions.set(transitionId, this.protocolVersion);
      }
      this.emit(
        "debug",
        `MLS welcome processed (transition id: ${transitionId})`
      );
      return { transitionId, success: true };
    } catch (error) {
      this.emit(
        "debug",
        `MLS welcome errored from transition ${transitionId}: ${error}`
      );
      this.recoverFromInvalidTransition(transitionId);
      return { transitionId, success: false };
    }
  }
  /**
   * Encrypt a packet using end-to-end encryption.
   *
   * @param packet - The packet to encrypt
   */
  encrypt(packet) {
    if (this.protocolVersion === 0 || !this.session?.ready || packet.equals(SILENCE_FRAME))
      return packet;
    return this.session.encryptOpus(packet);
  }
  /**
   * Decrypt a packet using end-to-end encryption.
   *
   * @param packet - The packet to decrypt
   * @param userId - The user id that sent the packet
   * @returns The decrypted packet, or `null` if the decryption failed but should be ignored
   */
  decrypt(packet, userId) {
    const canDecrypt = this.session?.ready && (this.protocolVersion !== 0 || this.session?.canPassthrough(userId));
    if (packet.equals(SILENCE_FRAME) || !canDecrypt || !this.session)
      return packet;
    try {
      const buffer = this.session.decrypt(
        userId,
        // @ts-expect-error - const enum is exported and works (todo: drop const modifier on Davey end)
        Davey.MediaType.AUDIO,
        packet
      );
      this.consecutiveFailures = 0;
      return buffer;
    } catch (error) {
      if (!this.reinitializing && this.pendingTransitions.size === 0) {
        this.consecutiveFailures++;
        this.emit(
          "debug",
          `Failed to decrypt a packet (${this.consecutiveFailures} consecutive fails)`
        );
        if (this.consecutiveFailures > this.failureTolerance) {
          if (this.lastTransitionId)
            this.recoverFromInvalidTransition(this.lastTransitionId);
          else
            throw error;
        }
      } else if (this.reinitializing) {
        this.emit(
          "debug",
          "Failed to decrypt a packet (reinitializing session)"
        );
      } else if (this.pendingTransitions.size > 0) {
        this.emit(
          "debug",
          `Failed to decrypt a packet (${this.pendingTransitions.size} pending transition[s])`
        );
      }
    }
    return null;
  }
  /**
   * Resets the session.
   */
  destroy() {
    try {
      this.session?.reset();
    } catch {
    }
  }
};
__name(_DAVESession, "DAVESession");
var DAVESession = _DAVESession;

// src/networking/VoiceUDPSocket.ts
var import_node_buffer4 = require("buffer");
var import_node_dgram = require("dgram");
var import_node_events3 = require("events");
var import_node_net = require("net");
function parseLocalPacket(message) {
  const packet = import_node_buffer4.Buffer.from(message);
  const ip = packet.subarray(8, packet.indexOf(0, 8)).toString("utf8");
  if (!(0, import_node_net.isIPv4)(ip)) {
    throw new Error("Malformed IP address");
  }
  const port = packet.readUInt16BE(packet.length - 2);
  return { ip, port };
}
__name(parseLocalPacket, "parseLocalPacket");
var KEEP_ALIVE_INTERVAL = 5e3;
var MAX_COUNTER_VALUE = 2 ** 32 - 1;
var _VoiceUDPSocket = class _VoiceUDPSocket extends import_node_events3.EventEmitter {
  /**
   * Creates a new VoiceUDPSocket.
   *
   * @param remote - Details of the remote socket
   */
  constructor(remote) {
    super();
    /**
     * The underlying network Socket for the VoiceUDPSocket.
     */
    __publicField(this, "socket");
    /**
     * The socket details for Discord (remote)
     */
    __publicField(this, "remote");
    /**
     * The counter used in the keep alive mechanism.
     */
    __publicField(this, "keepAliveCounter", 0);
    /**
     * The buffer used to write the keep alive counter into.
     */
    __publicField(this, "keepAliveBuffer");
    /**
     * The Node.js interval for the keep-alive mechanism.
     */
    __publicField(this, "keepAliveInterval");
    /**
     * The time taken to receive a response to keep alive messages.
     *
     * @deprecated This field is no longer updated as keep alive messages are no longer tracked.
     */
    __publicField(this, "ping");
    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.keepAliveBuffer = import_node_buffer4.Buffer.alloc(8);
    this.keepAliveInterval = setInterval(
      () => this.keepAlive(),
      KEEP_ALIVE_INTERVAL
    );
    setImmediate(() => this.keepAlive());
  }
  /**
   * Called when a message is received on the UDP socket.
   *
   * @param buffer - The received buffer
   */
  onMessage(buffer) {
    this.emit("message", buffer);
  }
  /**
   * Called at a regular interval to check whether we are still able to send datagrams to Discord.
   */
  keepAlive() {
    this.keepAliveBuffer.writeUInt32LE(this.keepAliveCounter, 0);
    this.send(this.keepAliveBuffer);
    this.keepAliveCounter++;
    if (this.keepAliveCounter > MAX_COUNTER_VALUE) {
      this.keepAliveCounter = 0;
    }
  }
  /**
   * Sends a buffer to Discord.
   *
   * @param buffer - The buffer to send
   */
  send(buffer) {
    this.socket.send(buffer, this.remote.port, this.remote.ip);
  }
  /**
   * Closes the socket, the instance will not be able to be reused.
   */
  destroy() {
    try {
      this.socket.close();
    } catch {
    }
    clearInterval(this.keepAliveInterval);
  }
  /**
   * Performs IP discovery to discover the local address and port to be used for the voice connection.
   *
   * @param ssrc - The SSRC received from Discord
   */
  async performIPDiscovery(ssrc) {
    return new Promise((resolve, reject) => {
      const listener = /* @__PURE__ */ __name((message) => {
        try {
          if (message.readUInt16BE(0) !== 2) return;
          const packet = parseLocalPacket(message);
          this.socket.off("message", listener);
          resolve(packet);
        } catch {
        }
      }, "listener");
      this.socket.on("message", listener);
      this.socket.once(
        "close",
        () => reject(new Error("Cannot perform IP discovery - socket closed"))
      );
      const discoveryBuffer = import_node_buffer4.Buffer.alloc(74);
      discoveryBuffer.writeUInt16BE(1, 0);
      discoveryBuffer.writeUInt16BE(70, 2);
      discoveryBuffer.writeUInt32BE(ssrc, 4);
      this.send(discoveryBuffer);
    });
  }
};
__name(_VoiceUDPSocket, "VoiceUDPSocket");
var VoiceUDPSocket = _VoiceUDPSocket;

// src/networking/VoiceWebSocket.ts
var import_node_buffer5 = require("buffer");
var import_node_events4 = require("events");
var import_v8 = require("discord-api-types/voice/v8");
var import_ws = __toESM(require("ws"));
var _VoiceWebSocket = class _VoiceWebSocket extends import_node_events4.EventEmitter {
  /**
   * Creates a new VoiceWebSocket.
   *
   * @param address - The address to connect to
   */
  constructor(address, debug) {
    super();
    /**
     * The current heartbeat interval, if any.
     */
    __publicField(this, "heartbeatInterval");
    /**
     * The time (milliseconds since UNIX epoch) that the last heartbeat acknowledgement packet was received.
     * This is set to 0 if an acknowledgement packet hasn't been received yet.
     */
    __publicField(this, "lastHeartbeatAck");
    /**
     * The time (milliseconds since UNIX epoch) that the last heartbeat was sent. This is set to 0 if a heartbeat
     * hasn't been sent yet.
     */
    __publicField(this, "lastHeartbeatSend");
    /**
     * The number of consecutively missed heartbeats.
     */
    __publicField(this, "missedHeartbeats", 0);
    /**
     * The last recorded ping.
     */
    __publicField(this, "ping");
    /**
     * The last sequence number acknowledged from Discord. Will be `-1` if no sequence numbered messages have been received.
     */
    __publicField(this, "sequence", -1);
    /**
     * The debug logger function, if debugging is enabled.
     */
    __publicField(this, "debug");
    /**
     * The underlying WebSocket of this wrapper.
     */
    __publicField(this, "ws");
    this.ws = new import_ws.default(address);
    this.ws.onmessage = (err) => this.onMessage(err);
    this.ws.onopen = (err) => this.emit("open", err);
    this.ws.onerror = (err) => this.emit("error", err instanceof Error ? err : err.error);
    this.ws.onclose = (err) => this.emit("close", err);
    this.lastHeartbeatAck = 0;
    this.lastHeartbeatSend = 0;
    this.debug = debug ? (message) => this.emit("debug", message) : null;
  }
  /**
   * Destroys the VoiceWebSocket. The heartbeat interval is cleared, and the connection is closed.
   */
  destroy() {
    try {
      this.debug?.("destroyed");
      this.setHeartbeatInterval(-1);
      this.ws.close(1e3);
    } catch (error) {
      const err = error;
      this.emit("error", err);
    }
  }
  /**
   * Handles message events on the WebSocket. Attempts to JSON parse the messages and emit them
   * as packets. Binary messages will be parsed and emitted.
   *
   * @param event - The message event
   */
  onMessage(event) {
    if (event.data instanceof import_node_buffer5.Buffer || event.data instanceof ArrayBuffer) {
      const buffer = event.data instanceof ArrayBuffer ? import_node_buffer5.Buffer.from(event.data) : event.data;
      const seq = buffer.readUInt16BE(0);
      const op = buffer.readUInt8(2);
      const payload = buffer.subarray(3);
      this.sequence = seq;
      this.debug?.(
        `<< [bin] opcode ${op}, seq ${seq}, ${payload.byteLength} bytes`
      );
      this.emit("binary", { op, seq, payload });
      return;
    } else if (typeof event.data !== "string") {
      return;
    }
    this.debug?.(`<< ${event.data}`);
    let packet;
    try {
      packet = JSON.parse(event.data);
    } catch (error) {
      const err = error;
      this.emit("error", err);
      return;
    }
    if (packet.seq) {
      this.sequence = packet.seq;
    }
    if (packet.op === import_v8.VoiceOpcodes.HeartbeatAck) {
      this.lastHeartbeatAck = Date.now();
      this.missedHeartbeats = 0;
      this.ping = this.lastHeartbeatAck - this.lastHeartbeatSend;
    }
    this.emit("packet", packet);
  }
  /**
   * Sends a JSON-stringifiable packet over the WebSocket.
   *
   * @param packet - The packet to send
   */
  sendPacket(packet) {
    try {
      const stringified = JSON.stringify(packet);
      this.debug?.(`>> ${stringified}`);
      this.ws.send(stringified);
    } catch (error) {
      const err = error;
      this.emit("error", err);
    }
  }
  /**
   * Sends a binary message over the WebSocket.
   *
   * @param opcode - The opcode to use
   * @param payload - The payload to send
   */
  sendBinaryMessage(opcode, payload) {
    try {
      const message = import_node_buffer5.Buffer.concat([new Uint8Array([opcode]), payload]);
      this.debug?.(`>> [bin] opcode ${opcode}, ${payload.byteLength} bytes`);
      this.ws.send(message);
    } catch (error) {
      const err = error;
      this.emit("error", err);
    }
  }
  /**
   * Sends a heartbeat over the WebSocket.
   */
  sendHeartbeat() {
    this.lastHeartbeatSend = Date.now();
    this.missedHeartbeats++;
    const nonce2 = this.lastHeartbeatSend;
    this.sendPacket({
      op: import_v8.VoiceOpcodes.Heartbeat,
      // eslint-disable-next-line id-length
      d: {
        // eslint-disable-next-line id-length
        t: nonce2,
        seq_ack: this.sequence
      }
    });
  }
  /**
   * Sets/clears an interval to send heartbeats over the WebSocket.
   *
   * @param ms - The interval in milliseconds. If negative, the interval will be unset
   */
  setHeartbeatInterval(ms) {
    if (this.heartbeatInterval !== void 0)
      clearInterval(this.heartbeatInterval);
    if (ms > 0) {
      this.heartbeatInterval = setInterval(() => {
        if (this.lastHeartbeatSend !== 0 && this.missedHeartbeats >= 3) {
          this.ws.close();
          this.setHeartbeatInterval(-1);
        }
        this.sendHeartbeat();
      }, ms);
    }
  }
};
__name(_VoiceWebSocket, "VoiceWebSocket");
var VoiceWebSocket = _VoiceWebSocket;

// src/networking/Networking.ts
var CHANNELS = 2;
var TIMESTAMP_INC = 48e3 / 100 * CHANNELS;
var MAX_NONCE_SIZE = 2 ** 32 - 1;
var SUPPORTED_ENCRYPTION_MODES = [
  import_v82.VoiceEncryptionMode.AeadXChaCha20Poly1305RtpSize
];
if (import_node_crypto.default.getCiphers().includes("aes-256-gcm")) {
  SUPPORTED_ENCRYPTION_MODES.unshift(import_v82.VoiceEncryptionMode.AeadAes256GcmRtpSize);
}
var nonce = import_node_buffer6.Buffer.alloc(24);
function stringifyState2(state) {
  return JSON.stringify({
    ...state,
    ws: Reflect.has(state, "ws"),
    udp: Reflect.has(state, "udp")
  });
}
__name(stringifyState2, "stringifyState");
function chooseEncryptionMode(options) {
  const option = options.find(
    (option2) => SUPPORTED_ENCRYPTION_MODES.includes(option2)
  );
  if (!option) {
    throw new Error(
      `No compatible encryption modes. Available include: ${options.join(
        ", "
      )}`
    );
  }
  return option;
}
__name(chooseEncryptionMode, "chooseEncryptionMode");
function randomNBit(numberOfBits) {
  return Math.floor(Math.random() * 2 ** numberOfBits);
}
__name(randomNBit, "randomNBit");
var _Networking = class _Networking extends import_node_events5.EventEmitter {
  /**
   * Creates a new Networking instance.
   */
  constructor(connectionOptions, options) {
    super();
    __publicField(this, "_state");
    /**
     * The debug logger function, if debugging is enabled.
     */
    __publicField(this, "debug");
    /**
     * The options used to create this Networking instance.
     */
    __publicField(this, "options");
    this.onWsOpen = this.onWsOpen.bind(this);
    this.onChildError = this.onChildError.bind(this);
    this.onWsPacket = this.onWsPacket.bind(this);
    this.onWsBinary = this.onWsBinary.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.onDaveDebug = this.onDaveDebug.bind(this);
    this.onDaveKeyPackage = this.onDaveKeyPackage.bind(this);
    this.onDaveInvalidateTransition = this.onDaveInvalidateTransition.bind(this);
    this.debug = options?.debug ? (message) => this.emit("debug", message) : null;
    this._state = {
      code: 0 /* OpeningWs */,
      ws: this.createWebSocket(connectionOptions.endpoint),
      connectionOptions
    };
    this.options = options;
  }
  /**
   * Destroys the Networking instance, transitioning it into the Closed state.
   */
  destroy() {
    this.state = {
      code: 6 /* Closed */
    };
  }
  /**
   * The current state of the networking instance.
   *
   * @remarks
   * The setter will perform clean-up operations where necessary.
   */
  get state() {
    return this._state;
  }
  set state(newState) {
    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("binary", this.onWsBinary);
      oldWs.off("close", this.onWsClose);
      oldWs.destroy();
    }
    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.destroy();
    }
    const oldDave = Reflect.get(this._state, "dave");
    const newDave = Reflect.get(newState, "dave");
    if (oldDave && oldDave !== newDave) {
      oldDave.off("error", this.onChildError);
      oldDave.off("debug", this.onDaveDebug);
      oldDave.off("keyPackage", this.onDaveKeyPackage);
      oldDave.off("invalidateTransition", this.onDaveInvalidateTransition);
      oldDave.destroy();
    }
    const oldState = this._state;
    this._state = newState;
    this.emit("stateChange", oldState, newState);
    this.debug?.(
      `state change:
from ${stringifyState2(oldState)}
to ${stringifyState2(
        newState
      )}`
    );
  }
  /**
   * Creates a new WebSocket to a Discord Voice gateway.
   *
   * @param endpoint - The endpoint to connect to
   * @param lastSequence - The last sequence to set for this WebSocket
   */
  createWebSocket(endpoint, lastSequence) {
    const ws = new VoiceWebSocket(`wss://${endpoint}?v=8`, Boolean(this.debug));
    if (lastSequence !== void 0) {
      ws.sequence = lastSequence;
    }
    ws.on("error", this.onChildError);
    ws.once("open", this.onWsOpen);
    ws.on("packet", this.onWsPacket);
    ws.on("binary", this.onWsBinary);
    ws.once("close", this.onWsClose);
    ws.on("debug", this.onWsDebug);
    return ws;
  }
  /**
   * Creates a new DAVE session for this voice connection if we can create one.
   *
   * @param protocolVersion - The protocol version to use
   */
  createDaveSession(protocolVersion) {
    if (this.options.daveEncryption === false || this.state.code !== 3 /* SelectingProtocol */ && this.state.code !== 4 /* Ready */ && this.state.code !== 5 /* Resuming */) {
      return;
    }
    const session = new DAVESession(
      protocolVersion,
      this.state.connectionOptions.userId,
      this.state.connectionOptions.channelId,
      {
        decryptionFailureTolerance: this.options.decryptionFailureTolerance
      }
    );
    session.on("error", this.onChildError);
    session.on("debug", this.onDaveDebug);
    session.on("keyPackage", this.onDaveKeyPackage);
    session.on("invalidateTransition", this.onDaveInvalidateTransition);
    session.reinit();
    return session;
  }
  /**
   * Propagates errors from the children VoiceWebSocket, VoiceUDPSocket and DAVESession.
   *
   * @param error - The error that was emitted by a child
   */
  onChildError(error) {
    this.emit("error", error);
  }
  /**
   * Called when the WebSocket opens. Depending on the state that the instance is in,
   * it will either identify with a new session, or it will attempt to resume an existing session.
   */
  onWsOpen() {
    if (this.state.code === 0 /* OpeningWs */) {
      this.state.ws.sendPacket({
        op: import_v82.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,
          max_dave_protocol_version: this.options.daveEncryption === false ? 0 : getMaxProtocolVersion()
        }
      });
      this.state = {
        ...this.state,
        code: 1 /* Identifying */
      };
    } else if (this.state.code === 5 /* Resuming */) {
      this.state.ws.sendPacket({
        op: import_v82.VoiceOpcodes.Resume,
        d: {
          server_id: this.state.connectionOptions.serverId,
          session_id: this.state.connectionOptions.sessionId,
          token: this.state.connectionOptions.token,
          seq_ack: this.state.ws.sequence
        }
      });
    }
  }
  /**
   * Called when the WebSocket closes. Based on the reason for closing (given by the code parameter),
   * the instance will either attempt to resume, or enter the closed state and emit a 'close' event
   * with the close code, allowing the user to decide whether or not they would like to reconnect.
   *
   * @param code - The close code
   */
  onWsClose({ code }) {
    const canResume = code === 4015 || code < 4e3;
    if (canResume && this.state.code === 4 /* Ready */) {
      const lastSequence = this.state.ws.sequence;
      this.state = {
        ...this.state,
        code: 5 /* Resuming */,
        ws: this.createWebSocket(
          this.state.connectionOptions.endpoint,
          lastSequence
        )
      };
    } else if (this.state.code !== 6 /* Closed */) {
      this.destroy();
      this.emit("close", code);
    }
  }
  /**
   * Called when the UDP socket has closed itself if it has stopped receiving replies from Discord.
   */
  onUdpClose() {
    if (this.state.code === 4 /* Ready */) {
      const lastSequence = this.state.ws.sequence;
      this.state = {
        ...this.state,
        code: 5 /* Resuming */,
        ws: this.createWebSocket(
          this.state.connectionOptions.endpoint,
          lastSequence
        )
      };
    }
  }
  /**
   * Called when a packet is received on the connection's WebSocket.
   *
   * @param packet - The received packet
   */
  onWsPacket(packet) {
    if (packet.op === import_v82.VoiceOpcodes.Hello && this.state.code !== 6 /* Closed */) {
      this.state.ws.setHeartbeatInterval(packet.d.heartbeat_interval);
    } else if (packet.op === import_v82.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_v82.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,
          connectedClients: /* @__PURE__ */ new Set()
        }
      };
    } else if (packet.op === import_v82.VoiceOpcodes.SessionDescription && this.state.code === 3 /* SelectingProtocol */) {
      const {
        mode: encryptionMode,
        secret_key: secretKey,
        dave_protocol_version: daveProtocolVersion
      } = packet.d;
      this.state = {
        ...this.state,
        code: 4 /* Ready */,
        dave: this.createDaveSession(daveProtocolVersion),
        connectionData: {
          ...this.state.connectionData,
          encryptionMode,
          secretKey: new Uint8Array(secretKey),
          sequence: randomNBit(16),
          timestamp: randomNBit(32),
          nonce: 0,
          nonceBuffer: encryptionMode === "aead_aes256_gcm_rtpsize" ? import_node_buffer6.Buffer.alloc(12) : import_node_buffer6.Buffer.alloc(24),
          speaking: false,
          packetsPlayed: 0
        }
      };
    } else if (packet.op === import_v82.VoiceOpcodes.Resumed && this.state.code === 5 /* Resuming */) {
      this.state = {
        ...this.state,
        code: 4 /* Ready */
      };
      this.state.connectionData.speaking = false;
    } else if ((packet.op === import_v82.VoiceOpcodes.ClientsConnect || packet.op === import_v82.VoiceOpcodes.ClientDisconnect) && (this.state.code === 4 /* Ready */ || this.state.code === 2 /* UdpHandshaking */ || this.state.code === 3 /* SelectingProtocol */ || this.state.code === 5 /* Resuming */)) {
      const { connectionData } = this.state;
      if (packet.op === import_v82.VoiceOpcodes.ClientsConnect)
        for (const id of packet.d.user_ids)
          connectionData.connectedClients.add(id);
      else {
        connectionData.connectedClients.delete(packet.d.user_id);
      }
    } else if ((this.state.code === 4 /* Ready */ || this.state.code === 5 /* Resuming */) && this.state.dave) {
      if (packet.op === import_v82.VoiceOpcodes.DavePrepareTransition) {
        const sendReady = this.state.dave.prepareTransition(packet.d);
        if (sendReady)
          this.state.ws.sendPacket({
            op: import_v82.VoiceOpcodes.DaveTransitionReady,
            d: { transition_id: packet.d.transition_id }
          });
        if (packet.d.transition_id === 0) {
          this.emit("transitioned", 0);
        }
      } else if (packet.op === import_v82.VoiceOpcodes.DaveExecuteTransition) {
        const transitioned = this.state.dave.executeTransition(
          packet.d.transition_id
        );
        if (transitioned) this.emit("transitioned", packet.d.transition_id);
      } else if (packet.op === import_v82.VoiceOpcodes.DavePrepareEpoch)
        this.state.dave.prepareEpoch(packet.d);
    }
  }
  /**
   * Called when a binary message is received on the connection's WebSocket.
   *
   * @param message - The received message
   */
  onWsBinary(message) {
    if (this.state.code === 4 /* Ready */ && this.state.dave) {
      if (message.op === import_v82.VoiceOpcodes.DaveMlsExternalSender) {
        this.state.dave.setExternalSender(message.payload);
      } else if (message.op === import_v82.VoiceOpcodes.DaveMlsProposals) {
        const payload = this.state.dave.processProposals(
          message.payload,
          this.state.connectionData.connectedClients
        );
        if (payload)
          this.state.ws.sendBinaryMessage(
            import_v82.VoiceOpcodes.DaveMlsCommitWelcome,
            payload
          );
      } else if (message.op === import_v82.VoiceOpcodes.DaveMlsAnnounceCommitTransition) {
        const { transitionId, success } = this.state.dave.processCommit(
          message.payload
        );
        if (success) {
          if (transitionId === 0) this.emit("transitioned", transitionId);
          else
            this.state.ws.sendPacket({
              op: import_v82.VoiceOpcodes.DaveTransitionReady,
              d: { transition_id: transitionId }
            });
        }
      } else if (message.op === import_v82.VoiceOpcodes.DaveMlsWelcome) {
        const { transitionId, success } = this.state.dave.processWelcome(
          message.payload
        );
        if (success) {
          if (transitionId === 0) this.emit("transitioned", transitionId);
          else
            this.state.ws.sendPacket({
              op: import_v82.VoiceOpcodes.DaveTransitionReady,
              d: { transition_id: transitionId }
            });
        }
      }
    }
  }
  /**
   * Called when a new key package is ready to be sent to the voice server.
   *
   * @param keyPackage - The new key package
   */
  onDaveKeyPackage(keyPackage) {
    if (this.state.code === 3 /* SelectingProtocol */ || this.state.code === 4 /* Ready */)
      this.state.ws.sendBinaryMessage(
        import_v82.VoiceOpcodes.DaveMlsKeyPackage,
        keyPackage
      );
  }
  /**
   * Called when the DAVE session wants to invalidate their transition and re-initialize.
   *
   * @param transitionId - The transition to invalidate
   */
  onDaveInvalidateTransition(transitionId) {
    if (this.state.code === 3 /* SelectingProtocol */ || this.state.code === 4 /* Ready */)
      this.state.ws.sendPacket({
        op: import_v82.VoiceOpcodes.DaveMlsInvalidCommitWelcome,
        d: { transition_id: transitionId }
      });
  }
  /**
   * Propagates debug messages from the child WebSocket.
   *
   * @param message - The emitted debug message
   */
  onWsDebug(message) {
    this.debug?.(`[WS] ${message}`);
  }
  /**
   * Propagates debug messages from the child UDPSocket.
   *
   * @param message - The emitted debug message
   */
  onUdpDebug(message) {
    this.debug?.(`[UDP] ${message}`);
  }
  /**
   * Propagates debug messages from the child DAVESession.
   *
   * @param message - The emitted debug message
   */
  onDaveDebug(message) {
    this.debug?.(`[DAVE] ${message}`);
  }
  /**
   * Prepares an Opus packet for playback. This includes attaching metadata to it and encrypting it.
   * It will be stored within the instance, and can be played by dispatchAudio()
   *
   * @remarks
   * Calling this method while there is already a prepared audio packet that has not yet been dispatched
   * will overwrite the existing audio packet. This should be avoided.
   * @param opusPacket - The Opus packet to encrypt
   * @returns The audio packet that was prepared
   */
  prepareAudioPacket(opusPacket) {
    const state = this.state;
    if (state.code !== 4 /* Ready */) return;
    state.preparedPacket = this.createAudioPacket(
      opusPacket,
      state.connectionData,
      state.dave
    );
    return state.preparedPacket;
  }
  /**
   * Dispatches the audio packet previously prepared by prepareAudioPacket(opusPacket). The audio packet
   * is consumed and cannot be dispatched again.
   */
  dispatchAudio() {
    const state = this.state;
    if (state.code !== 4 /* Ready */) return false;
    if (state.preparedPacket !== void 0) {
      this.playAudioPacket(state.preparedPacket);
      state.preparedPacket = void 0;
      return true;
    }
    return false;
  }
  /**
   * Plays an audio packet, updating timing metadata used for playback.
   *
   * @param audioPacket - The audio packet to play
   */
  playAudioPacket(audioPacket) {
    const state = this.state;
    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;
    this.setSpeaking(true);
    state.udp.send(audioPacket);
  }
  /**
   * Sends a packet to the voice gateway indicating that the client has start/stopped sending
   * audio.
   *
   * @param speaking - Whether or not the client should be shown as speaking
   */
  setSpeaking(speaking) {
    const state = this.state;
    if (state.code !== 4 /* Ready */) return;
    if (state.connectionData.speaking === speaking) return;
    state.connectionData.speaking = speaking;
    state.ws.sendPacket({
      op: import_v82.VoiceOpcodes.Speaking,
      d: {
        speaking: speaking ? 1 : 0,
        delay: 0,
        ssrc: state.connectionData.ssrc
      }
    });
  }
  /**
   * Creates a new audio packet from an Opus packet. This involves encrypting the packet,
   * then prepending a header that includes metadata.
   *
   * @param opusPacket - The Opus packet to prepare
   * @param connectionData - The current connection data of the instance
   * @param daveSession - The DAVE session to use for encryption
   */
  createAudioPacket(opusPacket, connectionData, daveSession) {
    const rtpHeader = import_node_buffer6.Buffer.alloc(12);
    rtpHeader[0] = 128;
    rtpHeader[1] = 120;
    const { sequence, timestamp, ssrc } = connectionData;
    rtpHeader.writeUIntBE(sequence, 2, 2);
    rtpHeader.writeUIntBE(timestamp, 4, 4);
    rtpHeader.writeUIntBE(ssrc, 8, 4);
    rtpHeader.copy(nonce, 0, 0, 12);
    return import_node_buffer6.Buffer.concat(
      [
        rtpHeader,
        ...this.encryptOpusPacket(
          opusPacket,
          connectionData,
          rtpHeader,
          daveSession
        )
      ]
    );
  }
  /**
   * Encrypts an Opus packet using the format agreed upon by the instance and Discord.
   *
   * @param opusPacket - The Opus packet to encrypt
   * @param connectionData - The current connection data of the instance
   * @param daveSession - The DAVE session to use for encryption
   */
  encryptOpusPacket(opusPacket, connectionData, additionalData, daveSession) {
    const { secretKey, encryptionMode } = connectionData;
    const packet = daveSession?.encrypt(opusPacket) ?? opusPacket;
    connectionData.nonce++;
    if (connectionData.nonce > MAX_NONCE_SIZE) connectionData.nonce = 0;
    connectionData.nonceBuffer.writeUInt32BE(connectionData.nonce, 0);
    const noncePadding = connectionData.nonceBuffer.subarray(0, 4);
    let encrypted;
    switch (encryptionMode) {
      case "aead_aes256_gcm_rtpsize": {
        const cipher = import_node_crypto.default.createCipheriv(
          "aes-256-gcm",
          secretKey,
          connectionData.nonceBuffer
        );
        cipher.setAAD(additionalData);
        encrypted = import_node_buffer6.Buffer.concat(
          [
            cipher.update(packet),
            cipher.final(),
            cipher.getAuthTag()
          ]
        );
        return [encrypted, noncePadding];
      }
      case "aead_xchacha20_poly1305_rtpsize": {
        encrypted = methods.crypto_aead_xchacha20poly1305_ietf_encrypt(
          packet,
          additionalData,
          connectionData.nonceBuffer,
          secretKey
        );
        return [encrypted, noncePadding];
      }
      default: {
        throw new RangeError(
          `Unsupported encryption method: ${encryptionMode}`
        );
      }
    }
  }
};
__name(_Networking, "Networking");
var Networking = _Networking;

// src/VoiceConnection.ts
var VoiceConnectionStatus = /* @__PURE__ */ ((VoiceConnectionStatus2) => {
  VoiceConnectionStatus2["Connecting"] = "connecting";
  VoiceConnectionStatus2["Destroyed"] = "destroyed";
  VoiceConnectionStatus2["Disconnected"] = "disconnected";
  VoiceConnectionStatus2["Ready"] = "ready";
  VoiceConnectionStatus2["Signalling"] = "signalling";
  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";
  return VoiceConnectionDisconnectReason2;
})(VoiceConnectionDisconnectReason || {});
var _VoiceConnection = class _VoiceConnection extends import_node_events6.EventEmitter {
  /**
   * Creates a new voice connection.
   *
   * @param joinConfig - The data required to establish the voice connection
   * @param options - The options used to create this voice connection
   */
  constructor(joinConfig, options) {
    super();
    /**
     * The number of consecutive rejoin attempts. Initially 0, and increments for each rejoin.
     * When a connection is successfully established, it resets to 0.
     */
    __publicField(this, "rejoinAttempts");
    /**
     * The state of the voice connection.
     */
    __publicField(this, "_state");
    /**
     * A configuration storing all the data needed to reconnect to a Guild's voice server.
     *
     * @internal
     */
    __publicField(this, "joinConfig");
    /**
     * The two packets needed to successfully establish a voice connection. They are received
     * from the main Discord gateway after signalling to change the voice state.
     */
    __publicField(this, "packets");
    /**
     * The debug logger function, if debugging is enabled.
     */
    __publicField(this, "debug");
    /**
     * The options used to create this voice connection.
     */
    __publicField(this, "options");
    this.debug = options.debug ? (message) => this.emit("debug", message) : null;
    this.rejoinAttempts = 0;
    this.onNetworkingClose = this.onNetworkingClose.bind(this);
    this.onNetworkingStateChange = this.onNetworkingStateChange.bind(this);
    this.onNetworkingError = this.onNetworkingError.bind(this);
    this.onNetworkingDebug = this.onNetworkingDebug.bind(this);
    this.onNetworkingTransitioned = this.onNetworkingTransitioned.bind(this);
    const adapter = options.adapterCreator({
      onVoiceServerUpdate: /* @__PURE__ */ __name((data) => this.addServerPacket(data), "onVoiceServerUpdate"),
      onVoiceStateUpdate: /* @__PURE__ */ __name((data) => this.addStatePacket(data), "onVoiceStateUpdate"),
      destroy: /* @__PURE__ */ __name(() => this.destroy(false), "destroy")
    });
    this._state = { status: "signalling" /* Signalling */, adapter };
    this.packets = {
      server: void 0,
      state: void 0
    };
    this.joinConfig = joinConfig;
    this.options = options;
  }
  /**
   * The current state of the voice connection.
   *
   * @remarks
   * The setter will perform clean-up operations where necessary.
   */
  get state() {
    return this._state;
  }
  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");
    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.off("transitioned", this.onNetworkingTransitioned);
        oldNetworking.destroy();
      }
    }
    if (newState.status === "ready" /* Ready */) {
      this.rejoinAttempts = 0;
    }
    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);
    if (oldState.status !== newState.status) {
      this.emit(newState.status, oldState, newState);
    }
  }
  /**
   * Registers a `VOICE_SERVER_UPDATE` packet to the voice connection. This will cause it to reconnect using the
   * new data provided in the packet.
   *
   * @param packet - The received `VOICE_SERVER_UPDATE` packet
   */
  addServerPacket(packet) {
    this.packets.server = packet;
    if (packet.endpoint) {
      this.configureNetworking();
    } else if (this.state.status !== "destroyed" /* Destroyed */) {
      this.state = {
        ...this.state,
        status: "disconnected" /* Disconnected */,
        reason: 2 /* EndpointRemoved */
      };
    }
  }
  /**
   * Registers a `VOICE_STATE_UPDATE` packet to the voice connection. Most importantly, it stores the id of the
   * channel that the client is connected to.
   *
   * @param packet - The received `VOICE_STATE_UPDATE` packet
   */
  addStatePacket(packet) {
    this.packets.state = packet;
    if (packet.self_deaf !== void 0)
      this.joinConfig.selfDeaf = packet.self_deaf;
    if (packet.self_mute !== void 0)
      this.joinConfig.selfMute = packet.self_mute;
    if (packet.channel_id) this.joinConfig.channelId = packet.channel_id;
  }
  /**
   * Attempts to configure a networking instance for this voice connection using the received packets.
   * Both packets are required, and any existing networking instance will be destroyed.
   *
   * @remarks
   * This is called when the voice server of the connection changes, e.g. if the bot is moved into a
   * different channel in the same guild but has a different voice server. In this instance, the connection
   * needs to be re-established to the new voice server.
   *
   * The connection will transition to the Connecting state when this is called.
   */
  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,
        channelId: state.channel_id
      },
      {
        debug: Boolean(this.debug),
        daveEncryption: this.options.daveEncryption ?? true,
        decryptionFailureTolerance: this.options.decryptionFailureTolerance
      }
    );
    networking.once("close", this.onNetworkingClose);
    networking.on("stateChange", this.onNetworkingStateChange);
    networking.on("error", this.onNetworkingError);
    networking.on("debug", this.onNetworkingDebug);
    networking.on("transitioned", this.onNetworkingTransitioned);
    this.state = {
      ...this.state,
      status: "connecting" /* Connecting */,
      networking
    };
  }
  /**
   * Called when the networking instance for this connection closes. If the close code is 4014 (do not reconnect),
   * the voice connection will transition to the Disconnected state which will store the close code. You can
   * decide whether or not to reconnect when this occurs by listening for the state change and calling reconnect().
   *
   * @remarks
   * If the close code was anything other than 4014, it is likely that the closing was not intended, and so the
   * VoiceConnection will signal to Discord that it would like to rejoin the channel. This automatically attempts
   * to re-establish the connection. This would be seen as a transition from the Ready state to the Signalling state.
   * @param code - The close code
   */
  onNetworkingClose(code) {
    if (this.state.status === "destroyed" /* Destroyed */) return;
    if (code === 4014) {
      this.state = {
        ...this.state,
        status: "disconnected" /* Disconnected */,
        reason: 0 /* WebSocketClose */,
        closeCode: code
      };
    } else {
      this.state = {
        ...this.state,
        status: "signalling" /* Signalling */
      };
      this.rejoinAttempts++;
      if (!this.state.adapter.sendPayload(
        createJoinVoiceChannelPayload(this.joinConfig)
      )) {
        this.state = {
          ...this.state,
          status: "disconnected" /* Disconnected */,
          reason: 1 /* AdapterUnavailable */
        };
      }
    }
  }
  /**
   * Called when the state of the networking instance changes. This is used to derive the state of the voice connection.
   *
   * @param oldState - The previous state
   * @param newState - The new state
   */
  onNetworkingStateChange(oldState, newState) {
    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 */
      };
    } else if (newState.code !== 6 /* Closed */) {
      this.state = {
        ...this.state,
        status: "connecting" /* Connecting */
      };
    }
  }
  /**
   * Propagates errors from the underlying network instance.
   *
   * @param error - The error to propagate
   */
  onNetworkingError(error) {
    this.emit("error", error);
  }
  /**
   * Propagates debug messages from the underlying network instance.
   *
   * @param message - The debug message to propagate
   */
  onNetworkingDebug(message) {
    this.debug?.(`[NW] ${message}`);
  }
  /**
   * Propagates transitions from the underlying network instance.
   *
   * @param transitionId - The transition id
   */
  onNetworkingTransitioned(transitionId) {
    this.emit("transitioned", transitionId);
  }
  /**
   * Prepares an audio packet for dispatch.
   *
   * @param buffer - The Opus packet to prepare
   */
  prepareAudioPacket(buffer) {
    const state = this.state;
    if (state.status !== "ready" /* Ready */) return;
    return state.networking.prepareAudioPacket(buffer);
  }
  /**
   * Dispatches the previously prepared audio packet (if any)
   */
  dispatchAudio() {
    const state = this.state;
    if (state.status !== "ready" /* Ready */) return;
    return state.networking.dispatchAudio();
  }
  /**
   * Prepares an audio packet and dispatches it immediately.
   *
   * @param buffer - The Opus packet to play
   */
  playOpusPacket(buffer) {
    const state = this.state;
    if (state.status !== "ready" /* Ready */) return;
    state.networking.prepareAudioPacket(buffer);
    return state.networking.dispatchAudio();
  }
  /**
   * Destroys the VoiceConnection, preventing it from connecting to voice again.
   * This method should be called when you no longer require the VoiceConnection to
   * prevent memory leaks.
   *
   * @param adapterAvailable - Whether the adapter can be used
   */
  destroy(adapterAvailable = true) {
    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);
    }
    if (adapterAvailable) {
      this.state.adapter.sendPayload(
        createJoinVoiceChannelPayload({ ...this.joinConfig, channelId: null })
      );
    }
    this.state = {
      status: "destroyed" /* Destroyed */
    };
  }
  /**
   * Disconnects the VoiceConnection, allowing the possibility of rejoining later on.
   *
   * @returns `true` if the connection was successfully disconnected
   */
  disconnect() {
    if (this.state.status === "destroyed" /* Destroyed */ || this.state.status === "signalling" /* Signalling */) {
      return false;
    }
    this.joinConfig.channelId = null;
    if (!this.state.adapter.sendPayload(
      createJoinVoiceChannelPayload(this.joinConfig)
    )) {
      this.state = {
        adapter: this.state.adapter,
        subscription: this.state.subscription,
        status: "disconnected" /* Disconnected */,
        reason: 1 /* AdapterUnavailable */
      };
      return false;
    }
    this.state = {
      adapter: this.state.adapter,
      reason: 3 /* Manual */,
      status: "disconnected" /* Disconnected */
    };
    return true;
  }
  /**
   * Attempts to rejoin (better explanation soon:tm:)
   *
   * @remarks
   * Calling this method successfully will automatically increment the `rejoinAttempts` counter,
   * which you can use to inform whether or not you'd like to keep attempting to reconnect your
   * voice connection.
   *
   * A state transition from Disconnected to Signalling will be observed when this is called.
   */
  rejoin(joinConfig) {
    if (this.state.status === "destroyed" /* Destroyed */) {
      return false;
    }
    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 */
        };
      }
      return true;
    }
    this.state = {
      adapter: this.state.adapter,
      subscription: this.state.subscription,
      status: "disconnected" /* Disconnected */,
      reason: 1 /* AdapterUnavailable */
    };
    return false;
  }
  /**
   * Updates the speaking status of the voice connection. This is used when audio players are done playing audio,
   * and need to signal that the connection is no longer playing audio.
   *
   * @param enabled - Whether or not to show as speaking
   */
  setSpeaking(enabled) {
    if (this.state.status !== "ready" /* Ready */) return false;
    return this.state.networking.setSpeaking(enabled);
  }
  /**
   * Subscribes to an audio player, allowing the player to play audio on this voice connection.
   *
   * @param player - The audio player to subscribe to
   * @returns The created subscription
   */
  subscribe(player) {
    if (this.state.status === "destroyed" /* Destroyed */) return;
    const subscription = player["subscribe"](this);
    this.state = {
      ...this.state,
      subscription
    };
    return subscription;
  }
  /**
   * The latest ping (in milliseconds) for the WebSocket connection and audio playback for this voice
   * connection, if this data is available.
   *
   * @remarks
   * For this data to be available, the VoiceConnection must be in the Ready state, and its underlying
   * WebSocket connection and UDP socket must have had at least one ping-pong exchange.
   */
  get ping() {
    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
      };
    }
    return {
      ws: void 0,
      udp: void 0
    };
  }
  /**
   * The current voice privacy code of the encrypted session.
   *
   * @remarks
   * For this data to be available, the VoiceConnection must be in the Ready state,
   * and the connection would have to be end-to-end encrypted.
   */
  get voicePrivacyCode() {
    if (this.state.status === "ready" /* Ready */ && this.state.networking.state.code === 4 /* Ready */) {
      return this.state.networking.state.dave?.voicePrivacyCode ?? void 0;
    }
    return void 0;
  }
  /**
   * Gets the verification code for a user in the session.
   *
   * @throws Will throw if end-to-end encryption is not on or if the user id provided is not in the session.
   */
  async getVerificationCode(userId) {
    if (this.state.status === "ready" /* Ready */ && this.state.networking.state.code === 4 /* Ready */ && this.state.networking.state.dave) {
      return this.state.networking.state.dave.getVerificationCode(userId);
    }
    throw new Error("Session not available");
  }
  /**
   * Called when a subscription of this voice connection to an audio player is removed.
   *
   * @param subscription - The removed subscription
   */
  onSubscriptionRemoved(subscription) {
    if (this.state.status !== "destroyed" /* Destroyed */ && this.state.subscription === subscription) {
      this.state = {
        ...this.state,
        subscription: void 0
      };
    }
  }
};
__name(_VoiceConnection, "VoiceConnection");
var VoiceConnection = _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 */) {
      existing.rejoin({
        channelId: joinConfig.channelId,
        selfDeaf: joinConfig.selfDeaf,
        selfMute: joinConfig.selfMute
      });
    } else if (!existing.state.adapter.sendPayload(payload)) {
      existing.state = {
        ...existing.state,
        status: "disconnected" /* Disconnected */,
        reason: 1 /* AdapterUnavailable */
      };
    }
    return existing;
  }
  const voiceConnection = new VoiceConnection(joinConfig, options);
  trackVoiceConnection(voiceConnection);
  if (voiceConnection.state.status !== "destroyed" /* Destroyed */ && !voiceConnection.state.adapter.sendPayload(payload)) {
    voiceConnection.state = {
      ...voiceConnection.state,
      status: "disconnected" /* Disconnected */,
      reason: 1 /* AdapterUnavailable */
    };
  }
  return voiceConnection;
}
__name(createVoiceConnection, "createVoiceConnection");

// src/joinVoiceChannel.ts
function joinVoiceChannel(options) {
  const joinConfig = {
    selfDeaf: true,
    selfMute: false,
    group: "default",
    ...options
  };
  return createVoiceConnection(joinConfig, {
    adapterCreator: options.adapterCreator,
    debug: options.debug,
    daveEncryption: options.daveEncryption,
    decryptionFailureTolerance: options.decryptionFailureTolerance
  });
}
__name(joinVoiceChannel, "joinVoiceChannel");

// src/audio/AudioResource.ts
var import_node_stream = require("stream");

// src/audio/TransformerGraph.ts
var import_opus = require("@discord-player/opus");
var import_ffmpeg = require("@discord-player/ffmpeg");
var import_equalizer = require("@discord-player/equalizer");
var FFMPEG_PCM_ARGUMENTS = (0, import_ffmpeg.createFFmpegArgs)({
  analyzeduration: "0",
  loglevel: "0",
  f: "s16le",
  ar: "48000",
  ac: "2"
});
var FFMPEG_OPUS_ARGUMENTS = (0, import_ffmpeg.createFFmpegArgs)({
  analyzeduration: "0",
  loglevel: "0",
  acodec: "libopus",
  f: "opus",
  ar: "48000",
  ac: "2"
});
var StreamType = /* @__PURE__ */ ((StreamType2) => {
  StreamType2["Arbitrary"] = "arbitrary";
  StreamType2["OggOpus"] = "ogg/opus";
  StreamType2["Opus"] = "opus";
  StreamType2["Raw"] = "raw";
  StreamType2["WebmOpus"] = "webm/opus";
  return StreamType2;
})(StreamType || {});
var _Node = class _Node {
  constructor(type) {
    /**
     * The outbound edges from this node.
     */
    __publicField(this, "edges", []);
    /**
     * The type of stream for this node.
     */
    __publicField(this, "type");
    this.type = type;
  }
  /**
   * Creates an outbound edge from this node.
   *
   * @param edge - The edge to create
   */
  addEdge(edge) {
    this.edges.push({ ...edge, from: this });
  }
};
__name(_Node, "Node");
var Node = _Node;
var NODES = null;
function canEnableFFmpegOptimizations() {
  return import_ffmpeg.FFmpeg.resolveSafe()?.result.includes("--enable-libopus") === true;
}
__name(canEnableFFmpegOptimizations, "canEnableFFmpegOptimizations");
function getNode(type) {
  const node = (NODES ?? (NODES = initializeNodes())).get(type);
  if (!node) throw new Error(`Node type '${type}' does not exist!`);
  return node;
}
__name(getNode, "getNode");
function initializeNodes() {
  const nodes = /* @__PURE__ */ new Map();
  for (const streamType of Object.values(StreamType)) {
    nodes.set(streamType, new Node(streamType));
  }
  nodes.get("raw" /* Raw */).addEdge({
    type: "opus encoder" /* OpusEncoder */,
    to: nodes.get("opus" /* Opus */),
    cost: 1.5,
    transformer: /* @__PURE__ */ __name(() => new import_opus.OpusEncoder({ rate: 48e3, channels: 2, frameSize: 960 }), "transformer")
  });
  nodes.get("opus" /* Opus */).addEdge({
    type: "opus decoder" /* OpusDecoder */,
    to: nodes.get("raw" /* Raw */),
    cost: 1.5,
    transformer: /* @__PURE__ */ __name(() => new import_opus.OpusDecoder({ rate: 48e3, channels: 2, frameSize: 960 }), "transformer")
  });
  nodes.get("ogg/opus" /* OggOpus */).addEdge({
    type: "ogg/opus demuxer" /* OggOpusDemuxer */,
    to: nodes.get("opus" /* Opus */),
    cost: 1,
    transformer: /* @__PURE__ */ __name(() => new import_opus.OggDemuxer(), "transformer")
  });
  nodes.get("webm/opus" /* WebmOpus */).addEdge({
    type: "webm/opus demuxer" /* WebmOpusDemuxer */,
    to: nodes.get("opus" /* Opus */),
    cost: 1,
    transformer: /* @__PURE__ */ __name(() => new import_opus.WebmDemuxer(), "transformer")
  });
  const FFMPEG_PCM_EDGE = {
    type: "ffmpeg pcm" /* FFmpegPCM */,
    to: nodes.get("raw" /* Raw */),
    cost: 2,
    transformer: /* @__PURE__ */ __name((input) => new import_ffmpeg.FFmpeg({
      args: [
        "-i",
        typeof input === "string" ? input : "-",
        ...FFMPEG_PCM_ARGUMENTS
      ]
    }), "transformer")
  };
  nodes.get("arbitrary" /* Arbitrary */).addEdge(FFMPEG_PCM_EDGE);
  nodes.get("ogg/opus" /* OggOpus */).addEdge(FFMPEG_PCM_EDGE);
  nodes.get("webm/opus" /* WebmOpus */).addEdge(FFMPEG_PCM_EDGE);
  nodes.get("raw" /* Raw */).addEdge({
    type: "volume transformer" /* InlineVolume */,
    to: nodes.get("raw" /* Raw */),
    cost: 0.5,
    transformer: /* @__PURE__ */ __name(() => new import_equalizer.VolumeTransformer({ type: "s16le" }), "transformer")
  });
  if (canEnableFFmpegOptimizations()) {
    const FFMPEG_OGG_EDGE = {
      type: "ffmpeg ogg" /* FFmpegOgg */,
      to: nodes.get("ogg/opus" /* OggOpus */),
      cost: 2,
      transformer: /* @__PURE__ */ __name((input) => new import_ffmpeg.FFmpeg({
        args: [
          "-i",
          typeof input === "string" ? input : "-",
          ...FFMPEG_OPUS_ARGUMENTS
        ]
      }), "transformer")
    };
    nodes.get("arbitrary" /* Arbitrary */).addEdge(FFMPEG_OGG_EDGE);
    nodes.get("ogg/opus" /* OggOpus */).addEdge(FFMPEG_OGG_EDGE);
    nodes.get("webm/opus" /* WebmOpus */).addEdge(FFMPEG_OGG_EDGE);
  }
  return nodes;
}
__name(initializeNodes, "initializeNodes");
function findPath(from, constraints, goal = getNode("opus" /* Opus */), path = [], depth = 5) {
  if (from === goal && constraints(path)) {
    return { cost: 0 };
  } else if (depth === 0) {
    return { cost: Number.POSITIVE_INFINITY };
  }
  let currentBest;
  for (const edge of from.edges) {
    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) {
      currentBest = { cost, edge, next };
    }
  }
  return currentBest ?? { cost: Number.POSITIVE_INFINITY };
}
__name(findPath, "findPath");
function constructPipeline(step) {
  const edges = [];
  let current = step;
  while (current?.edge) {
    edges.push(current.edge);
    current = current.next;
  }
  return edges;
}
__name(constructPipeline, "constructPipeline");
function findPipeline(from, constraint) {
  return constructPipeline(findPath(getNode(from), constraint));
}
__name(findPipeline, "findPipeline");

// src/audio/AudioResource.ts
var import_opus2 = require("@discord-player/opus");
var import_equalizer2 = require("@discord-player/equalizer");
var _AudioResource = class _AudioResource {
  constructor(edges, streams, metadata, silencePaddingFrames) {
    /**
     * An object-mode Readable stream that emits Opus packets. This is what is played by audio players.
     */
    __publicField(this, "playStream");
    /**
     * The pipeline used to convert the input stream into a playable format. For example, this may
     * contain an FFmpeg component for arbitrary inputs, and it may contain a VolumeTransformer component
     * for resources with inline volume transformation enabled.
     */
    __publicField(this, "edges");
    /**
     * Optional metadata that can be used to identify the resource.
     */
    __publicField(this, "metadata");
    /**
     * If the resource was created with inline volume transformation enabled, then this will be a
     * `@discord-player/equalizer` VolumeTransformer. You can use this to alter the volume of the stream.
     */
    __publicField(this, "volume");
    /**
     * If using an Opus encoder to create this audio resource, then this will be a`@discord-player/opus` opus.Encoder.
     * You can use this to control settings such as bitrate, FEC, PLP.
     */
    __publicField(this, "encoder");
    /**
     * The audio player that the resource is subscribed to, if any.
     */
    __publicField(this, "audioPlayer");
    /**
     * The playback duration of this audio resource, given in milliseconds.
     */
    __publicField(this, "playbackDuration", 0);
    /**
     * Whether or not the stream for this resource has started (data has become readable)
     */
    __publicField(this, "started", false);
    /**
     * The number of silence frames to append to the end of the resource's audio stream, to prevent interpolation glitches.
     */
    __publicField(this, "silencePaddingFrames");
    /**
     * The number of remaining silence frames to play. If -1, the frames have not yet started playing.
     */
    __publicField(this, "silenceRemaining", -1);
    this.edges = edges;
    this.playStream = streams.length > 1 ? (0, import_node_stream.pipeline)(streams, noop) : streams[0];
    this.metadata = metadata;
    this.silencePaddingFrames = silencePaddingFrames;
    for (const stream of streams) {
      if (stream instanceof import_equalizer2.VolumeTransformer) {
        this.volume = stream;
      } else if (stream instanceof import_opus2.OpusEncoder) {
        this.encoder = stream;
      }
    }
    this.playStream.once("readable", () => this.started = true);
  }
  /**
   * Whether this resource is readable. If the underlying resource is no longer readable, this will still return true
   * while there are silence padding frames left to play.
   */
  get readable() {
    if (this.silenceRemaining === 0) return false;
    const real = this.playStream.readable;
    if (!real) {
      if (this.silenceRemaining === -1)
        this.silenceRemaining = this.silencePaddingFrames;
      return this.silenceRemaining !== 0;
    }
    return real;
  }
  /**
   * Whether this resource has ended or not.
   */
  get ended() {
    return this.playStream.readableEnded || this.playStream.destroyed || this.silenceRemaining === 0;
  }
  /**
   * Attempts to read an Opus packet from the audio resource. If a packet is available, the playbackDuration
   * is incremented.
   *
   * @remarks
   * It is advisable to check that the playStream is readable before calling this method. While no runtime
   * errors will be thrown, you should check that the resource is still available before attempting to
   * read from it.
   * @internal
   */
  read() {
    if (this.silenceRemaining === 0) {
      return null;
    } else if (this.silenceRemaining > 0) {
      this.silenceRemaining--;
      return SILENCE_FRAME;
    }
    const packet = this.playStream.read();
    if (packet) {
      this.playbackDuration += 20;
    }
    return packet;
  }
};
__name(_AudioResource, "AudioResource");
var 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_opus2.OpusEncoder) {
    return { streamType: "opus" /* Opus */, hasVolume: false };
  } else if (stream instanceof import_opus2.OpusDecoder) {
    return { streamType: "raw" /* Raw */, hasVolume: false };
  } else if (stream instanceof import_equalizer2.VolumeTransformer) {
    return { streamType: "raw" /* Raw */, hasVolume: true };
  } else if (stream instanceof import_opus2.OggDemuxer) {
    return { streamType: "opus" /* Opus */, hasVolume: false };
  } else if (stream instanceof import_opus2.WebmDemuxer) {
    return { streamType: "opus" /* Opus */, hasVolume: false };
  }
  return { streamType: "arbitrary" /* Arbitrary */, hasVolume: false };
}
__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 (inputType === void 0) {
    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}'`
      );
    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);
  return new AudioResource(
    transformerPipeline,
    streams,
    options.metadata ?? null,
    options.silencePaddingFrames ?? 5
  );
}
__name(createAudioResource, "createAudioResource");

// src/util/entersState.ts
var import_node_events7 = require("events");

// src/util/abortAfter.ts
function abortAfter(delay) {
  const ac = new AbortController();
  const timeout = setTimeout(() => ac.abort(), delay);
  ac.signal.addEventListener("abort", () => clearTimeout(timeout));
  return [ac, ac.signal];
}
__name(abortAfter, "abortAfter");

// 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];
    try {
      await (0, import_node_events7.once)(target, status, { signal });
    } finally {
      ac?.abort();
    }
  }
  return target;
}
__name(entersState, "entersState");

// src/version.ts
var version = (
  /* @__MACRO__ getVersion */
  "7.2.0"
);
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  AudioPlayer,
  AudioPlayerError,
  AudioPlayerStatus,
  AudioResource,
  NoSubscriberBehavior,
  PlayerSubscription,
  StreamType,
  VoiceConnection,
  VoiceConnectionDisconnectReason,
  VoiceConnectionStatus,
  createAudioPlayer,
  createAudioResource,
  entersState,
  getGroups,
  getVoiceConnection,
  getVoiceConnections,
  joinVoiceChannel,
  version
});
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/VoiceConnection.ts", "../src/DataStore.ts", "../src/networking/Networking.ts", "../src/util/Secretbox.ts", "../src/util/util.ts", "../src/networking/DAVESession.ts", "../src/audio/AudioPlayer.ts", "../src/audio/AudioPlayerError.ts", "../src/audio/PlayerSubscription.ts", "../src/networking/VoiceUDPSocket.ts", "../src/networking/VoiceWebSocket.ts", "../src/joinVoiceChannel.ts", "../src/audio/AudioResource.ts", "../src/audio/TransformerGraph.ts", "../src/util/entersState.ts", "../src/util/abortAfter.ts", "../src/version.ts"],
  "sourcesContent": ["// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\nexport * from './joinVoiceChannel';\nexport * from './audio/index';\nexport * from './util/index';\n\nexport {\n  VoiceConnection,\n  type VoiceConnectionState,\n  VoiceConnectionStatus,\n  type VoiceConnectionConnectingState,\n  type VoiceConnectionDestroyedState,\n  type VoiceConnectionDisconnectedState,\n  type VoiceConnectionDisconnectedBaseState,\n  type VoiceConnectionDisconnectedOtherState,\n  type VoiceConnectionDisconnectedWebSocketState,\n  VoiceConnectionDisconnectReason,\n  type VoiceConnectionReadyState,\n  type VoiceConnectionSignallingState } from\n'./VoiceConnection';\n\nexport {\n  type JoinConfig,\n  getVoiceConnection,\n  getVoiceConnections,\n  getGroups } from\n'./DataStore';\n\nexport { version } from './version';", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\n/* eslint-disable @typescript-eslint/unbound-method, @typescript-eslint/no-unsafe-declaration-merging */\n/* eslint-disable @typescript-eslint/unbound-method */\nimport type { Buffer } from 'node:buffer';\nimport { EventEmitter } from 'node:events';\nimport type {\n  GatewayVoiceServerUpdateDispatchData,\n  GatewayVoiceStateUpdateDispatchData } from\n'discord-api-types/v10';\nimport type { JoinConfig } from './DataStore';\nimport {\n  getVoiceConnection,\n  createJoinVoiceChannelPayload,\n  trackVoiceConnection,\n  untrackVoiceConnection } from\n'./DataStore';\nimport type { AudioPlayer } from './audio/AudioPlayer';\nimport type { PlayerSubscription } from './audio/PlayerSubscription';\nimport {\n  Networking,\n  NetworkingStatusCode,\n  type NetworkingState } from\n'./networking/Networking';\nimport type { DiscordGatewayAdapterImplementerMethods } from './util/adapter';\nimport { noop } from './util/util';\nimport type { CreateVoiceConnectionOptions } from './index';\nimport { unsafe } from './common/types';\n\n/**\n * The various status codes a voice connection can hold at any one time.\n */\nexport enum VoiceConnectionStatus {\n  /**\n   * The `VOICE_SERVER_UPDATE` and `VOICE_STATE_UPDATE` packets have been received, now attempting to establish a voice connection.\n   */\n  Connecting = 'connecting',\n\n  /**\n   * The voice connection has been destroyed and untracked, it cannot be reused.\n   */\n  Destroyed = 'destroyed',\n\n  /**\n   * The voice connection has either been severed or not established.\n   */\n  Disconnected = 'disconnected',\n\n  /**\n   * A voice connection has been established, and is ready to be used.\n   */\n  Ready = 'ready',\n\n  /**\n   * Sending a packet to the main Discord gateway to indicate we want to change our voice state.\n   */\n  Signalling = 'signalling',\n}\n\n/**\n * The state that a VoiceConnection will be in when it is waiting to receive a VOICE_SERVER_UPDATE and\n * VOICE_STATE_UPDATE packet from Discord, provided by the adapter.\n */\nexport interface VoiceConnectionSignallingState {\n  adapter: DiscordGatewayAdapterImplementerMethods;\n  status: VoiceConnectionStatus.Signalling;\n  subscription?: PlayerSubscription | undefined;\n}\n\n/**\n * The reasons a voice connection can be in the disconnected state.\n */\nexport enum VoiceConnectionDisconnectReason {\n  /**\n   * When the WebSocket connection has been closed.\n   */\n  WebSocketClose,\n\n  /**\n   * When the adapter was unable to send a message requested by the VoiceConnection.\n   */\n  AdapterUnavailable,\n\n  /**\n   * When a VOICE_SERVER_UPDATE packet is received with a null endpoint, causing the connection to be severed.\n   */\n  EndpointRemoved,\n\n  /**\n   * When a manual disconnect was requested.\n   */\n  Manual,\n}\n\n/**\n * The state that a VoiceConnection will be in when it is not connected to a Discord voice server nor is\n * it attempting to connect. You can manually attempt to reconnect using VoiceConnection#reconnect.\n */\nexport interface VoiceConnectionDisconnectedBaseState {\n  adapter: DiscordGatewayAdapterImplementerMethods;\n  status: VoiceConnectionStatus.Disconnected;\n  subscription?: PlayerSubscription | undefined;\n}\n\n/**\n * The state that a VoiceConnection will be in when it is not connected to a Discord voice server nor is\n * it attempting to connect. You can manually attempt to reconnect using VoiceConnection#reconnect.\n */\nexport interface VoiceConnectionDisconnectedOtherState extends\n  VoiceConnectionDisconnectedBaseState {\n  reason: Exclude<\n    VoiceConnectionDisconnectReason,\n    VoiceConnectionDisconnectReason.WebSocketClose>;\n\n}\n\n/**\n * The state that a VoiceConnection will be in when its WebSocket connection was closed.\n * You can manually attempt to reconnect using VoiceConnection#reconnect.\n */\nexport interface VoiceConnectionDisconnectedWebSocketState extends\n  VoiceConnectionDisconnectedBaseState {\n  /**\n   * The close code of the WebSocket connection to the Discord voice server.\n   */\n  closeCode: number;\n\n  reason: VoiceConnectionDisconnectReason.WebSocketClose;\n}\n\n/**\n * The states that a VoiceConnection can be in when it is not connected to a Discord voice server nor is\n * it attempting to connect. You can manually attempt to connect using VoiceConnection#reconnect.\n */\nexport type VoiceConnectionDisconnectedState =\nVoiceConnectionDisconnectedOtherState |\nVoiceConnectionDisconnectedWebSocketState;\n\n/**\n * The state that a VoiceConnection will be in when it is establishing a connection to a Discord\n * voice server.\n */\nexport interface VoiceConnectionConnectingState {\n  adapter: DiscordGatewayAdapterImplementerMethods;\n  networking: Networking;\n  status: VoiceConnectionStatus.Connecting;\n  subscription?: PlayerSubscription | undefined;\n}\n\n/**\n * The state that a VoiceConnection will be in when it has an active connection to a Discord\n * voice server.\n */\nexport interface VoiceConnectionReadyState {\n  adapter: DiscordGatewayAdapterImplementerMethods;\n  networking: Networking;\n  status: VoiceConnectionStatus.Ready;\n  subscription?: PlayerSubscription | undefined;\n}\n\n/**\n * The state that a VoiceConnection will be in when it has been permanently been destroyed by the\n * user and untracked by the library. It cannot be reconnected, instead, a new VoiceConnection\n * needs to be established.\n */\nexport interface VoiceConnectionDestroyedState {\n  status: VoiceConnectionStatus.Destroyed;\n}\n\n/**\n * The various states that a voice connection can be in.\n */\nexport type VoiceConnectionState =\nVoiceConnectionConnectingState |\nVoiceConnectionDestroyedState |\nVoiceConnectionDisconnectedState |\nVoiceConnectionReadyState |\nVoiceConnectionSignallingState;\n\nexport interface VoiceConnection extends EventEmitter {\n  /**\n   * Emitted when there is an error emitted from the voice connection\n   *\n   * @eventProperty\n   */\n  on(event: 'error', listener: (error: Error) => void): this;\n  /**\n   * Emitted debugging information about the voice connection\n   *\n   * @eventProperty\n   */\n  on(event: 'debug', listener: (message: string) => void): this;\n  /**\n   * Emitted when the state of the voice connection changes\n   *\n   * @eventProperty\n   */\n  on(\n  event: 'stateChange',\n  listener: (\n  oldState: VoiceConnectionState,\n  newState: VoiceConnectionState)\n  => void)\n  : this;\n  /**\n   * Emitted when the end-to-end encrypted session has transitioned\n   *\n   * @eventProperty\n   */\n  on(event: 'transitioned', listener: (transitionId: number) => void): this;\n  /**\n   * Emitted when the state of the voice connection changes to a specific status\n   *\n   * @eventProperty\n   */\n  on<Event extends VoiceConnectionStatus>(\n  event: Event,\n  listener: (\n  oldState: VoiceConnectionState,\n  newState: VoiceConnectionState & {status: Event;})\n  => void)\n  : this;\n}\n\n/**\n * A connection to the voice server of a Guild, can be used to play audio in voice channels.\n */\nexport class VoiceConnection extends EventEmitter {\n  /**\n   * The number of consecutive rejoin attempts. Initially 0, and increments for each rejoin.\n   * When a connection is successfully established, it resets to 0.\n   */\n  public rejoinAttempts: number;\n\n  /**\n   * The state of the voice connection.\n   */\n  private _state: VoiceConnectionState;\n\n  /**\n   * A configuration storing all the data needed to reconnect to a Guild's voice server.\n   *\n   * @internal\n   */\n  public readonly joinConfig: JoinConfig;\n\n  /**\n   * The two packets needed to successfully establish a voice connection. They are received\n   * from the main Discord gateway after signalling to change the voice state.\n   */\n  private readonly packets: {\n    server: GatewayVoiceServerUpdateDispatchData | undefined;\n    state: GatewayVoiceStateUpdateDispatchData | undefined;\n  };\n\n  /**\n   * The debug logger function, if debugging is enabled.\n   */\n  private readonly debug: ((message: string) => void) | null;\n\n  /**\n   * The options used to create this voice connection.\n   */\n  private readonly options: CreateVoiceConnectionOptions;\n\n  /**\n   * Creates a new voice connection.\n   *\n   * @param joinConfig - The data required to establish the voice connection\n   * @param options - The options used to create this voice connection\n   */\n  public constructor(\n  joinConfig: JoinConfig,\n  options: CreateVoiceConnectionOptions)\n  {\n    super();\n\n    this.debug = options.debug ?\n    (message: string) => this.emit('debug', message) :\n    null;\n    this.rejoinAttempts = 0;\n\n    this.onNetworkingClose = this.onNetworkingClose.bind(this);\n    this.onNetworkingStateChange = this.onNetworkingStateChange.bind(this);\n    this.onNetworkingError = this.onNetworkingError.bind(this);\n    this.onNetworkingDebug = this.onNetworkingDebug.bind(this);\n    this.onNetworkingTransitioned = this.onNetworkingTransitioned.bind(this);\n\n    const adapter = options.adapterCreator({\n      onVoiceServerUpdate: (data) => this.addServerPacket(data),\n      onVoiceStateUpdate: (data) => this.addStatePacket(data),\n      destroy: () => this.destroy(false)\n    });\n\n    this._state = { status: VoiceConnectionStatus.Signalling, adapter };\n\n    this.packets = {\n      server: undefined,\n      state: undefined\n    };\n\n    this.joinConfig = joinConfig;\n    this.options = options;\n  }\n\n  /**\n   * The current state of the voice connection.\n   *\n   * @remarks\n   * The setter will perform clean-up operations where necessary.\n   */\n  public get state() {\n    return this._state;\n  }\n\n  public set state(newState: VoiceConnectionState) {\n    const oldState = this._state;\n    const oldNetworking = Reflect.get(oldState, 'networking') as\n    Networking |\n    undefined;\n    const newNetworking = Reflect.get(newState, 'networking') as\n    Networking |\n    undefined;\n\n    const oldSubscription = Reflect.get(oldState, 'subscription') as\n    PlayerSubscription |\n    undefined;\n    const newSubscription = Reflect.get(newState, 'subscription') as\n    PlayerSubscription |\n    undefined;\n\n    if (oldNetworking !== newNetworking) {\n      if (oldNetworking) {\n        oldNetworking.on('error', noop);\n        oldNetworking.off('debug', this.onNetworkingDebug);\n        oldNetworking.off('error', this.onNetworkingError);\n        oldNetworking.off('close', this.onNetworkingClose);\n        oldNetworking.off('stateChange', this.onNetworkingStateChange);\n        oldNetworking.off('transitioned', this.onNetworkingTransitioned);\n        oldNetworking.destroy();\n      }\n    }\n\n    if (newState.status === VoiceConnectionStatus.Ready) {\n      this.rejoinAttempts = 0;\n    }\n\n    // If destroyed, the adapter can also be destroyed so it can be cleaned up by the user\n    if (\n    oldState.status !== VoiceConnectionStatus.Destroyed &&\n    newState.status === VoiceConnectionStatus.Destroyed)\n    {\n      oldState.adapter.destroy();\n    }\n\n    this._state = newState;\n\n    if (oldSubscription && oldSubscription !== newSubscription) {\n      oldSubscription.unsubscribe();\n    }\n\n    this.emit('stateChange', oldState, newState);\n    if (oldState.status !== newState.status) {\n      this.emit(newState.status, oldState, newState as unsafe);\n    }\n  }\n\n  /**\n   * Registers a `VOICE_SERVER_UPDATE` packet to the voice connection. This will cause it to reconnect using the\n   * new data provided in the packet.\n   *\n   * @param packet - The received `VOICE_SERVER_UPDATE` packet\n   */\n  private addServerPacket(packet: GatewayVoiceServerUpdateDispatchData) {\n    this.packets.server = packet;\n    if (packet.endpoint) {\n      this.configureNetworking();\n    } else if (this.state.status !== VoiceConnectionStatus.Destroyed) {\n      this.state = {\n        ...this.state,\n        status: VoiceConnectionStatus.Disconnected,\n        reason: VoiceConnectionDisconnectReason.EndpointRemoved\n      };\n    }\n  }\n\n  /**\n   * Registers a `VOICE_STATE_UPDATE` packet to the voice connection. Most importantly, it stores the id of the\n   * channel that the client is connected to.\n   *\n   * @param packet - The received `VOICE_STATE_UPDATE` packet\n   */\n  private addStatePacket(packet: GatewayVoiceStateUpdateDispatchData) {\n    this.packets.state = packet;\n\n    if (packet.self_deaf !== undefined)\n    this.joinConfig.selfDeaf = packet.self_deaf;\n    if (packet.self_mute !== undefined)\n    this.joinConfig.selfMute = packet.self_mute;\n    if (packet.channel_id) this.joinConfig.channelId = packet.channel_id;\n    /*\n    the channel_id being null doesn't necessarily mean it was intended for the client to leave the voice channel\n    as it may have disconnected due to network failure. This will be gracefully handled once the voice websocket\n    dies, and then it is up to the user to decide how they wish to handle this.\n    */\n  }\n\n  /**\n   * Attempts to configure a networking instance for this voice connection using the received packets.\n   * Both packets are required, and any existing networking instance will be destroyed.\n   *\n   * @remarks\n   * This is called when the voice server of the connection changes, e.g. if the bot is moved into a\n   * different channel in the same guild but has a different voice server. In this instance, the connection\n   * needs to be re-established to the new voice server.\n   *\n   * The connection will transition to the Connecting state when this is called.\n   */\n  public configureNetworking() {\n    const { server, state } = this.packets;\n    if (\n    !server ||\n    !state ||\n    this.state.status === VoiceConnectionStatus.Destroyed ||\n    !server.endpoint)\n\n    return;\n\n    const networking = new Networking(\n      {\n        endpoint: server.endpoint,\n        serverId: server.guild_id,\n        token: server.token,\n        sessionId: state.session_id,\n        userId: state.user_id,\n        channelId: state.channel_id!\n      },\n      {\n        debug: Boolean(this.debug),\n        daveEncryption: this.options.daveEncryption ?? true,\n        decryptionFailureTolerance: this.options.decryptionFailureTolerance\n      }\n    );\n\n    networking.once('close', this.onNetworkingClose);\n    networking.on('stateChange', this.onNetworkingStateChange);\n    networking.on('error', this.onNetworkingError);\n    networking.on('debug', this.onNetworkingDebug);\n    networking.on('transitioned', this.onNetworkingTransitioned);\n\n    this.state = {\n      ...this.state,\n      status: VoiceConnectionStatus.Connecting,\n      networking\n    };\n  }\n\n  /**\n   * Called when the networking instance for this connection closes. If the close code is 4014 (do not reconnect),\n   * the voice connection will transition to the Disconnected state which will store the close code. You can\n   * decide whether or not to reconnect when this occurs by listening for the state change and calling reconnect().\n   *\n   * @remarks\n   * If the close code was anything other than 4014, it is likely that the closing was not intended, and so the\n   * VoiceConnection will signal to Discord that it would like to rejoin the channel. This automatically attempts\n   * to re-establish the connection. This would be seen as a transition from the Ready state to the Signalling state.\n   * @param code - The close code\n   */\n  private onNetworkingClose(code: number) {\n    if (this.state.status === VoiceConnectionStatus.Destroyed) return;\n    // If networking closes, try to connect to the voice channel again.\n    if (code === 4_014) {\n      // Disconnected - networking is already destroyed here\n      this.state = {\n        ...this.state,\n        status: VoiceConnectionStatus.Disconnected,\n        reason: VoiceConnectionDisconnectReason.WebSocketClose,\n        closeCode: code\n      };\n    } else {\n      this.state = {\n        ...this.state,\n        status: VoiceConnectionStatus.Signalling\n      };\n      this.rejoinAttempts++;\n      if (\n      !this.state.adapter.sendPayload(\n        createJoinVoiceChannelPayload(this.joinConfig)\n      ))\n      {\n        this.state = {\n          ...this.state,\n          status: VoiceConnectionStatus.Disconnected,\n          reason: VoiceConnectionDisconnectReason.AdapterUnavailable\n        };\n      }\n    }\n  }\n\n  /**\n   * Called when the state of the networking instance changes. This is used to derive the state of the voice connection.\n   *\n   * @param oldState - The previous state\n   * @param newState - The new state\n   */\n  private onNetworkingStateChange(\n  oldState: NetworkingState,\n  newState: NetworkingState)\n  {\n    if (oldState.code === newState.code) return;\n    if (\n    this.state.status !== VoiceConnectionStatus.Connecting &&\n    this.state.status !== VoiceConnectionStatus.Ready)\n\n    return;\n\n    if (newState.code === NetworkingStatusCode.Ready) {\n      this.state = {\n        ...this.state,\n        status: VoiceConnectionStatus.Ready\n      };\n    } else if (newState.code !== NetworkingStatusCode.Closed) {\n      this.state = {\n        ...this.state,\n        status: VoiceConnectionStatus.Connecting\n      };\n    }\n  }\n\n  /**\n   * Propagates errors from the underlying network instance.\n   *\n   * @param error - The error to propagate\n   */\n  private onNetworkingError(error: Error) {\n    this.emit('error', error);\n  }\n\n  /**\n   * Propagates debug messages from the underlying network instance.\n   *\n   * @param message - The debug message to propagate\n   */\n  private onNetworkingDebug(message: string) {\n    this.debug?.(`[NW] ${message}`);\n  }\n\n  /**\n   * Propagates transitions from the underlying network instance.\n   *\n   * @param transitionId - The transition id\n   */\n  private onNetworkingTransitioned(transitionId: number) {\n    this.emit('transitioned', transitionId);\n  }\n\n  /**\n   * Prepares an audio packet for dispatch.\n   *\n   * @param buffer - The Opus packet to prepare\n   */\n  public prepareAudioPacket(buffer: Buffer) {\n    const state = this.state;\n    if (state.status !== VoiceConnectionStatus.Ready) return;\n    return state.networking.prepareAudioPacket(buffer);\n  }\n\n  /**\n   * Dispatches the previously prepared audio packet (if any)\n   */\n  public dispatchAudio() {\n    const state = this.state;\n    if (state.status !== VoiceConnectionStatus.Ready) return;\n    return state.networking.dispatchAudio();\n  }\n\n  /**\n   * Prepares an audio packet and dispatches it immediately.\n   *\n   * @param buffer - The Opus packet to play\n   */\n  public playOpusPacket(buffer: Buffer) {\n    const state = this.state;\n    if (state.status !== VoiceConnectionStatus.Ready) return;\n    state.networking.prepareAudioPacket(buffer);\n    return state.networking.dispatchAudio();\n  }\n\n  /**\n   * Destroys the VoiceConnection, preventing it from connecting to voice again.\n   * This method should be called when you no longer require the VoiceConnection to\n   * prevent memory leaks.\n   *\n   * @param adapterAvailable - Whether the adapter can be used\n   */\n  public destroy(adapterAvailable = true) {\n    if (this.state.status === VoiceConnectionStatus.Destroyed) {\n      throw new Error(\n        'Cannot destroy VoiceConnection - it has already been destroyed'\n      );\n    }\n\n    if (\n    getVoiceConnection(this.joinConfig.guildId, this.joinConfig.group) ===\n    this)\n    {\n      untrackVoiceConnection(this);\n    }\n\n    if (adapterAvailable) {\n      this.state.adapter.sendPayload(\n        createJoinVoiceChannelPayload({ ...this.joinConfig, channelId: null })\n      );\n    }\n\n    this.state = {\n      status: VoiceConnectionStatus.Destroyed\n    };\n  }\n\n  /**\n   * Disconnects the VoiceConnection, allowing the possibility of rejoining later on.\n   *\n   * @returns `true` if the connection was successfully disconnected\n   */\n  public disconnect() {\n    if (\n    this.state.status === VoiceConnectionStatus.Destroyed ||\n    this.state.status === VoiceConnectionStatus.Signalling)\n    {\n      return false;\n    }\n\n    this.joinConfig.channelId = null;\n    if (\n    !this.state.adapter.sendPayload(\n      createJoinVoiceChannelPayload(this.joinConfig)\n    ))\n    {\n      this.state = {\n        adapter: this.state.adapter,\n        subscription: this.state.subscription,\n        status: VoiceConnectionStatus.Disconnected,\n        reason: VoiceConnectionDisconnectReason.AdapterUnavailable\n      };\n      return false;\n    }\n\n    this.state = {\n      adapter: this.state.adapter,\n      reason: VoiceConnectionDisconnectReason.Manual,\n      status: VoiceConnectionStatus.Disconnected\n    };\n    return true;\n  }\n\n  /**\n   * Attempts to rejoin (better explanation soon:tm:)\n   *\n   * @remarks\n   * Calling this method successfully will automatically increment the `rejoinAttempts` counter,\n   * which you can use to inform whether or not you'd like to keep attempting to reconnect your\n   * voice connection.\n   *\n   * A state transition from Disconnected to Signalling will be observed when this is called.\n   */\n  public rejoin(joinConfig?: Omit<JoinConfig, 'group' | 'guildId'>) {\n    if (this.state.status === VoiceConnectionStatus.Destroyed) {\n      return false;\n    }\n\n    const notReady = this.state.status !== VoiceConnectionStatus.Ready;\n\n    if (notReady) this.rejoinAttempts++;\n    Object.assign(this.joinConfig, joinConfig);\n    if (\n    this.state.adapter.sendPayload(\n      createJoinVoiceChannelPayload(this.joinConfig)\n    ))\n    {\n      if (notReady) {\n        this.state = {\n          ...this.state,\n          status: VoiceConnectionStatus.Signalling\n        };\n      }\n\n      return true;\n    }\n\n    this.state = {\n      adapter: this.state.adapter,\n      subscription: this.state.subscription,\n      status: VoiceConnectionStatus.Disconnected,\n      reason: VoiceConnectionDisconnectReason.AdapterUnavailable\n    };\n    return false;\n  }\n\n  /**\n   * Updates the speaking status of the voice connection. This is used when audio players are done playing audio,\n   * and need to signal that the connection is no longer playing audio.\n   *\n   * @param enabled - Whether or not to show as speaking\n   */\n  public setSpeaking(enabled: boolean) {\n    if (this.state.status !== VoiceConnectionStatus.Ready) return false;\n    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression\n    return this.state.networking.setSpeaking(enabled);\n  }\n\n  /**\n   * Subscribes to an audio player, allowing the player to play audio on this voice connection.\n   *\n   * @param player - The audio player to subscribe to\n   * @returns The created subscription\n   */\n  public subscribe(player: AudioPlayer) {\n    if (this.state.status === VoiceConnectionStatus.Destroyed) return;\n\n    // eslint-disable-next-line @typescript-eslint/dot-notation\n    const subscription = player['subscribe'](this);\n\n    this.state = {\n      ...this.state,\n      subscription\n    };\n\n    return subscription;\n  }\n\n  /**\n   * The latest ping (in milliseconds) for the WebSocket connection and audio playback for this voice\n   * connection, if this data is available.\n   *\n   * @remarks\n   * For this data to be available, the VoiceConnection must be in the Ready state, and its underlying\n   * WebSocket connection and UDP socket must have had at least one ping-pong exchange.\n   */\n  public get ping() {\n    if (\n    this.state.status === VoiceConnectionStatus.Ready &&\n    this.state.networking.state.code === NetworkingStatusCode.Ready)\n    {\n      return {\n        ws: this.state.networking.state.ws.ping,\n        udp: this.state.networking.state.udp.ping\n      };\n    }\n\n    return {\n      ws: undefined,\n      udp: undefined\n    };\n  }\n\n  /**\n   * The current voice privacy code of the encrypted session.\n   *\n   * @remarks\n   * For this data to be available, the VoiceConnection must be in the Ready state,\n   * and the connection would have to be end-to-end encrypted.\n   */\n  public get voicePrivacyCode() {\n    if (\n    this.state.status === VoiceConnectionStatus.Ready &&\n    this.state.networking.state.code === NetworkingStatusCode.Ready)\n    {\n      return this.state.networking.state.dave?.voicePrivacyCode ?? undefined;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Gets the verification code for a user in the session.\n   *\n   * @throws Will throw if end-to-end encryption is not on or if the user id provided is not in the session.\n   */\n  public async getVerificationCode(userId: string): Promise<string> {\n    if (\n    this.state.status === VoiceConnectionStatus.Ready &&\n    this.state.networking.state.code === NetworkingStatusCode.Ready &&\n    this.state.networking.state.dave)\n    {\n      return this.state.networking.state.dave.getVerificationCode(userId);\n    }\n\n    throw new Error('Session not available');\n  }\n\n  /**\n   * Called when a subscription of this voice connection to an audio player is removed.\n   *\n   * @param subscription - The removed subscription\n   */\n  protected onSubscriptionRemoved(subscription: PlayerSubscription) {\n    if (\n    this.state.status !== VoiceConnectionStatus.Destroyed &&\n    this.state.subscription === subscription)\n    {\n      this.state = {\n        ...this.state,\n        subscription: undefined\n      };\n    }\n  }\n}\n\n/**\n * Creates a new voice connection.\n *\n * @param joinConfig - The data required to establish the voice connection\n * @param options - The options to use when joining the voice channel\n */\nexport function createVoiceConnection(\njoinConfig: JoinConfig,\noptions: CreateVoiceConnectionOptions)\n{\n  const payload = createJoinVoiceChannelPayload(joinConfig);\n  const existing = getVoiceConnection(joinConfig.guildId, joinConfig.group);\n  if (existing && existing.state.status !== VoiceConnectionStatus.Destroyed) {\n    if (existing.state.status === VoiceConnectionStatus.Disconnected) {\n      existing.rejoin({\n        channelId: joinConfig.channelId,\n        selfDeaf: joinConfig.selfDeaf,\n        selfMute: joinConfig.selfMute\n      });\n    } else if (!existing.state.adapter.sendPayload(payload)) {\n      existing.state = {\n        ...existing.state,\n        status: VoiceConnectionStatus.Disconnected,\n        reason: VoiceConnectionDisconnectReason.AdapterUnavailable\n      };\n    }\n\n    return existing;\n  }\n\n  const voiceConnection = new VoiceConnection(joinConfig, options);\n  trackVoiceConnection(voiceConnection);\n  if (\n  voiceConnection.state.status !== VoiceConnectionStatus.Destroyed &&\n  !voiceConnection.state.adapter.sendPayload(payload))\n  {\n    voiceConnection.state = {\n      ...voiceConnection.state,\n      status: VoiceConnectionStatus.Disconnected,\n      reason: VoiceConnectionDisconnectReason.AdapterUnavailable\n    };\n  }\n\n  return voiceConnection;\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\nimport { GatewayOpcodes } from 'discord-api-types/v10';\nimport type { VoiceConnection } from './VoiceConnection';\nimport type { AudioPlayer } from './audio/index';\n\nexport interface JoinConfig {\n  channelId: string | null;\n  group: string;\n  guildId: string;\n  selfDeaf: boolean;\n  selfMute: boolean;\n}\n\n/**\n * Sends a voice state update to the main websocket shard of a guild, to indicate joining/leaving/moving across\n * voice channels.\n *\n * @param config - The configuration to use when joining the voice channel\n */\nexport function createJoinVoiceChannelPayload(config: JoinConfig) {\n  return {\n    op: GatewayOpcodes.VoiceStateUpdate,\n    // eslint-disable-next-line id-length\n    d: {\n      guild_id: config.guildId,\n      channel_id: config.channelId,\n      self_deaf: config.selfDeaf,\n      self_mute: config.selfMute\n    }\n  };\n}\n\n// Voice Connections\nconst groups = new Map<string, Map<string, VoiceConnection>>();\ngroups.set('default', new Map());\n\nfunction getOrCreateGroup(group: string) {\n  const existing = groups.get(group);\n  if (existing) return existing;\n  const map = new Map<string, VoiceConnection>();\n  groups.set(group, map);\n  return map;\n}\n\n/**\n * Retrieves the map of group names to maps of voice connections. By default, all voice connections\n * are created under the 'default' group.\n *\n * @returns The group map\n */\nexport function getGroups() {\n  return groups;\n}\n\n/**\n * Retrieves all the voice connections under the 'default' group.\n *\n * @param group - The group to look up\n * @returns The map of voice connections\n */\nexport function getVoiceConnections(\ngroup?: 'default')\n: Map<string, VoiceConnection>;\n\n/**\n * Retrieves all the voice connections under the given group name.\n *\n * @param group - The group to look up\n * @returns The map of voice connections\n */\nexport function getVoiceConnections(\ngroup: string)\n: Map<string, VoiceConnection> | undefined;\n\n/**\n * Retrieves all the voice connections under the given group name. Defaults to the 'default' group.\n *\n * @param group - The group to look up\n * @returns The map of voice connections\n */\nexport function getVoiceConnections(group = 'default') {\n  return groups.get(group);\n}\n\n/**\n * Finds a voice connection with the given guild id and group. Defaults to the 'default' group.\n *\n * @param guildId - The guild id of the voice connection\n * @param group - the group that the voice connection was registered with\n * @returns The voice connection, if it exists\n */\nexport function getVoiceConnection(guildId: string, group = 'default') {\n  return getVoiceConnections(group)?.get(guildId);\n}\n\nexport function untrackVoiceConnection(voiceConnection: VoiceConnection) {\n  return getVoiceConnections(voiceConnection.joinConfig.group)?.delete(\n    voiceConnection.joinConfig.guildId\n  );\n}\n\nexport function trackVoiceConnection(voiceConnection: VoiceConnection) {\n  return getOrCreateGroup(voiceConnection.joinConfig.group).set(\n    voiceConnection.joinConfig.guildId,\n    voiceConnection\n  );\n}\n\n// Audio Players\n\n// Each audio packet is 20ms long\nconst FRAME_LENGTH = 20;\n\nlet audioCycleInterval: NodeJS.Timeout | undefined;\nlet nextTime = -1;\n\n/**\n * A list of created audio players that are still active and haven't been destroyed.\n */\nconst audioPlayers: AudioPlayer[] = [];\n\n/**\n * Called roughly every 20 milliseconds. Dispatches audio from all players, and then gets the players to prepare\n * the next audio frame.\n */\nfunction audioCycleStep() {\n  if (nextTime === -1) return;\n\n  nextTime += FRAME_LENGTH;\n  const available = audioPlayers.filter((player) => player.checkPlayable());\n\n  for (const player of available) {\n    // eslint-disable-next-line @typescript-eslint/dot-notation\n    player['_stepDispatch']();\n  }\n\n  prepareNextAudioFrame(available);\n}\n\n/**\n * Recursively gets the players that have been passed as parameters to prepare audio frames that can be played\n * at the start of the next cycle.\n */\nfunction prepareNextAudioFrame(players: AudioPlayer[]) {\n  const nextPlayer = players.shift();\n\n  if (!nextPlayer) {\n    if (nextTime >= 0) {\n      audioCycleInterval = setTimeout(\n        () => audioCycleStep(),\n        Math.max(nextTime - Date.now(), 1)\n      );\n    }\n\n    return;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/dot-notation\n  nextPlayer['_stepPrepare']();\n\n  // setImmediate to avoid long audio player chains blocking other scheduled tasks\n  setImmediate(() => prepareNextAudioFrame(players));\n}\n\n/**\n * Checks whether or not the given audio player is being driven by the data store clock.\n *\n * @param target - The target to test for\n * @returns `true` if it is being tracked, `false` otherwise\n */\nexport function hasAudioPlayer(target: AudioPlayer) {\n  return audioPlayers.includes(target);\n}\n\n/**\n * Adds an audio player to the data store tracking list, if it isn't already there.\n *\n * @param player - The player to track\n */\nexport function addAudioPlayer(player: AudioPlayer) {\n  if (hasAudioPlayer(player)) return player;\n  audioPlayers.push(player);\n  if (audioPlayers.length === 1) {\n    nextTime = Date.now();\n    setImmediate(() => audioCycleStep());\n  }\n\n  return player;\n}\n\n/**\n * Removes an audio player from the data store tracking list, if it is present there.\n */\nexport function deleteAudioPlayer(player: AudioPlayer) {\n  const index = audioPlayers.indexOf(player);\n  if (index === -1) return;\n  audioPlayers.splice(index, 1);\n  if (audioPlayers.length === 0) {\n    nextTime = -1;\n    if (audioCycleInterval !== undefined) clearTimeout(audioCycleInterval);\n  }\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\n/* eslint-disable id-length */\n/* eslint-disable @typescript-eslint/unbound-method, @typescript-eslint/no-unsafe-declaration-merging */\nimport { Buffer } from 'node:buffer';\nimport crypto from 'node:crypto';\nimport { EventEmitter } from 'node:events';\nimport type {\n  VoiceReceivePayload,\n  VoiceSpeakingFlags } from\n'discord-api-types/voice/v8';\nimport { VoiceEncryptionMode, VoiceOpcodes } from 'discord-api-types/voice/v8';\nimport type { CloseEvent } from 'ws';\nimport * as secretbox from '../util/Secretbox';\nimport { noop } from '../util/util';\nimport { DAVESession, getMaxProtocolVersion } from './DAVESession';\nimport { VoiceUDPSocket } from './VoiceUDPSocket';\nimport type { BinaryWebSocketMessage } from './VoiceWebSocket';\nimport { VoiceWebSocket } from './VoiceWebSocket';\n\n// The number of audio channels required by Discord\nconst CHANNELS = 2;\nconst TIMESTAMP_INC = 48_000 / 100 * CHANNELS;\nconst MAX_NONCE_SIZE = 2 ** 32 - 1;\n\nexport const SUPPORTED_ENCRYPTION_MODES: VoiceEncryptionMode[] = [\nVoiceEncryptionMode.AeadXChaCha20Poly1305RtpSize];\n\n\n// Just in case there's some system that doesn't come with aes-256-gcm, conditionally add it as supported\nif (crypto.getCiphers().includes('aes-256-gcm')) {\n  SUPPORTED_ENCRYPTION_MODES.unshift(VoiceEncryptionMode.AeadAes256GcmRtpSize);\n}\n\n/**\n * The different statuses that a networking instance can hold. The order\n * of the states between OpeningWs and Ready is chronological (first the\n * instance enters OpeningWs, then it enters Identifying etc.)\n */\nexport enum NetworkingStatusCode {\n  OpeningWs,\n  Identifying,\n  UdpHandshaking,\n  SelectingProtocol,\n  Ready,\n  Resuming,\n  Closed,\n}\n\n/**\n * The initial Networking state. Instances will be in this state when a WebSocket connection to a Discord\n * voice gateway is being opened.\n */\nexport interface NetworkingOpeningWsState {\n  code: NetworkingStatusCode.OpeningWs;\n  connectionOptions: ConnectionOptions;\n  ws: VoiceWebSocket;\n}\n\n/**\n * The state that a Networking instance will be in when it is attempting to authorize itself.\n */\nexport interface NetworkingIdentifyingState {\n  code: NetworkingStatusCode.Identifying;\n  connectionOptions: ConnectionOptions;\n  ws: VoiceWebSocket;\n}\n\n/**\n * The state that a Networking instance will be in when opening a UDP connection to the IP and port provided\n * by Discord, as well as performing IP discovery.\n */\nexport interface NetworkingUdpHandshakingState {\n  code: NetworkingStatusCode.UdpHandshaking;\n  connectionData: Pick<ConnectionData, 'connectedClients' | 'ssrc'>;\n  connectionOptions: ConnectionOptions;\n  udp: VoiceUDPSocket;\n  ws: VoiceWebSocket;\n}\n\n/**\n * The state that a Networking instance will be in when selecting an encryption protocol for audio packets.\n */\nexport interface NetworkingSelectingProtocolState {\n  code: NetworkingStatusCode.SelectingProtocol;\n  connectionData: Pick<ConnectionData, 'connectedClients' | 'ssrc'>;\n  connectionOptions: ConnectionOptions;\n  udp: VoiceUDPSocket;\n  ws: VoiceWebSocket;\n}\n\n/**\n * The state that a Networking instance will be in when it has a fully established connection to a Discord\n * voice server.\n */\nexport interface NetworkingReadyState {\n  code: NetworkingStatusCode.Ready;\n  connectionData: ConnectionData;\n  connectionOptions: ConnectionOptions;\n  dave?: DAVESession | undefined;\n  preparedPacket?: Buffer | undefined;\n  udp: VoiceUDPSocket;\n  ws: VoiceWebSocket;\n}\n\n/**\n * The state that a Networking instance will be in when its connection has been dropped unexpectedly, and it\n * is attempting to resume an existing session.\n */\nexport interface NetworkingResumingState {\n  code: NetworkingStatusCode.Resuming;\n  connectionData: ConnectionData;\n  connectionOptions: ConnectionOptions;\n  dave?: DAVESession | undefined;\n  preparedPacket?: Buffer | undefined;\n  udp: VoiceUDPSocket;\n  ws: VoiceWebSocket;\n}\n\n/**\n * The state that a Networking instance will be in when it has been destroyed. It cannot be recovered from this\n * state.\n */\nexport interface NetworkingClosedState {\n  code: NetworkingStatusCode.Closed;\n}\n\n/**\n * The various states that a networking instance can be in.\n */\nexport type NetworkingState =\nNetworkingClosedState |\nNetworkingIdentifyingState |\nNetworkingOpeningWsState |\nNetworkingReadyState |\nNetworkingResumingState |\nNetworkingSelectingProtocolState |\nNetworkingUdpHandshakingState;\n\n/**\n * Details required to connect to the Discord voice gateway. These details\n * are first received on the main bot gateway, in the form of VOICE_SERVER_UPDATE\n * and VOICE_STATE_UPDATE packets.\n */\nexport interface ConnectionOptions {\n  channelId: string;\n  endpoint: string;\n  serverId: string;\n  sessionId: string;\n  token: string;\n  userId: string;\n}\n\n/**\n * Information about the current connection, e.g. which encryption mode is to be used on\n * the connection, timing information for playback of streams.\n */\nexport interface ConnectionData {\n  connectedClients: Set<string>;\n  encryptionMode: string;\n  nonce: number;\n  nonceBuffer: Buffer;\n  packetsPlayed: number;\n  secretKey: Uint8Array;\n  sequence: number;\n  speaking: boolean;\n  ssrc: number;\n  timestamp: number;\n}\n\n/**\n * Options for networking that dictate behavior.\n */\nexport interface NetworkingOptions {\n  daveEncryption?: boolean | undefined;\n  debug?: boolean | undefined;\n  decryptionFailureTolerance?: number | undefined;\n}\n\n/**\n * An empty buffer that is reused in packet encryption by many different networking instances.\n */\nconst nonce = Buffer.alloc(24);\n\nexport interface Networking extends EventEmitter {\n  /**\n   * Debug event for Networking.\n   *\n   * @eventProperty\n   */\n  on(event: 'debug', listener: (message: string) => void): this;\n  on(event: 'error', listener: (error: Error) => void): this;\n  on(\n  event: 'stateChange',\n  listener: (oldState: NetworkingState, newState: NetworkingState) => void)\n  : this;\n  on(event: 'close', listener: (code: number) => void): this;\n  on(event: 'transitioned', listener: (transitionId: number) => void): this;\n}\n\n/**\n * Stringifies a NetworkingState.\n *\n * @param state - The state to stringify\n */\nfunction stringifyState(state: NetworkingState) {\n  return JSON.stringify({\n    ...state,\n    ws: Reflect.has(state, 'ws'),\n    udp: Reflect.has(state, 'udp')\n  });\n}\n\n/**\n * Chooses an encryption mode from a list of given options. Chooses the most preferred option.\n *\n * @param options - The available encryption options\n */\nfunction chooseEncryptionMode(\noptions: VoiceEncryptionMode[])\n: VoiceEncryptionMode {\n  const option = options.find((option) =>\n  SUPPORTED_ENCRYPTION_MODES.includes(option)\n  );\n  if (!option) {\n    // This should only ever happen if the gateway does not give us any encryption modes we support.\n    throw new Error(\n      `No compatible encryption modes. Available include: ${options.join(\n        ', '\n      )}`\n    );\n  }\n\n  return option;\n}\n\n/**\n * Returns a random number that is in the range of n bits.\n *\n * @param numberOfBits - The number of bits\n */\nfunction randomNBit(numberOfBits: number) {\n  return Math.floor(Math.random() * 2 ** numberOfBits);\n}\n\n/**\n * Manages the networking required to maintain a voice connection and dispatch audio packets\n */\nexport class Networking extends EventEmitter {\n  private _state: NetworkingState;\n\n  /**\n   * The debug logger function, if debugging is enabled.\n   */\n  private readonly debug: ((message: string) => void) | null;\n\n  /**\n   * The options used to create this Networking instance.\n   */\n  private readonly options: NetworkingOptions;\n\n  /**\n   * Creates a new Networking instance.\n   */\n  public constructor(\n  connectionOptions: ConnectionOptions,\n  options: NetworkingOptions)\n  {\n    super();\n\n    this.onWsOpen = this.onWsOpen.bind(this);\n    this.onChildError = this.onChildError.bind(this);\n    this.onWsPacket = this.onWsPacket.bind(this);\n    this.onWsBinary = this.onWsBinary.bind(this);\n    this.onWsClose = this.onWsClose.bind(this);\n    this.onWsDebug = this.onWsDebug.bind(this);\n    this.onUdpDebug = this.onUdpDebug.bind(this);\n    this.onUdpClose = this.onUdpClose.bind(this);\n    this.onDaveDebug = this.onDaveDebug.bind(this);\n    this.onDaveKeyPackage = this.onDaveKeyPackage.bind(this);\n    this.onDaveInvalidateTransition =\n    this.onDaveInvalidateTransition.bind(this);\n\n    this.debug = options?.debug ?\n    (message: string) => this.emit('debug', message) :\n    null;\n\n    this._state = {\n      code: NetworkingStatusCode.OpeningWs,\n      ws: this.createWebSocket(connectionOptions.endpoint),\n      connectionOptions\n    };\n    this.options = options;\n  }\n\n  /**\n   * Destroys the Networking instance, transitioning it into the Closed state.\n   */\n  public destroy() {\n    this.state = {\n      code: NetworkingStatusCode.Closed\n    };\n  }\n\n  /**\n   * The current state of the networking instance.\n   *\n   * @remarks\n   * The setter will perform clean-up operations where necessary.\n   */\n  public get state(): NetworkingState {\n    return this._state;\n  }\n\n  public set state(newState: NetworkingState) {\n    const oldWs = Reflect.get(this._state, 'ws') as VoiceWebSocket | undefined;\n    const newWs = Reflect.get(newState, 'ws') as VoiceWebSocket | undefined;\n    if (oldWs && oldWs !== newWs) {\n      // The old WebSocket is being freed - remove all handlers from it\n      oldWs.off('debug', this.onWsDebug);\n      oldWs.on('error', noop);\n      oldWs.off('error', this.onChildError);\n      oldWs.off('open', this.onWsOpen);\n      oldWs.off('packet', this.onWsPacket);\n      oldWs.off('binary', this.onWsBinary);\n      oldWs.off('close', this.onWsClose);\n      oldWs.destroy();\n    }\n\n    const oldUdp = Reflect.get(this._state, 'udp') as\n    VoiceUDPSocket |\n    undefined;\n    const newUdp = Reflect.get(newState, 'udp') as VoiceUDPSocket | undefined;\n\n    if (oldUdp && oldUdp !== newUdp) {\n      oldUdp.on('error', noop);\n      oldUdp.off('error', this.onChildError);\n      oldUdp.off('close', this.onUdpClose);\n      oldUdp.off('debug', this.onUdpDebug);\n      oldUdp.destroy();\n    }\n\n    const oldDave = Reflect.get(this._state, 'dave') as DAVESession | undefined;\n    const newDave = Reflect.get(newState, 'dave') as DAVESession | undefined;\n\n    if (oldDave && oldDave !== newDave) {\n      oldDave.off('error', this.onChildError);\n      oldDave.off('debug', this.onDaveDebug);\n      oldDave.off('keyPackage', this.onDaveKeyPackage);\n      oldDave.off('invalidateTransition', this.onDaveInvalidateTransition);\n      oldDave.destroy();\n    }\n\n    const oldState = this._state;\n    this._state = newState;\n    this.emit('stateChange', oldState, newState);\n\n    this.debug?.(\n      `state change:\\nfrom ${stringifyState(oldState)}\\nto ${stringifyState(\n        newState\n      )}`\n    );\n  }\n\n  /**\n   * Creates a new WebSocket to a Discord Voice gateway.\n   *\n   * @param endpoint - The endpoint to connect to\n   * @param lastSequence - The last sequence to set for this WebSocket\n   */\n  private createWebSocket(endpoint: string, lastSequence?: number) {\n    const ws = new VoiceWebSocket(`wss://${endpoint}?v=8`, Boolean(this.debug));\n\n    if (lastSequence !== undefined) {\n      ws.sequence = lastSequence;\n    }\n\n    ws.on('error', this.onChildError);\n    ws.once('open', this.onWsOpen);\n    ws.on('packet', this.onWsPacket);\n    ws.on('binary', this.onWsBinary);\n    ws.once('close', this.onWsClose);\n    ws.on('debug', this.onWsDebug);\n\n    return ws;\n  }\n\n  /**\n   * Creates a new DAVE session for this voice connection if we can create one.\n   *\n   * @param protocolVersion - The protocol version to use\n   */\n  private createDaveSession(protocolVersion: number) {\n    if (\n    this.options.daveEncryption === false ||\n    this.state.code !== NetworkingStatusCode.SelectingProtocol &&\n    this.state.code !== NetworkingStatusCode.Ready &&\n    this.state.code !== NetworkingStatusCode.Resuming)\n    {\n      return;\n    }\n\n    const session = new DAVESession(\n      protocolVersion,\n      this.state.connectionOptions.userId,\n      this.state.connectionOptions.channelId,\n      {\n        decryptionFailureTolerance: this.options.decryptionFailureTolerance\n      }\n    );\n\n    session.on('error', this.onChildError);\n    session.on('debug', this.onDaveDebug);\n    session.on('keyPackage', this.onDaveKeyPackage);\n    session.on('invalidateTransition', this.onDaveInvalidateTransition);\n    session.reinit();\n\n    return session;\n  }\n\n  /**\n   * Propagates errors from the children VoiceWebSocket, VoiceUDPSocket and DAVESession.\n   *\n   * @param error - The error that was emitted by a child\n   */\n  private onChildError(error: Error) {\n    this.emit('error', error);\n  }\n\n  /**\n   * Called when the WebSocket opens. Depending on the state that the instance is in,\n   * it will either identify with a new session, or it will attempt to resume an existing session.\n   */\n  private onWsOpen() {\n    if (this.state.code === NetworkingStatusCode.OpeningWs) {\n      this.state.ws.sendPacket({\n        op: VoiceOpcodes.Identify,\n        d: {\n          server_id: this.state.connectionOptions.serverId,\n          user_id: this.state.connectionOptions.userId,\n          session_id: this.state.connectionOptions.sessionId,\n          token: this.state.connectionOptions.token,\n          max_dave_protocol_version:\n          this.options.daveEncryption === false ? 0 : getMaxProtocolVersion()\n        }\n      });\n      this.state = {\n        ...this.state,\n        code: NetworkingStatusCode.Identifying\n      };\n    } else if (this.state.code === NetworkingStatusCode.Resuming) {\n      this.state.ws.sendPacket({\n        op: VoiceOpcodes.Resume,\n        d: {\n          server_id: this.state.connectionOptions.serverId,\n          session_id: this.state.connectionOptions.sessionId,\n          token: this.state.connectionOptions.token,\n          seq_ack: this.state.ws.sequence\n        }\n      });\n    }\n  }\n\n  /**\n   * Called when the WebSocket closes. Based on the reason for closing (given by the code parameter),\n   * the instance will either attempt to resume, or enter the closed state and emit a 'close' event\n   * with the close code, allowing the user to decide whether or not they would like to reconnect.\n   *\n   * @param code - The close code\n   */\n  private onWsClose({ code }: CloseEvent) {\n    const canResume = code === 4_015 || code < 4_000;\n    if (canResume && this.state.code === NetworkingStatusCode.Ready) {\n      const lastSequence = this.state.ws.sequence;\n      this.state = {\n        ...this.state,\n        code: NetworkingStatusCode.Resuming,\n        ws: this.createWebSocket(\n          this.state.connectionOptions.endpoint,\n          lastSequence\n        )\n      };\n    } else if (this.state.code !== NetworkingStatusCode.Closed) {\n      this.destroy();\n      this.emit('close', code);\n    }\n  }\n\n  /**\n   * Called when the UDP socket has closed itself if it has stopped receiving replies from Discord.\n   */\n  private onUdpClose() {\n    if (this.state.code === NetworkingStatusCode.Ready) {\n      const lastSequence = this.state.ws.sequence;\n      this.state = {\n        ...this.state,\n        code: NetworkingStatusCode.Resuming,\n        ws: this.createWebSocket(\n          this.state.connectionOptions.endpoint,\n          lastSequence\n        )\n      };\n    }\n  }\n\n  /**\n   * Called when a packet is received on the connection's WebSocket.\n   *\n   * @param packet - The received packet\n   */\n  private onWsPacket(packet: VoiceReceivePayload) {\n    if (\n    packet.op === VoiceOpcodes.Hello &&\n    this.state.code !== NetworkingStatusCode.Closed)\n    {\n      this.state.ws.setHeartbeatInterval(packet.d.heartbeat_interval);\n    } else if (\n    packet.op === VoiceOpcodes.Ready &&\n    this.state.code === NetworkingStatusCode.Identifying)\n    {\n      const { ip, port, ssrc, modes } = packet.d;\n\n      const udp = new VoiceUDPSocket({ ip, port });\n      udp.on('error', this.onChildError);\n      udp.on('debug', this.onUdpDebug);\n      udp.once('close', this.onUdpClose);\n      udp.\n      performIPDiscovery(ssrc).\n      then((localConfig) => {\n        if (this.state.code !== NetworkingStatusCode.UdpHandshaking) return;\n        this.state.ws.sendPacket({\n          op: VoiceOpcodes.SelectProtocol,\n          d: {\n            protocol: 'udp',\n            data: {\n              address: localConfig.ip,\n              port: localConfig.port,\n              mode: chooseEncryptionMode(modes)\n            }\n          }\n        });\n        this.state = {\n          ...this.state,\n          code: NetworkingStatusCode.SelectingProtocol\n        };\n      }).\n      catch((error: Error) => this.emit('error', error));\n\n      this.state = {\n        ...this.state,\n        code: NetworkingStatusCode.UdpHandshaking,\n        udp,\n        connectionData: {\n          ssrc,\n          connectedClients: new Set()\n        }\n      };\n    } else if (\n    packet.op === VoiceOpcodes.SessionDescription &&\n    this.state.code === NetworkingStatusCode.SelectingProtocol)\n    {\n      const {\n        mode: encryptionMode,\n        secret_key: secretKey,\n        dave_protocol_version: daveProtocolVersion\n      } = packet.d;\n      this.state = {\n        ...this.state,\n        code: NetworkingStatusCode.Ready,\n        dave: this.createDaveSession(daveProtocolVersion),\n        connectionData: {\n          ...this.state.connectionData,\n          encryptionMode,\n          secretKey: new Uint8Array(secretKey),\n          sequence: randomNBit(16),\n          timestamp: randomNBit(32),\n          nonce: 0,\n          nonceBuffer:\n          encryptionMode === 'aead_aes256_gcm_rtpsize' ?\n          Buffer.alloc(12) :\n          Buffer.alloc(24),\n          speaking: false,\n          packetsPlayed: 0\n        }\n      };\n    } else if (\n    packet.op === VoiceOpcodes.Resumed &&\n    this.state.code === NetworkingStatusCode.Resuming)\n    {\n      this.state = {\n        ...this.state,\n        code: NetworkingStatusCode.Ready\n      };\n      this.state.connectionData.speaking = false;\n    } else if (\n    (packet.op === VoiceOpcodes.ClientsConnect ||\n    packet.op === VoiceOpcodes.ClientDisconnect) && (\n    this.state.code === NetworkingStatusCode.Ready ||\n    this.state.code === NetworkingStatusCode.UdpHandshaking ||\n    this.state.code === NetworkingStatusCode.SelectingProtocol ||\n    this.state.code === NetworkingStatusCode.Resuming))\n    {\n      const { connectionData } = this.state;\n      if (packet.op === VoiceOpcodes.ClientsConnect)\n      for (const id of packet.d.user_ids)\n      connectionData.connectedClients.add(id);else\n      {\n        connectionData.connectedClients.delete(packet.d.user_id);\n      }\n    } else if (\n    (this.state.code === NetworkingStatusCode.Ready ||\n    this.state.code === NetworkingStatusCode.Resuming) &&\n    this.state.dave)\n    {\n      if (packet.op === VoiceOpcodes.DavePrepareTransition) {\n        const sendReady = this.state.dave.prepareTransition(packet.d);\n        if (sendReady)\n        this.state.ws.sendPacket({\n          op: VoiceOpcodes.DaveTransitionReady,\n          d: { transition_id: packet.d.transition_id }\n        });\n        if (packet.d.transition_id === 0) {\n          this.emit('transitioned', 0);\n        }\n      } else if (packet.op === VoiceOpcodes.DaveExecuteTransition) {\n        const transitioned = this.state.dave.executeTransition(\n          packet.d.transition_id\n        );\n        if (transitioned) this.emit('transitioned', packet.d.transition_id);\n      } else if (packet.op === VoiceOpcodes.DavePrepareEpoch)\n      this.state.dave.prepareEpoch(packet.d);\n    }\n  }\n\n  /**\n   * Called when a binary message is received on the connection's WebSocket.\n   *\n   * @param message - The received message\n   */\n  private onWsBinary(message: BinaryWebSocketMessage) {\n    if (this.state.code === NetworkingStatusCode.Ready && this.state.dave) {\n      if (message.op === VoiceOpcodes.DaveMlsExternalSender) {\n        this.state.dave.setExternalSender(message.payload);\n      } else if (message.op === VoiceOpcodes.DaveMlsProposals) {\n        const payload = this.state.dave.processProposals(\n          message.payload,\n          this.state.connectionData.connectedClients\n        );\n        if (payload)\n        this.state.ws.sendBinaryMessage(\n          VoiceOpcodes.DaveMlsCommitWelcome,\n          payload\n        );\n      } else if (message.op === VoiceOpcodes.DaveMlsAnnounceCommitTransition) {\n        const { transitionId, success } = this.state.dave.processCommit(\n          message.payload\n        );\n        if (success) {\n          if (transitionId === 0) this.emit('transitioned', transitionId);else\n\n          this.state.ws.sendPacket({\n            op: VoiceOpcodes.DaveTransitionReady,\n            d: { transition_id: transitionId }\n          });\n        }\n      } else if (message.op === VoiceOpcodes.DaveMlsWelcome) {\n        const { transitionId, success } = this.state.dave.processWelcome(\n          message.payload\n        );\n        if (success) {\n          if (transitionId === 0) this.emit('transitioned', transitionId);else\n\n          this.state.ws.sendPacket({\n            op: VoiceOpcodes.DaveTransitionReady,\n            d: { transition_id: transitionId }\n          });\n        }\n      }\n    }\n  }\n\n  /**\n   * Called when a new key package is ready to be sent to the voice server.\n   *\n   * @param keyPackage - The new key package\n   */\n  private onDaveKeyPackage(keyPackage: Buffer) {\n    if (\n    this.state.code === NetworkingStatusCode.SelectingProtocol ||\n    this.state.code === NetworkingStatusCode.Ready)\n\n    this.state.ws.sendBinaryMessage(\n      VoiceOpcodes.DaveMlsKeyPackage,\n      keyPackage\n    );\n  }\n\n  /**\n   * Called when the DAVE session wants to invalidate their transition and re-initialize.\n   *\n   * @param transitionId - The transition to invalidate\n   */\n  private onDaveInvalidateTransition(transitionId: number) {\n    if (\n    this.state.code === NetworkingStatusCode.SelectingProtocol ||\n    this.state.code === NetworkingStatusCode.Ready)\n\n    this.state.ws.sendPacket({\n      op: VoiceOpcodes.DaveMlsInvalidCommitWelcome,\n      d: { transition_id: transitionId }\n    });\n  }\n\n  /**\n   * Propagates debug messages from the child WebSocket.\n   *\n   * @param message - The emitted debug message\n   */\n  private onWsDebug(message: string) {\n    this.debug?.(`[WS] ${message}`);\n  }\n\n  /**\n   * Propagates debug messages from the child UDPSocket.\n   *\n   * @param message - The emitted debug message\n   */\n  private onUdpDebug(message: string) {\n    this.debug?.(`[UDP] ${message}`);\n  }\n\n  /**\n   * Propagates debug messages from the child DAVESession.\n   *\n   * @param message - The emitted debug message\n   */\n  private onDaveDebug(message: string) {\n    this.debug?.(`[DAVE] ${message}`);\n  }\n\n  /**\n   * Prepares an Opus packet for playback. This includes attaching metadata to it and encrypting it.\n   * It will be stored within the instance, and can be played by dispatchAudio()\n   *\n   * @remarks\n   * Calling this method while there is already a prepared audio packet that has not yet been dispatched\n   * will overwrite the existing audio packet. This should be avoided.\n   * @param opusPacket - The Opus packet to encrypt\n   * @returns The audio packet that was prepared\n   */\n  public prepareAudioPacket(opusPacket: Buffer) {\n    const state = this.state;\n    if (state.code !== NetworkingStatusCode.Ready) return;\n    state.preparedPacket = this.createAudioPacket(\n      opusPacket,\n      state.connectionData,\n      state.dave\n    );\n    return state.preparedPacket;\n  }\n\n  /**\n   * Dispatches the audio packet previously prepared by prepareAudioPacket(opusPacket). The audio packet\n   * is consumed and cannot be dispatched again.\n   */\n  public dispatchAudio() {\n    const state = this.state;\n    if (state.code !== NetworkingStatusCode.Ready) return false;\n    if (state.preparedPacket !== undefined) {\n      this.playAudioPacket(state.preparedPacket);\n      state.preparedPacket = undefined;\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Plays an audio packet, updating timing metadata used for playback.\n   *\n   * @param audioPacket - The audio packet to play\n   */\n  private playAudioPacket(audioPacket: Buffer) {\n    const state = this.state;\n    if (state.code !== NetworkingStatusCode.Ready) return;\n    const { connectionData } = state;\n    connectionData.packetsPlayed++;\n    connectionData.sequence++;\n    connectionData.timestamp += TIMESTAMP_INC;\n    if (connectionData.sequence >= 2 ** 16) connectionData.sequence = 0;\n    if (connectionData.timestamp >= 2 ** 32) connectionData.timestamp = 0;\n    this.setSpeaking(true);\n    state.udp.send(audioPacket);\n  }\n\n  /**\n   * Sends a packet to the voice gateway indicating that the client has start/stopped sending\n   * audio.\n   *\n   * @param speaking - Whether or not the client should be shown as speaking\n   */\n  public setSpeaking(speaking: boolean) {\n    const state = this.state;\n    if (state.code !== NetworkingStatusCode.Ready) return;\n    if (state.connectionData.speaking === speaking) return;\n    state.connectionData.speaking = speaking;\n    state.ws.sendPacket({\n      op: VoiceOpcodes.Speaking,\n      d: {\n        speaking: (speaking ? 1 : 0) as VoiceSpeakingFlags,\n        delay: 0,\n        ssrc: state.connectionData.ssrc\n      }\n    });\n  }\n\n  /**\n   * Creates a new audio packet from an Opus packet. This involves encrypting the packet,\n   * then prepending a header that includes metadata.\n   *\n   * @param opusPacket - The Opus packet to prepare\n   * @param connectionData - The current connection data of the instance\n   * @param daveSession - The DAVE session to use for encryption\n   */\n  private createAudioPacket(\n  opusPacket: Buffer,\n  connectionData: ConnectionData,\n  daveSession?: DAVESession)\n  {\n    const rtpHeader = Buffer.alloc(12);\n    rtpHeader[0] = 0x80;\n    rtpHeader[1] = 0x78;\n\n    const { sequence, timestamp, ssrc } = connectionData;\n\n    rtpHeader.writeUIntBE(sequence, 2, 2);\n    rtpHeader.writeUIntBE(timestamp, 4, 4);\n    rtpHeader.writeUIntBE(ssrc, 8, 4);\n\n    rtpHeader.copy(nonce, 0, 0, 12);\n    return Buffer.concat([\n    rtpHeader,\n    ...this.encryptOpusPacket(\n      opusPacket,\n      connectionData,\n      rtpHeader,\n      daveSession\n    )]\n    );\n  }\n\n  /**\n   * Encrypts an Opus packet using the format agreed upon by the instance and Discord.\n   *\n   * @param opusPacket - The Opus packet to encrypt\n   * @param connectionData - The current connection data of the instance\n   * @param daveSession - The DAVE session to use for encryption\n   */\n  private encryptOpusPacket(\n  opusPacket: Buffer,\n  connectionData: ConnectionData,\n  additionalData: Buffer,\n  daveSession?: DAVESession)\n  {\n    const { secretKey, encryptionMode } = connectionData;\n\n    const packet = daveSession?.encrypt(opusPacket) ?? opusPacket;\n\n    // Both supported encryption methods want the nonce to be an incremental integer\n    connectionData.nonce++;\n    if (connectionData.nonce > MAX_NONCE_SIZE) connectionData.nonce = 0;\n    connectionData.nonceBuffer.writeUInt32BE(connectionData.nonce, 0);\n\n    // 4 extra bytes of padding on the end of the encrypted packet\n    const noncePadding = connectionData.nonceBuffer.subarray(0, 4);\n\n    let encrypted;\n    switch (encryptionMode) {\n      case 'aead_aes256_gcm_rtpsize':{\n          const cipher = crypto.createCipheriv(\n            'aes-256-gcm',\n            secretKey,\n            connectionData.nonceBuffer\n          );\n          cipher.setAAD(additionalData);\n\n          encrypted = Buffer.concat([\n          cipher.update(packet),\n          cipher.final(),\n          cipher.getAuthTag()]\n          );\n\n          return [encrypted, noncePadding];\n        }\n\n      case 'aead_xchacha20_poly1305_rtpsize':{\n          encrypted =\n          secretbox.methods.crypto_aead_xchacha20poly1305_ietf_encrypt(\n            packet,\n            additionalData,\n            connectionData.nonceBuffer,\n            secretKey as unknown as SharedArrayBuffer\n          );\n\n          return [encrypted, noncePadding];\n        }\n\n      default:{\n          // This should never happen. Our encryption mode is chosen from a list given to us by the gateway and checked with the ones we support.\n          throw new RangeError(\n            `Unsupported encryption method: ${encryptionMode}`\n          );\n        }\n    }\n  }\n}", "import { Buffer } from 'node:buffer';\n\ninterface Methods {\n  crypto_aead_xchacha20poly1305_ietf_encrypt(\n  plaintext: Buffer,\n  additionalData: Buffer,\n  nonce: Buffer,\n  key: ArrayBufferLike)\n  : Buffer;\n}\n\nconst libs = {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  'sodium-native': (sodium: any): Methods => ({\n    crypto_aead_xchacha20poly1305_ietf_encrypt: (\n    plaintext: Buffer,\n    additionalData: Buffer,\n    nonce: Buffer,\n    key: ArrayBufferLike) =>\n    {\n      const cipherText = Buffer.alloc(\n        plaintext.length + sodium.crypto_aead_xchacha20poly1305_ietf_ABYTES\n      );\n      sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(\n        cipherText,\n        plaintext,\n        additionalData,\n        null,\n        nonce,\n        key\n      );\n      return cipherText;\n    }\n  }),\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  sodium: (sodium: any): Methods => ({\n    crypto_aead_xchacha20poly1305_ietf_encrypt: (\n    plaintext: Buffer,\n    additionalData: Buffer,\n    nonce: Buffer,\n    key: ArrayBufferLike) =>\n    {\n      return sodium.api.crypto_aead_xchacha20poly1305_ietf_encrypt(\n        plaintext,\n        additionalData,\n        null,\n        nonce,\n        key\n      );\n    }\n  }),\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  'libsodium-wrappers': (sodium: any): Methods => ({\n    crypto_aead_xchacha20poly1305_ietf_encrypt: (\n    plaintext: Buffer,\n    additionalData: Buffer,\n    nonce: Buffer,\n    key: ArrayBufferLike) =>\n    {\n      return sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(\n        plaintext,\n        additionalData,\n        null,\n        nonce,\n        key\n      );\n    }\n  }),\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  '@stablelib/xchacha20poly1305': (stablelib: any): Methods => ({\n    crypto_aead_xchacha20poly1305_ietf_encrypt(\n    cipherText,\n    additionalData,\n    nonce,\n    key)\n    {\n      const crypto = new stablelib.XChaCha20Poly1305(key);\n      return crypto.seal(nonce, cipherText, additionalData);\n    }\n  }),\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  '@noble/ciphers/chacha': (noble: any): Methods => ({\n    crypto_aead_xchacha20poly1305_ietf_encrypt(\n    plaintext,\n    additionalData,\n    nonce,\n    key)\n    {\n      const chacha = noble.xchacha20poly1305(key, nonce, additionalData);\n      return chacha.encrypt(plaintext);\n    }\n  })\n} as const;\n\n// @ts-ignore\nlibs['sodium-javascript'] = libs['sodium-native'];\n\nconst validLibs = Object.keys(libs);\n\nconst fallbackError = () => {\n  throw new Error(\n    `Cannot play audio as no valid encryption package is installed.\n- Install one of the following packages: ${validLibs.join(', ')}\n- Use the generateDependencyReport() function for more information.\\n`\n  );\n};\n\nconst methods: Methods = {\n  crypto_aead_xchacha20poly1305_ietf_encrypt: fallbackError\n};\n\nvoid (async () => {\n  for (const libName of Object.keys(libs) as (keyof typeof libs)[]) {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n      const lib = await import(libName);\n      if (libName === 'libsodium-wrappers' && lib.ready) await lib.ready;\n      Object.assign(methods, libs[libName](lib));\n      break;\n    } catch {\n\n      //\n    }}\n})();\n\nexport { methods };", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\nexport const noop = () => {};", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */\n\nimport { Buffer } from 'node:buffer';\nimport { EventEmitter } from 'node:events';\nimport type {\n  VoiceDavePrepareEpochData,\n  VoiceDavePrepareTransitionData } from\n'discord-api-types/voice/v8';\nimport { SILENCE_FRAME } from '../audio/AudioPlayer';\n\ninterface SessionMethods {\n  canPassthrough(userId: string): boolean;\n  decrypt(userId: string, mediaType: 0 | 1, packet: Buffer): Buffer;\n  encryptOpus(packet: Buffer): Buffer;\n  getSerializedKeyPackage(): Buffer;\n  getVerificationCode(userId: string): Promise<string>;\n  processCommit(commit: Buffer): void;\n  processProposals(\n  optype: 0 | 1,\n  proposals: Buffer,\n  recognizedUserIds?: string[])\n  : ProposalsResult;\n  processWelcome(welcome: Buffer): void;\n  ready: boolean;\n  reinit(protocolVersion: number, userId: string, channelId: string): void;\n  reset(): void;\n  setExternalSender(externalSender: Buffer): void;\n  setPassthroughMode(passthrough: boolean, expiry: number): void;\n  voicePrivacyCode: string;\n}\n\ninterface ProposalsResult {\n  commit?: Buffer;\n  welcome?: Buffer;\n}\n\n/**\n * The amount of seconds that a previous transition should be valid for.\n */\nconst TRANSITION_EXPIRY = 10;\n\n/**\n * The arbitrary amount of seconds to allow passthrough for mid-downgrade.\n * Generally, transitions last about 3 seconds maximum, but this should cover for when connections are delayed.\n */\nconst TRANSITION_EXPIRY_PENDING_DOWNGRADE = 24;\n\n/**\n * The amount of packets to allow decryption failure for until we deem the transition bad and re-initialize.\n * Usually 4 packets on a good connection may slip past when entering a new session.\n * After re-initializing, 5-24 packets may fail to decrypt after.\n */\nexport const DEFAULT_DECRYPTION_FAILURE_TOLERANCE = 36;\n\ninterface TransitionResult {\n  success: boolean;\n  transitionId: number;\n}\n/**\n * Options that dictate the session behavior.\n */\nexport interface DAVESessionOptions {\n  decryptionFailureTolerance?: number | undefined;\n}\n\n// @ts-ignore\nlet Davey: typeof import('@snazzah/davey');\n\ntry {\n  Davey = require('@snazzah/davey');\n} catch {\n  // @ts-ignore\n  Davey = new Proxy({} as typeof import('@snazzah/davey'), {\n    get(_, prop) {\n      throw new Error(\n        `DAVE protocol support requires the @snazzah/davey package. Please install it to use this feature.\\nAttempted to access property ${String(\n          prop\n        )} on the DAVESession (class), but Davey is not available.`\n      );\n    }\n  });\n}\n\n/**\n * The maximum DAVE protocol version supported.\n */\nexport function getMaxProtocolVersion(): number {\n  return Davey.DAVE_PROTOCOL_VERSION;\n}\n\nexport interface DAVESession extends EventEmitter {\n  on(event: 'error', listener: (error: Error) => void): this;\n  on(event: 'debug', listener: (message: string) => void): this;\n  on(event: 'keyPackage', listener: (message: Buffer) => void): this;\n  on(\n  event: 'invalidateTransition',\n  listener: (transitionId: number) => void)\n  : this;\n}\n\n/**\n * Manages the DAVE protocol group session.\n */\nexport class DAVESession extends EventEmitter {\n  /**\n   * The channel id represented by this session.\n   */\n  public channelId: string;\n\n  /**\n   * The user id represented by this session.\n   */\n  public userId: string;\n\n  /**\n   * The protocol version being used.\n   */\n  public protocolVersion: number;\n\n  /**\n   * The last transition id executed.\n   */\n  public lastTransitionId?: number | undefined;\n\n  /**\n   * The pending transitions, mapped by their ID and the protocol version.\n   */\n  private pendingTransitions = new Map<number, number>();\n\n  /**\n   * Whether this session was downgraded previously.\n   */\n  private downgraded = false;\n\n  /**\n   * The amount of consecutive failures encountered when decrypting.\n   */\n  private consecutiveFailures = 0;\n\n  /**\n   * The amount of consecutive failures needed to attempt to recover.\n   */\n  private readonly failureTolerance: number;\n\n  /**\n   * Whether this session is currently re-initializing due to an invalid transition.\n   */\n  public reinitializing = false;\n\n  /**\n   * The underlying DAVE Session of this wrapper.\n   */\n  public session: SessionMethods | undefined;\n\n  public constructor(\n  protocolVersion: number,\n  userId: string,\n  channelId: string,\n  options: DAVESessionOptions)\n  {\n    super();\n\n    this.protocolVersion = protocolVersion;\n    this.userId = userId;\n    this.channelId = channelId;\n    this.failureTolerance =\n    options.decryptionFailureTolerance ??\n    DEFAULT_DECRYPTION_FAILURE_TOLERANCE;\n  }\n\n  /**\n   * The current voice privacy code of the session. Will be `null` if there is no session.\n   */\n  public get voicePrivacyCode(): string | null {\n    if (this.protocolVersion === 0 || !this.session?.voicePrivacyCode) {\n      return null;\n    }\n\n    return this.session.voicePrivacyCode;\n  }\n\n  /**\n   * Gets the verification code for a user in the session.\n   *\n   * @throws Will throw if there is not an active session or the user id provided is invalid or not in the session.\n   */\n  public async getVerificationCode(userId: string): Promise<string> {\n    if (!this.session) throw new Error('Session not available');\n    return this.session.getVerificationCode(userId);\n  }\n\n  /**\n   * Re-initializes (or initializes) the underlying session.\n   */\n  public reinit() {\n    if (this.protocolVersion > 0) {\n      if (this.session) {\n        this.session.reinit(this.protocolVersion, this.userId, this.channelId);\n        this.emit(\n          'debug',\n          `Session reinitialized for protocol version ${this.protocolVersion}`\n        );\n      } else {\n        this.session = new Davey.DAVESession(\n          this.protocolVersion,\n          this.userId,\n          this.channelId\n        );\n        this.emit(\n          'debug',\n          `Session initialized for protocol version ${this.protocolVersion}`\n        );\n      }\n\n      this.emit('keyPackage', this.session!.getSerializedKeyPackage());\n    } else if (this.session) {\n      this.session.reset();\n      this.session.setPassthroughMode(true, TRANSITION_EXPIRY);\n      this.emit('debug', 'Session reset');\n    }\n  }\n\n  /**\n   * Set the external sender for this session.\n   *\n   * @param externalSender - The external sender\n   */\n  public setExternalSender(externalSender: Buffer) {\n    if (!this.session) throw new Error('No session available');\n    this.session.setExternalSender(externalSender);\n    this.emit('debug', 'Set MLS external sender');\n  }\n\n  /**\n   * Prepare for a transition.\n   *\n   * @param data - The transition data\n   * @returns Whether we should signal to the voice server that we are ready\n   */\n  public prepareTransition(data: VoiceDavePrepareTransitionData) {\n    this.emit(\n      'debug',\n      `Preparing for transition (${data.transition_id}, v${data.protocol_version})`\n    );\n    this.pendingTransitions.set(data.transition_id, data.protocol_version);\n\n    // When the included transition id is 0, the transition is for (re)initialization and it can be executed immediately.\n    if (data.transition_id === 0) {\n      this.executeTransition(data.transition_id);\n    } else {\n      if (data.protocol_version === 0)\n      this.session?.setPassthroughMode(\n        true,\n        TRANSITION_EXPIRY_PENDING_DOWNGRADE\n      );\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Execute a transition.\n   *\n   * @param transitionId - The transition id to execute on\n   */\n  public executeTransition(transitionId: number) {\n    this.emit('debug', `Executing transition (${transitionId})`);\n    if (!this.pendingTransitions.has(transitionId)) {\n      this.emit(\n        'debug',\n        `Received execute transition, but we don't have a pending transition for ${transitionId}`\n      );\n      return false;\n    }\n\n    const oldVersion = this.protocolVersion;\n    this.protocolVersion = this.pendingTransitions.get(transitionId)!;\n\n    // Handle upgrades & defer downgrades\n    if (oldVersion !== this.protocolVersion && this.protocolVersion === 0) {\n      this.downgraded = true;\n      this.emit('debug', 'Session downgraded');\n    } else if (transitionId > 0 && this.downgraded) {\n      this.downgraded = false;\n      this.session?.setPassthroughMode(true, TRANSITION_EXPIRY);\n      this.emit('debug', 'Session upgraded');\n    }\n\n    // In the future we'd want to signal to the DAVESession to transition also, but it only supports v1 at this time\n    this.reinitializing = false;\n    this.lastTransitionId = transitionId;\n    this.emit(\n      'debug',\n      `Transition executed (v${oldVersion} -> v${this.protocolVersion}, id: ${transitionId})`\n    );\n\n    this.pendingTransitions.delete(transitionId);\n    return true;\n  }\n\n  /**\n   * Prepare for a new epoch.\n   *\n   * @param data - The epoch data\n   */\n  public prepareEpoch(data: VoiceDavePrepareEpochData) {\n    this.emit('debug', `Preparing for epoch (${data.epoch})`);\n    if (data.epoch === 1) {\n      this.protocolVersion = data.protocol_version;\n      this.reinit();\n    }\n  }\n\n  /**\n   * Recover from an invalid transition by re-initializing.\n   *\n   * @param transitionId - The transition id to invalidate\n   */\n  public recoverFromInvalidTransition(transitionId: number) {\n    if (this.reinitializing) return;\n    this.emit('debug', `Invalidating transition ${transitionId}`);\n    this.reinitializing = true;\n    this.consecutiveFailures = 0;\n    this.emit('invalidateTransition', transitionId);\n    this.reinit();\n  }\n\n  /**\n   * Processes proposals from the MLS group.\n   *\n   * @param payload - The binary message payload\n   * @param connectedClients - The set of connected client IDs\n   * @returns The payload to send back to the voice server, if there is one\n   */\n  public processProposals(\n  payload: Buffer,\n  connectedClients: Set<string>)\n  : Buffer | undefined {\n    if (!this.session) throw new Error('No session available');\n    const optype = payload.readUInt8(0) as 0 | 1;\n    const { commit, welcome } = this.session.processProposals(\n      optype,\n      payload.subarray(1),\n      Array.from(connectedClients)\n    );\n    this.emit('debug', 'MLS proposals processed');\n    if (!commit) return;\n    return welcome ? Buffer.concat([commit, welcome]) : commit;\n  }\n\n  /**\n   * Processes a commit from the MLS group.\n   *\n   * @param payload - The payload\n   * @returns The transaction id and whether it was successful\n   */\n  public processCommit(payload: Buffer): TransitionResult {\n    if (!this.session) throw new Error('No session available');\n    const transitionId = payload.readUInt16BE(0);\n    try {\n      this.session.processCommit(payload.subarray(2));\n      if (transitionId === 0) {\n        this.reinitializing = false;\n        this.lastTransitionId = transitionId;\n      } else {\n        this.pendingTransitions.set(transitionId, this.protocolVersion);\n      }\n\n      this.emit(\n        'debug',\n        `MLS commit processed (transition id: ${transitionId})`\n      );\n      return { transitionId, success: true };\n    } catch (error) {\n      this.emit(\n        'debug',\n        `MLS commit errored from transition ${transitionId}: ${error}`\n      );\n      this.recoverFromInvalidTransition(transitionId);\n      return { transitionId, success: false };\n    }\n  }\n\n  /**\n   * Processes a welcome from the MLS group.\n   *\n   * @param payload - The payload\n   * @returns The transaction id and whether it was successful\n   */\n  public processWelcome(payload: Buffer): TransitionResult {\n    if (!this.session) throw new Error('No session available');\n    const transitionId = payload.readUInt16BE(0);\n    try {\n      this.session.processWelcome(payload.subarray(2));\n      if (transitionId === 0) {\n        this.reinitializing = false;\n        this.lastTransitionId = transitionId;\n      } else {\n        this.pendingTransitions.set(transitionId, this.protocolVersion);\n      }\n\n      this.emit(\n        'debug',\n        `MLS welcome processed (transition id: ${transitionId})`\n      );\n      return { transitionId, success: true };\n    } catch (error) {\n      this.emit(\n        'debug',\n        `MLS welcome errored from transition ${transitionId}: ${error}`\n      );\n      this.recoverFromInvalidTransition(transitionId);\n      return { transitionId, success: false };\n    }\n  }\n\n  /**\n   * Encrypt a packet using end-to-end encryption.\n   *\n   * @param packet - The packet to encrypt\n   */\n  public encrypt(packet: Buffer) {\n    if (\n    this.protocolVersion === 0 ||\n    !this.session?.ready ||\n    packet.equals(SILENCE_FRAME))\n\n    return packet;\n    return this.session.encryptOpus(packet);\n  }\n\n  /**\n   * Decrypt a packet using end-to-end encryption.\n   *\n   * @param packet - The packet to decrypt\n   * @param userId - The user id that sent the packet\n   * @returns The decrypted packet, or `null` if the decryption failed but should be ignored\n   */\n  public decrypt(packet: Buffer, userId: string) {\n    const canDecrypt =\n    this.session?.ready && (\n    this.protocolVersion !== 0 || this.session?.canPassthrough(userId));\n    if (packet.equals(SILENCE_FRAME) || !canDecrypt || !this.session)\n    return packet;\n    try {\n      const buffer = this.session.decrypt(\n        userId,\n        // @ts-expect-error - const enum is exported and works (todo: drop const modifier on Davey end)\n        Davey.MediaType.AUDIO,\n        packet\n      );\n      this.consecutiveFailures = 0;\n      return buffer;\n    } catch (error) {\n      if (!this.reinitializing && this.pendingTransitions.size === 0) {\n        this.consecutiveFailures++;\n        this.emit(\n          'debug',\n          `Failed to decrypt a packet (${this.consecutiveFailures} consecutive fails)`\n        );\n        if (this.consecutiveFailures > this.failureTolerance) {\n          if (this.lastTransitionId)\n          this.recoverFromInvalidTransition(this.lastTransitionId);else\n          throw error;\n        }\n      } else if (this.reinitializing) {\n        this.emit(\n          'debug',\n          'Failed to decrypt a packet (reinitializing session)'\n        );\n      } else if (this.pendingTransitions.size > 0) {\n        this.emit(\n          'debug',\n          `Failed to decrypt a packet (${this.pendingTransitions.size} pending transition[s])`\n        );\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Resets the session.\n   */\n  public destroy() {\n    try {\n      this.session?.reset();\n    } catch {\n\n      //\n    }}\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\n/* eslint-disable @typescript-eslint/prefer-ts-expect-error, @typescript-eslint/method-signature-style */\nimport { Buffer } from 'node:buffer';\nimport { EventEmitter } from 'node:events';\nimport { addAudioPlayer, deleteAudioPlayer } from '../DataStore';\nimport {\n  VoiceConnectionStatus,\n  type VoiceConnection } from\n'../VoiceConnection';\nimport { noop } from '../util/util';\nimport { AudioPlayerError } from './AudioPlayerError';\nimport type { AudioResource } from './AudioResource';\nimport { PlayerSubscription } from './PlayerSubscription';\nimport { unsafe } from '../common/types';\n\n// The Opus \"silent\" frame\nexport const SILENCE_FRAME = Buffer.from([0xf8, 0xff, 0xfe]);\n\n/**\n * Describes the behavior of the player when an audio packet is played but there are no available\n * voice connections to play to.\n */\nexport enum NoSubscriberBehavior {\n  /**\n   * Pauses playing the stream until a voice connection becomes available.\n   */\n  Pause = 'pause',\n\n  /**\n   * Continues to play through the resource regardless.\n   */\n  Play = 'play',\n\n  /**\n   * The player stops and enters the Idle state.\n   */\n  Stop = 'stop',\n}\n\nexport enum AudioPlayerStatus {\n  /**\n   * When the player has paused itself. Only possible with the \"pause\" no subscriber behavior.\n   */\n  AutoPaused = 'autopaused',\n\n  /**\n   * When the player is waiting for an audio resource to become readable before transitioning to Playing.\n   */\n  Buffering = 'buffering',\n\n  /**\n   * When there is currently no resource for the player to be playing.\n   */\n  Idle = 'idle',\n\n  /**\n   * When the player has been manually paused.\n   */\n  Paused = 'paused',\n\n  /**\n   * When the player is actively playing an audio resource.\n   */\n  Playing = 'playing',\n}\n\n/**\n * Options that can be passed when creating an audio player, used to specify its behavior.\n */\nexport interface CreateAudioPlayerOptions {\n  behaviors?: {\n    maxMissedFrames?: number;\n    noSubscriber?: NoSubscriberBehavior;\n  };\n  debug?: boolean;\n}\n\n/**\n * The state that an AudioPlayer is in when it has no resource to play. This is the starting state.\n */\nexport interface AudioPlayerIdleState {\n  status: AudioPlayerStatus.Idle;\n}\n\n/**\n * The state that an AudioPlayer is in when it is waiting for a resource to become readable. Once this\n * happens, the AudioPlayer will enter the Playing state. If the resource ends/errors before this, then\n * it will re-enter the Idle state.\n */\nexport interface AudioPlayerBufferingState {\n  onFailureCallback: () => void;\n  onReadableCallback: () => void;\n  onStreamError: (error: Error) => void;\n  /**\n   * The resource that the AudioPlayer is waiting for\n   */\n  resource: AudioResource;\n  status: AudioPlayerStatus.Buffering;\n}\n\n/**\n * The state that an AudioPlayer is in when it is actively playing an AudioResource. When playback ends,\n * it will enter the Idle state.\n */\nexport interface AudioPlayerPlayingState {\n  /**\n   * The number of consecutive times that the audio resource has been unable to provide an Opus frame.\n   */\n  missedFrames: number;\n  onStreamError: (error: Error) => void;\n\n  /**\n   * The playback duration in milliseconds of the current audio resource. This includes filler silence packets\n   * that have been played when the resource was buffering.\n   */\n  playbackDuration: number;\n\n  /**\n   * The resource that is being played.\n   */\n  resource: AudioResource;\n\n  status: AudioPlayerStatus.Playing;\n}\n\n/**\n * The state that an AudioPlayer is in when it has either been explicitly paused by the user, or done\n * automatically by the AudioPlayer itself if there are no available subscribers.\n */\nexport interface AudioPlayerPausedState {\n  onStreamError: (error: Error) => void;\n  /**\n   * The playback duration in milliseconds of the current audio resource. This includes filler silence packets\n   * that have been played when the resource was buffering.\n   */\n  playbackDuration: number;\n\n  /**\n   * The current resource of the audio player.\n   */\n  resource: AudioResource;\n\n  /**\n   * How many silence packets still need to be played to avoid audio interpolation due to the stream suddenly pausing.\n   */\n  silencePacketsRemaining: number;\n\n  status: AudioPlayerStatus.AutoPaused | AudioPlayerStatus.Paused;\n}\n\n/**\n * The various states that the player can be in.\n */\nexport type AudioPlayerState =\nAudioPlayerBufferingState |\nAudioPlayerIdleState |\nAudioPlayerPausedState |\nAudioPlayerPlayingState;\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging\nexport interface AudioPlayer extends EventEmitter {\n  /**\n   * Emitted when there is an error emitted from the audio resource played by the audio player\n   *\n   * @eventProperty\n   */\n  on(event: 'error', listener: (error: AudioPlayerError) => void): this;\n  /**\n   * Emitted debugging information about the audio player\n   *\n   * @eventProperty\n   */\n  on(event: 'debug', listener: (message: string) => void): this;\n  /**\n   * Emitted when the state of the audio player changes\n   *\n   * @eventProperty\n   */\n  on(\n  event: 'stateChange',\n  listener: (oldState: AudioPlayerState, newState: AudioPlayerState) => void)\n  : this;\n  /**\n   * Emitted when the audio player is subscribed to a voice connection\n   *\n   * @eventProperty\n   */\n  on(\n  event: 'subscribe' | 'unsubscribe',\n  listener: (subscription: PlayerSubscription) => void)\n  : this;\n  /**\n   * Emitted when the status of state changes to a specific status\n   *\n   * @eventProperty\n   */\n  on<Event extends AudioPlayerStatus>(\n  event: Event,\n  listener: (\n  oldState: AudioPlayerState,\n  newState: AudioPlayerState & {status: Event;})\n  => void)\n  : this;\n}\n\n/**\n * Stringifies an AudioPlayerState instance.\n *\n * @param state - The state to stringify\n */\nfunction stringifyState(state: AudioPlayerState) {\n  return JSON.stringify({\n    ...state,\n    resource: Reflect.has(state, 'resource'),\n    stepTimeout: Reflect.has(state, 'stepTimeout')\n  });\n}\n\n/**\n * Used to play audio resources (i.e. tracks, streams) to voice connections.\n *\n * @remarks\n * Audio players are designed to be re-used - even if a resource has finished playing, the player itself\n * can still be used.\n *\n * The AudioPlayer drives the timing of playback, and therefore is unaffected by voice connections\n * becoming unavailable. Its behavior in these scenarios can be configured.\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging\nexport class AudioPlayer extends EventEmitter {\n  /**\n   * The state that the AudioPlayer is in.\n   */\n  private _state: AudioPlayerState;\n\n  /**\n   * A list of VoiceConnections that are registered to this AudioPlayer. The player will attempt to play audio\n   * to the streams in this list.\n   */\n  private readonly subscribers: PlayerSubscription[] = [];\n\n  /**\n   * The behavior that the player should follow when it enters certain situations.\n   */\n  private readonly behaviors: {\n    maxMissedFrames: number;\n    noSubscriber: NoSubscriberBehavior;\n  };\n\n  /**\n   * The debug logger function, if debugging is enabled.\n   */\n  private readonly debug: ((message: string) => void) | null;\n\n  /**\n   * Creates a new AudioPlayer.\n   */\n  public constructor(options: CreateAudioPlayerOptions = {}) {\n    super();\n    this._state = { status: AudioPlayerStatus.Idle };\n    this.behaviors = {\n      noSubscriber: NoSubscriberBehavior.Pause,\n      maxMissedFrames: 5,\n      ...options.behaviors\n    };\n    this.debug =\n    options.debug === false ?\n    null :\n    (message: string) => this.emit('debug', message);\n  }\n\n  /**\n   * A list of subscribed voice connections that can currently receive audio to play.\n   */\n  public get playable() {\n    return this.subscribers.\n    filter(\n      ({ connection }) =>\n      connection.state.status === VoiceConnectionStatus.Ready\n    ).\n    map(({ connection }) => connection);\n  }\n\n  /**\n   * Subscribes a VoiceConnection to the audio player's play list. If the VoiceConnection is already subscribed,\n   * then the existing subscription is used.\n   *\n   * @remarks\n   * This method should not be directly called. Instead, use VoiceConnection#subscribe.\n   * @param connection - The connection to subscribe\n   * @returns The new subscription if the voice connection is not yet subscribed, otherwise the existing subscription\n   */\n  // @ts-ignore\n  private subscribe(connection: VoiceConnection) {\n    const existingSubscription = this.subscribers.find(\n      (subscription) => subscription.connection === connection\n    );\n    if (!existingSubscription) {\n      const subscription = new PlayerSubscription(connection, this);\n      this.subscribers.push(subscription);\n      setImmediate(() => this.emit('subscribe', subscription));\n      return subscription;\n    }\n\n    return existingSubscription;\n  }\n\n  /**\n   * Unsubscribes a subscription - i.e. removes a voice connection from the play list of the audio player.\n   *\n   * @remarks\n   * This method should not be directly called. Instead, use PlayerSubscription#unsubscribe.\n   * @param subscription - The subscription to remove\n   * @returns Whether or not the subscription existed on the player and was removed\n   */\n  // @ts-ignore\n  private unsubscribe(subscription: PlayerSubscription) {\n    const index = this.subscribers.indexOf(subscription);\n    const exists = index !== -1;\n    if (exists) {\n      this.subscribers.splice(index, 1);\n      subscription.connection.setSpeaking(false);\n      this.emit('unsubscribe', subscription);\n    }\n\n    return exists;\n  }\n\n  /**\n   * The state that the player is in.\n   */\n  public get state() {\n    return this._state;\n  }\n\n  /**\n   * Sets a new state for the player, performing clean-up operations where necessary.\n   */\n  public set state(newState: AudioPlayerState) {\n    const oldState = this._state;\n    const newResource = Reflect.get(newState, 'resource') as\n    AudioResource |\n    undefined;\n\n    if (\n    oldState.status !== AudioPlayerStatus.Idle &&\n    oldState.resource !== newResource)\n    {\n      oldState.resource.playStream.on('error', noop);\n      oldState.resource.playStream.off('error', oldState.onStreamError);\n      oldState.resource.audioPlayer = undefined;\n      oldState.resource.playStream.destroy();\n      oldState.resource.playStream.read(); // required to ensure buffered data is drained, prevents memory leak\n    }\n\n    // When leaving the Buffering state (or buffering a new resource), then remove the event listeners from it\n    if (\n    oldState.status === AudioPlayerStatus.Buffering && (\n    newState.status !== AudioPlayerStatus.Buffering ||\n    newState.resource !== oldState.resource))\n    {\n      oldState.resource.playStream.off('end', oldState.onFailureCallback);\n      oldState.resource.playStream.off('close', oldState.onFailureCallback);\n      oldState.resource.playStream.off('finish', oldState.onFailureCallback);\n      oldState.resource.playStream.off('readable', oldState.onReadableCallback);\n    }\n\n    // transitioning into an idle should ensure that connections stop speaking\n    if (newState.status === AudioPlayerStatus.Idle) {\n      this._signalStopSpeaking();\n      deleteAudioPlayer(this);\n    }\n\n    // attach to the global audio player timer\n    if (newResource) {\n      addAudioPlayer(this);\n    }\n\n    // playing -> playing state changes should still transition if a resource changed (seems like it would be useful!)\n    const didChangeResources =\n    oldState.status !== AudioPlayerStatus.Idle &&\n    newState.status === AudioPlayerStatus.Playing &&\n    oldState.resource !== newState.resource;\n\n    this._state = newState;\n\n    this.emit('stateChange', oldState, this._state);\n    if (oldState.status !== newState.status || didChangeResources) {\n      this.emit(newState.status, oldState, this._state as unsafe);\n    }\n\n    this.debug?.(\n      `state change:\\nfrom ${stringifyState(oldState)}\\nto ${stringifyState(\n        newState\n      )}`\n    );\n  }\n\n  /**\n   * Plays a new resource on the player. If the player is already playing a resource, the existing resource is destroyed\n   * (it cannot be reused, even in another player) and is replaced with the new resource.\n   *\n   * @remarks\n   * The player will transition to the Playing state once playback begins, and will return to the Idle state once\n   * playback is ended.\n   *\n   * If the player was previously playing a resource and this method is called, the player will not transition to the\n   * Idle state during the swap over.\n   * @param resource - The resource to play\n   * @throws Will throw if attempting to play an audio resource that has already ended, or is being played by another player\n   */\n  public play<Metadata>(resource: AudioResource<Metadata>) {\n    if (resource.ended) {\n      throw new Error('Cannot play a resource that has already ended.');\n    }\n\n    if (resource.audioPlayer) {\n      if (resource.audioPlayer === this) {\n        return;\n      }\n\n      throw new Error(\n        'Resource is already being played by another audio player.'\n      );\n    }\n\n    resource.audioPlayer = this;\n\n    // Attach error listeners to the stream that will propagate the error and then return to the Idle\n    // state if the resource is still being used.\n    const onStreamError = (error: Error) => {\n      if (this.state.status !== AudioPlayerStatus.Idle) {\n        this.emit('error', new AudioPlayerError(error, this.state.resource));\n      }\n\n      if (\n      this.state.status !== AudioPlayerStatus.Idle &&\n      this.state.resource === resource)\n      {\n        this.state = {\n          status: AudioPlayerStatus.Idle\n        };\n      }\n    };\n\n    resource.playStream.once('error', onStreamError);\n\n    if (resource.started) {\n      this.state = {\n        status: AudioPlayerStatus.Playing,\n        missedFrames: 0,\n        playbackDuration: 0,\n        resource,\n        onStreamError\n      };\n    } else {\n      const onReadableCallback = () => {\n        if (\n        this.state.status === AudioPlayerStatus.Buffering &&\n        this.state.resource === resource)\n        {\n          this.state = {\n            status: AudioPlayerStatus.Playing,\n            missedFrames: 0,\n            playbackDuration: 0,\n            resource,\n            onStreamError\n          };\n        }\n      };\n\n      const onFailureCallback = () => {\n        if (\n        this.state.status === AudioPlayerStatus.Buffering &&\n        this.state.resource === resource)\n        {\n          this.state = {\n            status: AudioPlayerStatus.Idle\n          };\n        }\n      };\n\n      resource.playStream.once('readable', onReadableCallback);\n\n      resource.playStream.once('end', onFailureCallback);\n      resource.playStream.once('close', onFailureCallback);\n      resource.playStream.once('finish', onFailureCallback);\n\n      this.state = {\n        status: AudioPlayerStatus.Buffering,\n        resource,\n        onReadableCallback,\n        onFailureCallback,\n        onStreamError\n      };\n    }\n  }\n\n  /**\n   * Pauses playback of the current resource, if any.\n   *\n   * @param interpolateSilence - If true, the player will play 5 packets of silence after pausing to prevent audio glitches\n   * @returns `true` if the player was successfully paused, otherwise `false`\n   */\n  public pause(interpolateSilence = true) {\n    if (this.state.status !== AudioPlayerStatus.Playing) return false;\n    this.state = {\n      ...this.state,\n      status: AudioPlayerStatus.Paused,\n      silencePacketsRemaining: interpolateSilence ? 5 : 0\n    };\n    return true;\n  }\n\n  /**\n   * Unpauses playback of the current resource, if any.\n   *\n   * @returns `true` if the player was successfully unpaused, otherwise `false`\n   */\n  public unpause() {\n    if (this.state.status !== AudioPlayerStatus.Paused) return false;\n    this.state = {\n      ...this.state,\n      status: AudioPlayerStatus.Playing,\n      missedFrames: 0\n    };\n    return true;\n  }\n\n  /**\n   * Stops playback of the current resource and destroys the resource. The player will either transition to the Idle state,\n   * or remain in its current state until the silence padding frames of the resource have been played.\n   *\n   * @param force - If true, will force the player to enter the Idle state even if the resource has silence padding frames\n   * @returns `true` if the player will come to a stop, otherwise `false`\n   */\n  public stop(force = false) {\n    if (this.state.status === AudioPlayerStatus.Idle) return false;\n    if (force || this.state.resource.silencePaddingFrames === 0) {\n      this.state = {\n        status: AudioPlayerStatus.Idle\n      };\n    } else if (this.state.resource.silenceRemaining === -1) {\n      this.state.resource.silenceRemaining =\n      this.state.resource.silencePaddingFrames;\n    }\n\n    return true;\n  }\n\n  /**\n   * Checks whether the underlying resource (if any) is playable (readable)\n   *\n   * @returns `true` if the resource is playable, otherwise `false`\n   */\n  public checkPlayable() {\n    const state = this._state;\n    if (\n    state.status === AudioPlayerStatus.Idle ||\n    state.status === AudioPlayerStatus.Buffering)\n\n    return false;\n\n    // If the stream has been destroyed or is no longer readable, then transition to the Idle state.\n    if (!state.resource.readable) {\n      this.state = {\n        status: AudioPlayerStatus.Idle\n      };\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Called roughly every 20ms by the global audio player timer. Dispatches any audio packets that are buffered\n   * by the active connections of this audio player.\n   */\n  // @ts-ignore\n  private _stepDispatch() {\n    const state = this._state;\n\n    // Guard against the Idle state\n    if (\n    state.status === AudioPlayerStatus.Idle ||\n    state.status === AudioPlayerStatus.Buffering)\n\n    return;\n\n    // Dispatch any audio packets that were prepared in the previous cycle\n    for (const connection of this.playable) {\n      connection.dispatchAudio();\n    }\n  }\n\n  /**\n   * Called roughly every 20ms by the global audio player timer. Attempts to read an audio packet from the\n   * underlying resource of the stream, and then has all the active connections of the audio player prepare it\n   * (encrypt it, append header data) so that it is ready to play at the start of the next cycle.\n   */\n  // @ts-ignore\n  private _stepPrepare() {\n    const state = this._state;\n\n    // Guard against the Idle state\n    if (\n    state.status === AudioPlayerStatus.Idle ||\n    state.status === AudioPlayerStatus.Buffering)\n\n    return;\n\n    // List of connections that can receive the packet\n    const playable = this.playable;\n\n    /* If the player was previously in the AutoPaused state, check to see whether there are newly available\n     connections, allowing us to transition out of the AutoPaused state back into the Playing state */\n    if (state.status === AudioPlayerStatus.AutoPaused && playable.length > 0) {\n      this.state = {\n        ...state,\n        status: AudioPlayerStatus.Playing,\n        missedFrames: 0\n      };\n    }\n\n    /* If the player is (auto)paused, check to see whether silence packets should be played and\n     set a timeout to begin the next cycle, ending the current cycle here. */\n    if (\n    state.status === AudioPlayerStatus.Paused ||\n    state.status === AudioPlayerStatus.AutoPaused)\n    {\n      if (state.silencePacketsRemaining > 0) {\n        state.silencePacketsRemaining--;\n        this._preparePacket(SILENCE_FRAME, playable, state);\n        if (state.silencePacketsRemaining === 0) {\n          this._signalStopSpeaking();\n        }\n      }\n\n      return;\n    }\n\n    // If there are no available connections in this cycle, observe the configured \"no subscriber\" behavior.\n    if (playable.length === 0) {\n      if (this.behaviors.noSubscriber === NoSubscriberBehavior.Pause) {\n        this.state = {\n          ...state,\n          status: AudioPlayerStatus.AutoPaused,\n          silencePacketsRemaining: 5\n        };\n        return;\n      } else if (this.behaviors.noSubscriber === NoSubscriberBehavior.Stop) {\n        this.stop(true);\n      }\n    }\n\n    /**\n     * Attempt to read an Opus packet from the resource. If there isn't an available packet,\n     * play a silence packet. If there are 5 consecutive cycles with failed reads, then the\n     * playback will end.\n     */\n    const packet: Buffer | null = state.resource.read();\n\n    if (state.status === AudioPlayerStatus.Playing) {\n      if (packet) {\n        this._preparePacket(packet, playable, state);\n        state.missedFrames = 0;\n      } else {\n        this._preparePacket(SILENCE_FRAME, playable, state);\n        state.missedFrames++;\n        if (state.missedFrames >= this.behaviors.maxMissedFrames) {\n          this.stop();\n        }\n      }\n    }\n  }\n\n  /**\n   * Signals to all the subscribed connections that they should send a packet to Discord indicating\n   * they are no longer speaking. Called once playback of a resource ends.\n   */\n  private _signalStopSpeaking() {\n    for (const { connection } of this.subscribers) {\n      connection.setSpeaking(false);\n    }\n  }\n\n  /**\n   * Instructs the given connections to each prepare this packet to be played at the start of the\n   * next cycle.\n   *\n   * @param packet - The Opus packet to be prepared by each receiver\n   * @param receivers - The connections that should play this packet\n   */\n  private _preparePacket(\n  packet: Buffer,\n  receivers: VoiceConnection[],\n  state: AudioPlayerPausedState | AudioPlayerPlayingState)\n  {\n    state.playbackDuration += 20;\n    for (const connection of receivers) {\n      connection.prepareAudioPacket(packet);\n    }\n  }\n}\n\n/**\n * Creates a new AudioPlayer to be used.\n */\nexport function createAudioPlayer(options?: CreateAudioPlayerOptions) {\n  return new AudioPlayer(options);\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\nimport type { AudioResource } from './AudioResource';\n\n/**\n * An error emitted by an AudioPlayer. Contains an attached resource to aid with\n * debugging and identifying where the error came from.\n */\nexport class AudioPlayerError extends Error {\n  /**\n   * The resource associated with the audio player at the time the error was thrown.\n   */\n  public readonly resource: AudioResource;\n\n  public constructor(error: Error, resource: AudioResource) {\n    super(error.message);\n    this.resource = resource;\n    this.name = error.name;\n    this.stack = error.stack!;\n  }\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\n/* eslint-disable @typescript-eslint/dot-notation */\nimport type { VoiceConnection } from '../VoiceConnection';\nimport type { AudioPlayer } from './AudioPlayer';\n\n/**\n * Represents a subscription of a voice connection to an audio player, allowing\n * the audio player to play audio on the voice connection.\n */\nexport class PlayerSubscription {\n  /**\n   * The voice connection of this subscription.\n   */\n  public readonly connection: VoiceConnection;\n\n  /**\n   * The audio player of this subscription.\n   */\n  public readonly player: AudioPlayer;\n\n  public constructor(connection: VoiceConnection, player: AudioPlayer) {\n    this.connection = connection;\n    this.player = player;\n  }\n\n  /**\n   * Unsubscribes the connection from the audio player, meaning that the\n   * audio player cannot stream audio to it until a new subscription is made.\n   */\n  public unsubscribe() {\n    this.connection['onSubscriptionRemoved'](this);\n    this.player['unsubscribe'](this);\n  }\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */\nimport { Buffer } from 'node:buffer';\nimport { createSocket, type Socket } from 'node:dgram';\nimport { EventEmitter } from 'node:events';\nimport { isIPv4 } from 'node:net';\n\n/**\n * Stores an IP address and port. Used to store socket details for the local client as well as\n * for Discord.\n */\nexport interface SocketConfig {\n  ip: string;\n  port: number;\n}\n\n/**\n * Parses the response from Discord to aid with local IP discovery.\n *\n * @param message - The received message\n */\nexport function parseLocalPacket(message: Buffer): SocketConfig {\n  const packet = Buffer.from(message);\n\n  const ip = packet.subarray(8, packet.indexOf(0, 8)).toString('utf8');\n\n  if (!isIPv4(ip)) {\n    throw new Error('Malformed IP address');\n  }\n\n  const port = packet.readUInt16BE(packet.length - 2);\n\n  return { ip, port };\n}\n\n/**\n * The interval in milliseconds at which keep alive datagrams are sent.\n */\nconst KEEP_ALIVE_INTERVAL = 5e3;\n\n/**\n * The maximum value of the keep alive counter.\n */\nconst MAX_COUNTER_VALUE = 2 ** 32 - 1;\n\nexport interface VoiceUDPSocket extends EventEmitter {\n  on(event: 'error', listener: (error: Error) => void): this;\n  on(event: 'close', listener: () => void): this;\n  on(event: 'debug', listener: (message: string) => void): this;\n  on(event: 'message', listener: (message: Buffer) => void): this;\n}\n\n/**\n * Manages the UDP networking for a voice connection.\n */\nexport class VoiceUDPSocket extends EventEmitter {\n  /**\n   * The underlying network Socket for the VoiceUDPSocket.\n   */\n  private readonly socket: Socket;\n\n  /**\n   * The socket details for Discord (remote)\n   */\n  private readonly remote: SocketConfig;\n\n  /**\n   * The counter used in the keep alive mechanism.\n   */\n  private keepAliveCounter = 0;\n\n  /**\n   * The buffer used to write the keep alive counter into.\n   */\n  private readonly keepAliveBuffer: Buffer;\n\n  /**\n   * The Node.js interval for the keep-alive mechanism.\n   */\n  private readonly keepAliveInterval: NodeJS.Timeout;\n\n  /**\n   * The time taken to receive a response to keep alive messages.\n   *\n   * @deprecated This field is no longer updated as keep alive messages are no longer tracked.\n   */\n  public ping?: number;\n\n  /**\n   * Creates a new VoiceUDPSocket.\n   *\n   * @param remote - Details of the remote socket\n   */\n  public constructor(remote: SocketConfig) {\n    super();\n    this.socket = createSocket('udp4');\n    this.socket.on('error', (error: Error) => this.emit('error', error));\n    this.socket.on('message', (buffer: Buffer) => this.onMessage(buffer));\n    this.socket.on('close', () => this.emit('close'));\n    this.remote = remote;\n    this.keepAliveBuffer = Buffer.alloc(8);\n    this.keepAliveInterval = setInterval(\n      () => this.keepAlive(),\n      KEEP_ALIVE_INTERVAL\n    );\n    setImmediate(() => this.keepAlive());\n  }\n\n  /**\n   * Called when a message is received on the UDP socket.\n   *\n   * @param buffer - The received buffer\n   */\n  private onMessage(buffer: Buffer): void {\n    // Propagate the message\n    this.emit('message', buffer);\n  }\n\n  /**\n   * Called at a regular interval to check whether we are still able to send datagrams to Discord.\n   */\n  private keepAlive() {\n    this.keepAliveBuffer.writeUInt32LE(this.keepAliveCounter, 0);\n    this.send(this.keepAliveBuffer);\n    this.keepAliveCounter++;\n    if (this.keepAliveCounter > MAX_COUNTER_VALUE) {\n      this.keepAliveCounter = 0;\n    }\n  }\n\n  /**\n   * Sends a buffer to Discord.\n   *\n   * @param buffer - The buffer to send\n   */\n  public send(buffer: Buffer) {\n    this.socket.send(buffer, this.remote.port, this.remote.ip);\n  }\n\n  /**\n   * Closes the socket, the instance will not be able to be reused.\n   */\n  public destroy() {\n    try {\n      this.socket.close();\n    } catch {\n\n      //\n    }\n    clearInterval(this.keepAliveInterval);\n  }\n\n  /**\n   * Performs IP discovery to discover the local address and port to be used for the voice connection.\n   *\n   * @param ssrc - The SSRC received from Discord\n   */\n  public async performIPDiscovery(ssrc: number): Promise<SocketConfig> {\n    return new Promise((resolve, reject) => {\n      const listener = (message: Buffer) => {\n        try {\n          if (message.readUInt16BE(0) !== 2) return;\n          const packet = parseLocalPacket(message);\n          this.socket.off('message', listener);\n          resolve(packet);\n        } catch {\n\n          //\n        }};\n\n      this.socket.on('message', listener);\n      this.socket.once('close', () =>\n      reject(new Error('Cannot perform IP discovery - socket closed'))\n      );\n\n      const discoveryBuffer = Buffer.alloc(74);\n\n      discoveryBuffer.writeUInt16BE(1, 0);\n      discoveryBuffer.writeUInt16BE(70, 2);\n      discoveryBuffer.writeUInt32BE(ssrc, 4);\n      this.send(discoveryBuffer);\n    });\n  }\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\n/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */\nimport { Buffer } from 'node:buffer';\nimport { EventEmitter } from 'node:events';\nimport type { VoiceSendPayload } from 'discord-api-types/voice/v8';\nimport { VoiceOpcodes } from 'discord-api-types/voice/v8';\nimport WebSocket, { type MessageEvent } from 'ws';\nimport { unsafe } from '../common/types';\n\n/**\n * A binary WebSocket message.\n */\nexport interface BinaryWebSocketMessage {\n  op: VoiceOpcodes;\n  payload: Buffer;\n  seq: number;\n}\n\nexport interface VoiceWebSocket extends EventEmitter {\n  on(event: 'error', listener: (error: Error) => void): this;\n  on(event: 'open', listener: (event: WebSocket.Event) => void): this;\n  on(event: 'close', listener: (event: WebSocket.CloseEvent) => void): this;\n  /**\n   * Debug event for VoiceWebSocket.\n   *\n   * @eventProperty\n   */\n  on(event: 'debug', listener: (message: string) => void): this;\n  /**\n   * Packet event.\n   *\n   * @eventProperty\n   */\n  on(event: 'packet', listener: (packet: unsafe) => void): this;\n  /**\n   * Binary message event.\n   *\n   * @eventProperty\n   */\n  on(\n  event: 'binary',\n  listener: (message: BinaryWebSocketMessage) => void)\n  : this;\n}\n\n/**\n * An extension of the WebSocket class to provide helper functionality when interacting\n * with the Discord Voice gateway.\n */\nexport class VoiceWebSocket extends EventEmitter {\n  /**\n   * The current heartbeat interval, if any.\n   */\n  private heartbeatInterval?: NodeJS.Timeout;\n\n  /**\n   * The time (milliseconds since UNIX epoch) that the last heartbeat acknowledgement packet was received.\n   * This is set to 0 if an acknowledgement packet hasn't been received yet.\n   */\n  private lastHeartbeatAck: number;\n\n  /**\n   * The time (milliseconds since UNIX epoch) that the last heartbeat was sent. This is set to 0 if a heartbeat\n   * hasn't been sent yet.\n   */\n  private lastHeartbeatSend: number;\n\n  /**\n   * The number of consecutively missed heartbeats.\n   */\n  private missedHeartbeats = 0;\n\n  /**\n   * The last recorded ping.\n   */\n  public ping?: number;\n\n  /**\n   * The last sequence number acknowledged from Discord. Will be `-1` if no sequence numbered messages have been received.\n   */\n  public sequence = -1;\n\n  /**\n   * The debug logger function, if debugging is enabled.\n   */\n  private readonly debug: ((message: string) => void) | null;\n\n  /**\n   * The underlying WebSocket of this wrapper.\n   */\n  private readonly ws: WebSocket;\n\n  /**\n   * Creates a new VoiceWebSocket.\n   *\n   * @param address - The address to connect to\n   */\n  public constructor(address: string, debug: boolean) {\n    super();\n    this.ws = new WebSocket(address);\n    this.ws.onmessage = (err) => this.onMessage(err);\n    this.ws.onopen = (err) => this.emit('open', err);\n    this.ws.onerror = (err: Error | WebSocket.ErrorEvent) =>\n    this.emit('error', err instanceof Error ? err : err.error);\n    this.ws.onclose = (err) => this.emit('close', err);\n\n    this.lastHeartbeatAck = 0;\n    this.lastHeartbeatSend = 0;\n\n    this.debug = debug ?\n    (message: string) => this.emit('debug', message) :\n    null;\n  }\n\n  /**\n   * Destroys the VoiceWebSocket. The heartbeat interval is cleared, and the connection is closed.\n   */\n  public destroy() {\n    try {\n      this.debug?.('destroyed');\n      this.setHeartbeatInterval(-1);\n      this.ws.close(1_000);\n    } catch (error) {\n      const err = error as Error;\n      this.emit('error', err);\n    }\n  }\n\n  /**\n   * Handles message events on the WebSocket. Attempts to JSON parse the messages and emit them\n   * as packets. Binary messages will be parsed and emitted.\n   *\n   * @param event - The message event\n   */\n  public onMessage(event: MessageEvent) {\n    if (event.data instanceof Buffer || event.data instanceof ArrayBuffer) {\n      const buffer =\n      event.data instanceof ArrayBuffer ?\n      Buffer.from(event.data) :\n      event.data;\n      const seq = buffer.readUInt16BE(0);\n      const op = buffer.readUInt8(2);\n      const payload = buffer.subarray(3);\n\n      this.sequence = seq;\n      this.debug?.(\n        `<< [bin] opcode ${op}, seq ${seq}, ${payload.byteLength} bytes`\n      );\n\n      this.emit('binary', { op, seq, payload });\n      return;\n    } else if (typeof event.data !== 'string') {\n      return;\n    }\n\n    this.debug?.(`<< ${event.data}`);\n\n    let packet: unsafe;\n    try {\n      packet = JSON.parse(event.data);\n    } catch (error) {\n      const err = error as Error;\n      this.emit('error', err);\n      return;\n    }\n\n    if (packet.seq) {\n      this.sequence = packet.seq;\n    }\n\n    if (packet.op === VoiceOpcodes.HeartbeatAck) {\n      this.lastHeartbeatAck = Date.now();\n      this.missedHeartbeats = 0;\n      this.ping = this.lastHeartbeatAck - this.lastHeartbeatSend;\n    }\n\n    this.emit('packet', packet);\n  }\n\n  /**\n   * Sends a JSON-stringifiable packet over the WebSocket.\n   *\n   * @param packet - The packet to send\n   */\n  public sendPacket(packet: VoiceSendPayload) {\n    try {\n      const stringified = JSON.stringify(packet);\n      this.debug?.(`>> ${stringified}`);\n      this.ws.send(stringified);\n    } catch (error) {\n      const err = error as Error;\n      this.emit('error', err);\n    }\n  }\n\n  /**\n   * Sends a binary message over the WebSocket.\n   *\n   * @param opcode - The opcode to use\n   * @param payload - The payload to send\n   */\n  public sendBinaryMessage(opcode: VoiceOpcodes, payload: Buffer) {\n    try {\n      const message = Buffer.concat([new Uint8Array([opcode]), payload]);\n      this.debug?.(`>> [bin] opcode ${opcode}, ${payload.byteLength} bytes`);\n      this.ws.send(message);\n    } catch (error) {\n      const err = error as Error;\n      this.emit('error', err);\n    }\n  }\n\n  /**\n   * Sends a heartbeat over the WebSocket.\n   */\n  private sendHeartbeat() {\n    this.lastHeartbeatSend = Date.now();\n    this.missedHeartbeats++;\n    const nonce = this.lastHeartbeatSend;\n    this.sendPacket({\n      op: VoiceOpcodes.Heartbeat,\n      // eslint-disable-next-line id-length\n      d: {\n        // eslint-disable-next-line id-length\n        t: nonce,\n        seq_ack: this.sequence\n      }\n    });\n  }\n\n  /**\n   * Sets/clears an interval to send heartbeats over the WebSocket.\n   *\n   * @param ms - The interval in milliseconds. If negative, the interval will be unset\n   */\n  public setHeartbeatInterval(ms: number) {\n    if (this.heartbeatInterval !== undefined)\n    clearInterval(this.heartbeatInterval);\n    if (ms > 0) {\n      this.heartbeatInterval = setInterval(() => {\n        if (this.lastHeartbeatSend !== 0 && this.missedHeartbeats >= 3) {\n          // Missed too many heartbeats - disconnect\n          this.ws.close();\n          this.setHeartbeatInterval(-1);\n        }\n\n        this.sendHeartbeat();\n      }, ms);\n    }\n  }\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\nimport type { JoinConfig } from './DataStore';\nimport { createVoiceConnection } from './VoiceConnection';\nimport type { DiscordGatewayAdapterCreator } from './util/adapter';\n\n/**\n * The options that can be given when creating a voice connection.\n */\nexport interface CreateVoiceConnectionOptions {\n  adapterCreator: DiscordGatewayAdapterCreator;\n\n  /**\n   * Whether to use the DAVE protocol for end-to-end encryption. Defaults to true.\n   */\n  daveEncryption?: boolean | undefined;\n\n  /**\n   * If true, debug messages will be enabled for the voice connection and its\n   * related components. Defaults to false.\n   */\n  debug?: boolean | undefined;\n\n  /**\n   * The amount of consecutive decryption failures needed to try to\n   * re-initialize the end-to-end encrypted session to recover. Defaults to 24.\n   */\n  decryptionFailureTolerance?: number | undefined;\n}\n\n/**\n * The options that can be given when joining a voice channel.\n */\nexport interface JoinVoiceChannelOptions {\n  /**\n   * The id of the Discord voice channel to join.\n   */\n  channelId: string;\n\n  /**\n   * An optional group identifier for the voice connection.\n   */\n  group?: string;\n\n  /**\n   * The id of the guild that the voice channel belongs to.\n   */\n  guildId: string;\n\n  /**\n   * Whether to join the channel deafened (defaults to true)\n   */\n  selfDeaf?: boolean;\n\n  /**\n   * Whether to join the channel muted (defaults to true)\n   */\n  selfMute?: boolean;\n}\n\n/**\n * Creates a VoiceConnection to a Discord voice channel.\n *\n * @param options - the options for joining the voice channel\n */\nexport function joinVoiceChannel(\noptions: CreateVoiceConnectionOptions & JoinVoiceChannelOptions)\n{\n  const joinConfig: JoinConfig = {\n    selfDeaf: true,\n    selfMute: false,\n    group: 'default',\n    ...options\n  };\n\n  return createVoiceConnection(joinConfig, {\n    adapterCreator: options.adapterCreator,\n    debug: options.debug,\n    daveEncryption: options.daveEncryption,\n    decryptionFailureTolerance: options.decryptionFailureTolerance\n  });\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\nimport type { Buffer } from 'node:buffer';\nimport { pipeline, type Readable } from 'node:stream';\nimport { noop } from '../util/util';\nimport { SILENCE_FRAME, type AudioPlayer } from './AudioPlayer';\nimport {\n  findPipeline,\n  StreamType,\n  TransformerType,\n  type Edge } from\n'./TransformerGraph';\nimport {\n  OggDemuxer,\n  OpusDecoder,\n  OpusEncoder,\n  WebmDemuxer } from\n'@discord-player/opus';\nimport { VolumeTransformer } from '@discord-player/equalizer';\n\n/**\n * Options that are set when creating a new audio resource.\n *\n * @typeParam Metadata - the type for the metadata (if any) of the audio resource\n */\nexport interface CreateAudioResourceOptions<Metadata> {\n  /**\n   * Whether or not inline volume should be enabled. If enabled, you will be able to change the volume\n   * of the stream on-the-fly. However, this also increases the performance cost of playback. Defaults to `false`.\n   */\n  inlineVolume?: boolean;\n\n  /**\n   * The type of the input stream. Defaults to `StreamType.Arbitrary`.\n   */\n  inputType?: StreamType;\n\n  /**\n   * Optional metadata that can be attached to the resource (e.g. track title, random id).\n   * This is useful for identification purposes when the resource is passed around in events.\n   * See {@link AudioResource.metadata}\n   */\n  metadata?: Metadata;\n\n  /**\n   * The number of silence frames to append to the end of the resource's audio stream, to prevent interpolation glitches.\n   * Defaults to 5.\n   */\n  silencePaddingFrames?: number;\n}\n\n/**\n * Represents an audio resource that can be played by an audio player.\n *\n * @typeParam Metadata - the type for the metadata (if any) of the audio resource\n */\nexport class AudioResource<Metadata = unknown> {\n  /**\n   * An object-mode Readable stream that emits Opus packets. This is what is played by audio players.\n   */\n  public readonly playStream: Readable;\n\n  /**\n   * The pipeline used to convert the input stream into a playable format. For example, this may\n   * contain an FFmpeg component for arbitrary inputs, and it may contain a VolumeTransformer component\n   * for resources with inline volume transformation enabled.\n   */\n  public readonly edges: readonly Edge[];\n\n  /**\n   * Optional metadata that can be used to identify the resource.\n   */\n  public metadata: Metadata;\n\n  /**\n   * If the resource was created with inline volume transformation enabled, then this will be a\n   * `@discord-player/equalizer` VolumeTransformer. You can use this to alter the volume of the stream.\n   */\n  public readonly volume?: VolumeTransformer;\n\n  /**\n   * If using an Opus encoder to create this audio resource, then this will be a`@discord-player/opus` opus.Encoder.\n   * You can use this to control settings such as bitrate, FEC, PLP.\n   */\n  public readonly encoder?: OpusEncoder;\n\n  /**\n   * The audio player that the resource is subscribed to, if any.\n   */\n  public audioPlayer?: AudioPlayer | undefined;\n\n  /**\n   * The playback duration of this audio resource, given in milliseconds.\n   */\n  public playbackDuration = 0;\n\n  /**\n   * Whether or not the stream for this resource has started (data has become readable)\n   */\n  public started = false;\n\n  /**\n   * The number of silence frames to append to the end of the resource's audio stream, to prevent interpolation glitches.\n   */\n  public readonly silencePaddingFrames: number;\n\n  /**\n   * The number of remaining silence frames to play. If -1, the frames have not yet started playing.\n   */\n  public silenceRemaining = -1;\n\n  public constructor(\n  edges: readonly Edge[],\n  streams: readonly Readable[],\n  metadata: Metadata,\n  silencePaddingFrames: number)\n  {\n    this.edges = edges;\n    this.playStream =\n    streams.length > 1 ?\n    pipeline(streams, noop) as unknown as Readable :\n    streams[0]!;\n    this.metadata = metadata;\n    this.silencePaddingFrames = silencePaddingFrames;\n\n    for (const stream of streams) {\n      if (stream instanceof VolumeTransformer) {\n        this.volume = stream;\n      } else if (stream instanceof OpusEncoder) {\n        this.encoder = stream;\n      }\n    }\n\n    this.playStream.once('readable', () => this.started = true);\n  }\n\n  /**\n   * Whether this resource is readable. If the underlying resource is no longer readable, this will still return true\n   * while there are silence padding frames left to play.\n   */\n  public get readable() {\n    if (this.silenceRemaining === 0) return false;\n    const real = this.playStream.readable;\n    if (!real) {\n      if (this.silenceRemaining === -1)\n      this.silenceRemaining = this.silencePaddingFrames;\n      return this.silenceRemaining !== 0;\n    }\n\n    return real;\n  }\n\n  /**\n   * Whether this resource has ended or not.\n   */\n  public get ended() {\n    return (\n      this.playStream.readableEnded ||\n      this.playStream.destroyed ||\n      this.silenceRemaining === 0);\n\n  }\n\n  /**\n   * Attempts to read an Opus packet from the audio resource. If a packet is available, the playbackDuration\n   * is incremented.\n   *\n   * @remarks\n   * It is advisable to check that the playStream is readable before calling this method. While no runtime\n   * errors will be thrown, you should check that the resource is still available before attempting to\n   * read from it.\n   * @internal\n   */\n  public read(): Buffer | null {\n    if (this.silenceRemaining === 0) {\n      return null;\n    } else if (this.silenceRemaining > 0) {\n      this.silenceRemaining--;\n      return SILENCE_FRAME;\n    }\n\n    const packet = this.playStream.read() as Buffer | null;\n    if (packet) {\n      this.playbackDuration += 20;\n    }\n\n    return packet;\n  }\n}\n\n/**\n * Ensures that a path contains at least one volume transforming component.\n *\n * @param path - The path to validate constraints on\n */\nexport const VOLUME_CONSTRAINT = (path: Edge[]) =>\npath.some((edge) => edge.type === TransformerType.InlineVolume);\n\nexport const NO_CONSTRAINT = () => true;\n\n/**\n * Tries to infer the type of a stream to aid with transcoder pipelining.\n *\n * @param stream - The stream to infer the type of\n */\nexport function inferStreamType(stream: Readable): {\n  hasVolume: boolean;\n  streamType: StreamType;\n} {\n  if (stream instanceof OpusEncoder) {\n    return { streamType: StreamType.Opus, hasVolume: false };\n  } else if (stream instanceof OpusDecoder) {\n    return { streamType: StreamType.Raw, hasVolume: false };\n  } else if (stream instanceof VolumeTransformer) {\n    return { streamType: StreamType.Raw, hasVolume: true };\n  } else if (stream instanceof OggDemuxer) {\n    return { streamType: StreamType.Opus, hasVolume: false };\n  } else if (stream instanceof WebmDemuxer) {\n    return { streamType: StreamType.Opus, hasVolume: false };\n  }\n\n  return { streamType: StreamType.Arbitrary, hasVolume: false };\n}\n\n/**\n * Creates an audio resource that can be played by audio players.\n *\n * @remarks\n * If the input is given as a string, then the inputType option will be overridden and FFmpeg will be used.\n *\n * If the input is not in the correct format, then a pipeline of transcoders and transformers will be created\n * to ensure that the resultant stream is in the correct format for playback. This could involve using FFmpeg,\n * Opus transcoders, and Ogg/WebM demuxers.\n * @param input - The resource to play\n * @param options - Configurable options for creating the resource\n * @typeParam Metadata - the type for the metadata (if any) of the audio resource\n */\nexport function createAudioResource<Metadata>(\ninput: Readable | string,\noptions: CreateAudioResourceOptions<Metadata> &\nPick<\n  Metadata extends null | undefined ?\n  CreateAudioResourceOptions<Metadata> :\n  Required<CreateAudioResourceOptions<Metadata>>,\n  'metadata'>)\n\n: AudioResource<Metadata extends null | undefined ? null : Metadata>;\n\n/**\n * Creates an audio resource that can be played by audio players.\n *\n * @remarks\n * If the input is given as a string, then the inputType option will be overridden and FFmpeg will be used.\n *\n * If the input is not in the correct format, then a pipeline of transcoders and transformers will be created\n * to ensure that the resultant stream is in the correct format for playback. This could involve using FFmpeg,\n * Opus transcoders, and Ogg/WebM demuxers.\n * @param input - The resource to play\n * @param options - Configurable options for creating the resource\n * @typeParam Metadata - the type for the metadata (if any) of the audio resource\n */\nexport function createAudioResource<Metadata extends null | undefined>(\ninput: Readable | string,\noptions?: Omit<CreateAudioResourceOptions<Metadata>, 'metadata'>)\n: AudioResource<null>;\n\n/**\n * Creates an audio resource that can be played by audio players.\n *\n * @remarks\n * If the input is given as a string, then the inputType option will be overridden and FFmpeg will be used.\n *\n * If the input is not in the correct format, then a pipeline of transcoders and transformers will be created\n * to ensure that the resultant stream is in the correct format for playback. This could involve using FFmpeg,\n * Opus transcoders, and Ogg/WebM demuxers.\n * @param input - The resource to play\n * @param options - Configurable options for creating the resource\n * @typeParam Metadata - the type for the metadata (if any) of the audio resource\n */\nexport function createAudioResource<Metadata>(\ninput: Readable | string,\noptions: CreateAudioResourceOptions<Metadata> = {})\n: AudioResource<Metadata> {\n  let inputType = options.inputType;\n  let needsInlineVolume = Boolean(options.inlineVolume);\n\n  // string inputs can only be used with FFmpeg\n  if (typeof input === 'string') {\n    inputType = StreamType.Arbitrary;\n  } else if (inputType === undefined) {\n    const analysis = inferStreamType(input);\n    inputType = analysis.streamType;\n    needsInlineVolume = needsInlineVolume && !analysis.hasVolume;\n  }\n\n  const transformerPipeline = findPipeline(\n    inputType,\n    needsInlineVolume ? VOLUME_CONSTRAINT : NO_CONSTRAINT\n  );\n\n  if (transformerPipeline.length === 0) {\n    if (typeof input === 'string')\n    throw new Error(\n      `Invalid pipeline constructed for string resource '${input}'`\n    );\n    // No adjustments required\n    return new AudioResource<Metadata>(\n      [],\n      [input],\n      (options.metadata ?? null) as Metadata,\n      options.silencePaddingFrames ?? 5\n    );\n  }\n\n  const streams = transformerPipeline.map((edge) => edge.transformer(input));\n  if (typeof input !== 'string') streams.unshift(input);\n\n  return new AudioResource<Metadata>(\n    transformerPipeline,\n    streams,\n    (options.metadata ?? null) as Metadata,\n    options.silencePaddingFrames ?? 5\n  );\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\nimport type { Readable } from 'node:stream';\nimport {\n  OpusEncoder,\n  OpusDecoder,\n  OggDemuxer,\n  WebmDemuxer } from\n'@discord-player/opus';\nimport { createFFmpegArgs, FFmpeg } from '@discord-player/ffmpeg';\nimport { VolumeTransformer } from '@discord-player/equalizer';\n\nconst FFMPEG_PCM_ARGUMENTS = createFFmpegArgs({\n  analyzeduration: '0',\n  loglevel: '0',\n  f: 's16le',\n  ar: '48000',\n  ac: '2'\n});\n\nconst FFMPEG_OPUS_ARGUMENTS = createFFmpegArgs({\n  analyzeduration: '0',\n  loglevel: '0',\n  acodec: 'libopus',\n  f: 'opus',\n  ar: '48000',\n  ac: '2'\n});\n\n/**\n * The different types of stream that can exist within the pipeline.\n */\nexport enum StreamType {\n  /**\n   * The type of the stream at this point is unknown.\n   */\n  Arbitrary = 'arbitrary',\n  /**\n   * The stream at this point is Opus audio encoded in an Ogg wrapper.\n   */\n  OggOpus = 'ogg/opus',\n  /**\n   * The stream at this point is Opus audio, and the stream is in object-mode. This is ready to play.\n   */\n  Opus = 'opus',\n  /**\n   * The stream at this point is s16le PCM.\n   */\n  Raw = 'raw',\n  /**\n   * The stream at this point is Opus audio encoded in a WebM wrapper.\n   */\n  WebmOpus = 'webm/opus',\n}\n\n/**\n * The different types of transformers that can exist within the pipeline.\n */\nexport enum TransformerType {\n  FFmpegOgg = 'ffmpeg ogg',\n  FFmpegPCM = 'ffmpeg pcm',\n  InlineVolume = 'volume transformer',\n  OggOpusDemuxer = 'ogg/opus demuxer',\n  OpusDecoder = 'opus decoder',\n  OpusEncoder = 'opus encoder',\n  WebmOpusDemuxer = 'webm/opus demuxer',\n}\n\n/**\n * Represents a pathway from one stream type to another using a transformer.\n */\nexport interface Edge {\n  cost: number;\n  from: Node;\n  to: Node;\n  transformer(input: Readable | string): Readable;\n  type: TransformerType;\n}\n\n/**\n * Represents a type of stream within the graph, e.g. an Opus stream, or a stream of raw audio.\n */\nexport class Node {\n  /**\n   * The outbound edges from this node.\n   */\n  public readonly edges: Edge[] = [];\n\n  /**\n   * The type of stream for this node.\n   */\n  public readonly type: StreamType;\n\n  public constructor(type: StreamType) {\n    this.type = type;\n  }\n\n  /**\n   * Creates an outbound edge from this node.\n   *\n   * @param edge - The edge to create\n   */\n  public addEdge(edge: Omit<Edge, 'from'>) {\n    this.edges.push({ ...edge, from: this });\n  }\n}\n\n// Create a node for each stream type\nlet NODES: Map<StreamType, Node> | null = null;\n\nfunction canEnableFFmpegOptimizations(): boolean {\n  return FFmpeg.resolveSafe()?.result.includes('--enable-libopus') === true;\n}\n\n/**\n * Gets a node from its stream type.\n *\n * @param type - The stream type of the target node\n */\nexport function getNode(type: StreamType) {\n  const node = (NODES ??= initializeNodes()).get(type);\n  if (!node) throw new Error(`Node type '${type}' does not exist!`);\n  return node;\n}\n\nfunction initializeNodes(): Map<StreamType, Node> {\n  const nodes = new Map<StreamType, Node>();\n  for (const streamType of Object.values(StreamType)) {\n    nodes.set(streamType, new Node(streamType));\n  }\n\n  nodes.get(StreamType.Raw)!.addEdge({\n    type: TransformerType.OpusEncoder,\n    to: nodes.get(StreamType.Opus)!,\n    cost: 1.5,\n    transformer: () =>\n    new OpusEncoder({ rate: 48_000, channels: 2, frameSize: 960 })\n  });\n\n  nodes.get(StreamType.Opus)!.addEdge({\n    type: TransformerType.OpusDecoder,\n    to: nodes.get(StreamType.Raw)!,\n    cost: 1.5,\n    transformer: () =>\n    new OpusDecoder({ rate: 48_000, channels: 2, frameSize: 960 })\n  });\n\n  nodes.get(StreamType.OggOpus)!.addEdge({\n    type: TransformerType.OggOpusDemuxer,\n    to: nodes.get(StreamType.Opus)!,\n    cost: 1,\n    transformer: () => new OggDemuxer()\n  });\n\n  nodes.get(StreamType.WebmOpus)!.addEdge({\n    type: TransformerType.WebmOpusDemuxer,\n    to: nodes.get(StreamType.Opus)!,\n    cost: 1,\n    transformer: () => new WebmDemuxer()\n  });\n\n  const FFMPEG_PCM_EDGE: Omit<Edge, 'from'> = {\n    type: TransformerType.FFmpegPCM,\n    to: nodes.get(StreamType.Raw)!,\n    cost: 2,\n    transformer: (input) =>\n    new FFmpeg({\n      args: [\n      '-i',\n      typeof input === 'string' ? input : '-',\n      ...FFMPEG_PCM_ARGUMENTS]\n\n    })\n  };\n\n  nodes.get(StreamType.Arbitrary)!.addEdge(FFMPEG_PCM_EDGE);\n  nodes.get(StreamType.OggOpus)!.addEdge(FFMPEG_PCM_EDGE);\n  nodes.get(StreamType.WebmOpus)!.addEdge(FFMPEG_PCM_EDGE);\n\n  nodes.get(StreamType.Raw)!.addEdge({\n    type: TransformerType.InlineVolume,\n    to: nodes.get(StreamType.Raw)!,\n    cost: 0.5,\n    transformer: () => new VolumeTransformer({ type: 's16le' })\n  });\n\n  if (canEnableFFmpegOptimizations()) {\n    const FFMPEG_OGG_EDGE: Omit<Edge, 'from'> = {\n      type: TransformerType.FFmpegOgg,\n      to: nodes.get(StreamType.OggOpus)!,\n      cost: 2,\n      transformer: (input) =>\n      new FFmpeg({\n        args: [\n        '-i',\n        typeof input === 'string' ? input : '-',\n        ...FFMPEG_OPUS_ARGUMENTS]\n\n      })\n    };\n    nodes.get(StreamType.Arbitrary)!.addEdge(FFMPEG_OGG_EDGE);\n    // Include Ogg and WebM as well in case they have different sampling rates or are mono instead of stereo\n    // at the moment, this will not do anything. However, if/when detection for correct Opus headers is\n    // implemented, this will help inform the voice engine that it is able to transcode the audio.\n    nodes.get(StreamType.OggOpus)!.addEdge(FFMPEG_OGG_EDGE);\n    nodes.get(StreamType.WebmOpus)!.addEdge(FFMPEG_OGG_EDGE);\n  }\n\n  return nodes;\n}\n\n/**\n * Represents a step in the path from node A to node B.\n */\ninterface Step {\n  /**\n   * The cost of the steps after this step.\n   */\n  cost: number;\n\n  /**\n   * The edge associated with this step.\n   */\n  edge?: Edge;\n\n  /**\n   * The next step.\n   */\n  next?: Step;\n}\n\n/**\n * Finds the shortest cost path from node A to node B.\n *\n * @param from - The start node\n * @param constraints - Extra validation for a potential solution. Takes a path, returns true if the path is valid\n * @param goal - The target node\n * @param path - The running path\n * @param depth - The number of remaining recursions\n */\nfunction findPath(\nfrom: Node,\nconstraints: (path: Edge[]) => boolean,\ngoal = getNode(StreamType.Opus),\npath: Edge[] = [],\ndepth = 5)\n: Step {\n  if (from === goal && constraints(path)) {\n    return { cost: 0 };\n  } else if (depth === 0) {\n    return { cost: Number.POSITIVE_INFINITY };\n  }\n\n  let currentBest: Step | undefined;\n  for (const edge of from.edges) {\n    if (currentBest && edge.cost > currentBest.cost) continue;\n    const next = findPath(\n      edge.to,\n      constraints,\n      goal,\n      [...path, edge],\n      depth - 1\n    );\n    const cost = edge.cost + next.cost;\n    if (!currentBest || cost < currentBest.cost) {\n      currentBest = { cost, edge, next };\n    }\n  }\n\n  return currentBest ?? { cost: Number.POSITIVE_INFINITY };\n}\n\n/**\n * Takes the solution from findPath and assembles it into a list of edges.\n *\n * @param step - The first step of the path\n */\nfunction constructPipeline(step: Step) {\n  const edges: Edge[] = [];\n  let current: Step | undefined = step;\n  while (current?.edge) {\n    edges.push(current.edge);\n    current = current.next;\n  }\n\n  return edges;\n}\n\n/**\n * Finds the lowest-cost pipeline to convert the input stream type into an Opus stream.\n *\n * @param from - The stream type to start from\n * @param constraint - Extra constraints that may be imposed on potential solution\n */\nexport function findPipeline(\nfrom: StreamType,\nconstraint: (path: Edge[]) => boolean)\n{\n  return constructPipeline(findPath(getNode(from), constraint));\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\nimport { type EventEmitter, once } from 'node:events';\nimport type {\n  VoiceConnection,\n  VoiceConnectionStatus } from\n'../VoiceConnection';\nimport type { AudioPlayer, AudioPlayerStatus } from '../audio/AudioPlayer';\nimport { abortAfter } from './abortAfter';\n\n/**\n * Allows a voice connection a specified amount of time to enter a given state, otherwise rejects with an error.\n *\n * @param target - The voice connection that we want to observe the state change for\n * @param status - The status that the voice connection should be in\n * @param timeoutOrSignal - The maximum time we are allowing for this to occur, or a signal that will abort the operation\n */\nexport function entersState(\ntarget: VoiceConnection,\nstatus: VoiceConnectionStatus,\ntimeoutOrSignal: AbortSignal | number)\n: Promise<VoiceConnection>;\n\n/**\n * Allows an audio player a specified amount of time to enter a given state, otherwise rejects with an error.\n *\n * @param target - The audio player that we want to observe the state change for\n * @param status - The status that the audio player should be in\n * @param timeoutOrSignal - The maximum time we are allowing for this to occur, or a signal that will abort the operation\n */\nexport function entersState(\ntarget: AudioPlayer,\nstatus: AudioPlayerStatus,\ntimeoutOrSignal: AbortSignal | number)\n: Promise<AudioPlayer>;\n\n/**\n * Allows a target a specified amount of time to enter a given state, otherwise rejects with an error.\n *\n * @param target - The object that we want to observe the state change for\n * @param status - The status that the target should be in\n * @param timeoutOrSignal - The maximum time we are allowing for this to occur, or a signal that will abort the operation\n */\nexport async function entersState<Target extends AudioPlayer | VoiceConnection>(\ntarget: Target,\nstatus: AudioPlayerStatus | VoiceConnectionStatus,\ntimeoutOrSignal: AbortSignal | number)\n{\n  if (target.state.status !== status) {\n    const [ac, signal] =\n    typeof timeoutOrSignal === 'number' ?\n    abortAfter(timeoutOrSignal) :\n    [undefined, timeoutOrSignal];\n    try {\n      await once(target as EventEmitter, status, { signal });\n    } finally {\n      ac?.abort();\n    }\n  }\n\n  return target;\n}", "// Copyright discord-player authors. All rights reserved. MIT License.\n// Copyright discord.js authors. All rights reserved. Apache License 2.0\n\n/**\n * Creates an abort controller that aborts after the given time.\n *\n * @param delay - The time in milliseconds to wait before aborting\n */\nexport function abortAfter(delay: number): [AbortController, AbortSignal] {\n  const ac = new AbortController();\n  const timeout = setTimeout(() => ac.abort(), delay);\n  ac.signal.addEventListener('abort', () => clearTimeout(timeout));\n  return [ac, ac.signal];\n}", "\n\n\n\n\n\nexport const version = /* @__MACRO__ getVersion */\"7.2.0\";"],
  "mappings": "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",
  "names": ["import_node_events", "import_node_buffer", "import_node_events", "import_v8", "nonce", "crypto", "import_node_buffer", "import_node_events", "import_node_buffer", "NoSubscriberBehavior", "AudioPlayerStatus", "import_node_buffer", "import_node_events", "import_node_buffer", "import_node_events", "WebSocket", "nonce", "crypto", "stringifyState", "option", "crypto", "VoiceConnectionStatus", "VoiceConnectionDisconnectReason", "StreamType", "import_opus", "import_equalizer", "import_node_events"]
}
