discord-player 6.0.0-dev.2 → 6.0.0-dev.3

package/dist/index.js

@@ -57,11 +57,13 @@ __export(src_exports, {
   BaseExtractor: () => BaseExtractor,
   BiquadFilterType: () => import_equalizer3.FilterType,
   BiquadFilters: () => import_equalizer3.BiquadFilters,
+  DiscordPlayerQueryResultCache: () => DiscordPlayerQueryResultCache,
   EqualizerConfigurationPreset: () => EqualizerConfigurationPreset,
   ErrorStatusCode: () => ErrorStatusCode,
   ExtractorExecutionContext: () => ExtractorExecutionContext,
   FFMPEG_ARGS_PIPED: () => FFMPEG_ARGS_PIPED,
   FFMPEG_ARGS_STRING: () => FFMPEG_ARGS_STRING,
+  FFMPEG_SRATE_REGEX: () => FFMPEG_SRATE_REGEX,
   FFmpegFilterer: () => FFmpegFilterer,
   FiltersChain: () => import_equalizer3.FiltersChain,
   GuildNodeManager: () => GuildNodeManager,
@@ -75,10 +77,10 @@ __export(src_exports, {
   PlayerError: () => PlayerError,
   Playlist: () => Playlist,
   Q_BUTTERWORTH: () => import_equalizer3.Q_BUTTERWORTH,
-  QueryResolver: () => QueryResolver,
+  QueryCache: () => QueryCache,
   QueryType: () => QueryType,
-  Queue: () => Queue,
   QueueRepeatMode: () => QueueRepeatMode,
+  SearchResult: () => SearchResult,
   StreamDispatcher: () => StreamDispatcher,
   Track: () => Track,
   Util: () => Util,
@@ -88,7 +90,7 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_discord5 = require("discord.js");
+var import_discord4 = require("discord.js");
 
 // src/utils/AudioFilters.ts
 var bass = /* @__PURE__ */ __name((g) => `bass=g=${g}:f=110:w=0.3`, "bass");
@@ -137,6 +139,7 @@ AudioFilters.filters = {
   "8D": "apulsator=hz=0.09",
   vaporwave: "aresample=48000,asetrate=48000*0.8",
   nightcore: "aresample=48000,asetrate=48000*1.25",
+  lofi: "aresample=48000,asetrate=48000*0.9,extrastereo=m=2.5:c=disabled",
   phaser: "aphaser=in_gain=0.4",
   tremolo: "tremolo",
   vibrato: "vibrato=f=6.5",
@@ -196,6 +199,9 @@ var BaseExtractor = class {
   emit(event, ...args) {
     return this.context.player.emit(event, ...args);
   }
+  createResponse(playlist, tracks = playlist?.tracks || []) {
+    return { playlist: playlist || null, tracks };
+  }
 };
 __name(BaseExtractor, "BaseExtractor");
 BaseExtractor.identifier = "com.discord-player.extractor";
@@ -249,8 +255,11 @@ var ExtractorExecutionContext = class {
     } catch {
     }
   }
-  async run(fn) {
+  async run(fn, filterBlocked = true) {
+    const blocked = this.player.options.blockExtractors ?? [];
     for (const ext of this.store.values()) {
+      if (filterBlocked && blocked.some((e) => e === ext.identifier))
+        continue;
       const result = await fn(ext).catch(() => {
         return false;
       });
@@ -265,48 +274,12 @@ var ExtractorExecutionContext = class {
 };
 __name(ExtractorExecutionContext, "ExtractorExecutionContext");
 
-// src/Structures/Playlist.ts
-var Playlist = class {
-  constructor(player, data) {
-    this.player = player;
-    this.tracks = data.tracks ?? [];
-    this.author = data.author;
-    this.description = data.description;
-    this.thumbnail = data.thumbnail;
-    this.type = data.type;
-    this.source = data.source;
-    this.id = data.id;
-    this.url = data.url;
-    this.title = data.title;
-  }
-  *[Symbol.iterator]() {
-    yield* this.tracks;
-  }
-  toJSON(withTracks = true) {
-    const payload = {
-      id: this.id,
-      url: this.url,
-      title: this.title,
-      description: this.description,
-      thumbnail: this.thumbnail,
-      type: this.type,
-      source: this.source,
-      author: this.author,
-      tracks: []
-    };
-    if (withTracks)
-      payload.tracks = this.tracks.map((m) => m.toJSON(true));
-    return payload;
-  }
-};
-__name(Playlist, "Playlist");
-
-// src/Player.ts
-var import_discord4 = require("discord.js");
-var import_utils8 = require("@discord-player/utils");
+// src/Structures/GuildNodeManager.ts
+var import_utils4 = require("@discord-player/utils");
 
-// src/Structures/Queue.ts
+// src/Structures/GuildQueue.ts
 var import_discord2 = require("discord.js");
+var import_utils3 = require("@discord-player/utils");
 
 // src/Structures/Track.ts
 var import_discord = require("discord.js");
@@ -332,7 +305,7 @@ var Track = class {
     Object.defineProperty(this, "raw", { value: Object.assign({}, { source: data.raw?.source ?? data.source }, data.raw ?? data), enumerable: false });
   }
   get queue() {
-    return this.player.queues.find((q) => q.tracks.some((ab) => ab.id === this.id));
+    return this.player.nodes.cache.find((q) => q.tracks.some((ab) => ab.id === this.id));
   }
   get durationMS() {
     const times = /* @__PURE__ */ __name((n, t) => {
@@ -367,39 +340,8 @@ var Track = class {
 };
 __name(Track, "Track");
 
-// src/types/types.ts
-var QueryType = {
-  AUTO: "auto",
-  YOUTUBE: "youtube",
-  YOUTUBE_PLAYLIST: "youtubePlaylist",
-  SOUNDCLOUD_TRACK: "soundcloudTrack",
-  SOUNDCLOUD_PLAYLIST: "soundcloudPlaylist",
-  SOUNDCLOUD: "soundcloud",
-  SPOTIFY_SONG: "spotifySong",
-  SPOTIFY_ALBUM: "spotifyAlbum",
-  SPOTIFY_PLAYLIST: "spotifyPlaylist",
-  FACEBOOK: "facebook",
-  VIMEO: "vimeo",
-  ARBITRARY: "arbitrary",
-  REVERBNATION: "reverbnation",
-  YOUTUBE_SEARCH: "youtubeSearch",
-  YOUTUBE_VIDEO: "youtubeVideo",
-  SOUNDCLOUD_SEARCH: "soundcloudSearch",
-  APPLE_MUSIC_SONG: "appleMusicSong",
-  APPLE_MUSIC_ALBUM: "appleMusicAlbum",
-  APPLE_MUSIC_PLAYLIST: "appleMusicPlaylist",
-  FILE: "file"
-};
-var QueueRepeatMode = /* @__PURE__ */ ((QueueRepeatMode2) => {
-  QueueRepeatMode2[QueueRepeatMode2["OFF"] = 0] = "OFF";
-  QueueRepeatMode2[QueueRepeatMode2["TRACK"] = 1] = "TRACK";
-  QueueRepeatMode2[QueueRepeatMode2["QUEUE"] = 2] = "QUEUE";
-  QueueRepeatMode2[QueueRepeatMode2["AUTOPLAY"] = 3] = "AUTOPLAY";
-  return QueueRepeatMode2;
-})(QueueRepeatMode || {});
-
-// src/Structures/Queue.ts
-var import_voice = require("@discordjs/voice");
+// src/Structures/GuildQueue.ts
+var import_voice2 = require("@discordjs/voice");
 
 // src/utils/Util.ts
 var import_promises = require("timers/promises");
@@ -472,128 +414,138 @@ var Util = class {
 };
 __name(Util, "Util");
 
-// src/Structures/PlayerError.ts
-var ErrorStatusCode = /* @__PURE__ */ ((ErrorStatusCode2) => {
-  ErrorStatusCode2["STREAM_ERROR"] = "StreamError";
-  ErrorStatusCode2["AUDIO_PLAYER_ERROR"] = "AudioPlayerError";
-  ErrorStatusCode2["PLAYER_ERROR"] = "PlayerError";
-  ErrorStatusCode2["NO_AUDIO_RESOURCE"] = "NoAudioResource";
-  ErrorStatusCode2["UNKNOWN_GUILD"] = "UnknownGuild";
-  ErrorStatusCode2["INVALID_ARG_TYPE"] = "InvalidArgType";
-  ErrorStatusCode2["UNKNOWN_EXTRACTOR"] = "UnknownExtractor";
-  ErrorStatusCode2["INVALID_EXTRACTOR"] = "InvalidExtractor";
-  ErrorStatusCode2["INVALID_CHANNEL_TYPE"] = "InvalidChannelType";
-  ErrorStatusCode2["INVALID_TRACK"] = "InvalidTrack";
-  ErrorStatusCode2["UNKNOWN_REPEAT_MODE"] = "UnknownRepeatMode";
-  ErrorStatusCode2["TRACK_NOT_FOUND"] = "TrackNotFound";
-  ErrorStatusCode2["NO_CONNECTION"] = "NoConnection";
-  ErrorStatusCode2["DESTROYED_QUEUE"] = "DestroyedQueue";
-  return ErrorStatusCode2;
-})(ErrorStatusCode || {});
-var PlayerError = class extends Error {
-  constructor(message, code = "PlayerError" /* PLAYER_ERROR */) {
-    super();
-    this.createdAt = new Date();
-    this.message = `[${code}] ${message}`;
-    this.statusCode = code;
-    this.name = code;
-    Error.captureStackTrace(this);
-  }
-  get createdTimestamp() {
-    return this.createdAt.getTime();
+// src/Structures/Playlist.ts
+var Playlist = class {
+  constructor(player, data) {
+    this.player = player;
+    this.tracks = data.tracks ?? [];
+    this.author = data.author;
+    this.description = data.description;
+    this.thumbnail = data.thumbnail;
+    this.type = data.type;
+    this.source = data.source;
+    this.id = data.id;
+    this.url = data.url;
+    this.title = data.title;
   }
-  valueOf() {
-    return this.statusCode;
+  *[Symbol.iterator]() {
+    yield* this.tracks;
   }
-  toJSON() {
-    return {
-      stack: this.stack,
-      code: this.statusCode,
-      message: this.message,
-      created: this.createdTimestamp
+  toJSON(withTracks = true) {
+    const payload = {
+      id: this.id,
+      url: this.url,
+      title: this.title,
+      description: this.description,
+      thumbnail: this.thumbnail,
+      type: this.type,
+      source: this.source,
+      author: this.author,
+      tracks: []
     };
-  }
-  toString() {
-    return this.stack;
+    if (withTracks)
+      payload.tracks = this.tracks.map((m) => m.toJSON(true));
+    return payload;
   }
 };
-__name(PlayerError, "PlayerError");
+__name(Playlist, "Playlist");
 
-// src/utils/FFmpegStream.ts
-var import_prism_media = require("prism-media");
-function FFMPEG_ARGS_STRING(stream, fmt) {
-  return [
-    "-reconnect",
-    "1",
-    "-reconnect_streamed",
-    "1",
-    "-reconnect_delay_max",
-    "5",
-    "-i",
-    stream,
-    "-analyzeduration",
-    "0",
-    "-loglevel",
-    "0",
-    "-f",
-    `${typeof fmt === "string" ? fmt : "s16le"}`,
-    "-ar",
-    "48000",
-    "-ac",
-    "2"
-  ];
-}
-__name(FFMPEG_ARGS_STRING, "FFMPEG_ARGS_STRING");
-function FFMPEG_ARGS_PIPED(fmt) {
-  return [
-    "-analyzeduration",
-    "0",
-    "-loglevel",
-    "0",
-    "-f",
-    `${typeof fmt === "string" ? fmt : "s16le"}`,
-    "-ar",
-    "48000",
-    "-ac",
-    "2"
-  ];
-}
-__name(FFMPEG_ARGS_PIPED, "FFMPEG_ARGS_PIPED");
-function createFFmpegStream(stream, options) {
-  if (options?.skip && typeof stream !== "string")
-    return stream;
-  options ?? (options = {});
-  const args = typeof stream === "string" ? FFMPEG_ARGS_STRING(stream, options.fmt) : FFMPEG_ARGS_PIPED(options.fmt);
-  if (!Number.isNaN(options.seek))
-    args.unshift("-ss", String(options.seek));
-  if (Array.isArray(options.encoderArgs))
-    args.push(...options.encoderArgs);
-  const transcoder = new import_prism_media.FFmpeg({ shell: false, args });
-  transcoder.on("close", () => transcoder.destroy());
-  if (typeof stream !== "string") {
-    stream.on("error", () => transcoder.destroy());
-    stream.pipe(transcoder);
+// src/Structures/GuildQueueHistory.ts
+var import_utils2 = require("@discord-player/utils");
+var GuildQueueHistory = class {
+  constructor(queue) {
+    this.queue = queue;
+    this.tracks = new import_utils2.Queue("LIFO");
   }
-  return transcoder;
-}
-__name(createFFmpegStream, "createFFmpegStream");
+  get currentTrack() {
+    return this.queue.dispatcher?.audioResource?.metadata || this.queue.__current;
+  }
+  get nextTrack() {
+    return this.queue.tracks.at(0) || null;
+  }
+  get previousTrack() {
+    return this.tracks.at(0) || null;
+  }
+  get disabled() {
+    return this.queue.options.disableHistory;
+  }
+  isEmpty() {
+    return this.tracks.size < 1;
+  }
+  push(track) {
+    if (this.disabled)
+      return false;
+    this.tracks.add(track);
+    return true;
+  }
+  clear() {
+    this.tracks.clear();
+  }
+  next() {
+    const track = this.nextTrack;
+    if (!track) {
+      throw new Error("No next track in the queue");
+    }
+    this.queue.node.skip();
+  }
+  previous() {
+    const track = this.previousTrack;
+    if (!track) {
+      throw new Error("No previous track in the queue");
+    }
+    this.queue.node.play(track, { queue: true });
+    this.queue.node.skip();
+  }
+};
+__name(GuildQueueHistory, "GuildQueueHistory");
 
-// src/Structures/Queue.ts
-var import_os = __toESM(require("os"));
-var import_worker_threads = require("worker_threads");
-var import_utils2 = require("@discord-player/utils");
+// src/Structures/GuildQueuePlayerNode.ts
+var import_voice = require("@discordjs/voice");
 
 // src/utils/QueryResolver.ts
 var import_youtube_sr = require("youtube-sr");
-var import_soundcloud_scraper = require("soundcloud-scraper");
-var spotifySongRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:track\/|\?uri=spotify:track:)((\w|-){22})(\?si=.+)?$/;
-var spotifyPlaylistRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:playlist\/|\?uri=spotify:playlist:)((\w|-){22})(\?si=.+)?$/;
-var spotifyAlbumRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:album\/|\?uri=spotify:album:)((\w|-){22})(\?si=.+)?$/;
-var vimeoRegex = /^(http|https)?:\/\/(www\.|player\.)?vimeo\.com\/(?:channels\/(?:\w+\/)?|groups\/([^/]*)\/videos\/|video\/|)(\d+)(?:|\/\?)$/;
-var reverbnationRegex = /^https:\/\/(www.)?reverbnation.com\/(.+)\/song\/(.+)$/;
-var attachmentRegex = /^https?:\/\/.+$/;
-var appleMusicSongRegex = /^https?:\/\/music\.apple\.com\/.+?\/(song|album)\/.+?(\/.+?\?i=|\/)([0-9]+)$/;
-var appleMusicPlaylistRegex = /^https?:\/\/music\.apple\.com\/.+?\/playlist\/.+\/pl\.[a-f0-9]+$/;
+
+// src/types/types.ts
+var QueryType = {
+  AUTO: "auto",
+  YOUTUBE: "youtube",
+  YOUTUBE_PLAYLIST: "youtubePlaylist",
+  SOUNDCLOUD_TRACK: "soundcloudTrack",
+  SOUNDCLOUD_PLAYLIST: "soundcloudPlaylist",
+  SOUNDCLOUD: "soundcloud",
+  SPOTIFY_SONG: "spotifySong",
+  SPOTIFY_ALBUM: "spotifyAlbum",
+  SPOTIFY_PLAYLIST: "spotifyPlaylist",
+  FACEBOOK: "facebook",
+  VIMEO: "vimeo",
+  ARBITRARY: "arbitrary",
+  REVERBNATION: "reverbnation",
+  YOUTUBE_SEARCH: "youtubeSearch",
+  YOUTUBE_VIDEO: "youtubeVideo",
+  SOUNDCLOUD_SEARCH: "soundcloudSearch",
+  APPLE_MUSIC_SONG: "appleMusicSong",
+  APPLE_MUSIC_ALBUM: "appleMusicAlbum",
+  APPLE_MUSIC_PLAYLIST: "appleMusicPlaylist",
+  FILE: "file"
+};
+var QueueRepeatMode = /* @__PURE__ */ ((QueueRepeatMode2) => {
+  QueueRepeatMode2[QueueRepeatMode2["OFF"] = 0] = "OFF";
+  QueueRepeatMode2[QueueRepeatMode2["TRACK"] = 1] = "TRACK";
+  QueueRepeatMode2[QueueRepeatMode2["QUEUE"] = 2] = "QUEUE";
+  QueueRepeatMode2[QueueRepeatMode2["AUTOPLAY"] = 3] = "AUTOPLAY";
+  return QueueRepeatMode2;
+})(QueueRepeatMode || {});
+
+// src/utils/QueryResolver.ts
+var import_soundcloud_scraper = require("soundcloud-scraper");
+var spotifySongRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:track\/|\?uri=spotify:track:)((\w|-){22})(\?si=.+)?$/;
+var spotifyPlaylistRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:playlist\/|\?uri=spotify:playlist:)((\w|-){22})(\?si=.+)?$/;
+var spotifyAlbumRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:album\/|\?uri=spotify:album:)((\w|-){22})(\?si=.+)?$/;
+var vimeoRegex = /^(http|https)?:\/\/(www\.|player\.)?vimeo\.com\/(?:channels\/(?:\w+\/)?|groups\/([^/]*)\/videos\/|video\/|)(\d+)(?:|\/\?)$/;
+var reverbnationRegex = /^https:\/\/(www.)?reverbnation.com\/(.+)\/song\/(.+)$/;
+var attachmentRegex = /^https?:\/\/.+$/;
+var appleMusicSongRegex = /^https?:\/\/music\.apple\.com\/.+?\/(song|album)\/.+?(\/.+?\?i=|\/)([0-9]+)$/;
+var appleMusicPlaylistRegex = /^https?:\/\/music\.apple\.com\/.+?\/playlist\/.+\/pl\.(u-)?[a-zA-Z0-9]+$/;
 var appleMusicAlbumRegex = /^https?:\/\/music\.apple\.com\/.+?\/album\/.+\/([0-9]+)$/;
 var QueryResolver = class {
   constructor() {
@@ -653,237 +605,123 @@ var QueryResolver = class {
 };
 __name(QueryResolver, "QueryResolver");
 
-// src/Structures/Queue.ts
-var import_youtube_sr2 = require("youtube-sr");
-var OBCS_DEFAULT = /* @__PURE__ */ __name(async () => {
-  return void 0;
-}, "OBCS_DEFAULT");
-var _destroyed, _watchDestroyed, watchDestroyed_fn, _getBufferingTimeout, getBufferingTimeout_fn;
-var Queue = class {
-  constructor(player, guild, options = {}) {
-    __privateAdd(this, _watchDestroyed);
-    __privateAdd(this, _getBufferingTimeout);
-    this.tracks = [];
-    this.previousTracks = [];
-    this.playing = false;
-    this.metadata = null;
-    this.repeatMode = 0;
-    this.id = import_discord2.SnowflakeUtil.generate().toString();
-    this._streamTime = 0;
-    this._cooldownsTimeout = new import_utils2.Collection();
-    this._activeFilters = [];
-    this._filtersUpdate = false;
-    this._lastEQBands = [];
-    this._lastAudioFilters = [];
-    __privateAdd(this, _destroyed, false);
-    this.onBeforeCreateStream = OBCS_DEFAULT;
-    this.player = player;
-    this.guild = guild;
-    this.options = {};
-    Object.assign(
-      this.options,
-      {
-        leaveOnEnd: true,
-        leaveOnStop: true,
-        leaveOnEmpty: true,
-        leaveOnEndCooldown: 1e3,
-        leaveOnEmptyCooldown: 1e3,
-        autoSelfDeaf: true,
-        ytdlOptions: {
-          highWaterMark: 1 << 25
-        },
-        initialVolume: 100,
-        bufferingTimeout: 3e3,
-        spotifyBridge: true,
-        disableVolume: false,
-        disableEqualizer: false,
-        equalizerBands: [],
-        disableBiquad: false,
-        disableFilters: false,
-        defaultFilters: []
-      },
-      options
-    );
-    if (Array.isArray(options.equalizerBands))
-      this._lastEQBands = options.equalizerBands;
-    if (Array.isArray(options.defaultFilters))
-      this._lastAudioFilters = options.defaultFilters;
-    if (options.biquadFilter != null)
-      this._lastBiquadFilter = options.biquadFilter;
-    if ("onBeforeCreateStream" in this.options)
-      this.onBeforeCreateStream = this.options.onBeforeCreateStream;
-    this.player.emit("debug", this, `Queue initialized:
-
-${this.player.scanDeps()}`);
+// src/Structures/GuildQueuePlayerNode.ts
+var import_promises2 = require("timers/promises");
+var FFMPEG_SRATE_REGEX = /asetrate=\d+\*(\d(\.\d)?)/;
+var _progress, _performPlay, performPlay_fn, _createGenericStream, createGenericStream_fn, _createFFmpegStream, createFFmpegStream_fn;
+var GuildQueuePlayerNode = class {
+  constructor(queue) {
+    this.queue = queue;
+    __privateAdd(this, _performPlay);
+    __privateAdd(this, _createGenericStream);
+    __privateAdd(this, _createFFmpegStream);
+    __privateAdd(this, _progress, 0);
   }
-  get filters() {
-    return this.connection.filters;
+  isIdle() {
+    return !!this.queue.dispatcher?.isIdle();
   }
-  get equalizer() {
-    return this.connection.equalizer;
+  isBuffering() {
+    return !!this.queue.dispatcher?.isBuffering();
   }
-  get biquad() {
-    return this.connection.biquad;
+  isPlaying() {
+    return !!this.queue.dispatcher?.isPlaying();
   }
-  async forceNext() {
-    if (this.connection.audioResource) {
-      this.connection.emit("finish", this.connection.audioResource);
-    } else if (this.tracks.length) {
-      await this.play();
-    }
+  isPaused() {
+    return !!this.queue.dispatcher?.isPaused();
   }
-  get current() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    return this.connection.audioResource?.metadata ?? this.tracks[0];
+  resetProgress() {
+    __privateSet(this, _progress, 0);
   }
-  get destroyed() {
-    return __privateGet(this, _destroyed);
+  get streamTime() {
+    return this.queue.dispatcher?.streamTime ?? 0;
   }
-  nowPlaying() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    return this.current;
+  get playbackTime() {
+    const dur = __privateGet(this, _progress) + this.streamTime;
+    return dur;
   }
-  async connect(channel) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    const _channel = this.guild.channels.resolve(channel);
-    if (![import_discord2.ChannelType.GuildStageVoice, import_discord2.ChannelType.GuildVoice].includes(_channel?.type))
-      throw new PlayerError(`Channel type must be GuildVoice or GuildStageVoice, got ${_channel?.type}!`, "InvalidArgType" /* INVALID_ARG_TYPE */);
-    const connection = await this.player.voiceUtils.connect(_channel, {
-      deaf: this.options.autoSelfDeaf
-    });
-    this.connection = connection;
-    if (_channel.type === import_discord2.ChannelType.GuildStageVoice) {
-      await _channel.guild.members.me.voice.setSuppressed(false).catch(async () => {
-        return await _channel.guild.members.me.voice.setRequestToSpeak(true).catch(Util.noop);
-      });
-    }
-    this.connection.on("dsp", (filters) => {
-      this._lastAudioFilters = filters;
-    });
-    this.connection.on("eqBands", (filters) => {
-      this._lastEQBands = filters;
-    });
-    this.connection.on("biquad", (filters) => {
-      this._lastBiquadFilter = filters;
-    });
-    this.connection.on("volume", (vol) => {
-      this.options.initialVolume = vol;
-    });
-    this.connection.on("error", (err) => {
-      if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this, false))
-        return;
-      this.player.emit("connectionError", this, err);
-    });
-    this.connection.on("debug", (msg) => {
-      if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this, false))
-        return;
-      this.player.emit("debug", this, msg);
-    });
-    this.player.emit("connectionCreate", this, this.connection);
-    this.connection.on("start", (resource) => {
-      if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this, false))
-        return;
-      this.playing = true;
-      if (!this._filtersUpdate)
-        this.player.emit("trackStart", this, resource?.metadata ?? this.current);
-      this._filtersUpdate = false;
-    });
-    this.connection.on("finish", async (resource) => {
-      if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this, false))
-        return;
-      this.playing = false;
-      if (this._filtersUpdate)
-        return;
-      this._streamTime = 0;
-      this.player.emit("trackEnd", this, resource.metadata);
-      if (!this.tracks.length && this.repeatMode === 0 /* OFF */) {
-        this.emitEnd();
-      } else if (!this.tracks.length && this.repeatMode === 3 /* AUTOPLAY */) {
-        this._handleAutoplay(Util.last(this.previousTracks));
+  getDurationMultiplier() {
+    const srateFilters = this.queue.filters.ffmpeg.toArray().filter((ff) => FFMPEG_SRATE_REGEX.test(ff));
+    const multipliers = srateFilters.map((m) => {
+      return parseFloat(FFMPEG_SRATE_REGEX.exec(m)?.[1]);
+    }).filter((f) => !isNaN(f));
+    return !multipliers.length ? 1 : multipliers.reduce((accumulator, current) => current + accumulator);
+  }
+  get estimatedPlaybackTime() {
+    const dur = this.playbackTime;
+    return Math.round(this.getDurationMultiplier() * dur);
+  }
+  get estimatedDuration() {
+    const dur = this.queue.currentTrack?.durationMS ?? 0;
+    return Math.round(dur / this.getDurationMultiplier());
+  }
+  getTimestamp(ignoreFilters = false) {
+    if (!this.queue.currentTrack)
+      return null;
+    const current = ignoreFilters ? this.playbackTime : this.estimatedPlaybackTime;
+    const total = ignoreFilters ? this.queue.currentTrack.durationMS : this.estimatedDuration;
+    return {
+      current: {
+        label: Util.buildTimeCode(Util.parseMS(current)),
+        value: current
+      },
+      total: {
+        label: Util.buildTimeCode(Util.parseMS(total)),
+        value: total
+      },
+      progress: Math.round(current / total * 100)
+    };
+  }
+  createProgressBar(options) {
+    const timestamp = this.getTimestamp();
+    if (!timestamp)
+      return null;
+    const { indicator = "\u{1F518}", length = 15, line = "\u25AC", timecodes = true } = options || {};
+    if (isNaN(length) || length < 0 || !Number.isFinite(length))
+      throw new Error("invalid progressbar length");
+    const index = Math.round(timestamp.current.value / timestamp.total.value * length);
+    if (index >= 1 && index <= length) {
+      const bar = line.repeat(length - 1).split("");
+      bar.splice(index, 0, indicator);
+      if (timecodes) {
+        return `${timestamp.current.label} \u2503 ${bar.join("")} \u2503 ${timestamp.total.label}`;
       } else {
-        if (this.repeatMode === 1 /* TRACK */)
-          return void this.play(Util.last(this.previousTracks), { immediate: true });
-        if (this.repeatMode === 2 /* QUEUE */)
-          this.tracks.push(Util.last(this.previousTracks));
-        const nextTrack = this.tracks.shift();
-        this.play(nextTrack, { immediate: true });
-        return;
+        return `${bar.join("")}`;
+      }
+    } else {
+      if (timecodes) {
+        return `${timestamp.current.label} \u2503 ${indicator}${line.repeat(length - 1)} \u2503 ${timestamp.total.label}`;
+      } else {
+        return `${indicator}${line.repeat(length - 1)}`;
       }
-    });
-    return this;
-  }
-  emitEnd() {
-    const timeout = setTimeout(() => {
-      if (!this.player.queues.has(this.guild.id))
-        return;
-      if (this.tracks.length || this.current)
-        return;
-      if (this.options.leaveOnEnd)
-        this.destroy();
-      this.player.emit("queueEnd", this);
-    }, this.options.leaveOnEndCooldown || 0).unref();
-    this._cooldownsTimeout.set(`queueEnd_${this.guild.id}`, timeout);
-  }
-  refreshEndCooldown() {
-    const existingTimeout = this._cooldownsTimeout.get(`queueEnd_${this.guild.id}`);
-    if (this.tracks.length || this.current) {
-      clearTimeout(existingTimeout);
-      this._cooldownsTimeout.delete(`queueEnd_${this.guild.id}`);
     }
   }
-  destroy(disconnect = this.options.leaveOnStop) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (this.connection)
-      this.connection.end();
-    if (disconnect)
-      this.connection?.disconnect();
-    this.player.queues.delete(this.guild.id);
-    this.player.voiceUtils.cache.delete(this.guild.id);
-    __privateSet(this, _destroyed, true);
-  }
-  skip() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!this.connection)
+  async seek(duration) {
+    if (!this.queue.currentTrack)
       return false;
-    this._filtersUpdate = false;
-    this.connection.end();
+    await this.play(this.queue.currentTrack, {
+      seek: duration,
+      transitionMode: true
+    });
     return true;
   }
-  addTrack(track) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!(track instanceof Track))
-      throw new PlayerError("invalid track", "InvalidTrack" /* INVALID_TRACK */);
-    this.tracks.push(track);
-    this.refreshEndCooldown();
-    this.player.emit("trackAdd", this, track);
+  get volume() {
+    return this.queue.dispatcher?.volume ?? 100;
   }
-  addTracks(tracks) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!tracks.every((y) => y instanceof Track))
-      throw new PlayerError("invalid track", "InvalidTrack" /* INVALID_TRACK */);
-    this.tracks.push(...tracks);
-    this.refreshEndCooldown();
-    this.player.emit("tracksAdd", this, tracks);
-  }
-  setPaused(paused) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return false;
-    if (!this.connection)
+  setVolume(vol) {
+    if (!this.queue.dispatcher)
       return false;
-    return paused ? this.connection.pause(true) : this.connection.resume();
+    const res = this.queue.dispatcher.setVolume(vol);
+    if (res)
+      this.queue.filters._lastFiltersCache.volume = vol;
+    return res;
   }
-  get paused() {
-    return this.connection.paused;
+  setBitrate(rate) {
+    this.queue.dispatcher?.audioResource?.encoder?.setBitrate(rate === "auto" ? this.queue.channel?.bitrate ?? 64e3 : rate);
   }
-  set paused(val) {
-    this.setPaused(val);
+  setPaused(state) {
+    if (state)
+      return this.queue.dispatcher?.pause(true) || false;
+    return this.queue.dispatcher?.resume() || false;
   }
   pause() {
     return this.setPaused(true);
@@ -891,1640 +729,1402 @@ ${this.player.scanDeps()}`);
   resume() {
     return this.setPaused(false);
   }
-  setBitrate(bitrate) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!this.connection?.audioResource?.encoder)
-      return;
-    if (bitrate === "auto")
-      bitrate = this.connection.channel?.bitrate ?? 64e3;
-    this.connection.audioResource.encoder.setBitrate(bitrate);
-  }
-  setVolume(amount) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!this.connection)
-      return false;
-    this.options.initialVolume = amount;
-    return this.connection.setVolume(amount);
-  }
-  setRepeatMode(mode) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (![0 /* OFF */, 2 /* QUEUE */, 1 /* TRACK */, 3 /* AUTOPLAY */].includes(mode))
-      throw new PlayerError(`Unknown repeat mode "${mode}"!`, "UnknownRepeatMode" /* UNKNOWN_REPEAT_MODE */);
-    if (mode === this.repeatMode)
+  skip() {
+    if (!this.queue.dispatcher)
       return false;
-    this.repeatMode = mode;
+    this.queue.setTransitioning(false);
+    this.queue.dispatcher.end();
     return true;
   }
-  get volume() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return 100;
-    if (!this.connection)
-      return 100;
-    return this.connection.volume;
-  }
-  set volume(amount) {
-    this.setVolume(amount);
-  }
-  get streamTime() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return 0;
-    if (!this.connection)
-      return 0;
-    const playbackTime = this._streamTime + this.connection.streamTime;
-    const NC = this._activeFilters.includes("nightcore") ? 1.25 : null;
-    const VW = this._activeFilters.includes("vaporwave") ? 0.8 : null;
-    if (NC && VW)
-      return playbackTime * (NC + VW);
-    return NC ? playbackTime * NC : VW ? playbackTime * VW : playbackTime;
-  }
-  set streamTime(time) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    this.seek(time);
-  }
-  getFiltersEnabled() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    return AudioFilters_default.names.filter((x) => this._activeFilters.includes(x));
-  }
-  getFiltersDisabled() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    return AudioFilters_default.names.filter((x) => !this._activeFilters.includes(x));
-  }
-  async setFilters(filters) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!filters || !Object.keys(filters).length) {
-      const streamTime2 = this.streamTime;
-      this._activeFilters = [];
-      return await this.play(this.current, {
-        immediate: true,
-        filtersUpdate: true,
-        seek: streamTime2,
-        encoderArgs: []
-      });
-    }
-    const _filters = [];
-    for (const filter in filters) {
-      if (filters[filter] === true)
-        _filters.push(filter);
-    }
-    if (this._activeFilters.join("") === _filters.join(""))
-      return;
-    const newFilters = AudioFilters_default.create(_filters).trim();
-    const streamTime = this.streamTime;
-    this._activeFilters = _filters;
-    return await this.play(this.current, {
-      immediate: true,
-      filtersUpdate: true,
-      seek: streamTime,
-      encoderArgs: !_filters.length ? void 0 : ["-af", newFilters]
+  remove(track) {
+    const foundTrack = this.queue.tracks.find((t, idx) => {
+      if (track instanceof Track || typeof track === "string") {
+        return (typeof track === "string" ? track : track.id) === t.id;
+      }
+      if (typeof track === "string")
+        return track === t.id;
+      return idx === track;
     });
+    if (!foundTrack)
+      return null;
+    this.queue.tracks.removeOne((t) => t.id === foundTrack.id);
+    return foundTrack;
   }
-  async seek(position) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!this.playing || !this.current)
+  jump(track) {
+    const removed = this.remove(track);
+    if (!removed)
       return false;
-    if (position < 1)
-      position = 0;
-    if (position >= this.current.durationMS)
-      return this.skip();
-    await this.play(this.current, {
-      immediate: true,
-      filtersUpdate: true,
-      seek: position
-    });
-    return true;
+    this.queue.tracks.store.unshift(removed);
+    return this.skip();
   }
-  async back() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    const prev = this.previousTracks[this.previousTracks.length - 2];
-    if (!prev)
-      throw new PlayerError("Could not find previous track", "TrackNotFound" /* TRACK_NOT_FOUND */);
-    return await this.play(prev, { immediate: true });
+  getTrackPosition(track) {
+    return this.queue.tracks.toArray().findIndex((t, idx) => {
+      if (track instanceof Track || typeof track === "string") {
+        return (typeof track === "string" ? track : track.id) === t.id;
+      }
+      if (typeof track === "string")
+        return track === t.id;
+      return idx === track;
+    });
   }
-  clear() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    this.tracks = [];
-    this.previousTracks = [];
+  skipTo(track) {
+    const idx = this.getTrackPosition(track);
+    if (idx < 0)
+      return false;
+    const removed = this.remove(idx);
+    if (!removed)
+      return false;
+    this.queue.tracks.store.splice(0, idx, removed);
+    return this.skip();
   }
-  stop() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    return this.destroy();
+  insert(track, index = 0) {
+    if (!(track instanceof Track))
+      throw new Error("invalid track");
+    this.queue.tracks.store.splice(index, 0, track);
   }
-  shuffle() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!this.tracks.length || this.tracks.length < 2)
+  stop(force = false) {
+    if (!this.queue.dispatcher)
       return false;
-    for (let i = this.tracks.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [this.tracks[i], this.tracks[j]] = [this.tracks[j], this.tracks[i]];
+    this.queue.dispatcher.end();
+    if (force) {
+      this.queue.dispatcher.disconnect();
+      return true;
+    }
+    if (this.queue.options.leaveOnStop) {
+      const tm = setTimeout(() => {
+        if (this.isPlaying() || this.queue.tracks.size)
+          return clearTimeout(tm);
+        this.queue.dispatcher?.disconnect();
+      }, this.queue.options.leaveOnStopCooldown).unref();
     }
     return true;
   }
-  remove(track) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    let trackFound = null;
-    if (typeof track === "number") {
-      trackFound = this.tracks[track];
-      if (trackFound) {
-        this.tracks = this.tracks.filter((t) => t.id !== trackFound.id);
+  async play(res, options) {
+    if (!this.queue.dispatcher?.voiceConnection) {
+      throw new Error("No voice connection available");
+    }
+    this.queue.debug(`Received play request from guild ${this.queue.guild.name} (ID: ${this.queue.guild.id})`);
+    options = Object.assign(
+      {},
+      {
+        queue: this.queue.currentTrack != null,
+        transitionMode: false,
+        seek: 0
+      },
+      options
+    );
+    if (res && options.queue) {
+      this.queue.debug("Requested option requires to queue the track, adding the given track to queue instead...");
+      return this.queue.tracks.add(res);
+    }
+    const track = res || this.queue.tracks.dispatch();
+    if (!track) {
+      throw new Error("Play request received but track was not provided");
+    }
+    this.queue.debug("Requested option requires to play the track, initializing...");
+    this.queue.initializing = true;
+    try {
+      this.queue.debug(`Initiating stream extraction process...`);
+      const qt = track.queryType || (track.raw.source === "spotify" ? "spotifySong" : track.raw.source === "apple_music" ? "appleMusicSong" : track.raw.source) || "arbitrary";
+      this.queue.debug(`Executing onBeforeCreateStream hook (QueryType: ${qt})...`);
+      let stream = await this.queue.onBeforeCreateStream?.(track, qt, this.queue).catch(() => null);
+      if (!stream) {
+        this.queue.debug("Failed to get stream from onBeforeCreateStream!");
+        stream = await __privateMethod(this, _createGenericStream, createGenericStream_fn).call(this, track).catch(() => null);
       }
-    } else {
-      trackFound = this.tracks.find((s) => s.id === (track instanceof Track ? track.id : track));
-      if (trackFound) {
-        this.tracks = this.tracks.filter((s) => s.id !== trackFound.id);
+      if (!stream) {
+        const error = new Error("Could not extract stream for this track");
+        this.queue.initializing = false;
+        if (this.queue.options.skipOnNoStream) {
+          this.queue.player.events.emit("playerSkip", this.queue, track);
+          this.queue.player.events.emit("playerError", this.queue, error, track);
+          this.play(this.queue.tracks.dispatch());
+          return;
+        }
+        throw error;
+      }
+      if (typeof options.seek === "number" && options.seek >= 0) {
+        __privateSet(this, _progress, options.seek);
+      } else {
+        __privateSet(this, _progress, 0);
+      }
+      const cookies = track.source === "youtube" ? this.queue.player.options.ytdlOptions?.requestOptions?.headers?.cookie : void 0;
+      const pcmStream = __privateMethod(this, _createFFmpegStream, createFFmpegStream_fn).call(this, stream, track, options.seek ?? 0, cookies);
+      if (options.transitionMode) {
+        this.queue.debug(`Transition mode detected, player will wait for buffering timeout to expire (Timeout: ${this.queue.options.bufferingTimeout}ms)`);
+        await (0, import_promises2.setTimeout)(this.queue.options.bufferingTimeout);
+        this.queue.debug("Buffering timeout has expired!");
       }
+      this.queue.debug(
+        `Preparing final stream config: ${JSON.stringify(
+          {
+            disableBiquad: this.queue.options.biquad === false,
+            disableEqualizer: this.queue.options.equalizer === false,
+            disableVolume: this.queue.options.volume === false,
+            disableFilters: this.queue.options.filterer === false,
+            disableResampler: this.queue.options.resampler === false,
+            sampleRate: typeof this.queue.options.resampler === "number" && this.queue.options.resampler > 0 ? this.queue.options.resampler : void 0,
+            biquadFilter: this.queue.filters._lastFiltersCache.biquad || void 0,
+            eq: this.queue.filters._lastFiltersCache.equalizer,
+            defaultFilters: this.queue.filters._lastFiltersCache.filters,
+            volume: this.queue.filters._lastFiltersCache.volume,
+            transitionMode: !!options.transitionMode,
+            ffmpegFilters: this.queue.filters.ffmpeg.toString(),
+            seek: options.seek
+          },
+          null,
+          2
+        )}`
+      );
+      const resource = await this.queue.dispatcher.createStream(pcmStream, {
+        disableBiquad: this.queue.options.biquad === false,
+        disableEqualizer: this.queue.options.equalizer === false,
+        disableVolume: this.queue.options.volume === false,
+        disableFilters: this.queue.options.filterer === false,
+        disableResampler: this.queue.options.resampler === false,
+        sampleRate: typeof this.queue.options.resampler === "number" && this.queue.options.resampler > 0 ? this.queue.options.resampler : void 0,
+        biquadFilter: this.queue.filters._lastFiltersCache.biquad || void 0,
+        eq: this.queue.filters._lastFiltersCache.equalizer,
+        defaultFilters: this.queue.filters._lastFiltersCache.filters,
+        volume: this.queue.filters._lastFiltersCache.volume,
+        data: track,
+        type: import_voice.StreamType.Raw
+      });
+      this.queue.setTransitioning(!!options.transitionMode);
+      await __privateMethod(this, _performPlay, performPlay_fn).call(this, resource);
+    } catch (e) {
+      this.queue.debug(`Failed to initialize audio player: ${e}`);
+      this.queue.initializing = false;
+      throw e;
     }
-    return trackFound;
   }
-  getTrackPosition(track) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (typeof track === "number")
-      return this.tracks[track] != null ? track : -1;
-    return this.tracks.findIndex((pred) => pred.id === (track instanceof Track ? track.id : track));
+};
+__name(GuildQueuePlayerNode, "GuildQueuePlayerNode");
+_progress = new WeakMap();
+_performPlay = new WeakSet();
+performPlay_fn = /* @__PURE__ */ __name(async function(resource) {
+  this.queue.debug("Initializing audio player...");
+  await this.queue.dispatcher.playStream(resource);
+  this.queue.debug("Dispatching audio...");
+}, "#performPlay");
+_createGenericStream = new WeakSet();
+createGenericStream_fn = /* @__PURE__ */ __name(async function(track) {
+  this.queue.debug(`Attempting to extract stream for Track { title: ${track.title}, url: ${track.url} } using registered extractors`);
+  const streamInfo = await this.queue.player.extractors.run(async (extractor) => {
+    if (this.queue.player.options.blockStreamFrom?.some((ext) => ext === extractor.identifier))
+      return false;
+    const canStream = await extractor.validate(track.url, track.queryType || QueryResolver.resolve(track.url));
+    if (!canStream)
+      return false;
+    return await extractor.stream(track);
+  }, false);
+  if (!streamInfo || !streamInfo.result) {
+    this.queue.debug(`Failed to extract stream for Track { title: ${track.title}, url: ${track.url} } using registered extractors`);
+    return null;
   }
-  jump(track) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
+  this.queue.debug(`Stream extraction was successful for Track { title: ${track.title}, url: ${track.url} } (Extractor: ${streamInfo.extractor.identifier})`);
+  const stream = streamInfo.result;
+  return stream;
+}, "#createGenericStream");
+_createFFmpegStream = new WeakSet();
+createFFmpegStream_fn = /* @__PURE__ */ __name(function(stream, track, seek = 0, cookies) {
+  const ffmpegStream = this.queue.filters.ffmpeg.createStream(stream, {
+    encoderArgs: this.queue.filters.ffmpeg.filters.length ? ["-af", this.queue.filters.ffmpeg.toString()] : [],
+    seek: seek / 1e3,
+    fmt: "s16le",
+    cookies
+  }).on("error", (err) => {
+    const m = `${err}`.toLowerCase();
+    this.queue.debug(`Stream closed due to an error from FFmpeg stream: ${err.stack || err.message || err}`);
+    if (m.includes("premature close") || m.includes("epipe"))
       return;
-    const foundTrack = this.remove(track);
-    if (!foundTrack)
-      throw new PlayerError("Track not found", "TrackNotFound" /* TRACK_NOT_FOUND */);
-    this.tracks.splice(0, 0, foundTrack);
-    return void this.skip();
+    this.queue.player.events.emit("playerError", this.queue, err, track);
+  });
+  return ffmpegStream;
+}, "#createFFmpegStream");
+
+// src/Structures/GuildQueueAudioFilters.ts
+var import_equalizer = require("@discord-player/equalizer");
+
+// src/utils/FFmpegStream.ts
+var import_prism_media = require("prism-media");
+function FFMPEG_ARGS_STRING(stream, fmt, cookies) {
+  const args = [
+    "-reconnect",
+    "1",
+    "-reconnect_streamed",
+    "1",
+    "-reconnect_delay_max",
+    "5",
+    "-i",
+    stream,
+    "-analyzeduration",
+    "0",
+    "-loglevel",
+    "0",
+    "-f",
+    `${typeof fmt === "string" ? fmt : "s16le"}`,
+    "-ar",
+    "48000",
+    "-ac",
+    "2"
+  ];
+  if (typeof cookies === "string") {
+    args.push("-cookies", cookies.startsWith('"') ? cookies : `"${cookies}"`);
   }
-  skipTo(track) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    const trackIndex = this.getTrackPosition(track);
-    const removedTrack = this.remove(track);
-    if (!removedTrack)
-      throw new PlayerError("Track not found", "TrackNotFound" /* TRACK_NOT_FOUND */);
-    this.tracks.splice(0, trackIndex, removedTrack);
-    return void this.skip();
+  return args;
+}
+__name(FFMPEG_ARGS_STRING, "FFMPEG_ARGS_STRING");
+function FFMPEG_ARGS_PIPED(fmt) {
+  return [
+    "-analyzeduration",
+    "0",
+    "-loglevel",
+    "0",
+    "-f",
+    `${typeof fmt === "string" ? fmt : "s16le"}`,
+    "-ar",
+    "48000",
+    "-ac",
+    "2"
+  ];
+}
+__name(FFMPEG_ARGS_PIPED, "FFMPEG_ARGS_PIPED");
+function createFFmpegStream(stream, options) {
+  if (options?.skip && typeof stream !== "string")
+    return stream;
+  options ?? (options = {});
+  const args = typeof stream === "string" ? FFMPEG_ARGS_STRING(stream, options.fmt, options.cookies) : FFMPEG_ARGS_PIPED(options.fmt);
+  if (!Number.isNaN(options.seek))
+    args.unshift("-ss", String(options.seek));
+  if (Array.isArray(options.encoderArgs))
+    args.push(...options.encoderArgs);
+  const transcoder = new import_prism_media.FFmpeg({ shell: false, args });
+  transcoder.on("close", () => transcoder.destroy());
+  if (typeof stream !== "string") {
+    stream.on("error", () => transcoder.destroy());
+    stream.pipe(transcoder);
   }
-  insert(track, index = 0) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!track || !(track instanceof Track))
-      throw new PlayerError("track must be the instance of Track", "InvalidTrack" /* INVALID_TRACK */);
-    if (typeof index !== "number" || index < 0 || !Number.isFinite(index))
-      throw new PlayerError(`Invalid index "${index}"`, "InvalidArgType" /* INVALID_ARG_TYPE */);
-    this.tracks.splice(index, 0, track);
-    this.player.emit("trackAdd", this, track);
-  }
-  getPlayerTimestamp() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    const currentStreamTime = this.streamTime;
-    const totalTime = this.current.durationMS;
-    const currentTimecode = Util.buildTimeCode(Util.parseMS(currentStreamTime));
-    const endTimecode = Util.buildTimeCode(Util.parseMS(totalTime));
-    return {
-      current: currentTimecode,
-      end: endTimecode,
-      progress: Math.round(currentStreamTime / totalTime * 100)
-    };
+  return transcoder;
+}
+__name(createFFmpegStream, "createFFmpegStream");
+
+// src/Structures/GuildQueueAudioFilters.ts
+var makeBands = /* @__PURE__ */ __name((arr) => {
+  return Array.from(
+    {
+      length: import_equalizer.Equalizer.BAND_COUNT
+    },
+    (_, i) => ({
+      band: i,
+      gain: arr[i] ? arr[i] / 30 : 0
+    })
+  );
+}, "makeBands");
+var EqualizerConfigurationPreset = {
+  Flat: makeBands([]),
+  Classical: makeBands([-111022e-20, -111022e-20, -111022e-20, -111022e-20, -111022e-20, -111022e-20, -7.2, -7.2, -7.2, -9.6]),
+  Club: makeBands([-111022e-20, -111022e-20, 8, 5.6, 5.6, 5.6, 3.2, -111022e-20, -111022e-20, -111022e-20]),
+  Dance: makeBands([9.6, 7.2, 2.4, -111022e-20, -111022e-20, -5.6, -7.2, -7.2, -111022e-20, -111022e-20]),
+  FullBass: makeBands([-8, 9.6, 9.6, 5.6, 1.6, -4, -8, -10.4, -11.2, -11.2]),
+  FullBassTreble: makeBands([7.2, 5.6, -111022e-20, -7.2, -4.8, 1.6, 8, 11.2, 12, 12]),
+  FullTreble: makeBands([-9.6, -9.6, -9.6, -4, 2.4, 11.2, 16, 16, 16, 16.8]),
+  Headphones: makeBands([4.8, 11.2, 5.6, -3.2, -2.4, 1.6, 4.8, 9.6, 12.8, 14.4]),
+  LargeHall: makeBands([10.4, 10.4, 5.6, 5.6, -111022e-20, -4.8, -4.8, -4.8, -111022e-20, -111022e-20]),
+  Live: makeBands([-4.8, -111022e-20, 4, 5.6, 5.6, 5.6, 4, 2.4, 2.4, 2.4]),
+  Party: makeBands([7.2, 7.2, -111022e-20, -111022e-20, -111022e-20, -111022e-20, -111022e-20, -111022e-20, 7.2, 7.2]),
+  Pop: makeBands([-1.6, 4.8, 7.2, 8, 5.6, -111022e-20, -2.4, -2.4, -1.6, -1.6]),
+  Reggae: makeBands([-111022e-20, -111022e-20, -111022e-20, -5.6, -111022e-20, 6.4, 6.4, -111022e-20, -111022e-20, -111022e-20]),
+  Rock: makeBands([8, 4.8, -5.6, -8, -3.2, 4, 8.8, 11.2, 11.2, 11.2]),
+  Ska: makeBands([-2.4, -4.8, -4, -111022e-20, 4, 5.6, 8.8, 9.6, 11.2, 9.6]),
+  Soft: makeBands([4.8, 1.6, -111022e-20, -2.4, -111022e-20, 4, 8, 9.6, 11.2, 12]),
+  SoftRock: makeBands([4, 4, 2.4, -111022e-20, -4, -5.6, -3.2, -111022e-20, 2.4, 8.8]),
+  Techno: makeBands([8, 5.6, -111022e-20, -5.6, -4.8, -111022e-20, 8, 9.6, 9.6, 8.8])
+};
+var _ffmpegFilters, _setFilters, setFilters_fn;
+var FFmpegFilterer = class {
+  constructor(af) {
+    this.af = af;
+    __privateAdd(this, _setFilters);
+    __privateAdd(this, _ffmpegFilters, []);
   }
-  createProgressBar(options = { timecodes: true }) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    const length = typeof options.length === "number" ? options.length <= 0 || options.length === Infinity ? 15 : options.length : 15;
-    const index = Math.round(this.streamTime / this.current.durationMS * length);
-    const indicator = typeof options.indicator === "string" && options.indicator.length > 0 ? options.indicator : "\u{1F518}";
-    const line = typeof options.line === "string" && options.line.length > 0 ? options.line : "\u25AC";
-    if (index >= 1 && index <= length) {
-      const bar = line.repeat(length - 1).split("");
-      bar.splice(index, 0, indicator);
-      if (options.timecodes) {
-        const timestamp = this.getPlayerTimestamp();
-        return `${timestamp.current} \u2503 ${bar.join("")} \u2503 ${timestamp.end}`;
-      } else {
-        return `${bar.join("")}`;
-      }
+  createStream(source, options) {
+    return createFFmpegStream(source, options);
+  }
+  setFilters(filters) {
+    let _filters = [];
+    if (typeof filters === "boolean") {
+      _filters = !filters ? [] : Object.keys(AudioFilters_default.filters);
+    } else if (Array.isArray(filters)) {
+      _filters = filters;
     } else {
-      if (options.timecodes) {
-        const timestamp = this.getPlayerTimestamp();
-        return `${timestamp.current} \u2503 ${indicator}${line.repeat(length - 1)} \u2503 ${timestamp.end}`;
-      } else {
-        return `${indicator}${line.repeat(length - 1)}`;
-      }
+      _filters = Object.entries(filters).filter((res) => res[1] === true).map((m) => m[0]);
     }
+    return __privateMethod(this, _setFilters, setFilters_fn).call(this, _filters);
   }
-  get totalTime() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return 0;
-    return this.tracks.length > 0 ? this.tracks.map((t) => t.durationMS).reduce((p, c) => p + c) : 0;
-  }
-  generateStatistics() {
-    return {
-      guild: this.guild.id,
-      memory: process.memoryUsage(),
-      tracks: this.tracks.length,
-      os: {
-        cpuCount: import_os.default.cpus().length,
-        totalMem: import_os.default.totalmem(),
-        freeMem: import_os.default.freemem(),
-        platform: process.platform
-      },
-      isShard: typeof process.send === "function" || import_worker_threads.parentPort != null,
-      latency: {
-        client: this.player.client.ws.ping,
-        udp: this.connection.voiceConnection.ping.udp,
-        ws: this.connection.voiceConnection.ping.ws,
-        eventLoop: this.player.eventLoopLag
-      },
-      subscribers: this.player.queues.size,
-      connections: this.player.queues.filter((x) => x.connection?.voiceConnection != null).size,
-      extractors: this.player.extractors.size
-    };
+  get filters() {
+    return __privateGet(this, _ffmpegFilters);
   }
-  get ping() {
-    return this.connection.voiceConnection.ping.udp;
+  set filters(filters) {
+    this.setFilters(filters);
   }
-  async play(src, options = {}) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this, false))
-      return;
-    if (!this.connection || !this.connection.voiceConnection)
-      throw new PlayerError("Voice connection is not available, use <Queue>.connect()!", "NoConnection" /* NO_CONNECTION */);
-    if (src && (this.playing || this.tracks.length) && !options.immediate)
-      return this.addTrack(src);
-    const track = options.filtersUpdate && !options.immediate ? src || this.current : src ?? this.tracks.shift();
-    if (!track)
-      return;
-    this.player.emit("debug", this, "Received play request");
-    if (!options.filtersUpdate) {
-      this.previousTracks = this.previousTracks.filter((x) => x.id !== track.id);
-      this.previousTracks.push(track);
-    }
-    let stream = null;
-    const hasCustomDownloader = typeof this.onBeforeCreateStream === "function";
-    if (hasCustomDownloader) {
-      const qt = track.queryType || (track.raw.source === "spotify" ? "spotifySong" : track.raw.source === "apple_music" ? "appleMusicSong" : track.raw.source) || "arbitrary";
-      stream = await this.onBeforeCreateStream(track, qt, this) || null;
-    }
-    if (!stream) {
-      const streamInfo = await this.player.extractors.run(async (extractor) => {
-        const canStream = await extractor.validate(track.url, track.queryType || QueryResolver.resolve(track.url));
-        if (!canStream)
-          return false;
-        return await extractor.stream(track);
-      });
-      if (!streamInfo || !streamInfo.result) {
-        this.player.emit("error", this, new Error("No stream extractors are available for this track"));
-        return void this.play(this.tracks.shift(), { immediate: true });
-      }
-      stream = streamInfo.result;
-    }
-    const ffmpegStream = createFFmpegStream(stream, {
-      encoderArgs: options.encoderArgs || this._activeFilters.length ? ["-af", AudioFilters_default.create(this._activeFilters)] : [],
-      seek: options.seek ? options.seek / 1e3 : 0,
-      fmt: "s16le"
-    }).on("error", (err) => {
-      if (!`${err}`.toLowerCase().includes("premature close"))
-        this.player.emit("error", this, err);
-    });
-    const resource = this.connection.createStream(ffmpegStream, {
-      type: import_voice.StreamType.Raw,
-      data: track,
-      disableVolume: Boolean(this.options.disableVolume),
-      disableEqualizer: Boolean(this.options.disableEqualizer),
-      eq: this._lastEQBands,
-      disableBiquad: Boolean(this.options.disableBiquad),
-      biquadFilter: this._lastBiquadFilter,
-      defaultFilters: this._lastAudioFilters,
-      disableFilters: Boolean(this.options.disableFilters),
-      volume: this.options.initialVolume,
-      disableResampler: false
-    });
-    if (options.seek)
-      this._streamTime = options.seek;
-    this._filtersUpdate = options.filtersUpdate;
-    setTimeout(() => {
-      this.connection.playStream(resource);
-    }, __privateMethod(this, _getBufferingTimeout, getBufferingTimeout_fn).call(this)).unref();
-  }
-  async _handleAutoplay(track) {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!track || ![track.source, track.raw?.source].includes("youtube")) {
-      return this.emitEnd();
-    }
-    let info = await import_youtube_sr2.YouTube.getVideo(track.url).then((x) => x.videos[0]).catch(Util.noop);
-    if (!info)
-      info = await import_youtube_sr2.YouTube.search(track.author).then((x) => x[0]).catch(Util.noop);
-    if (!info) {
-      return this.emitEnd();
-    }
-    const nextTrack = new Track(this.player, {
-      title: info.title,
-      url: `https://www.youtube.com/watch?v=${info.id}`,
-      duration: info.durationFormatted || Util.buildTimeCode(Util.parseMS(info.duration * 1e3)),
-      description: "",
-      thumbnail: typeof info.thumbnail === "string" ? info.thumbnail : info.thumbnail.url,
-      views: info.views,
-      author: info.channel.name,
-      requestedBy: track.requestedBy,
-      source: "youtube",
-      queryType: "youtubeVideo"
+  toggle(filters) {
+    if (!Array.isArray(filters))
+      filters = [filters];
+    const fresh = [];
+    filters.forEach((f) => {
+      if (this.filters.includes(f))
+        return;
+      fresh.push(f);
     });
-    this.play(nextTrack, { immediate: true });
+    return __privateMethod(this, _setFilters, setFilters_fn).call(this, __privateGet(this, _ffmpegFilters).filter((r) => !filters.includes(r)).concat(fresh));
   }
-  *[Symbol.iterator]() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    yield* this.tracks;
+  setDefaults(ff) {
+    __privateSet(this, _ffmpegFilters, ff);
+  }
+  getFiltersEnabled() {
+    return __privateGet(this, _ffmpegFilters);
+  }
+  getFiltersDisabled() {
+    return AudioFilters_default.names.filter((f) => !__privateGet(this, _ffmpegFilters).includes(f));
+  }
+  isEnabled(filter) {
+    return __privateGet(this, _ffmpegFilters).includes(filter);
+  }
+  isDisabled(filter) {
+    return !this.isEnabled(filter);
+  }
+  isValidFilter(filter) {
+    return AudioFilters_default.has(filter);
+  }
+  toArray() {
+    return this.filters.map((filter) => AudioFilters_default.get(filter));
   }
   toJSON() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    return {
-      id: this.id,
-      guild: this.guild.id,
-      voiceChannel: this.connection?.channel?.id,
-      options: this.options,
-      tracks: this.tracks.map((m) => m.toJSON())
-    };
+    const obj = {};
+    this.filters.forEach((filter) => obj[filter] = AudioFilters_default.get(filter));
+    return obj;
   }
   toString() {
-    if (__privateMethod(this, _watchDestroyed, watchDestroyed_fn).call(this))
-      return;
-    if (!this.tracks.length)
-      return "No songs available to display!";
-    return `**Upcoming Songs:**
-${this.tracks.map((m, i) => `${i + 1}. **${m.title}**`).join("\n")}`;
+    return AudioFilters_default.create(this.filters);
   }
 };
-__name(Queue, "Queue");
-_destroyed = new WeakMap();
-_watchDestroyed = new WeakSet();
-watchDestroyed_fn = /* @__PURE__ */ __name(function(emit = true) {
-  if (__privateGet(this, _destroyed)) {
-    if (emit)
-      this.player.emit("error", this, new PlayerError("Cannot use destroyed queue", "DestroyedQueue" /* DESTROYED_QUEUE */));
-    return true;
-  }
-  return false;
-}, "#watchDestroyed");
-_getBufferingTimeout = new WeakSet();
-getBufferingTimeout_fn = /* @__PURE__ */ __name(function() {
-  const timeout = this.options.bufferingTimeout;
-  if (isNaN(timeout) || timeout < 0 || !Number.isFinite(timeout))
-    return 1e3;
-  return timeout;
-}, "#getBufferingTimeout");
-
-// src/VoiceInterface/VoiceUtils.ts
-var import_voice3 = require("@discordjs/voice");
-
-// src/VoiceInterface/StreamDispatcher.ts
-var import_voice2 = require("@discordjs/voice");
-var import_utils3 = require("@discord-player/utils");
-var import_equalizer = require("@discord-player/equalizer");
-var StreamDispatcher = class extends import_utils3.EventEmitter {
-  constructor(connection, channel, connectionTimeout = 2e4) {
-    super();
-    this.connectionTimeout = connectionTimeout;
-    this.readyLock = false;
-    this.dsp = new import_equalizer.FiltersChain();
-    this.voiceConnection = connection;
-    this.audioPlayer = (0, import_voice2.createAudioPlayer)();
-    this.channel = channel;
-    this.dsp.onUpdate = () => {
-      if (!this.dsp)
-        return;
-      if (this.dsp.filters?.filters)
-        this.emit("dsp", this.dsp.filters?.filters);
-      if (this.dsp.biquad?.filter)
-        this.emit("biquad", this.dsp.biquad?.filter);
-      if (this.dsp.equalizer)
-        this.emit("eqBands", this.dsp.equalizer.getEQ());
-      if (this.dsp.volume)
-        this.emit("volume", this.dsp.volume.volume);
-      if (this.dsp.resampler)
-        this.emit("sampleRate", this.dsp.resampler.targetSampleRate);
+__name(FFmpegFilterer, "FFmpegFilterer");
+_ffmpegFilters = new WeakMap();
+_setFilters = new WeakSet();
+setFilters_fn = /* @__PURE__ */ __name(function(filters) {
+  const ignoreFilters = this.filters.some((ff) => ff === "nightcore" || ff === "vaporwave") && !filters.some((ff) => ff === "nightcore" || ff === "vaporwave");
+  const seekTime = this.af.queue.node.getTimestamp(ignoreFilters)?.current.value || 0;
+  __privateSet(this, _ffmpegFilters, [...new Set(filters)]);
+  return this.af.triggerReplay(seekTime);
+}, "#setFilters");
+var GuildQueueAudioFilters = class {
+  constructor(queue) {
+    this.queue = queue;
+    this.graph = new AFilterGraph(this);
+    this.ffmpeg = new FFmpegFilterer(this);
+    this.equalizerPresets = EqualizerConfigurationPreset;
+    this._lastFiltersCache = {
+      biquad: null,
+      equalizer: [],
+      filters: [],
+      volume: 100,
+      sampleRate: -1
     };
-    this.dsp.onError = (e) => this.emit("error", e);
-    this.voiceConnection.on("stateChange", async (_, newState) => {
-      if (newState.status === import_voice2.VoiceConnectionStatus.Disconnected) {
-        if (newState.reason === import_voice2.VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
-          try {
-            await (0, import_voice2.entersState)(this.voiceConnection, import_voice2.VoiceConnectionStatus.Connecting, this.connectionTimeout);
-          } catch {
-            try {
-              this.voiceConnection.destroy();
-            } catch (err) {
-              this.emit("error", err);
-            }
-          }
-        } else if (this.voiceConnection.rejoinAttempts < 5) {
-          await Util.wait((this.voiceConnection.rejoinAttempts + 1) * 5e3);
-          this.voiceConnection.rejoin();
-        } else {
-          try {
-            this.voiceConnection.destroy();
-          } catch (err) {
-            this.emit("error", err);
-          }
-        }
-      } else if (newState.status === import_voice2.VoiceConnectionStatus.Destroyed) {
-        this.end();
-      } else if (!this.readyLock && (newState.status === import_voice2.VoiceConnectionStatus.Connecting || newState.status === import_voice2.VoiceConnectionStatus.Signalling)) {
-        this.readyLock = true;
-        try {
-          await (0, import_voice2.entersState)(this.voiceConnection, import_voice2.VoiceConnectionStatus.Ready, this.connectionTimeout);
-        } catch {
-          if (this.voiceConnection.state.status !== import_voice2.VoiceConnectionStatus.Destroyed) {
-            try {
-              this.voiceConnection.destroy();
-            } catch (err) {
-              this.emit("error", err);
-            }
-          }
-        } finally {
-          this.readyLock = false;
-        }
-      }
-    });
-    this.audioPlayer.on("stateChange", (oldState, newState) => {
-      if (newState.status === import_voice2.AudioPlayerStatus.Playing) {
-        if (!this.paused)
-          return void this.emit("start", this.audioResource);
-      } else if (newState.status === import_voice2.AudioPlayerStatus.Idle && oldState.status !== import_voice2.AudioPlayerStatus.Idle) {
-        if (!this.paused) {
-          void this.emit("finish", this.audioResource);
-          this.dsp.destroy();
-          this.audioResource = null;
-        }
-      }
-    });
-    this.audioPlayer.on("debug", (m) => void this.emit("debug", m));
-    this.audioPlayer.on("error", (error) => void this.emit("error", error));
-    this.voiceConnection.subscribe(this.audioPlayer);
-  }
-  get paused() {
-    return this.audioPlayer.state.status === import_voice2.AudioPlayerStatus.Paused;
-  }
-  set paused(val) {
-    val ? this.pause(true) : this.resume();
-  }
-  isPaused() {
-    return this.paused || this.audioPlayer.state.status === import_voice2.AudioPlayerStatus.AutoPaused;
-  }
-  isBuffering() {
-    return this.audioPlayer.state.status === import_voice2.AudioPlayerStatus.Buffering;
-  }
-  isPlaying() {
-    return this.audioPlayer.state.status === import_voice2.AudioPlayerStatus.Playing;
-  }
-  isIdle() {
-    return this.audioPlayer.state.status === import_voice2.AudioPlayerStatus.Idle;
-  }
-  createStream(src, ops) {
-    const stream = !ops?.disableFilters && typeof src !== "string" ? this.dsp.create(src, {
-      dsp: {
-        filters: ops?.defaultFilters,
-        disabled: ops?.disableFilters
-      },
-      biquad: ops?.biquadFilter ? {
-        filter: ops.biquadFilter,
-        disabled: ops?.disableBiquad
-      } : void 0,
-      resampler: {
-        targetSampleRate: ops?.sampleRate,
-        disabled: ops?.disableResampler
-      },
-      equalizer: {
-        bandMultiplier: ops?.eq,
-        disabled: ops?.disableEqualizer
-      },
-      volume: {
-        volume: ops?.volume,
-        disabled: ops?.disableVolume
-      }
-    }) : src;
-    this.audioResource = (0, import_voice2.createAudioResource)(stream, {
-      inputType: ops?.type ?? import_voice2.StreamType.Arbitrary,
-      metadata: ops?.data,
-      inlineVolume: false
-    });
-    return this.audioResource;
+    if (typeof this.queue.options.volume === "number") {
+      this._lastFiltersCache.volume = this.queue.options.volume;
+    }
   }
-  get resampler() {
-    return this.dsp?.resampler;
+  get volume() {
+    return this.queue.dispatcher?.dsp?.volume || null;
   }
-  get filters() {
-    return this.dsp?.filters;
+  get equalizer() {
+    return this.queue.dispatcher?.equalizer || null;
   }
   get biquad() {
-    return this.dsp?.biquad || null;
+    return this.queue.dispatcher?.biquad || null;
   }
-  get equalizer() {
-    return this.dsp?.equalizer || null;
+  get filters() {
+    return this.queue.dispatcher?.filters || null;
   }
-  get status() {
-    return this.audioPlayer.state.status;
+  get resampler() {
+    return this.queue.dispatcher?.resampler || null;
   }
-  disconnect() {
+  async triggerReplay(seek = 0) {
+    if (!this.queue.currentTrack)
+      return false;
     try {
-      this.audioPlayer.stop(true);
-      this.voiceConnection.destroy();
+      await this.queue.node.play(this.queue.currentTrack, {
+        queue: false,
+        seek,
+        transitionMode: true
+      });
+      return true;
     } catch {
+      return false;
     }
   }
-  end() {
-    this.audioPlayer.stop();
+};
+__name(GuildQueueAudioFilters, "GuildQueueAudioFilters");
+var AFilterGraph = class {
+  constructor(af) {
+    this.af = af;
   }
-  pause(interpolateSilence) {
-    const success = this.audioPlayer.pause(interpolateSilence);
-    return success;
+  get ffmpeg() {
+    return this.af.ffmpeg.filters;
   }
-  resume() {
-    const success = this.audioPlayer.unpause();
-    return success;
+  get equalizer() {
+    return (this.af.equalizer?.bandMultipliers || []).map((m, i) => ({
+      band: i,
+      gain: m
+    }));
   }
-  async playStream(resource = this.audioResource) {
-    if (!resource)
-      throw new PlayerError("Audio resource is not available!", "NoAudioResource" /* NO_AUDIO_RESOURCE */);
-    if (resource.ended) {
-      return void this.emit("finish", resource);
-    }
-    if (!this.audioResource)
-      this.audioResource = resource;
-    if (this.voiceConnection.state.status !== import_voice2.VoiceConnectionStatus.Ready) {
-      try {
-        await (0, import_voice2.entersState)(this.voiceConnection, import_voice2.VoiceConnectionStatus.Ready, this.connectionTimeout);
-      } catch (err) {
-        return void this.emit("error", err);
-      }
-    }
-    try {
-      this.audioPlayer.play(resource);
-    } catch (e) {
-      this.emit("error", e);
-    }
-    return this;
+  get biquad() {
+    return null;
   }
-  setVolume(value) {
-    if (!this.dsp.volume)
-      return false;
-    return this.dsp.volume.setVolume(value);
+  get filters() {
+    return this.af.filters?.filters || [];
   }
   get volume() {
-    if (!this.dsp.volume)
-      return 100;
-    return this.dsp.volume.volume;
+    return this.af.volume;
   }
-  get streamTime() {
-    if (!this.audioResource)
-      return 0;
-    return this.audioResource.playbackDuration;
+  get resampler() {
+    return this.af.resampler;
+  }
+  dump() {
+    return {
+      ffmpeg: this.ffmpeg,
+      equalizer: this.equalizer,
+      biquad: this.biquad,
+      filters: this.filters,
+      sampleRate: this.resampler?.targetSampleRate || this.resampler?.sampleRate || 48e3,
+      volume: this.volume?.volume ?? 100
+    };
   }
 };
-__name(StreamDispatcher, "StreamDispatcher");
+__name(AFilterGraph, "AFilterGraph");
 
-// src/VoiceInterface/VoiceUtils.ts
-var import_utils4 = require("@discord-player/utils");
-var VoiceUtils = class {
-  constructor() {
-    this.cache = new import_utils4.Collection();
-  }
-  async connect(channel, options) {
-    const conn = await this.join(channel, options);
-    const sub = new StreamDispatcher(conn, channel, options?.maxTime);
-    this.cache.set(channel.guild.id, sub);
-    return sub;
-  }
-  async join(channel, options) {
-    const conn = (0, import_voice3.joinVoiceChannel)({
-      guildId: channel.guild.id,
-      channelId: channel.id,
-      adapterCreator: channel.guild.voiceAdapterCreator,
-      selfDeaf: Boolean(options?.deaf)
-    });
-    return conn;
-  }
-  disconnect(connection) {
-    if (connection instanceof StreamDispatcher)
-      return connection.voiceConnection.destroy();
-    return connection.destroy();
+// src/Structures/GuildQueue.ts
+var import_timers = require("timers");
+var import_youtube_sr2 = require("youtube-sr");
+
+// src/Structures/GuildQueueStatistics.ts
+var GuildQueueStatistics = class {
+  constructor(queue) {
+    this.queue = queue;
   }
-  getConnection(guild) {
-    return this.cache.get(guild) || (0, import_voice3.getVoiceConnection)(guild);
+  generate() {
+    return {
+      latency: {
+        eventLoop: this.queue.player.eventLoopLag,
+        voiceConnection: this.queue.ping
+      },
+      status: {
+        buffering: this.queue.node.isBuffering(),
+        playing: this.queue.node.isPlaying(),
+        paused: this.queue.node.isPaused(),
+        idle: this.queue.node.isIdle()
+      },
+      tracksCount: this.queue.tracks.size,
+      historySize: this.queue.history.tracks.size,
+      extractors: this.queue.player.extractors.size,
+      listeners: this.queue.guild.members.me?.voice.channel?.members.filter((m) => !m.user.bot).size || 0,
+      memoryUsage: process.memoryUsage(),
+      versions: {
+        node: process.version,
+        player: "6.0.0-dev.3"
+      }
+    };
   }
 };
-__name(VoiceUtils, "VoiceUtils");
+__name(GuildQueueStatistics, "GuildQueueStatistics");
 
-// src/Player.ts
-var import_voice5 = require("@discordjs/voice");
-var import_utils9 = require("@discord-player/utils");
-
-// src/Structures/SearchResult.ts
-var SearchResult = class {
-  constructor(player, _data) {
+// src/Structures/GuildQueue.ts
+var _transitioning, _initializing, _deleted, _initializingPromises, _attachListeners, attachListeners_fn, _removeListeners, removeListeners_fn, _performStart, performStart_fn, _performFinish, performFinish_fn, _emitEnd, emitEnd_fn, _handleAutoplay, handleAutoplay_fn, _resolveInitializerAwaiters, resolveInitializerAwaiters_fn, _warnIfDeleted, warnIfDeleted_fn;
+var GuildQueue = class {
+  constructor(player, options) {
     this.player = player;
-    this._data = _data;
+    this.options = options;
+    __privateAdd(this, _attachListeners);
+    __privateAdd(this, _removeListeners);
+    __privateAdd(this, _performStart);
+    __privateAdd(this, _performFinish);
+    __privateAdd(this, _emitEnd);
+    __privateAdd(this, _handleAutoplay);
+    __privateAdd(this, _resolveInitializerAwaiters);
+    __privateAdd(this, _warnIfDeleted);
+    __privateAdd(this, _transitioning, false);
+    __privateAdd(this, _initializing, false);
+    __privateAdd(this, _deleted, false);
+    __privateAdd(this, _initializingPromises, []);
+    this.__current = null;
+    this.history = new GuildQueueHistory(this);
+    this.dispatcher = null;
+    this.node = new GuildQueuePlayerNode(this);
+    this.filters = new GuildQueueAudioFilters(this);
+    this.onBeforeCreateStream = /* @__PURE__ */ __name(async () => null, "onBeforeCreateStream");
+    this.onAfterCreateStream = /* @__PURE__ */ __name(async (stream) => ({
+      stream,
+      type: import_voice2.StreamType.Raw
+    }), "onAfterCreateStream");
+    this.repeatMode = 0 /* OFF */;
+    this.timeouts = new import_utils3.Collection();
+    this.stats = new GuildQueueStatistics(this);
+    this.tracks = new import_utils3.Queue(options.queueStrategy);
+    if (typeof options.onBeforeCreateStream === "function")
+      this.onBeforeCreateStream = options.onBeforeCreateStream;
+    if (typeof options.onAfterCreateStream === "function")
+      this.onAfterCreateStream = options.onAfterCreateStream;
+    if (options.repeatMode != null)
+      this.repeatMode = options.repeatMode;
+    options.selfDeaf ?? (options.selfDeaf = true);
+    if (this.options.biquad != null && typeof this.options.biquad !== "boolean") {
+      this.filters._lastFiltersCache.biquad = this.options.biquad;
+    }
+    if (Array.isArray(this.options.equalizer)) {
+      this.filters._lastFiltersCache.equalizer = this.options.equalizer;
+    }
+    if (Array.isArray(this.options.filterer)) {
+      this.filters._lastFiltersCache.filters = this.options.filterer;
+    }
+    if (typeof this.options.resampler === "number") {
+      this.filters._lastFiltersCache.sampleRate = this.options.resampler;
+    }
+    if (Array.isArray(this.options.ffmpegFilters)) {
+      this.filters.ffmpeg.setDefaults(this.options.ffmpegFilters);
+    }
+    this.debug(`GuildQueue initialized for guild ${this.options.guild.name} (ID: ${this.options.guild.id})`);
   }
-  get query() {
-    return this._data.query;
+  debug(m) {
+    this.player.events.emit("debug", this, m);
   }
-  get queryType() {
-    return this._data.queryType || QueryType.AUTO;
+  get metadata() {
+    return this.options.metadata;
   }
-  get extractor() {
-    return this._data.extractor || null;
+  set metadata(m) {
+    this.options.metadata = m;
   }
-  get playlist() {
-    return this._data.playlist;
+  setMetadata(m) {
+    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
+    this.options.metadata = m;
   }
-  get tracks() {
-    return this._data.tracks || [];
+  get initializing() {
+    return __privateGet(this, _initializing);
   }
-  get requestedBy() {
-    return this._data.requestedBy || null;
+  set initializing(v) {
+    __privateSet(this, _initializing, v);
+    if (v)
+      __privateMethod(this, _resolveInitializerAwaiters, resolveInitializerAwaiters_fn).call(this);
   }
-  async execute() {
-    return this.player.search(this.query, {
-      searchEngine: this.queryType,
-      requestedBy: this.requestedBy
-    });
+  get currentTrack() {
+    return this.dispatcher?.audioResource?.metadata || this.__current;
   }
-  isEmpty() {
-    return !this.tracks.length;
+  get deleted() {
+    return __privateGet(this, _deleted);
   }
-  hasPlaylist() {
-    return this.playlist != null;
+  get channel() {
+    return this.dispatcher?.channel || null;
   }
-  hasTracks() {
-    return this.tracks.length > 0;
+  set channel(c) {
+    if (this.dispatcher) {
+      if (c) {
+        this.dispatcher.channel = c;
+      } else {
+        this.delete();
+      }
+    }
   }
-  toJSON() {
-    return {
-      query: this.query,
-      queryType: this.queryType,
-      playlist: this.playlist?.toJSON(false) || null,
-      tracks: this.tracks.map((m) => m.toJSON(true)),
-      extractor: this.extractor?.identifier || null,
-      requestedBy: this.requestedBy?.toJSON() || null
-    };
+  get connection() {
+    return this.dispatcher?.voiceConnection || null;
   }
-};
-__name(SearchResult, "SearchResult");
-
-// src/Structures/GuildQueue/GuildNodeManager.ts
-var import_utils7 = require("@discord-player/utils");
-
-// src/Structures/GuildQueue/GuildQueue.ts
-var import_discord3 = require("discord.js");
-var import_utils6 = require("@discord-player/utils");
-
-// src/Structures/GuildQueue/GuildQueueHistory.ts
-var import_utils5 = require("@discord-player/utils");
-var GuildQueueHistory = class {
-  constructor(queue) {
-    this.queue = queue;
-    this.tracks = new import_utils5.Queue("LIFO");
+  get guild() {
+    return this.options.guild;
   }
-  get currentTrack() {
-    return this.queue.dispatcher?.audioResource?.metadata || this.queue.__current;
+  get id() {
+    return this.guild.id;
   }
-  get nextTrack() {
-    return this.queue.tracks.at(0) || null;
+  setTransitioning(state) {
+    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
+    __privateSet(this, _transitioning, state);
   }
-  get previousTrack() {
-    return this.tracks.at(0) || null;
+  isTransitioning() {
+    return __privateGet(this, _transitioning);
   }
-  get disabled() {
-    return this.queue.options.disableHistory;
+  setRepeatMode(mode) {
+    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
+    this.repeatMode = mode;
   }
   isEmpty() {
+    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
     return this.tracks.size < 1;
   }
-  push(track) {
-    if (this.disabled)
-      return false;
-    this.tracks.add(track);
-    return true;
-  }
-  clear() {
-    this.tracks.clear();
+  isPlaying() {
+    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
+    return this.dispatcher?.audioResource != null;
   }
-  next() {
-    const track = this.nextTrack;
-    if (!track) {
-      throw new Error("No next track in the queue");
+  addTrack(track) {
+    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
+    const toAdd = track instanceof Playlist ? track.tracks : track;
+    this.tracks.add(toAdd);
+    const isMulti = Array.isArray(toAdd);
+    if (isMulti) {
+      this.player.events.emit("audioTrackAdd", this, toAdd[0]);
+      this.player.events.emit("audioTracksAdd", this, toAdd);
+    } else {
+      this.player.events.emit("audioTrackAdd", this, toAdd);
     }
-    this.queue.node.skip();
   }
-  previous() {
-    const track = this.previousTrack;
-    if (!track) {
-      throw new Error("No previous track in the queue");
+  async connect(channelResolvable, options = {}) {
+    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
+    const channel = this.player.client.channels.resolve(channelResolvable);
+    if (!channel || !channel.isVoiceBased()) {
+      throw new Error(`Expected a voice based channel (type ${import_discord2.ChannelType.GuildVoice}/${import_discord2.ChannelType.GuildStageVoice}), received ${channel?.type}`);
     }
-    this.queue.node.play(track, { queue: true });
-    this.queue.node.skip();
-  }
-};
-__name(GuildQueueHistory, "GuildQueueHistory");
-
-// src/Structures/GuildQueue/GuildQueuePlayerNode.ts
-var import_voice4 = require("@discordjs/voice");
-var _progress, _createGenericStream, createGenericStream_fn, _createFFmpegStream, createFFmpegStream_fn;
-var GuildQueuePlayerNode = class {
-  constructor(queue) {
-    this.queue = queue;
-    __privateAdd(this, _createGenericStream);
-    __privateAdd(this, _createFFmpegStream);
-    __privateAdd(this, _progress, 0);
-  }
-  isIdle() {
-    return !!this.queue.dispatcher?.isIdle();
-  }
-  isBuffering() {
-    return !!this.queue.dispatcher?.isBuffering();
-  }
-  isPlaying() {
-    return !!this.queue.dispatcher?.isPlaying();
-  }
-  isPaused() {
-    return !!this.queue.dispatcher?.isPaused();
-  }
-  resetProgress() {
-    __privateSet(this, _progress, 0);
+    this.debug(`Connecting to ${channel.type === import_discord2.ChannelType.GuildStageVoice ? "stage" : "voice"} channel ${channel.name} (ID: ${channel.id})`);
+    if (this.dispatcher) {
+      this.debug("Destroying old connection");
+      __privateMethod(this, _removeListeners, removeListeners_fn).call(this, this.dispatcher);
+      this.dispatcher.disconnect();
+    }
+    this.dispatcher = await this.player.voiceUtils.connect(channel, {
+      deaf: options.deaf ?? this.options.selfDeaf ?? true,
+      maxTime: options?.timeout ?? this.options.connectionTimeout ?? 12e4,
+      queue: this
+    });
+    this.player.events.emit("connection", this);
+    if (this.channel.type === import_discord2.ChannelType.GuildStageVoice) {
+      await this.channel.guild.members.me.voice.setSuppressed(false).catch(async () => {
+        return await this.channel.guild.members.me.voice.setRequestToSpeak(true).catch(Util.noop);
+      });
+    }
+    __privateMethod(this, _attachListeners, attachListeners_fn).call(this, this.dispatcher);
+    return this;
   }
-  get playbackTime() {
-    if (this.queue.dispatcher?.streamTime == null)
-      return 0;
-    const dur = __privateGet(this, _progress) + this.queue.dispatcher.streamTime;
-    const hasNightcore = this.queue.filters.ffmpeg.filters.includes("nightcore");
-    const hasVwave = this.queue.filters.ffmpeg.filters.includes("vaporwave");
-    if (hasNightcore && hasVwave)
-      return dur * (1.25 + 0.8);
-    return hasNightcore ? dur * 1.25 : hasVwave ? dur * 0.8 : dur;
-  }
-  getTimestamp() {
-    if (!this.queue.currentTrack)
-      return null;
-    const current = this.playbackTime;
-    const total = this.queue.currentTrack.durationMS;
-    return {
-      current: {
-        label: Util.buildTimeCode(Util.parseMS(current)),
-        value: current
-      },
-      total: {
-        label: Util.buildTimeCode(Util.parseMS(total)),
-        value: total
-      },
-      progress: Math.round(current / total * 100)
-    };
+  get ping() {
+    return this.connection?.ping.udp ?? -1;
   }
-  createProgressBar(options) {
-    const timestamp = this.getTimestamp();
-    if (!timestamp)
-      return null;
-    const { indicator = "\u{1F518}", length = 15, line = "\u25AC", timecodes = true } = options || {};
-    if (isNaN(length) || length < 0 || !Number.isFinite(length))
-      throw new Error("invalid progressbar length");
-    const index = Math.round(timestamp.current.value / timestamp.total.value * length);
-    if (index >= 1 && index <= length) {
-      const bar = line.repeat(length - 1).split("");
-      bar.splice(index, 0, indicator);
-      if (timecodes) {
-        return `${timestamp.current.label} \u2503 ${bar.join("")} \u2503 ${timestamp.total.label}`;
-      } else {
-        return `${bar.join("")}`;
-      }
-    } else {
-      if (timecodes) {
-        return `${timestamp.current.label} \u2503 ${indicator}${line.repeat(length - 1)} \u2503 ${timestamp.total.label}`;
-      } else {
-        return `${indicator}${line.repeat(length - 1)}`;
-      }
+  delete() {
+    if (this.player.nodes.delete(this.id)) {
+      __privateSet(this, _deleted, true);
     }
   }
-  async seek(duration) {
-    if (!this.queue.currentTrack)
-      return false;
-    await this.play(this.queue.currentTrack, {
-      seek: duration,
-      transitionMode: true
-    });
-    return true;
-  }
-  get volume() {
-    return this.queue.dispatcher?.volume ?? 100;
-  }
-  setVolume(vol) {
-    if (!this.queue.dispatcher)
-      return false;
-    const res = this.queue.dispatcher.setVolume(vol);
-    if (res)
-      this.queue.filters._lastFiltersCache.volume = vol;
-    return res;
-  }
-  setBitrate(rate) {
-    this.queue.dispatcher?.audioResource?.encoder?.setBitrate(rate === "auto" ? this.queue.channel?.bitrate ?? 64e3 : rate);
-  }
-  setPaused(state) {
-    if (state)
-      return this.queue.dispatcher?.pause(true) || false;
-    return this.queue.dispatcher?.resume() || false;
-  }
-  pause() {
-    return this.setPaused(true);
-  }
-  resume() {
-    return this.setPaused(false);
-  }
-  skip() {
-    if (!this.queue.dispatcher)
-      return false;
-    this.queue.setTransitioning(false);
-    this.queue.dispatcher.end();
-    return true;
-  }
-  remove(track) {
-    const foundTrack = this.queue.tracks.find((t, idx) => {
-      if (track instanceof Track || typeof track === "string") {
-        return (typeof track === "string" ? track : track.id) === t.id;
-      }
-      if (typeof track === "string")
-        return track === t.id;
-      return idx === track;
+  awaitInitialization() {
+    return new Promise((r) => {
+      if (!__privateGet(this, _initializing))
+        return r(true);
+      __privateGet(this, _initializingPromises).push(r);
     });
-    if (!foundTrack)
-      return null;
-    this.queue.tracks.removeOne((t) => t.id === foundTrack.id);
-    return foundTrack;
-  }
-  jump(track) {
-    const removed = this.remove(track);
-    if (!removed)
-      return false;
-    this.queue.tracks.store.unshift(removed);
-    return this.skip();
   }
-  getTrackPosition(track) {
-    return this.queue.tracks.toArray().findIndex((t, idx) => {
-      if (track instanceof Track || typeof track === "string") {
-        return (typeof track === "string" ? track : track.id) === t.id;
+};
+__name(GuildQueue, "GuildQueue");
+_transitioning = new WeakMap();
+_initializing = new WeakMap();
+_deleted = new WeakMap();
+_initializingPromises = new WeakMap();
+_attachListeners = new WeakSet();
+attachListeners_fn = /* @__PURE__ */ __name(function(dispatcher) {
+  dispatcher.on("error", (e) => this.player.events.emit("error", this, e));
+  dispatcher.on("debug", (m) => this.player.events.emit("debug", this, m));
+  dispatcher.on("finish", (r) => __privateMethod(this, _performFinish, performFinish_fn).call(this, r));
+  dispatcher.on("start", (r) => __privateMethod(this, _performStart, performStart_fn).call(this, r));
+  dispatcher.on("dsp", (f) => {
+    this.filters._lastFiltersCache.filters = f;
+  });
+  dispatcher.on("biquad", (f) => {
+    this.filters._lastFiltersCache.biquad = f;
+  });
+  dispatcher.on("eqBands", (f) => {
+    this.filters._lastFiltersCache.equalizer = f;
+  });
+  dispatcher.on("volume", (f) => {
+    this.filters._lastFiltersCache.volume = f;
+  });
+}, "#attachListeners");
+_removeListeners = new WeakSet();
+removeListeners_fn = /* @__PURE__ */ __name(function(dispatcher) {
+  dispatcher.removeAllListeners();
+}, "#removeListeners");
+_performStart = new WeakSet();
+performStart_fn = /* @__PURE__ */ __name(function(resource) {
+  const track = resource?.metadata || this.currentTrack;
+  this.player.events.emit("playerTrigger", this, track, this.isTransitioning() ? "filters" : "normal");
+  if (track && !this.isTransitioning())
+    this.player.events.emit("playerStart", this, track);
+  this.setTransitioning(false);
+  this.initializing = false;
+}, "#performStart");
+_performFinish = new WeakSet();
+performFinish_fn = /* @__PURE__ */ __name(function(resource) {
+  const track = resource?.metadata || this.currentTrack;
+  if (track && !this.isTransitioning()) {
+    this.history.push(track);
+    this.node.resetProgress();
+    this.player.events.emit("playerFinish", this, track);
+    if (this.tracks.size < 1 && this.repeatMode === 0 /* OFF */) {
+      __privateMethod(this, _emitEnd, emitEnd_fn).call(this);
+    } else {
+      if (this.repeatMode === 1 /* TRACK */) {
+        this.__current = this.history.tracks.dispatch() || track;
+        return this.node.play(this.__current);
       }
-      if (typeof track === "string")
-        return track === t.id;
-      return idx === track;
-    });
-  }
-  skipTo(track) {
-    const idx = this.getTrackPosition(track);
-    if (idx < 0)
-      return false;
-    const removed = this.remove(idx);
-    if (!removed)
-      return false;
-    this.queue.tracks.store.splice(0, idx, removed);
-    return this.skip();
-  }
-  insert(track, index = 0) {
-    if (!(track instanceof Track))
-      throw new Error("invalid track");
-    this.queue.tracks.store.splice(index, 0, track);
-  }
-  stop(force = false) {
-    if (!this.queue.dispatcher)
-      return false;
-    this.queue.dispatcher.end();
-    if (force) {
-      this.queue.dispatcher.disconnect();
-      return true;
-    }
-    if (this.queue.options.leaveOnStop) {
-      const tm = setTimeout(() => {
-        if (this.isPlaying() || this.queue.tracks.size)
-          return clearTimeout(tm);
-        this.queue.dispatcher?.disconnect();
-      }, this.queue.options.leaveOnStopCooldown).unref();
-    }
-    return true;
-  }
-  async play(res, options) {
-    if (!this.queue.dispatcher?.voiceConnection) {
-      throw new Error("No voice connection available");
-    }
-    options = Object.assign(
-      {},
-      {
-        queue: this.queue.currentTrack != null,
-        transitionMode: false,
-        seek: 0
-      },
-      options
-    );
-    if (res && options.queue) {
-      return this.queue.tracks.add(res);
-    }
-    this.queue.debug(`Received play request from guild ${this.queue.guild.name} (ID: ${this.queue.guild.id})`);
-    const track = res || this.queue.tracks.dispatch();
-    if (!track) {
-      throw new Error("Play request received but track was not provided");
-    }
-    this.queue.initializing = true;
-    try {
-      const qt = track.queryType || (track.raw.source === "spotify" ? "spotifySong" : track.raw.source === "apple_music" ? "appleMusicSong" : track.raw.source) || "arbitrary";
-      const stream = await this.queue.onBeforeCreateStream?.(track, qt, this.queue).catch(() => null) || await __privateMethod(this, _createGenericStream, createGenericStream_fn).call(this, track).catch(() => null);
-      if (!stream) {
-        const error = new Error("Could not extract stream for this track");
-        this.queue.initializing = false;
-        if (this.queue.options.skipOnNoStream) {
-          this.queue.player.events.emit("playerSkip", this.queue, track);
-          this.queue.player.events.emit("playerError", this.queue, error, track);
-          this.play(this.queue.tracks.dispatch());
+      if (this.repeatMode === 2 /* QUEUE */)
+        this.tracks.add(this.history.tracks.dispatch() || track);
+      if (!this.tracks.size) {
+        if (this.repeatMode === 3 /* AUTOPLAY */) {
+          __privateMethod(this, _handleAutoplay, handleAutoplay_fn).call(this, track);
           return;
         }
-        throw error;
-      }
-      if (typeof options.seek === "number" && options.seek >= 0) {
-        __privateSet(this, _progress, options.seek);
       } else {
-        __privateSet(this, _progress, 0);
+        this.__current = this.tracks.dispatch();
+        this.node.play(this.__current, {
+          queue: false
+        });
       }
-      const pcmStream = __privateMethod(this, _createFFmpegStream, createFFmpegStream_fn).call(this, stream, track, options.seek ?? 0);
-      const resource = this.queue.dispatcher.createStream(pcmStream, {
-        disableBiquad: this.queue.options.biquad === false,
-        disableEqualizer: this.queue.options.equalizer === false,
-        disableVolume: this.queue.options.volume === false,
-        disableFilters: this.queue.options.filterer === false,
-        disableResampler: this.queue.options.resampler === false,
-        sampleRate: typeof this.queue.options.resampler === "number" && this.queue.options.resampler > 0 ? this.queue.options.resampler : void 0,
-        biquadFilter: this.queue.filters._lastFiltersCache.biquad || void 0,
-        eq: this.queue.filters._lastFiltersCache.equalizer,
-        defaultFilters: this.queue.filters._lastFiltersCache.filters,
-        volume: this.queue.filters._lastFiltersCache.volume,
-        data: track,
-        type: import_voice4.StreamType.Raw
-      });
-      this.queue.setTransitioning(!!options.transitionMode);
-      await this.queue.dispatcher.playStream(resource);
-    } catch (e) {
-      this.queue.initializing = false;
-      throw e;
     }
   }
-};
-__name(GuildQueuePlayerNode, "GuildQueuePlayerNode");
-_progress = new WeakMap();
-_createGenericStream = new WeakSet();
-createGenericStream_fn = /* @__PURE__ */ __name(async function(track) {
-  const streamInfo = await this.queue.player.extractors.run(async (extractor) => {
-    const canStream = await extractor.validate(track.url, track.queryType || QueryResolver.resolve(track.url));
-    if (!canStream)
-      return false;
-    return await extractor.stream(track);
-  });
-  if (!streamInfo || !streamInfo.result) {
-    return null;
+}, "#performFinish");
+_emitEnd = new WeakSet();
+emitEnd_fn = /* @__PURE__ */ __name(function() {
+  this.__current = null;
+  this.player.events.emit("emptyQueue", this);
+  if (this.options.leaveOnEnd) {
+    const tm = (0, import_timers.setTimeout)(() => {
+      if (this.tracks.size)
+        return clearTimeout(tm);
+      this.dispatcher?.disconnect();
+    }, this.options.leaveOnEndCooldown).unref();
   }
-  const stream = streamInfo.result;
-  return stream;
-}, "#createGenericStream");
-_createFFmpegStream = new WeakSet();
-createFFmpegStream_fn = /* @__PURE__ */ __name(function(stream, track, seek = 0) {
-  const ffmpegStream = createFFmpegStream(stream, {
-    encoderArgs: this.queue.filters.ffmpeg.filters.length ? ["-af", AudioFilters_default.create(this.queue.filters.ffmpeg.filters)] : [],
-    seek: seek / 1e3,
-    fmt: "s16le"
-  }).on("error", (err) => {
-    if (!`${err}`.toLowerCase().includes("premature close"))
-      this.queue.player.events.emit("playerError", this.queue, err, track);
+}, "#emitEnd");
+_handleAutoplay = new WeakSet();
+handleAutoplay_fn = /* @__PURE__ */ __name(async function(track) {
+  let info = await import_youtube_sr2.YouTube.getVideo(track.url).then((x) => x.videos[0]).catch(Util.noop);
+  if (!info)
+    info = await import_youtube_sr2.YouTube.search(track.author).then((x) => x[0]).catch(Util.noop);
+  if (!info) {
+    return __privateMethod(this, _emitEnd, emitEnd_fn).call(this);
+  }
+  const nextTrack = new Track(this.player, {
+    title: info.title,
+    url: `https://www.youtube.com/watch?v=${info.id}`,
+    duration: info.durationFormatted || Util.buildTimeCode(Util.parseMS(info.duration * 1e3)),
+    description: info.title,
+    thumbnail: typeof info.thumbnail === "string" ? info.thumbnail : info.thumbnail.url,
+    views: info.views,
+    author: info.channel.name,
+    requestedBy: track.requestedBy,
+    source: "youtube",
+    queryType: "youtubeVideo"
   });
-  return ffmpegStream;
-}, "#createFFmpegStream");
+  this.node.play(nextTrack, {
+    queue: false,
+    seek: 0,
+    transitionMode: false
+  });
+}, "#handleAutoplay");
+_resolveInitializerAwaiters = new WeakSet();
+resolveInitializerAwaiters_fn = /* @__PURE__ */ __name(function() {
+  __privateGet(this, _initializingPromises).forEach((p) => {
+    p(!__privateGet(this, _initializing));
+  });
+  __privateSet(this, _initializingPromises, []);
+}, "#resolveInitializerAwaiters");
+_warnIfDeleted = new WeakSet();
+warnIfDeleted_fn = /* @__PURE__ */ __name(function() {
+  if (!this.deleted)
+    return;
+  Util.warn("Deleted queue usage detected! Please remove references to deleted queues in order to prevent memory leaks.", "DiscordPlayerWarning");
+}, "#warnIfDeleted");
 
-// src/Structures/GuildQueue/GuildQueueAudioFilters.ts
-var import_equalizer2 = require("@discord-player/equalizer");
-var EqualizerConfigurationPreset = {
-  Jazz: Array.from({ length: 15 }, (_, i) => ({
-    band: i,
-    gain: i > 2 && i < 6 ? 0.5 : i > 6 && i < 14 ? -0.75 : 0
-  })),
-  EDM: Array.from(
-    {
-      length: import_equalizer2.Equalizer.BAND_COUNT
-    },
-    (_, i) => ({
-      band: i,
-      gain: i > 3 && i < 7 ? 0.75 : i > 9 && i < 13 ? -0.75 : 0
-    })
-  ),
-  HipHop: Array.from(
-    {
-      length: import_equalizer2.Equalizer.BAND_COUNT
-    },
-    (_, i) => ({
-      band: i,
-      gain: i > 4 && i < 8 ? 0.75 : i > 10 && i < 14 ? -0.5 : 0
-    })
-  ),
-  Rock: Array.from(
-    {
-      length: import_equalizer2.Equalizer.BAND_COUNT
-    },
-    (_, i) => ({
-      band: i,
-      gain: i > 2 && i < 6 ? 0.75 : i > 8 && i < 12 ? -0.75 : 0
-    })
-  ),
-  Metal: Array.from(
-    {
-      length: import_equalizer2.Equalizer.BAND_COUNT
-    },
-    (_, i) => ({
-      band: i,
-      gain: i > 4 && i < 8 ? 0.75 : i > 9 && i < 14 ? -0.75 : 0
-    })
-  ),
-  Folk: Array.from(
-    {
-      length: import_equalizer2.Equalizer.BAND_COUNT
-    },
-    (_, i) => ({
-      band: i,
-      gain: i > 3 && i < 7 ? 0.5 : i > 9 && i < 14 ? -0.5 : 0
-    })
-  ),
-  RnB: Array.from(
-    {
-      length: import_equalizer2.Equalizer.BAND_COUNT
-    },
-    (_, i) => ({
-      band: i,
-      gain: i > 4 && i < 8 ? 0.5 : i > 9 && i < 14 ? -0.5 : 0
-    })
-  ),
-  Country: Array.from(
-    {
-      length: import_equalizer2.Equalizer.BAND_COUNT
-    },
-    (_, i) => ({
-      band: i,
-      gain: i > 2 && i < 6 ? 0.5 : i > 9 && i < 13 ? -0.5 : 0
-    })
-  ),
-  Classical: Array.from(
-    {
-      length: import_equalizer2.Equalizer.BAND_COUNT
-    },
-    (_, i) => ({
-      band: i,
-      gain: i > 4 && i < 8 ? 0.5 : i > 10 && i < 14 ? -0.5 : 0
-    })
-  )
-};
-var _ffmpegFilters, _setFilters, setFilters_fn;
-var FFmpegFilterer = class {
-  constructor(af) {
-    this.af = af;
-    __privateAdd(this, _setFilters);
-    __privateAdd(this, _ffmpegFilters, []);
+// src/Structures/GuildNodeManager.ts
+var GuildNodeManager = class {
+  constructor(player) {
+    this.player = player;
+    this.cache = new import_utils4.Collection();
   }
-  setFilters(filters) {
-    let _filters = [];
-    if (typeof filters === "boolean") {
-      _filters = !filters ? [] : Object.keys(AudioFilters_default.filters);
-    } else if (Array.isArray(filters)) {
-      _filters = filters;
-    } else {
-      _filters = Object.entries(filters).filter((res) => res[1] === true).map((m) => m[0]);
+  create(guild, options = {}) {
+    const server = this.player.client.guilds.resolve(guild);
+    if (!server) {
+      throw new Error("Invalid or unknown guild");
     }
-    return __privateMethod(this, _setFilters, setFilters_fn).call(this, _filters);
-  }
-  get filters() {
-    return __privateGet(this, _ffmpegFilters);
-  }
-  set filters(filters) {
-    this.setFilters(filters);
-  }
-  toggle(filters) {
-    if (!Array.isArray(filters))
-      filters = [filters];
-    const fresh = [];
-    this.filters.forEach((f) => {
-      if (this.filters.includes(f))
-        return;
-      fresh.push(f);
+    if (this.cache.has(server.id)) {
+      return this.cache.get(server.id);
+    }
+    options.strategy ?? (options.strategy = "FIFO");
+    options.volume ?? (options.volume = 100);
+    options.equalizer ?? (options.equalizer = []);
+    options.a_filter ?? (options.a_filter = []);
+    options.disableHistory ?? (options.disableHistory = false);
+    options.skipOnNoStream ?? (options.skipOnNoStream = false);
+    options.leaveOnEmpty ?? (options.leaveOnEmpty = true);
+    options.leaveOnEmptyCooldown ?? (options.leaveOnEmptyCooldown = 0);
+    options.leaveOnEnd ?? (options.leaveOnEnd = true);
+    options.leaveOnEndCooldown ?? (options.leaveOnEndCooldown = 0);
+    options.leaveOnStop ?? (options.leaveOnStop = true);
+    options.leaveOnStopCooldown ?? (options.leaveOnStopCooldown = 0);
+    options.resampler ?? (options.resampler = 48e3);
+    options.selfDeaf ?? (options.selfDeaf = true);
+    options.connectionTimeout ?? (options.connectionTimeout = this.player.options.connectionTimeout);
+    options.bufferingTimeout ?? (options.bufferingTimeout = 1e3);
+    const queue = new GuildQueue(this.player, {
+      guild: server,
+      queueStrategy: options.strategy,
+      volume: options.volume,
+      equalizer: options.equalizer,
+      filterer: options.a_filter,
+      biquad: options.biquad,
+      resampler: options.resampler,
+      disableHistory: options.disableHistory,
+      skipOnNoStream: options.skipOnNoStream,
+      onBeforeCreateStream: options.onBeforeCreateStream,
+      onAfterCreateStream: options.onAfterCreateStream,
+      repeatMode: options.repeatMode,
+      leaveOnEmpty: options.leaveOnEmpty,
+      leaveOnEmptyCooldown: options.leaveOnEmptyCooldown,
+      leaveOnEnd: options.leaveOnEnd,
+      leaveOnEndCooldown: options.leaveOnEndCooldown,
+      leaveOnStop: options.leaveOnStop,
+      leaveOnStopCooldown: options.leaveOnStopCooldown,
+      metadata: options.metadata,
+      connectionTimeout: options.connectionTimeout ?? 12e4,
+      selfDeaf: options.selfDeaf,
+      ffmpegFilters: options.defaultFFmpegFilters ?? [],
+      bufferingTimeout: options.bufferingTimeout
     });
-    return __privateMethod(this, _setFilters, setFilters_fn).call(this, __privateGet(this, _ffmpegFilters).filter((r) => !filters.includes(r)).concat(fresh));
-  }
-  getFiltersEnabled() {
-    return __privateGet(this, _ffmpegFilters);
-  }
-  getFiltersDisabled() {
-    return AudioFilters_default.names.filter((f) => !__privateGet(this, _ffmpegFilters).includes(f));
+    this.cache.set(server.id, queue);
+    return queue;
   }
-  isEnabled(filter) {
-    return __privateGet(this, _ffmpegFilters).includes(filter);
+  get(node) {
+    const queue = this.resolve(node);
+    if (!queue)
+      return null;
+    return this.cache.get(queue.id) || null;
   }
-  isDisabled(filter) {
-    return !this.isEnabled(filter);
+  has(node) {
+    const id = node instanceof GuildQueue ? node.id : this.player.client.guilds.resolveId(node);
+    return this.cache.has(id);
   }
-  isValidFilter(filter) {
-    return AudioFilters_default.has(filter);
+  delete(node) {
+    const queue = this.resolve(node);
+    if (!queue)
+      throw new Error("Cannot delete non-existing queue");
+    queue.node.stop(true);
+    queue.connection?.removeAllListeners();
+    queue.dispatcher?.removeAllListeners();
+    queue.dispatcher?.disconnect();
+    queue.timeouts.forEach((tm) => clearTimeout(tm));
+    queue.history.clear();
+    queue.tracks.clear();
+    return this.cache.delete(queue.id);
   }
-};
-__name(FFmpegFilterer, "FFmpegFilterer");
-_ffmpegFilters = new WeakMap();
-_setFilters = new WeakSet();
-setFilters_fn = /* @__PURE__ */ __name(function(filters) {
-  __privateSet(this, _ffmpegFilters, [...new Set(filters)]);
-  return this.af.triggerReplay(this.af.queue.node.getTimestamp()?.current.value || 0);
-}, "#setFilters");
-var GuildQueueAudioFilters = class {
-  constructor(queue) {
-    this.queue = queue;
-    this.graph = new AFilterGraph(this);
-    this.ffmpeg = new FFmpegFilterer(this);
-    this.equalizerPresets = EqualizerConfigurationPreset;
-    this._lastFiltersCache = {
-      biquad: null,
-      equalizer: [],
-      filters: [],
-      volume: 100,
-      sampleRate: -1
-    };
-    if (typeof this.queue.options.volume === "number") {
-      this._lastFiltersCache.volume = this.queue.options.volume;
+  resolve(node) {
+    if (node instanceof GuildQueue) {
+      return node;
     }
+    return this.cache.get(this.player.client.guilds.resolveId(node));
   }
-  get volume() {
-    return this.queue.dispatcher?.dsp?.volume || null;
-  }
-  get equalizer() {
-    return this.queue.dispatcher?.equalizer || null;
+  resolveId(node) {
+    const q = this.resolve(node);
+    return q?.id || null;
   }
-  get biquad() {
-    return this.queue.dispatcher?.biquad || null;
+};
+__name(GuildNodeManager, "GuildNodeManager");
+
+// src/Structures/SearchResult.ts
+var SearchResult = class {
+  constructor(player, _data) {
+    this.player = player;
+    this._data = _data;
   }
-  get filters() {
-    return this.queue.dispatcher?.filters || null;
+  get query() {
+    return this._data.query;
   }
-  get resampler() {
-    return this.queue.dispatcher?.resampler || null;
+  get queryType() {
+    return this._data.queryType || QueryType.AUTO;
   }
-  async triggerReplay(seek = 0) {
-    if (!this.queue.currentTrack)
-      return false;
-    try {
-      await this.queue.node.play(this.queue.currentTrack, {
-        queue: false,
-        seek,
-        transitionMode: true
-      });
-      return true;
-    } catch {
-      return false;
-    }
+  get extractor() {
+    return this._data.extractor || null;
   }
-};
-__name(GuildQueueAudioFilters, "GuildQueueAudioFilters");
-var AFilterGraph = class {
-  constructor(af) {
-    this.af = af;
+  get playlist() {
+    return this._data.playlist;
   }
-  get ffmpeg() {
-    return this.af.ffmpeg.filters;
+  get tracks() {
+    return this._data.tracks || [];
   }
-  get equalizer() {
-    return (this.af.equalizer?.bandMultipliers || []).map((m, i) => ({
-      band: i,
-      gain: m
-    }));
+  get requestedBy() {
+    return this._data.requestedBy || null;
   }
-  get biquad() {
-    return null;
+  async execute() {
+    return this.player.search(this.query, {
+      searchEngine: this.queryType,
+      requestedBy: this.requestedBy
+    });
   }
-  get filters() {
-    return this.af.filters?.filters || [];
+  isEmpty() {
+    return !this.tracks.length;
   }
-  get volume() {
-    return this.af.volume;
+  hasPlaylist() {
+    return this.playlist != null;
   }
-  get resampler() {
-    return this.af.resampler;
+  hasTracks() {
+    return this.tracks.length > 0;
   }
-  dump() {
+  toJSON() {
     return {
-      ffmpeg: this.ffmpeg,
-      equalizer: this.equalizer,
-      biquad: this.biquad,
-      filters: this.filters,
-      sampleRate: this.resampler?.targetSampleRate || this.resampler?.sampleRate || 48e3,
-      volume: this.volume?.volume ?? 100
+      query: this.query,
+      queryType: this.queryType,
+      playlist: this.playlist?.toJSON(false) || null,
+      tracks: this.tracks.map((m) => m.toJSON(true)),
+      extractor: this.extractor?.identifier || null,
+      requestedBy: this.requestedBy?.toJSON() || null
     };
   }
 };
-__name(AFilterGraph, "AFilterGraph");
+__name(SearchResult, "SearchResult");
 
-// src/Structures/GuildQueue/GuildQueue.ts
-var import_timers = require("timers");
-var import_youtube_sr3 = require("youtube-sr");
-var _transitioning, _initializing, _deleted, _initializingPromises, _attachListeners, attachListeners_fn, _removeListeners, removeListeners_fn, _performStart, performStart_fn, _performFinish, performFinish_fn, _emitEnd, emitEnd_fn, _handleAutoplay, handleAutoplay_fn, _resolveInitializerAwaiters, resolveInitializerAwaiters_fn, _warnIfDeleted, warnIfDeleted_fn;
-var GuildQueue = class {
-  constructor(player, options) {
-    this.player = player;
-    this.options = options;
-    __privateAdd(this, _attachListeners);
-    __privateAdd(this, _removeListeners);
-    __privateAdd(this, _performStart);
-    __privateAdd(this, _performFinish);
-    __privateAdd(this, _emitEnd);
-    __privateAdd(this, _handleAutoplay);
-    __privateAdd(this, _resolveInitializerAwaiters);
-    __privateAdd(this, _warnIfDeleted);
-    __privateAdd(this, _transitioning, false);
-    __privateAdd(this, _initializing, false);
-    __privateAdd(this, _deleted, false);
-    __privateAdd(this, _initializingPromises, []);
-    this.__current = null;
-    this.history = new GuildQueueHistory(this);
-    this.dispatcher = null;
-    this.node = new GuildQueuePlayerNode(this);
-    this.filters = new GuildQueueAudioFilters(this);
-    this.onBeforeCreateStream = /* @__PURE__ */ __name(async () => null, "onBeforeCreateStream");
-    this.repeatMode = 0 /* OFF */;
-    this.timeouts = new import_utils6.Collection();
-    this.tracks = new import_utils6.Queue(options.queueStrategy);
-    if (typeof options.onBeforeCreateStream === "function")
-      this.onBeforeCreateStream = options.onBeforeCreateStream;
-    if (options.repeatMode != null)
-      this.repeatMode = options.repeatMode;
-    if (this.options.biquad != null && typeof this.options.biquad !== "boolean") {
-      this.filters._lastFiltersCache.biquad = this.options.biquad;
-    }
-    if (Array.isArray(this.options.equalizer)) {
-      this.filters._lastFiltersCache.equalizer = this.options.equalizer;
-    }
-    if (Array.isArray(this.options.filterer)) {
-      this.filters._lastFiltersCache.filters = this.options.filterer;
-    }
-    if (typeof this.options.resampler === "number") {
-      this.filters._lastFiltersCache.sampleRate = this.options.resampler;
-    }
-    this.debug(`GuildQueue initialized for guild ${this.options.guild.name} (ID: ${this.options.guild.id})`);
+// src/Structures/PlayerError.ts
+var ErrorStatusCode = /* @__PURE__ */ ((ErrorStatusCode2) => {
+  ErrorStatusCode2["STREAM_ERROR"] = "StreamError";
+  ErrorStatusCode2["AUDIO_PLAYER_ERROR"] = "AudioPlayerError";
+  ErrorStatusCode2["PLAYER_ERROR"] = "PlayerError";
+  ErrorStatusCode2["NO_AUDIO_RESOURCE"] = "NoAudioResource";
+  ErrorStatusCode2["UNKNOWN_GUILD"] = "UnknownGuild";
+  ErrorStatusCode2["INVALID_ARG_TYPE"] = "InvalidArgType";
+  ErrorStatusCode2["UNKNOWN_EXTRACTOR"] = "UnknownExtractor";
+  ErrorStatusCode2["INVALID_EXTRACTOR"] = "InvalidExtractor";
+  ErrorStatusCode2["INVALID_CHANNEL_TYPE"] = "InvalidChannelType";
+  ErrorStatusCode2["INVALID_TRACK"] = "InvalidTrack";
+  ErrorStatusCode2["UNKNOWN_REPEAT_MODE"] = "UnknownRepeatMode";
+  ErrorStatusCode2["TRACK_NOT_FOUND"] = "TrackNotFound";
+  ErrorStatusCode2["NO_CONNECTION"] = "NoConnection";
+  ErrorStatusCode2["DESTROYED_QUEUE"] = "DestroyedQueue";
+  return ErrorStatusCode2;
+})(ErrorStatusCode || {});
+var PlayerError = class extends Error {
+  constructor(message, code = "PlayerError" /* PLAYER_ERROR */) {
+    super();
+    this.createdAt = new Date();
+    this.message = `[${code}] ${message}`;
+    this.statusCode = code;
+    this.name = code;
+    Error.captureStackTrace(this);
   }
-  debug(m) {
-    this.player.events.emit("debug", this, m);
+  get createdTimestamp() {
+    return this.createdAt.getTime();
   }
-  get metadata() {
-    return this.options.metadata;
+  valueOf() {
+    return this.statusCode;
   }
-  set metadata(m) {
-    this.options.metadata = m;
+  toJSON() {
+    return {
+      stack: this.stack,
+      code: this.statusCode,
+      message: this.message,
+      created: this.createdTimestamp
+    };
+  }
+  toString() {
+    return this.stack;
+  }
+};
+__name(PlayerError, "PlayerError");
+
+// src/VoiceInterface/VoiceUtils.ts
+var import_voice4 = require("@discordjs/voice");
+
+// src/VoiceInterface/StreamDispatcher.ts
+var import_voice3 = require("@discordjs/voice");
+var import_utils5 = require("@discord-player/utils");
+var import_equalizer2 = require("@discord-player/equalizer");
+var StreamDispatcher = class extends import_utils5.EventEmitter {
+  constructor(connection, channel, queue, connectionTimeout = 2e4) {
+    super();
+    this.queue = queue;
+    this.connectionTimeout = connectionTimeout;
+    this.readyLock = false;
+    this.dsp = new import_equalizer2.FiltersChain();
+    this.voiceConnection = connection;
+    this.audioPlayer = (0, import_voice3.createAudioPlayer)();
+    this.channel = channel;
+    this.dsp.onUpdate = () => {
+      if (!this.dsp)
+        return;
+      if (this.dsp.filters?.filters)
+        this.emit("dsp", this.dsp.filters?.filters);
+      if (this.dsp.biquad?.filter)
+        this.emit("biquad", this.dsp.biquad?.filter);
+      if (this.dsp.equalizer)
+        this.emit("eqBands", this.dsp.equalizer.getEQ());
+      if (this.dsp.volume)
+        this.emit("volume", this.dsp.volume.volume);
+      if (this.dsp.resampler)
+        this.emit("sampleRate", this.dsp.resampler.targetSampleRate);
+    };
+    this.dsp.onError = (e) => this.emit("error", e);
+    this.voiceConnection.on("stateChange", async (_, newState) => {
+      if (newState.status === import_voice3.VoiceConnectionStatus.Disconnected) {
+        if (newState.reason === import_voice3.VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
+          try {
+            await (0, import_voice3.entersState)(this.voiceConnection, import_voice3.VoiceConnectionStatus.Connecting, this.connectionTimeout);
+          } catch {
+            try {
+              this.voiceConnection.destroy();
+            } catch (err) {
+              this.emit("error", err);
+            }
+          }
+        } else if (this.voiceConnection.rejoinAttempts < 5) {
+          await Util.wait((this.voiceConnection.rejoinAttempts + 1) * 5e3);
+          this.voiceConnection.rejoin();
+        } else {
+          try {
+            this.voiceConnection.destroy();
+          } catch (err) {
+            this.emit("error", err);
+          }
+        }
+      } else if (newState.status === import_voice3.VoiceConnectionStatus.Destroyed) {
+        this.end();
+      } else if (!this.readyLock && (newState.status === import_voice3.VoiceConnectionStatus.Connecting || newState.status === import_voice3.VoiceConnectionStatus.Signalling)) {
+        this.readyLock = true;
+        try {
+          await (0, import_voice3.entersState)(this.voiceConnection, import_voice3.VoiceConnectionStatus.Ready, this.connectionTimeout);
+        } catch {
+          if (this.voiceConnection.state.status !== import_voice3.VoiceConnectionStatus.Destroyed) {
+            try {
+              this.voiceConnection.destroy();
+            } catch (err) {
+              this.emit("error", err);
+            }
+          }
+        } finally {
+          this.readyLock = false;
+        }
+      }
+    });
+    this.audioPlayer.on("stateChange", (oldState, newState) => {
+      if (newState.status === import_voice3.AudioPlayerStatus.Playing) {
+        if (oldState.status === import_voice3.AudioPlayerStatus.Idle || oldState.status === import_voice3.AudioPlayerStatus.Buffering) {
+          return this.emit("start", this.audioResource);
+        }
+      } else if (newState.status === import_voice3.AudioPlayerStatus.Idle && oldState.status !== import_voice3.AudioPlayerStatus.Idle) {
+        this.emit("finish", this.audioResource);
+        this.dsp.destroy();
+        this.audioResource = null;
+      }
+    });
+    this.audioPlayer.on("debug", (m) => void this.emit("debug", m));
+    this.audioPlayer.on("error", (error) => void this.emit("error", error));
+    this.voiceConnection.subscribe(this.audioPlayer);
   }
-  setMetadata(m) {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
-    this.options.metadata = m;
+  get paused() {
+    return this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.Paused;
   }
-  get initializing() {
-    return __privateGet(this, _initializing);
+  set paused(val) {
+    val ? this.pause(true) : this.resume();
   }
-  set initializing(v) {
-    __privateSet(this, _initializing, v);
-    if (v)
-      __privateMethod(this, _resolveInitializerAwaiters, resolveInitializerAwaiters_fn).call(this);
+  isPaused() {
+    return this.paused || this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.AutoPaused;
   }
-  get currentTrack() {
-    return this.dispatcher?.audioResource?.metadata || this.__current;
+  isBuffering() {
+    return this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.Buffering;
   }
-  get deleted() {
-    return __privateGet(this, _deleted);
+  isPlaying() {
+    return this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.Playing;
   }
-  get channel() {
-    return this.dispatcher?.channel || null;
+  isIdle() {
+    return this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.Idle;
   }
-  set channel(c) {
-    if (this.dispatcher) {
-      if (c) {
-        this.dispatcher.channel = c;
-      } else {
-        this.delete();
+  async createStream(src, ops) {
+    if (!ops?.disableFilters)
+      this.queue.debug("Initiating DSP filters pipeline...");
+    const stream = !ops?.disableFilters ? this.dsp.create(src, {
+      dsp: {
+        filters: ops?.defaultFilters,
+        disabled: ops?.disableFilters
+      },
+      biquad: ops?.biquadFilter ? {
+        filter: ops.biquadFilter,
+        disabled: ops?.disableBiquad
+      } : void 0,
+      resampler: {
+        targetSampleRate: ops?.sampleRate,
+        disabled: ops?.disableResampler
+      },
+      equalizer: {
+        bandMultiplier: ops?.eq,
+        disabled: ops?.disableEqualizer
+      },
+      volume: {
+        volume: ops?.volume,
+        disabled: ops?.disableVolume
       }
-    }
+    }) : src;
+    this.queue.debug("Executing onAfterCreateStream hook...");
+    const postStream = await this.queue.onAfterCreateStream?.(stream, this.queue).catch(
+      () => ({
+        stream,
+        type: ops?.type ?? import_voice3.StreamType.Arbitrary
+      })
+    );
+    this.queue.debug("Preparing AudioResource...");
+    this.audioResource = (0, import_voice3.createAudioResource)(postStream?.stream ?? stream, {
+      inputType: postStream?.type ?? ops?.type ?? import_voice3.StreamType.Arbitrary,
+      metadata: ops?.data,
+      inlineVolume: false
+    });
+    return this.audioResource;
   }
-  get connection() {
-    return this.dispatcher?.voiceConnection || null;
+  get resampler() {
+    return this.dsp?.resampler;
   }
-  get guild() {
-    return this.options.guild;
+  get filters() {
+    return this.dsp?.filters;
   }
-  get id() {
-    return this.guild.id;
+  get biquad() {
+    return this.dsp?.biquad || null;
   }
-  setTransitioning(state) {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
-    __privateSet(this, _transitioning, state);
+  get equalizer() {
+    return this.dsp?.equalizer || null;
   }
-  isTransitioning() {
-    return __privateGet(this, _transitioning);
+  get status() {
+    return this.audioPlayer.state.status;
   }
-  setRepeatMode(mode) {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
-    this.repeatMode = mode;
+  disconnect() {
+    try {
+      if (this.audioPlayer)
+        this.audioPlayer.stop(true);
+      this.voiceConnection.destroy();
+    } catch {
+    }
   }
-  isEmpty() {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
-    return this.tracks.size < 1;
+  end() {
+    this.audioPlayer.stop();
   }
-  isPlaying() {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
-    return this.dispatcher?.audioResource != null;
+  pause(interpolateSilence) {
+    const success = this.audioPlayer.pause(interpolateSilence);
+    return success;
   }
-  addTrack(track) {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
-    const toAdd = track instanceof Playlist ? track.tracks : track;
-    this.tracks.add(toAdd);
-    const isMulti = Array.isArray(toAdd);
-    if (isMulti) {
-      this.player.events.emit("audioTracksAdd", this, toAdd);
-    } else {
-      this.player.events.emit("audioTrackAdd", this, toAdd);
-    }
+  resume() {
+    const success = this.audioPlayer.unpause();
+    return success;
   }
-  async connect(channelResolvable, options) {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
-    const channel = this.player.client.channels.resolve(channelResolvable);
-    if (!channel || !channel.isVoiceBased()) {
-      throw new Error(`Expected a voice based channel (type ${import_discord3.ChannelType.GuildVoice}/${import_discord3.ChannelType.GuildStageVoice}), received ${channel?.type}`);
+  async playStream(resource = this.audioResource) {
+    if (!resource)
+      throw new PlayerError("Audio resource is not available!", "NoAudioResource" /* NO_AUDIO_RESOURCE */);
+    if (resource.ended) {
+      return void this.emit("finish", resource);
     }
-    this.debug(`Connecting to ${channel.type === import_discord3.ChannelType.GuildStageVoice ? "stage" : "voice"} channel ${channel.name} (ID: ${channel.id})`);
-    if (this.dispatcher) {
-      this.debug("Destroying old connection");
-      __privateMethod(this, _removeListeners, removeListeners_fn).call(this, this.dispatcher);
-      this.dispatcher.disconnect();
+    if (!this.audioResource)
+      this.audioResource = resource;
+    if (this.voiceConnection.state.status !== import_voice3.VoiceConnectionStatus.Ready) {
+      try {
+        await (0, import_voice3.entersState)(this.voiceConnection, import_voice3.VoiceConnectionStatus.Ready, this.connectionTimeout);
+      } catch (err) {
+        return void this.emit("error", err);
+      }
     }
-    this.dispatcher = await this.player.voiceUtils.connect(channel, {
-      deaf: Boolean(options?.deaf),
-      maxTime: options?.timeout ?? this.player.options.connectionTimeout ?? 12e4
-    });
-    this.player.events.emit("connection", this);
-    if (this.channel.type === import_discord3.ChannelType.GuildStageVoice) {
-      await this.channel.guild.members.me.voice.setSuppressed(false).catch(async () => {
-        return await this.channel.guild.members.me.voice.setRequestToSpeak(true).catch(Util.noop);
-      });
+    try {
+      this.audioPlayer.play(resource);
+    } catch (e) {
+      this.emit("error", e);
     }
-    __privateMethod(this, _attachListeners, attachListeners_fn).call(this, this.dispatcher);
     return this;
   }
-  get ping() {
-    return this.connection?.ping.udp ?? -1;
-  }
-  delete() {
-    if (this.player.nodes.delete(this.id)) {
-      __privateSet(this, _deleted, true);
-    }
+  setVolume(value) {
+    if (!this.dsp.volume)
+      return false;
+    return this.dsp.volume.setVolume(value);
   }
-  awaitInitialization() {
-    return new Promise((r) => {
-      if (!__privateGet(this, _initializing))
-        return r(true);
-      __privateGet(this, _initializingPromises).push(r);
-    });
+  get volume() {
+    if (!this.dsp.volume)
+      return 100;
+    return this.dsp.volume.volume;
   }
-};
-__name(GuildQueue, "GuildQueue");
-_transitioning = new WeakMap();
-_initializing = new WeakMap();
-_deleted = new WeakMap();
-_initializingPromises = new WeakMap();
-_attachListeners = new WeakSet();
-attachListeners_fn = /* @__PURE__ */ __name(function(dispatcher) {
-  dispatcher.on("error", (e) => this.player.events.emit("error", this, e));
-  dispatcher.on("debug", (m) => this.player.events.emit("debug", this, m));
-  dispatcher.on("finish", (r) => __privateMethod(this, _performFinish, performFinish_fn).call(this, r));
-  dispatcher.on("start", (r) => __privateMethod(this, _performStart, performStart_fn).call(this, r));
-  dispatcher.on("dsp", (f) => {
-    this.filters._lastFiltersCache.filters = f;
-  });
-  dispatcher.on("biquad", (f) => {
-    this.filters._lastFiltersCache.biquad = f;
-  });
-  dispatcher.on("eqBands", (f) => {
-    this.filters._lastFiltersCache.equalizer = f;
-  });
-  dispatcher.on("volume", (f) => {
-    this.filters._lastFiltersCache.volume = f;
-  });
-}, "#attachListeners");
-_removeListeners = new WeakSet();
-removeListeners_fn = /* @__PURE__ */ __name(function(dispatcher) {
-  dispatcher.removeAllListeners();
-}, "#removeListeners");
-_performStart = new WeakSet();
-performStart_fn = /* @__PURE__ */ __name(function(resource) {
-  const track = resource?.metadata || this.currentTrack;
-  if (track && !this.isTransitioning())
-    this.player.events.emit("playerStart", this, track);
-  this.setTransitioning(false);
-  this.initializing = false;
-}, "#performStart");
-_performFinish = new WeakSet();
-performFinish_fn = /* @__PURE__ */ __name(function(resource) {
-  const track = resource?.metadata || this.currentTrack;
-  if (track && !this.isTransitioning()) {
-    this.history.push(track);
-    this.node.resetProgress();
-    this.player.events.emit("playerFinish", this, track);
-    if (this.tracks.size < 1 && this.repeatMode === 0 /* OFF */) {
-      __privateMethod(this, _emitEnd, emitEnd_fn).call(this);
-    } else {
-      if (this.repeatMode === 3 /* AUTOPLAY */) {
-        __privateMethod(this, _handleAutoplay, handleAutoplay_fn).call(this, track);
-        return;
-      }
-      if (this.repeatMode === 1 /* TRACK */) {
-        this.__current = this.history.tracks.dispatch() || track;
-        return this.node.play(this.__current);
-      }
-      if (this.repeatMode === 2 /* QUEUE */)
-        this.tracks.add(this.history.tracks.dispatch() || track);
-      this.__current = this.tracks.dispatch();
-      this.node.play(this.__current, {
-        queue: false
-      });
-    }
+  get streamTime() {
+    if (!this.audioResource)
+      return 0;
+    return this.audioResource.playbackDuration;
   }
-}, "#performFinish");
-_emitEnd = new WeakSet();
-emitEnd_fn = /* @__PURE__ */ __name(function() {
-  this.__current = null;
-  this.player.events.emit("emptyQueue", this);
-  if (this.options.leaveOnEnd) {
-    const tm = (0, import_timers.setTimeout)(() => {
-      if (this.tracks.size)
-        return clearTimeout(tm);
-      this.dispatcher?.disconnect();
-    }, this.options.leaveOnEndCooldown).unref();
+};
+__name(StreamDispatcher, "StreamDispatcher");
+
+// src/VoiceInterface/VoiceUtils.ts
+var import_utils6 = require("@discord-player/utils");
+var VoiceUtils = class {
+  constructor() {
+    this.cache = new import_utils6.Collection();
   }
-}, "#emitEnd");
-_handleAutoplay = new WeakSet();
-handleAutoplay_fn = /* @__PURE__ */ __name(async function(track) {
-  let info = await import_youtube_sr3.YouTube.getVideo(track.url).then((x) => x.videos[0]).catch(Util.noop);
-  if (!info)
-    info = await import_youtube_sr3.YouTube.search(track.author).then((x) => x[0]).catch(Util.noop);
-  if (!info) {
-    return __privateMethod(this, _emitEnd, emitEnd_fn).call(this);
+  async connect(channel, options) {
+    if (!options?.queue)
+      throw new Error("GuildQueue is required");
+    const conn = await this.join(channel, options);
+    const sub = new StreamDispatcher(conn, channel, options.queue, options.maxTime);
+    this.cache.set(channel.guild.id, sub);
+    return sub;
   }
-  const nextTrack = new Track(this.player, {
-    title: info.title,
-    url: `https://www.youtube.com/watch?v=${info.id}`,
-    duration: info.durationFormatted || Util.buildTimeCode(Util.parseMS(info.duration * 1e3)),
-    description: info.title,
-    thumbnail: typeof info.thumbnail === "string" ? info.thumbnail : info.thumbnail.url,
-    views: info.views,
-    author: info.channel.name,
-    requestedBy: track.requestedBy,
-    source: "youtube",
-    queryType: "youtubeVideo"
-  });
-  this.node.play(nextTrack, {
-    queue: false,
-    seek: 0,
-    transitionMode: false
-  });
-}, "#handleAutoplay");
-_resolveInitializerAwaiters = new WeakSet();
-resolveInitializerAwaiters_fn = /* @__PURE__ */ __name(function() {
-  __privateGet(this, _initializingPromises).forEach((p) => {
-    p(!__privateGet(this, _initializing));
-  });
-  __privateSet(this, _initializingPromises, []);
-}, "#resolveInitializerAwaiters");
-_warnIfDeleted = new WeakSet();
-warnIfDeleted_fn = /* @__PURE__ */ __name(function() {
-  if (!this.deleted)
-    return;
-  Util.warn("Deleted queue usage detected! Please remove references to deleted queues in order to prevent memory leaks.", "DiscordPlayerWarning");
-}, "#warnIfDeleted");
+  async join(channel, options) {
+    const conn = (0, import_voice4.joinVoiceChannel)({
+      guildId: channel.guild.id,
+      channelId: channel.id,
+      adapterCreator: channel.guild.voiceAdapterCreator,
+      selfDeaf: Boolean(options?.deaf)
+    });
+    return conn;
+  }
+  disconnect(connection) {
+    if (connection instanceof StreamDispatcher)
+      return connection.voiceConnection.destroy();
+    return connection.destroy();
+  }
+  getConnection(guild) {
+    return this.cache.get(guild) || (0, import_voice4.getVoiceConnection)(guild);
+  }
+};
+__name(VoiceUtils, "VoiceUtils");
 
-// src/Structures/GuildQueue/GuildNodeManager.ts
-var GuildNodeManager = class {
-  constructor(player) {
+// src/utils/QueryCache.ts
+var import_fuse = __toESM(require("fuse.js"));
+var DEFAULT_EXPIRY_TIMEOUT = 18e6;
+var _defaultCache;
+var QueryCache = class {
+  constructor(player, options = {
+    checkInterval: DEFAULT_EXPIRY_TIMEOUT
+  }) {
     this.player = player;
-    this.cache = new import_utils7.Collection();
+    this.options = options;
+    __privateAdd(this, _defaultCache, /* @__PURE__ */ new Map());
+    this.fuse = new import_fuse.default([], {
+      keys: [
+        "url"
+      ]
+    });
+    this.timer = setInterval(this.cleanup.bind(this), this.checkInterval).unref();
   }
-  create(guild, options = {}) {
-    const server = this.player.client.guilds.resolve(guild);
-    if (!server) {
-      throw new Error("Invalid or unknown guild");
-    }
-    if (this.cache.has(server.id)) {
-      return this.cache.get(server.id);
+  get checkInterval() {
+    return this.options.checkInterval ?? DEFAULT_EXPIRY_TIMEOUT;
+  }
+  async cleanup() {
+    for (const [id, value] of __privateGet(this, _defaultCache)) {
+      if (value.hasExpired()) {
+        __privateGet(this, _defaultCache).delete(id);
+      }
     }
-    options.strategy ?? (options.strategy = "FIFO");
-    options.volume ?? (options.volume = 100);
-    options.equalizer ?? (options.equalizer = []);
-    options.a_filter ?? (options.a_filter = []);
-    options.disableHistory ?? (options.disableHistory = false);
-    options.skipOnNoStream ?? (options.skipOnNoStream = false);
-    options.leaveOnEmpty ?? (options.leaveOnEmpty = true);
-    options.leaveOnEmptyCooldown ?? (options.leaveOnEmptyCooldown = 0);
-    options.leaveOnEnd ?? (options.leaveOnEnd = true);
-    options.leaveOnEndCooldown ?? (options.leaveOnEndCooldown = 0);
-    options.leaveOnStop ?? (options.leaveOnStop = true);
-    options.leaveOnStopCooldown ?? (options.leaveOnStopCooldown = 0);
-    options.resampler ?? (options.resampler = 48e3);
-    const queue = new GuildQueue(this.player, {
-      guild: server,
-      queueStrategy: options.strategy,
-      volume: options.volume,
-      equalizer: options.equalizer,
-      filterer: options.a_filter,
-      biquad: options.biquad,
-      resampler: options.resampler,
-      disableHistory: options.disableHistory,
-      skipOnNoStream: options.skipOnNoStream,
-      onBeforeCreateStream: options.onBeforeCreateStream,
-      repeatMode: options.repeatMode,
-      leaveOnEmpty: options.leaveOnEmpty,
-      leaveOnEmptyCooldown: options.leaveOnEmptyCooldown,
-      leaveOnEnd: options.leaveOnEnd,
-      leaveOnEndCooldown: options.leaveOnEndCooldown,
-      leaveOnStop: options.leaveOnStop,
-      leaveOnStopCooldown: options.leaveOnStopCooldown,
-      metadata: options.metadata
-    });
-    this.cache.set(server.id, queue);
-    return queue;
   }
-  get(node) {
-    const queue = this.resolve(node);
-    if (!queue)
-      return null;
-    return this.cache.get(queue.id) || null;
+  async clear() {
+    __privateGet(this, _defaultCache).clear();
   }
-  has(node) {
-    const id = node instanceof GuildQueue ? node.id : this.player.client.guilds.resolveId(node);
-    return this.cache.has(id);
+  async getData() {
+    return [...__privateGet(this, _defaultCache).values()];
   }
-  delete(node) {
-    const queue = this.resolve(node);
-    if (!queue)
-      throw new Error("Cannot delete non-existing queue");
-    queue.node.stop(true);
-    return this.cache.delete(queue.id);
+  async addData(data) {
+    data.tracks.forEach((d) => {
+      if (__privateGet(this, _defaultCache).has(d.url))
+        return;
+      __privateGet(this, _defaultCache).set(d.url, new DiscordPlayerQueryResultCache(d));
+    });
   }
-  resolve(node) {
-    if (node instanceof GuildQueue) {
-      return node;
-    }
-    return this.cache.get(this.player.client.guilds.resolveId(node));
+  async resolve(context) {
+    const cacheData = await this.getData();
+    this.fuse.setCollection(cacheData.map((m) => m.data));
+    const result = this.fuse.search(context.query);
+    if (!result.length)
+      return new SearchResult(this.player, {
+        query: context.query,
+        requestedBy: context.requestedBy,
+        queryType: context.queryType
+      });
+    return new SearchResult(this.player, {
+      query: context.query,
+      tracks: result.map((m) => m.item),
+      playlist: null,
+      queryType: context.queryType,
+      requestedBy: context.requestedBy
+    });
   }
-  resolveId(node) {
-    const q = this.resolve(node);
-    return q?.id || null;
+};
+__name(QueryCache, "QueryCache");
+_defaultCache = new WeakMap();
+var DiscordPlayerQueryResultCache = class {
+  constructor(data, expireAfter = DEFAULT_EXPIRY_TIMEOUT) {
+    this.data = data;
+    this.expireAfter = DEFAULT_EXPIRY_TIMEOUT;
+    if (typeof expireAfter === "number") {
+      this.expireAfter = Date.now() + expireAfter;
+    }
+  }
+  hasExpired() {
+    if (typeof this.expireAfter !== "number" || isNaN(this.expireAfter) || this.expireAfter < 1)
+      return false;
+    return Date.now() <= this.expireAfter;
   }
 };
-__name(GuildNodeManager, "GuildNodeManager");
+__name(DiscordPlayerQueryResultCache, "DiscordPlayerQueryResultCache");
+
+// src/Player.ts
+var import_discord3 = require("discord.js");
+var import_utils7 = require("@discord-player/utils");
+var import_voice5 = require("@discordjs/voice");
+
+// src/utils/__internal__/_container.ts
+var instances = /* @__PURE__ */ new Map();
+
+// src/utils/__internal__/addPlayer.ts
+function addPlayer(player) {
+  if (instances.has(player.id))
+    return true;
+  instances.set(player.id, player);
+  return instances.has(player.id);
+}
+__name(addPlayer, "addPlayer");
+
+// src/utils/__internal__/clearPlayer.ts
+function clearPlayer(player) {
+  return instances.delete(player.id);
+}
+__name(clearPlayer, "clearPlayer");
+
+// src/utils/__internal__/getPlayers.ts
+function getPlayers() {
+  return [...instances.values()];
+}
+__name(getPlayers, "getPlayers");
 
 // src/Player.ts
-var _lastLatency;
-var Player = class extends import_utils8.EventEmitter {
+var kSingleton = Symbol("InstanceDiscordPlayerSingleton");
+var _lastLatency, _voiceStateUpdateListener, _lagMonitorTimeout, _lagMonitorInterval;
+var _Player = class extends import_utils7.EventEmitter {
   constructor(client, options = {}) {
     super();
-    this.options = {
-      autoRegisterExtractor: true,
-      lockVoiceStateHandler: false,
-      blockExtractors: [],
-      ytdlOptions: {
-        highWaterMark: 1 << 25
-      },
-      connectionTimeout: 2e4,
-      smoothVolume: true,
-      lagMonitor: 3e4
-    };
-    this.queues = new import_utils9.Collection();
+    this.id = import_discord3.SnowflakeUtil.generate().toString();
     this.nodes = new GuildNodeManager(this);
     this.voiceUtils = new VoiceUtils();
     this.requiredEvents = ["error", "connectionError"];
     this.extractors = new ExtractorExecutionContext(this);
-    this.events = new import_utils8.EventEmitter();
+    this.events = new import_utils7.EventEmitter();
     __privateAdd(this, _lastLatency, -1);
+    __privateAdd(this, _voiceStateUpdateListener, this.handleVoiceState.bind(this));
+    __privateAdd(this, _lagMonitorTimeout, void 0);
+    __privateAdd(this, _lagMonitorInterval, void 0);
     this.client = client;
-    if (this.client?.options?.intents && !new import_discord4.IntentsBitField(this.client?.options?.intents).has(import_discord4.IntentsBitField.Flags.GuildVoiceStates)) {
-      throw new PlayerError('client is missing "GuildVoiceStates" intent');
+    if (this.client?.options?.intents && !new import_discord3.IntentsBitField(this.client?.options?.intents).has(import_discord3.IntentsBitField.Flags.GuildVoiceStates)) {
+      Util.warn('client is missing "GuildVoiceStates" intent', "InvalidIntentsBitField");
     }
-    this.options = Object.assign(this.options, options);
-    this.client.on("voiceStateUpdate", this.handleVoiceState.bind(this));
+    this.options = {
+      autoRegisterExtractor: true,
+      lockVoiceStateHandler: false,
+      blockExtractors: [],
+      blockStreamFrom: [],
+      connectionTimeout: 2e4,
+      smoothVolume: true,
+      lagMonitor: 3e4,
+      queryCache: options.queryCache === null ? null : new QueryCache(this),
+      ...options,
+      ytdlOptions: {
+        highWaterMark: 1 << 25,
+        ...options.ytdlOptions
+      }
+    };
+    this.client.on("voiceStateUpdate", __privateGet(this, _voiceStateUpdateListener));
     if (this.options?.autoRegisterExtractor) {
       let nv;
       if (nv = Util.require("@discord-player/extractor")) {
@@ -2532,113 +2132,60 @@ var Player = class extends import_utils8.EventEmitter {
       }
     }
     if (typeof this.options.lagMonitor === "number" && this.options.lagMonitor > 0) {
-      setInterval(() => {
+      __privateSet(this, _lagMonitorInterval, setInterval(() => {
         const start = performance.now();
-        setTimeout(() => {
+        __privateSet(this, _lagMonitorTimeout, setTimeout(() => {
           __privateSet(this, _lastLatency, performance.now() - start);
-        }, 0).unref();
-      }, this.options.lagMonitor).unref();
+        }, 0).unref());
+      }, this.options.lagMonitor).unref());
+    }
+    addPlayer(this);
+  }
+  static singleton(client, options = {}) {
+    if (!(kSingleton in _Player)) {
+      Object.defineProperty(_Player, kSingleton, {
+        value: new _Player(client, options),
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
     }
+    return _Player[kSingleton];
+  }
+  static getAllPlayers() {
+    return getPlayers();
+  }
+  static clearAllPlayers() {
+    return instances.clear();
+  }
+  get queryCache() {
+    return this.options.queryCache ?? null;
+  }
+  get queues() {
+    return this.nodes;
   }
   get eventLoopLag() {
     return __privateGet(this, _lastLatency);
   }
   generateStatistics() {
-    return this.queues.map((m) => m.generateStatistics());
+    return {
+      instances: instances.size,
+      queuesCount: this.queues.cache.size,
+      queryCacheEnabled: this.queryCache != null,
+      queues: this.queues.cache.map((m) => m.stats.generate())
+    };
   }
-  _handleVoiceStateLegacy(oldState, newState) {
-    const queue = this.getQueue(oldState.guild.id);
-    if (!queue || !queue.connection)
-      return;
-    const wasHandled = this.emit("voiceStateUpdate", queue, oldState, newState);
-    if (wasHandled && !this.options.lockVoiceStateHandler)
-      return;
-    if (oldState.channelId && !newState.channelId && newState.member.id === newState.guild.members.me.id) {
-      try {
-        queue.destroy();
-      } catch {
-      }
-      return void this.emit("botDisconnect", queue);
-    }
-    if (!oldState.channelId && newState.channelId && newState.member.id === newState.guild.members.me.id) {
-      if (newState.serverMute != null && oldState.serverMute !== newState.serverMute) {
-        queue.setPaused(newState.serverMute);
-      } else if (newState.channel?.type === import_discord4.ChannelType.GuildStageVoice && newState.suppress != null && oldState.suppress !== newState.suppress) {
-        queue.setPaused(newState.suppress);
-        if (newState.suppress) {
-          newState.guild.members.me.voice.setRequestToSpeak(true).catch(Util.noop);
-        }
-      }
-    }
-    if (!newState.channelId && oldState.channelId === queue.connection.channel.id) {
-      if (!Util.isVoiceEmpty(queue.connection.channel))
-        return;
-      const timeout = setTimeout(() => {
-        if (!Util.isVoiceEmpty(queue.connection.channel))
-          return;
-        if (!this.queues.has(queue.guild.id))
-          return;
-        if (queue.options.leaveOnEmpty)
-          queue.destroy(true);
-        this.emit("channelEmpty", queue);
-      }, queue.options.leaveOnEmptyCooldown || 0).unref();
-      queue._cooldownsTimeout.set(`empty_${oldState.guild.id}`, timeout);
-    }
-    if (newState.channelId && newState.channelId === queue.connection.channel.id) {
-      const emptyTimeout = queue._cooldownsTimeout.get(`empty_${oldState.guild.id}`);
-      const channelEmpty = Util.isVoiceEmpty(queue.connection.channel);
-      if (!channelEmpty && emptyTimeout) {
-        clearTimeout(emptyTimeout);
-        queue._cooldownsTimeout.delete(`empty_${oldState.guild.id}`);
-      }
-    }
-    if (oldState.channelId && newState.channelId && oldState.channelId !== newState.channelId) {
-      if (newState.member.id === newState.guild.members.me.id) {
-        if (queue.connection && newState.member.id === newState.guild.members.me.id)
-          queue.connection.channel = newState.channel;
-        const emptyTimeout = queue._cooldownsTimeout.get(`empty_${oldState.guild.id}`);
-        const channelEmpty = Util.isVoiceEmpty(queue.connection.channel);
-        if (!channelEmpty && emptyTimeout) {
-          clearTimeout(emptyTimeout);
-          queue._cooldownsTimeout.delete(`empty_${oldState.guild.id}`);
-        } else {
-          const timeout = setTimeout(() => {
-            if (queue.connection && !Util.isVoiceEmpty(queue.connection.channel))
-              return;
-            if (!this.queues.has(queue.guild.id))
-              return;
-            if (queue.options.leaveOnEmpty)
-              queue.destroy(true);
-            this.emit("channelEmpty", queue);
-          }, queue.options.leaveOnEmptyCooldown || 0).unref();
-          queue._cooldownsTimeout.set(`empty_${oldState.guild.id}`, timeout);
-        }
-      } else {
-        if (newState.channelId !== queue.connection.channel.id) {
-          if (!Util.isVoiceEmpty(queue.connection.channel))
-            return;
-          if (queue._cooldownsTimeout.has(`empty_${oldState.guild.id}`))
-            return;
-          const timeout = setTimeout(() => {
-            if (!Util.isVoiceEmpty(queue.connection.channel))
-              return;
-            if (!this.queues.has(queue.guild.id))
-              return;
-            if (queue.options.leaveOnEmpty)
-              queue.destroy(true);
-            this.emit("channelEmpty", queue);
-          }, queue.options.leaveOnEmptyCooldown || 0).unref();
-          queue._cooldownsTimeout.set(`empty_${oldState.guild.id}`, timeout);
-        } else {
-          const emptyTimeout = queue._cooldownsTimeout.get(`empty_${oldState.guild.id}`);
-          const channelEmpty = Util.isVoiceEmpty(queue.connection.channel);
-          if (!channelEmpty && emptyTimeout) {
-            clearTimeout(emptyTimeout);
-            queue._cooldownsTimeout.delete(`empty_${oldState.guild.id}`);
-          }
-        }
-      }
-    }
+  async destroy() {
+    this.nodes.cache.forEach((node) => node.delete());
+    this.client.off("voiceStateUpdate", __privateGet(this, _voiceStateUpdateListener));
+    this.removeAllListeners();
+    this.events.removeAllListeners();
+    await this.extractors.unregisterAll();
+    if (__privateGet(this, _lagMonitorInterval))
+      clearInterval(__privateGet(this, _lagMonitorInterval));
+    if (__privateGet(this, _lagMonitorTimeout))
+      clearInterval(__privateGet(this, _lagMonitorTimeout));
+    clearPlayer(this);
   }
   _handleVoiceState(oldState, newState) {
     const queue = this.nodes.get(oldState.guild.id);
@@ -2657,7 +2204,7 @@ var Player = class extends import_utils8.EventEmitter {
     if (!oldState.channelId && newState.channelId && newState.member.id === newState.guild.members.me.id) {
       if (newState.serverMute != null && oldState.serverMute !== newState.serverMute) {
         queue.node.setPaused(newState.serverMute);
-      } else if (newState.channel?.type === import_discord4.ChannelType.GuildStageVoice && newState.suppress != null && oldState.suppress !== newState.suppress) {
+      } else if (newState.channel?.type === import_discord3.ChannelType.GuildStageVoice && newState.suppress != null && oldState.suppress !== newState.suppress) {
         queue.node.setPaused(newState.suppress);
         if (newState.suppress) {
           newState.guild.members.me.voice.setRequestToSpeak(true).catch(Util.noop);
@@ -2736,7 +2283,6 @@ var Player = class extends import_utils8.EventEmitter {
   }
   handleVoiceState(oldState, newState) {
     this._handleVoiceState(oldState, newState);
-    this._handleVoiceStateLegacy(oldState, newState);
   }
   lockVoiceStateHandler() {
     this.options.lockVoiceStateHandler = true;
@@ -2747,42 +2293,6 @@ var Player = class extends import_utils8.EventEmitter {
   isVoiceStateHandlerLocked() {
     return !!this.options.lockVoiceStateHandler;
   }
-  createQueue(guild, queueInitOptions = {}) {
-    Util.warn("<Player.createQueue> is deprecated and will be removed in the future. Use new <Player.nodes.create> instead!");
-    guild = this.client.guilds.resolve(guild);
-    if (!guild)
-      throw new PlayerError("Unknown Guild", "UnknownGuild" /* UNKNOWN_GUILD */);
-    if (this.queues.has(guild.id))
-      return this.queues.get(guild.id);
-    const _meta = queueInitOptions.metadata;
-    delete queueInitOptions["metadata"];
-    queueInitOptions.volumeSmoothness ?? (queueInitOptions.volumeSmoothness = this.options.smoothVolume ? 0.08 : 0);
-    queueInitOptions.ytdlOptions ?? (queueInitOptions.ytdlOptions = this.options.ytdlOptions);
-    const queue = new Queue(this, guild, queueInitOptions);
-    queue.metadata = _meta;
-    this.queues.set(guild.id, queue);
-    return queue;
-  }
-  getQueue(guild) {
-    Util.warn("<Player.getQueue> is deprecated and will be removed in the future. Use new <Player.nodes.get> instead!");
-    guild = this.client.guilds.resolve(guild);
-    if (!guild)
-      throw new PlayerError("Unknown Guild", "UnknownGuild" /* UNKNOWN_GUILD */);
-    return this.queues.get(guild.id);
-  }
-  deleteQueue(guild) {
-    Util.warn("<Player.deleteQueue> is deprecated and will be removed in the future. Use new <Player.nodes.delete> instead!");
-    guild = this.client.guilds.resolve(guild);
-    if (!guild)
-      throw new PlayerError("Unknown Guild", "UnknownGuild" /* UNKNOWN_GUILD */);
-    const prev = this.getQueue(guild);
-    try {
-      prev.destroy();
-    } catch {
-    }
-    this.queues.delete(guild.id);
-    return prev;
-  }
   async play(channel, query, options = {}) {
     const vc = this.client.channels.resolve(channel);
     if (!vc?.isVoiceBased())
@@ -2829,6 +2339,15 @@ var Player = class extends import_utils8.EventEmitter {
         return new SearchResult(this, { query, queryType });
     }
     if (!extractor) {
+      if (!options.ignoreCache) {
+        const res2 = await this.queryCache?.resolve({
+          query,
+          queryType,
+          requestedBy: options.requestedBy
+        });
+        if (res2?.hasTracks())
+          return res2;
+      }
       extractor = (await this.extractors.run(async (ext) => {
         if (options.blockExtractors?.includes(ext.identifier))
           return false;
@@ -2843,29 +2362,37 @@ var Player = class extends import_utils8.EventEmitter {
       requestedBy: options.requestedBy
     }).catch(() => null);
     if (res) {
-      return new SearchResult(this, {
+      const result2 = new SearchResult(this, {
         query,
         queryType,
         playlist: res.playlist,
         tracks: res.tracks,
         extractor
       });
+      if (!options.ignoreCache) {
+        await this.queryCache?.addData(result2);
+      }
+      return result2;
     }
     const result = await this.extractors.run(
-      async (ext) => await ext.validate(query) && ext.handle(query, {
+      async (ext) => !options.blockExtractors?.includes(ext.identifier) && await ext.validate(query) && ext.handle(query, {
         type: queryType,
         requestedBy: options.requestedBy
       })
     );
     if (!result?.result)
       return new SearchResult(this, { query, queryType });
-    return new SearchResult(this, {
+    const data = new SearchResult(this, {
       query,
       queryType,
       playlist: result.result.playlist,
       tracks: result.result.tracks,
       extractor: result.extractor
     });
+    if (!options.ignoreCache) {
+      await this.queryCache?.addData(data);
+    }
+    return data;
   }
   scanDeps() {
     const line = "-".repeat(50);
@@ -2887,25 +2414,26 @@ ${line}`;
       return super.emit(eventName, ...args);
     }
   }
-  resolveQueue(queueLike) {
-    Util.warn("<Player.resolveQueue> is deprecated and will be removed in the future. Use new <Player.nodes.resolve> instead!");
-    return this.getQueue(queueLike instanceof Queue ? queueLike.guild : queueLike);
-  }
   *[Symbol.iterator]() {
-    yield* this.nodes.cache.size ? this.nodes.cache.values() : this.queues.values();
+    yield* this.nodes.cache.values();
   }
   createPlaylist(data) {
     return new Playlist(this, data);
   }
 };
+var Player = _Player;
 __name(Player, "Player");
 _lastLatency = new WeakMap();
+_voiceStateUpdateListener = new WeakMap();
+_lagMonitorTimeout = new WeakMap();
+_lagMonitorInterval = new WeakMap();
+Player._singletonKey = kSingleton;
 
 // src/index.ts
 var import_equalizer3 = require("@discord-player/equalizer");
-var version = "5.4.0";
-if (!import_discord5.version.startsWith("14")) {
-  process.emitWarning(`Discord.js v${import_discord5.version} is incompatible with Discord Player v${version}! Please use >=v14.x of Discord.js`);
+var version = "6.0.0-dev.3";
+if (!import_discord4.version.startsWith("14")) {
+  process.emitWarning(`Discord.js v${import_discord4.version} is incompatible with Discord Player v${version}! Please use >=v14.x of Discord.js`);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2917,11 +2445,13 @@ if (!import_discord5.version.startsWith("14")) {
   BaseExtractor,
   BiquadFilterType,
   BiquadFilters,
+  DiscordPlayerQueryResultCache,
   EqualizerConfigurationPreset,
   ErrorStatusCode,
   ExtractorExecutionContext,
   FFMPEG_ARGS_PIPED,
   FFMPEG_ARGS_STRING,
+  FFMPEG_SRATE_REGEX,
   FFmpegFilterer,
   FiltersChain,
   GuildNodeManager,
@@ -2935,10 +2465,10 @@ if (!import_discord5.version.startsWith("14")) {
   PlayerError,
   Playlist,
   Q_BUTTERWORTH,
-  QueryResolver,
+  QueryCache,
   QueryType,
-  Queue,
   QueueRepeatMode,
+  SearchResult,
   StreamDispatcher,
   Track,
   Util,