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

package/dist/index.js

@@ -56,7 +56,6 @@ __export(src_exports, {
   BASS_EQ_BANDS: () => import_equalizer3.BASS_EQ_BANDS,
   BaseExtractor: () => BaseExtractor,
   BiquadFilterType: () => import_equalizer3.FilterType,
-  BiquadFilters: () => import_equalizer3.BiquadFilters,
   DiscordPlayerQueryResultCache: () => DiscordPlayerQueryResultCache,
   EqualizerConfigurationPreset: () => EqualizerConfigurationPreset,
   ErrorStatusCode: () => ErrorStatusCode,
@@ -72,9 +71,9 @@ __export(src_exports, {
   GuildQueueHistory: () => GuildQueueHistory,
   GuildQueuePlayerNode: () => GuildQueuePlayerNode,
   PCMAudioFilters: () => import_equalizer3.AudioFilters,
-  PCMFilters: () => import_equalizer3.PCMFilters,
   Player: () => Player,
   PlayerError: () => PlayerError,
+  PlayerEventsEmitter: () => PlayerEventsEmitter,
   Playlist: () => Playlist,
   Q_BUTTERWORTH: () => import_equalizer3.Q_BUTTERWORTH,
   QueryCache: () => QueryCache,
@@ -84,6 +83,7 @@ __export(src_exports, {
   StreamDispatcher: () => StreamDispatcher,
   Track: () => Track,
   Util: () => Util,
+  VoiceReceiverNode: () => VoiceReceiverNode,
   VoiceUtils: () => VoiceUtils,
   VolumeTransformer: () => import_equalizer3.VolumeTransformer,
   createFFmpegStream: () => createFFmpegStream,
@@ -92,6 +92,108 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_discord4 = require("discord.js");
 
+// src/utils/PlayerEventsEmitter.ts
+var import_utils = require("@discord-player/utils");
+
+// src/utils/Util.ts
+var import_promises = require("timers/promises");
+var Util = class {
+  constructor() {
+  }
+  static durationString(durObj) {
+    return Object.values(durObj).map((m) => isNaN(m) ? 0 : m).join(":");
+  }
+  static parseMS(milliseconds) {
+    if (isNaN(milliseconds))
+      milliseconds = 0;
+    const round = milliseconds > 0 ? Math.floor : Math.ceil;
+    return {
+      days: round(milliseconds / 864e5),
+      hours: round(milliseconds / 36e5) % 24,
+      minutes: round(milliseconds / 6e4) % 60,
+      seconds: round(milliseconds / 1e3) % 60
+    };
+  }
+  static buildTimeCode(duration) {
+    const items = Object.keys(duration);
+    const required = ["days", "hours", "minutes", "seconds"];
+    const parsed = items.filter((x) => required.includes(x)).map((m) => duration[m]);
+    const final = parsed.slice(parsed.findIndex((x) => x !== 0)).map((x) => x.toString().padStart(2, "0")).join(":");
+    return final.length <= 3 ? `0:${final.padStart(2, "0") || 0}` : final;
+  }
+  static last(arr) {
+    if (!Array.isArray(arr))
+      return arr;
+    return arr[arr.length - 1];
+  }
+  static isVoiceEmpty(channel) {
+    return channel && channel.members.filter((member) => !member.user.bot).size === 0;
+  }
+  static require(id) {
+    try {
+      return { module: require(id), error: null };
+    } catch (error) {
+      return { module: null, error };
+    }
+  }
+  static async import(id) {
+    try {
+      const mod = await import(id);
+      return { module: mod, error: null };
+    } catch (error) {
+      return { module: null, error };
+    }
+  }
+  static wait(time) {
+    return (0, import_promises.setTimeout)(time, void 0, { ref: false });
+  }
+  static noop() {
+  }
+  static async getFetch() {
+    if ("fetch" in globalThis)
+      return globalThis.fetch;
+    for (const lib of ["node-fetch", "undici"]) {
+      try {
+        return await import(lib).then((res) => res.fetch || res.default?.fetch || res.default);
+      } catch {
+        try {
+          const res = require(lib);
+          if (res)
+            return res.fetch || res.default?.fetch || res.default;
+        } catch {
+        }
+      }
+    }
+  }
+  static warn(message, code = "DeprecationWarning", detail) {
+    process.emitWarning(message, {
+      code,
+      detail
+    });
+  }
+};
+__name(Util, "Util");
+
+// src/utils/PlayerEventsEmitter.ts
+var PlayerEventsEmitter = class extends import_utils.EventEmitter {
+  constructor(requiredEvents = []) {
+    super();
+    this.requiredEvents = requiredEvents;
+  }
+  emit(name, ...args) {
+    if (this.requiredEvents.includes(name) && !this.eventNames().includes(name)) {
+      console.error(...args);
+      Util.warn(
+        `No event listener found for event "${String(name)}". Events ${this.requiredEvents.map((m) => `"${String(m)}"`).join(", ")} must have event listeners.`,
+        "UnhandledEventsWarning"
+      );
+      return false;
+    }
+    return super.emit(name, ...args);
+  }
+};
+__name(PlayerEventsEmitter, "PlayerEventsEmitter");
+
 // src/utils/AudioFilters.ts
 var bass = /* @__PURE__ */ __name((g) => `bass=g=${g}:f=110:w=0.3`, "bass");
 var _AudioFilters = class {
@@ -202,16 +304,32 @@ var BaseExtractor = class {
   createResponse(playlist, tracks = playlist?.tracks || []) {
     return { playlist: playlist || null, tracks };
   }
+  debug(message) {
+    return this.context.player.debug(message);
+  }
 };
 __name(BaseExtractor, "BaseExtractor");
 BaseExtractor.identifier = "com.discord-player.extractor";
 
 // src/extractors/ExtractorExecutionContext.ts
-var import_utils = require("@discord-player/utils");
+var import_utils2 = require("@discord-player/utils");
+var knownExtractorKeys = ["YouTubeExtractor", "SoundCloudExtractor", "ReverbnationExtractor", "VimeoExtractor", "AttachmentExtractor"];
+var knownExtractorLib = "@discord-player/extractor";
 var ExtractorExecutionContext = class {
   constructor(player) {
     this.player = player;
-    this.store = new import_utils.Collection();
+    this.store = new import_utils2.Collection();
+  }
+  async loadDefault() {
+    const mod = await Util.import(knownExtractorLib);
+    if (mod.error)
+      return { success: false, error: mod.error };
+    knownExtractorKeys.forEach((key) => {
+      if (!mod.module[key])
+        return;
+      this.register(mod.module[key]);
+    });
+    return { success: true, error: null };
   }
   isRegistered(identifier) {
     return this.store.has(identifier);
@@ -228,9 +346,12 @@ var ExtractorExecutionContext = class {
     const extractor = new _extractor(this);
     try {
       this.store.set(_extractor.identifier, extractor);
+      this.player.debug(`${_extractor.identifier} extractor loaded!`);
       await extractor.activate();
-    } catch {
+      this.player.debug(`${_extractor.identifier} extractor activated!`);
+    } catch (e) {
       this.store.delete(_extractor.identifier);
+      this.player.debug(`${_extractor.identifier} extractor failed to activate! Error: ${e}`);
     }
   }
   async unregister(_extractor) {
@@ -240,8 +361,11 @@ var ExtractorExecutionContext = class {
     try {
       const key = extractor.identifier || this.store.findKey((e) => e === extractor);
       this.store.delete(key);
+      this.player.debug(`${extractor.identifier} extractor disabled!`);
       await extractor.deactivate();
+      this.player.debug(`${extractor.identifier} extractor deactivated!`);
     } catch {
+      this.player.debug(`${extractor.identifier} extractor failed to deactivate!`);
     }
   }
   async unregisterAll() {
@@ -275,11 +399,11 @@ var ExtractorExecutionContext = class {
 __name(ExtractorExecutionContext, "ExtractorExecutionContext");
 
 // src/Structures/GuildNodeManager.ts
-var import_utils4 = require("@discord-player/utils");
+var import_utils5 = require("@discord-player/utils");
 
 // src/Structures/GuildQueue.ts
 var import_discord2 = require("discord.js");
-var import_utils3 = require("@discord-player/utils");
+var import_utils4 = require("@discord-player/utils");
 
 // src/Structures/Track.ts
 var import_discord = require("discord.js");
@@ -287,7 +411,10 @@ var Track = class {
   constructor(player, data) {
     this.requestedBy = null;
     this.queryType = null;
-    this.raw = {};
+    this.raw = {
+      source: "arbitrary"
+    };
+    this.extractor = null;
     this.id = import_discord.SnowflakeUtil.generate().toString();
     Object.defineProperty(this, "player", { value: player, enumerable: false });
     void this._patch(data);
@@ -302,7 +429,7 @@ var Track = class {
     this.queryType = data.queryType;
     this.requestedBy = data.requestedBy || null;
     this.playlist = data.playlist;
-    Object.defineProperty(this, "raw", { value: Object.assign({}, { source: data.raw?.source ?? data.source }, data.raw ?? data), enumerable: false });
+    this.raw = Object.assign({}, { source: data.raw?.source ?? data.source }, data.raw ?? data);
   }
   get queue() {
     return this.player.nodes.cache.find((q) => q.tracks.some((ab) => ab.id === this.id));
@@ -317,7 +444,7 @@ var Track = class {
     return this.duration.split(":").reverse().map((m, i) => parseInt(m) * times(60, i)).reduce((a, c) => a + c, 0);
   }
   get source() {
-    return this.raw.source ?? "arbitrary";
+    return this.raw?.source ?? "arbitrary";
   }
   toString() {
     return `${this.title} by ${this.author}`;
@@ -343,77 +470,6 @@ __name(Track, "Track");
 // src/Structures/GuildQueue.ts
 var import_voice2 = require("@discordjs/voice");
 
-// src/utils/Util.ts
-var import_promises = require("timers/promises");
-var Util = class {
-  constructor() {
-  }
-  static durationString(durObj) {
-    return Object.values(durObj).map((m) => isNaN(m) ? 0 : m).join(":");
-  }
-  static parseMS(milliseconds) {
-    if (isNaN(milliseconds))
-      milliseconds = 0;
-    const round = milliseconds > 0 ? Math.floor : Math.ceil;
-    return {
-      days: round(milliseconds / 864e5),
-      hours: round(milliseconds / 36e5) % 24,
-      minutes: round(milliseconds / 6e4) % 60,
-      seconds: round(milliseconds / 1e3) % 60
-    };
-  }
-  static buildTimeCode(duration) {
-    const items = Object.keys(duration);
-    const required = ["days", "hours", "minutes", "seconds"];
-    const parsed = items.filter((x) => required.includes(x)).map((m) => duration[m]);
-    const final = parsed.slice(parsed.findIndex((x) => x !== 0)).map((x) => x.toString().padStart(2, "0")).join(":");
-    return final.length <= 3 ? `0:${final.padStart(2, "0") || 0}` : final;
-  }
-  static last(arr) {
-    if (!Array.isArray(arr))
-      return arr;
-    return arr[arr.length - 1];
-  }
-  static isVoiceEmpty(channel) {
-    return channel && channel.members.filter((member) => !member.user.bot).size === 0;
-  }
-  static require(id) {
-    try {
-      return require(id);
-    } catch {
-      return null;
-    }
-  }
-  static wait(time) {
-    return (0, import_promises.setTimeout)(time, void 0, { ref: false });
-  }
-  static noop() {
-  }
-  static async getFetch() {
-    if ("fetch" in globalThis)
-      return globalThis.fetch;
-    for (const lib of ["node-fetch", "undici"]) {
-      try {
-        return await import(lib).then((res) => res.fetch || res.default?.fetch || res.default);
-      } catch {
-        try {
-          const res = require(lib);
-          if (res)
-            return res.fetch || res.default?.fetch || res.default;
-        } catch {
-        }
-      }
-    }
-  }
-  static warn(message, code = "DeprecationWarning", detail) {
-    process.emitWarning(message, {
-      code,
-      detail
-    });
-  }
-};
-__name(Util, "Util");
-
 // src/Structures/Playlist.ts
 var Playlist = class {
   constructor(player, data) {
@@ -451,11 +507,11 @@ var Playlist = class {
 __name(Playlist, "Playlist");
 
 // src/Structures/GuildQueueHistory.ts
-var import_utils2 = require("@discord-player/utils");
+var import_utils3 = require("@discord-player/utils");
 var GuildQueueHistory = class {
   constructor(queue) {
     this.queue = queue;
-    this.tracks = new import_utils2.Queue("LIFO");
+    this.tracks = new import_utils3.Queue("LIFO");
   }
   get currentTrack() {
     return this.queue.dispatcher?.audioResource?.metadata || this.queue.__current;
@@ -481,20 +537,25 @@ var GuildQueueHistory = class {
   clear() {
     this.tracks.clear();
   }
-  next() {
+  async 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;
+  async previous() {
+    const track = this.tracks.dispatch();
     if (!track) {
       throw new Error("No previous track in the queue");
     }
-    this.queue.node.play(track, { queue: true });
-    this.queue.node.skip();
+    const current = this.currentTrack;
+    await this.queue.node.play(track, { queue: false });
+    if (current)
+      this.queue.node.insert(current, 0);
+  }
+  back() {
+    return this.previous();
   }
 };
 __name(GuildQueueHistory, "GuildQueueHistory");
@@ -537,7 +598,7 @@ var QueueRepeatMode = /* @__PURE__ */ ((QueueRepeatMode2) => {
 })(QueueRepeatMode || {});
 
 // src/utils/QueryResolver.ts
-var import_soundcloud_scraper = require("soundcloud-scraper");
+var soundcloud = __toESM(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=.+)?$/;
@@ -565,9 +626,9 @@ var QueryResolver = class {
   }
   static resolve(query) {
     query = query.trim();
-    if ((0, import_soundcloud_scraper.validateURL)(query, "track"))
+    if (soundcloud.validateURL(query, "track"))
       return QueryType.SOUNDCLOUD_TRACK;
-    if ((0, import_soundcloud_scraper.validateURL)(query, "playlist") || query.includes("/sets/"))
+    if (soundcloud.validateURL(query, "playlist") || query.includes("/sets/"))
       return QueryType.SOUNDCLOUD_PLAYLIST;
     if (import_youtube_sr.YouTube.isPlaylist(query))
       return QueryType.YOUTUBE_PLAYLIST;
@@ -799,6 +860,9 @@ var GuildQueuePlayerNode = class {
     }
     return true;
   }
+  async playRaw(resource) {
+    await this.queue.dispatcher?.playStream(resource);
+  }
   async play(res, options) {
     if (!this.queue.dispatcher?.voiceConnection) {
       throw new Error("No voice connection available");
@@ -821,23 +885,29 @@ var GuildQueuePlayerNode = class {
     if (!track) {
       throw new Error("Play request received but track was not provided");
     }
+    if (this.queue.initializing) {
+      this.queue.debug("Queue is currently initializing another track, waiting...");
+      await this.queue.awaitInitialization();
+      this.queue.debug("Queue has finished initialization...");
+    }
     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";
+      const src = track.raw?.source || track.source;
+      const qt = track.queryType || (src === "spotify" ? "spotifySong" : src === "apple_music" ? "appleMusicSong" : src);
       this.queue.debug(`Executing onBeforeCreateStream hook (QueryType: ${qt})...`);
-      let stream = await this.queue.onBeforeCreateStream?.(track, qt, this.queue).catch(() => null);
+      let stream = await this.queue.onBeforeCreateStream?.(track, qt || "arbitrary", 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);
       }
       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.queue.initializing = false;
           this.play(this.queue.tracks.dispatch());
           return;
         }
@@ -848,7 +918,7 @@ var GuildQueuePlayerNode = class {
       } else {
         __privateSet(this, _progress, 0);
       }
-      const cookies = track.source === "youtube" ? this.queue.player.options.ytdlOptions?.requestOptions?.headers?.cookie : void 0;
+      const cookies = track.raw?.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)`);
@@ -892,6 +962,7 @@ var GuildQueuePlayerNode = class {
       });
       this.queue.setTransitioning(!!options.transitionMode);
       await __privateMethod(this, _performPlay, performPlay_fn).call(this, resource);
+      this.queue.initializing = false;
     } catch (e) {
       this.queue.debug(`Failed to initialize audio player: ${e}`);
       this.queue.initializing = false;
@@ -947,7 +1018,7 @@ createFFmpegStream_fn = /* @__PURE__ */ __name(function(stream, track, seek = 0,
 var import_equalizer = require("@discord-player/equalizer");
 
 // src/utils/FFmpegStream.ts
-var import_prism_media = require("prism-media");
+var prism = __toESM(require("prism-media"));
 function FFMPEG_ARGS_STRING(stream, fmt, cookies) {
   const args = [
     "-reconnect",
@@ -999,7 +1070,7 @@ function createFFmpegStream(stream, options) {
     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 });
+  const transcoder = new prism.FFmpeg({ shell: false, args });
   transcoder.on("close", () => transcoder.destroy());
   if (typeof stream !== "string") {
     stream.on("error", () => transcoder.destroy());
@@ -1232,7 +1303,7 @@ var GuildQueueStatistics = class {
       memoryUsage: process.memoryUsage(),
       versions: {
         node: process.version,
-        player: "6.0.0-dev.3"
+        player: "6.0.0-dev.4"
       }
     };
   }
@@ -1240,7 +1311,7 @@ var GuildQueueStatistics = class {
 __name(GuildQueueStatistics, "GuildQueueStatistics");
 
 // 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 _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;
 var GuildQueue = class {
   constructor(player, options) {
     this.player = player;
@@ -1252,7 +1323,6 @@ var GuildQueue = class {
     __privateAdd(this, _emitEnd);
     __privateAdd(this, _handleAutoplay);
     __privateAdd(this, _resolveInitializerAwaiters);
-    __privateAdd(this, _warnIfDeleted);
     __privateAdd(this, _transitioning, false);
     __privateAdd(this, _initializing, false);
     __privateAdd(this, _deleted, false);
@@ -1268,9 +1338,9 @@ var GuildQueue = class {
       type: import_voice2.StreamType.Raw
     }), "onAfterCreateStream");
     this.repeatMode = 0 /* OFF */;
-    this.timeouts = new import_utils3.Collection();
+    this.timeouts = new import_utils4.Collection();
     this.stats = new GuildQueueStatistics(this);
-    this.tracks = new import_utils3.Queue(options.queueStrategy);
+    this.tracks = new import_utils4.Queue(options.queueStrategy);
     if (typeof options.onBeforeCreateStream === "function")
       this.onBeforeCreateStream = options.onBeforeCreateStream;
     if (typeof options.onAfterCreateStream === "function")
@@ -1295,6 +1365,9 @@ var GuildQueue = class {
     }
     this.debug(`GuildQueue initialized for guild ${this.options.guild.name} (ID: ${this.options.guild.id})`);
   }
+  get voiceReceiver() {
+    return this.dispatcher?.receiver ?? null;
+  }
   debug(m) {
     this.player.events.emit("debug", this, m);
   }
@@ -1305,7 +1378,6 @@ var GuildQueue = class {
     this.options.metadata = m;
   }
   setMetadata(m) {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
     this.options.metadata = m;
   }
   get initializing() {
@@ -1344,26 +1416,21 @@ var GuildQueue = class {
     return this.guild.id;
   }
   setTransitioning(state) {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
     __privateSet(this, _transitioning, state);
   }
   isTransitioning() {
     return __privateGet(this, _transitioning);
   }
   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;
   }
   isPlaying() {
-    __privateMethod(this, _warnIfDeleted, warnIfDeleted_fn).call(this);
     return this.dispatcher?.audioResource != null;
   }
   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);
@@ -1374,8 +1441,13 @@ var GuildQueue = class {
       this.player.events.emit("audioTrackAdd", this, toAdd);
     }
   }
+  removeTrack(track) {
+    return this.node.remove(track);
+  }
+  insertTrack(track, index = 0) {
+    return this.node.insert(track, index);
+  }
   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}`);
@@ -1408,6 +1480,12 @@ var GuildQueue = class {
       __privateSet(this, _deleted, true);
     }
   }
+  revive() {
+    if (!this.deleted || this.player.nodes.has(this.id))
+      return;
+    __privateSet(this, _deleted, false);
+    this.player.nodes.cache.set(this.id, this);
+  }
   awaitInitialization() {
     return new Promise((r) => {
       if (!__privateGet(this, _initializing))
@@ -1415,6 +1493,12 @@ var GuildQueue = class {
       __privateGet(this, _initializingPromises).push(r);
     });
   }
+  setSelfDeaf(mode, reason) {
+    return this.guild.members.me.voice.setDeaf(mode, reason);
+  }
+  setSelfMute(mode, reason) {
+    return this.guild.members.me.voice.setMute(mode, reason);
+  }
 };
 __name(GuildQueue, "GuildQueue");
 _transitioning = new WeakMap();
@@ -1465,7 +1549,7 @@ performFinish_fn = /* @__PURE__ */ __name(function(resource) {
     } else {
       if (this.repeatMode === 1 /* TRACK */) {
         this.__current = this.history.tracks.dispatch() || track;
-        return this.node.play(this.__current);
+        return this.node.play(this.__current, { queue: false });
       }
       if (this.repeatMode === 2 /* QUEUE */)
         this.tracks.add(this.history.tracks.dispatch() || track);
@@ -1528,18 +1612,12 @@ resolveInitializerAwaiters_fn = /* @__PURE__ */ __name(function() {
   });
   __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/GuildNodeManager.ts
 var GuildNodeManager = class {
   constructor(player) {
     this.player = player;
-    this.cache = new import_utils4.Collection();
+    this.cache = new import_utils5.Collection();
   }
   create(guild, options = {}) {
     const server = this.player.client.guilds.resolve(guild);
@@ -1629,11 +1707,82 @@ var GuildNodeManager = class {
 };
 __name(GuildNodeManager, "GuildNodeManager");
 
+// src/Structures/VoiceReceiverNode.ts
+var import_stream = require("stream");
+var import_voice3 = require("@discordjs/voice");
+var prism2 = __toESM(require("prism-media"));
+var VoiceReceiverNode = class {
+  constructor(dispatcher) {
+    this.dispatcher = dispatcher;
+  }
+  createRawTrack(stream, data = {}) {
+    data.title ?? (data.title = `Recording ${Date.now()}`);
+    return new Track(this.dispatcher.queue.player, {
+      author: "Discord",
+      description: data.title,
+      title: data.title,
+      duration: data.duration || "0:00",
+      views: 0,
+      requestedBy: data.requestedBy,
+      thumbnail: data.thumbnail || "https://cdn.discordapp.com/embed/avatars/0.png",
+      url: data.url || "https://discord.com",
+      source: "arbitrary",
+      raw: {
+        engine: stream,
+        source: "arbitrary"
+      }
+    });
+  }
+  mergeRecordings(streams) {
+    throw new Error("Not implemented");
+  }
+  recordUser(user, options = {
+    end: import_voice3.EndBehaviorType.AfterSilence,
+    mode: "pcm",
+    silenceDuration: 1e3
+  }) {
+    const _user = this.dispatcher.queue.player.client.users.resolveId(user);
+    const passThrough = new import_stream.PassThrough();
+    const receiver = this.dispatcher.voiceConnection.receiver;
+    if (!receiver)
+      throw new Error("Voice receiver is not available, maybe connect to a voice channel first?");
+    receiver.speaking.on("start", (userId) => {
+      if (userId === _user) {
+        const receiveStream = receiver.subscribe(_user, {
+          end: {
+            behavior: options.end || import_voice3.EndBehaviorType.AfterSilence,
+            duration: options.silenceDuration ?? 1e3
+          }
+        });
+        setImmediate(async () => {
+          if (options.mode === "pcm") {
+            const pcm = receiveStream.pipe(
+              new prism2.opus.Decoder({
+                channels: 2,
+                frameSize: 960,
+                rate: 48e3
+              })
+            );
+            return pcm.pipe(passThrough);
+          } else {
+            return receiveStream.pipe(passThrough);
+          }
+        }).unref();
+      }
+    });
+    return passThrough;
+  }
+};
+__name(VoiceReceiverNode, "VoiceReceiverNode");
+
 // src/Structures/SearchResult.ts
 var SearchResult = class {
   constructor(player, _data) {
     this.player = player;
     this._data = _data;
+    this._data.tracks?.forEach((track) => {
+      track.extractor = this._data.extractor || null;
+    });
   }
   get query() {
     return this._data.query;
@@ -1729,21 +1878,22 @@ var PlayerError = class extends Error {
 __name(PlayerError, "PlayerError");
 
 // src/VoiceInterface/VoiceUtils.ts
-var import_voice4 = require("@discordjs/voice");
+var import_voice5 = require("@discordjs/voice");
 
 // src/VoiceInterface/StreamDispatcher.ts
-var import_voice3 = require("@discordjs/voice");
-var import_utils5 = require("@discord-player/utils");
+var import_voice4 = require("@discordjs/voice");
+var import_utils6 = require("@discord-player/utils");
 var import_equalizer2 = require("@discord-player/equalizer");
-var StreamDispatcher = class extends import_utils5.EventEmitter {
+var StreamDispatcher = class extends import_utils6.EventEmitter {
   constructor(connection, channel, queue, connectionTimeout = 2e4) {
     super();
     this.queue = queue;
     this.connectionTimeout = connectionTimeout;
+    this.receiver = new VoiceReceiverNode(this);
     this.readyLock = false;
     this.dsp = new import_equalizer2.FiltersChain();
     this.voiceConnection = connection;
-    this.audioPlayer = (0, import_voice3.createAudioPlayer)();
+    this.audioPlayer = (0, import_voice4.createAudioPlayer)();
     this.channel = channel;
     this.dsp.onUpdate = () => {
       if (!this.dsp)
@@ -1761,10 +1911,10 @@ var StreamDispatcher = class extends import_utils5.EventEmitter {
     };
     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) {
+      if (newState.status === import_voice4.VoiceConnectionStatus.Disconnected) {
+        if (newState.reason === import_voice4.VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
           try {
-            await (0, import_voice3.entersState)(this.voiceConnection, import_voice3.VoiceConnectionStatus.Connecting, this.connectionTimeout);
+            await (0, import_voice4.entersState)(this.voiceConnection, import_voice4.VoiceConnectionStatus.Connecting, this.connectionTimeout);
           } catch {
             try {
               this.voiceConnection.destroy();
@@ -1782,14 +1932,14 @@ var StreamDispatcher = class extends import_utils5.EventEmitter {
             this.emit("error", err);
           }
         }
-      } else if (newState.status === import_voice3.VoiceConnectionStatus.Destroyed) {
+      } else if (newState.status === import_voice4.VoiceConnectionStatus.Destroyed) {
         this.end();
-      } else if (!this.readyLock && (newState.status === import_voice3.VoiceConnectionStatus.Connecting || newState.status === import_voice3.VoiceConnectionStatus.Signalling)) {
+      } else if (!this.readyLock && (newState.status === import_voice4.VoiceConnectionStatus.Connecting || newState.status === import_voice4.VoiceConnectionStatus.Signalling)) {
         this.readyLock = true;
         try {
-          await (0, import_voice3.entersState)(this.voiceConnection, import_voice3.VoiceConnectionStatus.Ready, this.connectionTimeout);
+          await (0, import_voice4.entersState)(this.voiceConnection, import_voice4.VoiceConnectionStatus.Ready, this.connectionTimeout);
         } catch {
-          if (this.voiceConnection.state.status !== import_voice3.VoiceConnectionStatus.Destroyed) {
+          if (this.voiceConnection.state.status !== import_voice4.VoiceConnectionStatus.Destroyed) {
             try {
               this.voiceConnection.destroy();
             } catch (err) {
@@ -1802,11 +1952,11 @@ var StreamDispatcher = class extends import_utils5.EventEmitter {
       }
     });
     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) {
+      if (newState.status === import_voice4.AudioPlayerStatus.Playing) {
+        if (oldState.status === import_voice4.AudioPlayerStatus.Idle || oldState.status === import_voice4.AudioPlayerStatus.Buffering) {
           return this.emit("start", this.audioResource);
         }
-      } else if (newState.status === import_voice3.AudioPlayerStatus.Idle && oldState.status !== import_voice3.AudioPlayerStatus.Idle) {
+      } else if (newState.status === import_voice4.AudioPlayerStatus.Idle && oldState.status !== import_voice4.AudioPlayerStatus.Idle) {
         this.emit("finish", this.audioResource);
         this.dsp.destroy();
         this.audioResource = null;
@@ -1817,22 +1967,22 @@ var StreamDispatcher = class extends import_utils5.EventEmitter {
     this.voiceConnection.subscribe(this.audioPlayer);
   }
   get paused() {
-    return this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.Paused;
+    return this.audioPlayer.state.status === import_voice4.AudioPlayerStatus.Paused;
   }
   set paused(val) {
     val ? this.pause(true) : this.resume();
   }
   isPaused() {
-    return this.paused || this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.AutoPaused;
+    return this.paused || this.audioPlayer.state.status === import_voice4.AudioPlayerStatus.AutoPaused;
   }
   isBuffering() {
-    return this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.Buffering;
+    return this.audioPlayer.state.status === import_voice4.AudioPlayerStatus.Buffering;
   }
   isPlaying() {
-    return this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.Playing;
+    return this.audioPlayer.state.status === import_voice4.AudioPlayerStatus.Playing;
   }
   isIdle() {
-    return this.audioPlayer.state.status === import_voice3.AudioPlayerStatus.Idle;
+    return this.audioPlayer.state.status === import_voice4.AudioPlayerStatus.Idle;
   }
   async createStream(src, ops) {
     if (!ops?.disableFilters)
@@ -1863,12 +2013,12 @@ var StreamDispatcher = class extends import_utils5.EventEmitter {
     const postStream = await this.queue.onAfterCreateStream?.(stream, this.queue).catch(
       () => ({
         stream,
-        type: ops?.type ?? import_voice3.StreamType.Arbitrary
+        type: ops?.type ?? import_voice4.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,
+    this.audioResource = (0, import_voice4.createAudioResource)(postStream?.stream ?? stream, {
+      inputType: postStream?.type ?? ops?.type ?? import_voice4.StreamType.Arbitrary,
       metadata: ops?.data,
       inlineVolume: false
     });
@@ -1916,9 +2066,9 @@ var StreamDispatcher = class extends import_utils5.EventEmitter {
     }
     if (!this.audioResource)
       this.audioResource = resource;
-    if (this.voiceConnection.state.status !== import_voice3.VoiceConnectionStatus.Ready) {
+    if (this.voiceConnection.state.status !== import_voice4.VoiceConnectionStatus.Ready) {
       try {
-        await (0, import_voice3.entersState)(this.voiceConnection, import_voice3.VoiceConnectionStatus.Ready, this.connectionTimeout);
+        await (0, import_voice4.entersState)(this.voiceConnection, import_voice4.VoiceConnectionStatus.Ready, this.connectionTimeout);
       } catch (err) {
         return void this.emit("error", err);
       }
@@ -1949,10 +2099,10 @@ var StreamDispatcher = class extends import_utils5.EventEmitter {
 __name(StreamDispatcher, "StreamDispatcher");
 
 // src/VoiceInterface/VoiceUtils.ts
-var import_utils6 = require("@discord-player/utils");
+var import_utils7 = require("@discord-player/utils");
 var VoiceUtils = class {
   constructor() {
-    this.cache = new import_utils6.Collection();
+    this.cache = new import_utils7.Collection();
   }
   async connect(channel, options) {
     if (!options?.queue)
@@ -1963,7 +2113,7 @@ var VoiceUtils = class {
     return sub;
   }
   async join(channel, options) {
-    const conn = (0, import_voice4.joinVoiceChannel)({
+    const conn = (0, import_voice5.joinVoiceChannel)({
       guildId: channel.guild.id,
       channelId: channel.id,
       adapterCreator: channel.guild.voiceAdapterCreator,
@@ -1977,7 +2127,7 @@ var VoiceUtils = class {
     return connection.destroy();
   }
   getConnection(guild) {
-    return this.cache.get(guild) || (0, import_voice4.getVoiceConnection)(guild);
+    return this.cache.get(guild) || (0, import_voice5.getVoiceConnection)(guild);
   }
 };
 __name(VoiceUtils, "VoiceUtils");
@@ -2062,8 +2212,7 @@ __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");
+var import_voice6 = require("@discordjs/voice");
 
 // src/utils/__internal__/_container.ts
 var instances = /* @__PURE__ */ new Map();
@@ -2092,19 +2241,18 @@ __name(getPlayers, "getPlayers");
 // src/Player.ts
 var kSingleton = Symbol("InstanceDiscordPlayerSingleton");
 var _lastLatency, _voiceStateUpdateListener, _lagMonitorTimeout, _lagMonitorInterval;
-var _Player = class extends import_utils7.EventEmitter {
+var _Player = class extends PlayerEventsEmitter {
   constructor(client, options = {}) {
-    super();
-    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_utils7.EventEmitter();
+    super(["error"]);
     __privateAdd(this, _lastLatency, -1);
     __privateAdd(this, _voiceStateUpdateListener, this.handleVoiceState.bind(this));
     __privateAdd(this, _lagMonitorTimeout, void 0);
     __privateAdd(this, _lagMonitorInterval, void 0);
+    this.id = import_discord3.SnowflakeUtil.generate().toString();
+    this.nodes = new GuildNodeManager(this);
+    this.voiceUtils = new VoiceUtils();
+    this.extractors = new ExtractorExecutionContext(this);
+    this.events = new PlayerEventsEmitter(["error", "playerError"]);
     this.client = client;
     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");
@@ -2126,21 +2274,30 @@ var _Player = class extends import_utils7.EventEmitter {
     };
     this.client.on("voiceStateUpdate", __privateGet(this, _voiceStateUpdateListener));
     if (this.options?.autoRegisterExtractor) {
-      let nv;
-      if (nv = Util.require("@discord-player/extractor")) {
-        ["YouTubeExtractor", "SoundCloudExtractor", "ReverbnationExtractor", "VimeoExtractor", "AttachmentExtractor"].forEach((ext) => void this.extractors.register(nv[ext]));
-      }
+      this.extractors.loadDefault().then((r) => {
+        if (r.error) {
+          this.emit("error", new Error(`Failed to load default extractors: ${r.error?.stack ?? r.error}`));
+        } else {
+          this.debug("Default extractors loaded!");
+        }
+        this.debug(`[Dependencies Report]
+${this.scanDeps()}`);
+      });
     }
     if (typeof this.options.lagMonitor === "number" && this.options.lagMonitor > 0) {
       __privateSet(this, _lagMonitorInterval, setInterval(() => {
         const start = performance.now();
         __privateSet(this, _lagMonitorTimeout, setTimeout(() => {
           __privateSet(this, _lastLatency, performance.now() - start);
+          this.debug(`[Lag Monitor] Event loop latency: ${__privateGet(this, _lastLatency)}ms`);
         }, 0).unref());
       }, this.options.lagMonitor).unref());
     }
     addPlayer(this);
   }
+  debug(m) {
+    return this.emit("debug", m);
+  }
   static singleton(client, options = {}) {
     if (!(kSingleton in _Player)) {
       Object.defineProperty(_Player, kSingleton, {
@@ -2321,7 +2478,8 @@ var _Player = class extends import_utils7.EventEmitter {
     if (options.requestedBy != null)
       options.requestedBy = this.client.users.resolve(options.requestedBy);
     options.blockExtractors ?? (options.blockExtractors = this.options.blockExtractors);
-    if (query instanceof Track)
+    if (query instanceof Track) {
+      this.debug(`Searching ${query.title}`);
       return new SearchResult(this, {
         playlist: query.playlist || null,
         tracks: [query],
@@ -2330,9 +2488,13 @@ var _Player = class extends import_utils7.EventEmitter {
         queryType: query.queryType,
         requestedBy: options.requestedBy
       });
+    }
+    this.debug(`Searching ${query}`);
     let extractor = null;
     options.searchEngine ?? (options.searchEngine = QueryType.AUTO);
+    this.debug(`Search engine set to ${options.searchEngine}`);
     const queryType = options.searchEngine === QueryType.AUTO ? QueryResolver.resolve(query) : options.searchEngine;
+    this.debug(`Query type identified as ${queryType}`);
     if (options.searchEngine.startsWith("ext:")) {
       extractor = this.extractors.get(options.searchEngine.substring(4));
       if (!extractor)
@@ -2340,14 +2502,19 @@ var _Player = class extends import_utils7.EventEmitter {
     }
     if (!extractor) {
       if (!options.ignoreCache) {
+        this.debug(`Checking cache...`);
         const res2 = await this.queryCache?.resolve({
           query,
           queryType,
           requestedBy: options.requestedBy
         });
-        if (res2?.hasTracks())
+        if (res2?.hasTracks()) {
+          this.debug(`Cache hit for query ${query}`);
           return res2;
+        }
+        this.debug(`Cache miss for query ${query}`);
       }
+      this.debug(`Executing extractors...`);
       extractor = (await this.extractors.run(async (ext) => {
         if (options.blockExtractors?.includes(ext.identifier))
           return false;
@@ -2355,13 +2522,16 @@ var _Player = class extends import_utils7.EventEmitter {
       }))?.extractor || null;
     }
     if (!extractor) {
+      this.debug("Failed to find appropriate extractor");
       return new SearchResult(this, { query, queryType });
     }
+    this.debug(`Executing metadata query using ${extractor.identifier} extractor...`);
     const res = await extractor.handle(query, {
       type: queryType,
       requestedBy: options.requestedBy
     }).catch(() => null);
     if (res) {
+      this.debug("Metadata query was successful!");
       const result2 = new SearchResult(this, {
         query,
         queryType,
@@ -2370,18 +2540,23 @@ var _Player = class extends import_utils7.EventEmitter {
         extractor
       });
       if (!options.ignoreCache) {
+        this.debug(`Adding data to cache...`);
         await this.queryCache?.addData(result2);
       }
       return result2;
     }
+    this.debug("Failed to find result using appropriate extractor. Querying all extractors...");
     const result = await this.extractors.run(
       async (ext) => !options.blockExtractors?.includes(ext.identifier) && await ext.validate(query) && ext.handle(query, {
         type: queryType,
         requestedBy: options.requestedBy
       })
     );
-    if (!result?.result)
+    if (!result?.result) {
+      this.debug(`Failed to query metadata query using ${result?.extractor.identifier || "N/A"} extractor.`);
       return new SearchResult(this, { query, queryType });
+    }
+    this.debug(`Metadata query was successful using ${result.extractor.identifier}!`);
     const data = new SearchResult(this, {
       query,
       queryType,
@@ -2390,13 +2565,14 @@ var _Player = class extends import_utils7.EventEmitter {
       extractor: result.extractor
     });
     if (!options.ignoreCache) {
+      this.debug(`Adding data to cache...`);
       await this.queryCache?.addData(data);
     }
     return data;
   }
   scanDeps() {
     const line = "-".repeat(50);
-    const depsReport = (0, import_voice5.generateDependencyReport)();
+    const depsReport = (0, import_voice6.generateDependencyReport)();
     const extractorReport = this.extractors.store.map((m) => {
       return m.identifier;
     }).join("\n");
@@ -2405,15 +2581,6 @@ Loaded Extractors:
 ${extractorReport || "None"}
 ${line}`;
   }
-  emit(eventName, ...args) {
-    if (this.requiredEvents.includes(eventName) && !super.eventNames().includes(eventName)) {
-      console.error(...args);
-      Util.warn(`Unhandled "${eventName}" event! Events ${this.requiredEvents.map((m) => `"${m}"`).join(", ")} must have event listeners!`, "UnhandledEventWarning");
-      return false;
-    } else {
-      return super.emit(eventName, ...args);
-    }
-  }
   *[Symbol.iterator]() {
     yield* this.nodes.cache.values();
   }
@@ -2431,7 +2598,7 @@ Player._singletonKey = kSingleton;
 
 // src/index.ts
 var import_equalizer3 = require("@discord-player/equalizer");
-var version = "6.0.0-dev.3";
+var version = "6.0.0-dev.4";
 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`);
 }
@@ -2444,7 +2611,6 @@ if (!import_discord4.version.startsWith("14")) {
   BASS_EQ_BANDS,
   BaseExtractor,
   BiquadFilterType,
-  BiquadFilters,
   DiscordPlayerQueryResultCache,
   EqualizerConfigurationPreset,
   ErrorStatusCode,
@@ -2460,9 +2626,9 @@ if (!import_discord4.version.startsWith("14")) {
   GuildQueueHistory,
   GuildQueuePlayerNode,
   PCMAudioFilters,
-  PCMFilters,
   Player,
   PlayerError,
+  PlayerEventsEmitter,
   Playlist,
   Q_BUTTERWORTH,
   QueryCache,
@@ -2472,6 +2638,7 @@ if (!import_discord4.version.startsWith("14")) {
   StreamDispatcher,
   Track,
   Util,
+  VoiceReceiverNode,
   VoiceUtils,
   VolumeTransformer,
   createFFmpegStream,