discord-player 6.0.0-dev.4 → 6.0.0

package/dist/index.js

@@ -68,15 +68,18 @@ __export(src_exports, {
   GuildNodeManager: () => GuildNodeManager,
   GuildQueue: () => GuildQueue,
   GuildQueueAudioFilters: () => GuildQueueAudioFilters,
+  GuildQueueEvent: () => GuildQueueEvent,
   GuildQueueHistory: () => GuildQueueHistory,
   GuildQueuePlayerNode: () => GuildQueuePlayerNode,
   PCMAudioFilters: () => import_equalizer3.AudioFilters,
   Player: () => Player,
   PlayerError: () => PlayerError,
+  PlayerEvent: () => PlayerEvent,
   PlayerEventsEmitter: () => PlayerEventsEmitter,
   Playlist: () => Playlist,
   Q_BUTTERWORTH: () => import_equalizer3.Q_BUTTERWORTH,
   QueryCache: () => QueryCache,
+  QueryResolver: () => QueryResolver,
   QueryType: () => QueryType,
   QueueRepeatMode: () => QueueRepeatMode,
   SearchResult: () => SearchResult,
@@ -87,7 +90,11 @@ __export(src_exports, {
   VoiceUtils: () => VoiceUtils,
   VolumeTransformer: () => import_equalizer3.VolumeTransformer,
   createFFmpegStream: () => createFFmpegStream,
-  version: () => version
+  useHistory: () => useHistory,
+  useMasterPlayer: () => useMasterPlayer,
+  usePlayer: () => usePlayer,
+  useQueue: () => useQueue,
+  version: () => version2
 });
 module.exports = __toCommonJS(src_exports);
 var import_discord4 = require("discord.js");
@@ -171,6 +178,9 @@ var Util = class {
       detail
     });
   }
+  static randomChoice(src) {
+    return src[Math.floor(Math.random() * src.length)];
+  }
 };
 __name(Util, "Util");
 
@@ -313,7 +323,15 @@ BaseExtractor.identifier = "com.discord-player.extractor";
 
 // src/extractors/ExtractorExecutionContext.ts
 var import_utils2 = require("@discord-player/utils");
-var knownExtractorKeys = ["YouTubeExtractor", "SoundCloudExtractor", "ReverbnationExtractor", "VimeoExtractor", "AttachmentExtractor"];
+var knownExtractorKeys = [
+  "SoundCloudExtractor",
+  "AppleMusicExtractor",
+  "SpotifyExtractor",
+  "VimeoExtractor",
+  "YouTubeExtractor",
+  "ReverbnationExtractor",
+  "AttachmentExtractor"
+];
 var knownExtractorLib = "@discord-player/extractor";
 var ExtractorExecutionContext = class {
   constructor(player) {
@@ -487,6 +505,12 @@ var Playlist = class {
   *[Symbol.iterator]() {
     yield* this.tracks;
   }
+  get estimatedDuration() {
+    return this.tracks.reduce((p, c) => p + c.durationMS, 0);
+  }
+  get durationFormatted() {
+    return Util.buildTimeCode(Util.parseMS(this.estimatedDuration));
+  }
   toJSON(withTracks = true) {
     const payload = {
       id: this.id,
@@ -525,6 +549,12 @@ var GuildQueueHistory = class {
   get disabled() {
     return this.queue.options.disableHistory;
   }
+  get size() {
+    return this.tracks.size;
+  }
+  getSize() {
+    return this.size;
+  }
   isEmpty() {
     return this.tracks.size < 1;
   }
@@ -544,14 +574,14 @@ var GuildQueueHistory = class {
     }
     this.queue.node.skip();
   }
-  async previous() {
+  async previous(preserveCurrent = true) {
     const track = this.tracks.dispatch();
     if (!track) {
       throw new Error("No previous track in the queue");
     }
     const current = this.currentTrack;
     await this.queue.node.play(track, { queue: false });
-    if (current)
+    if (current && preserveCurrent)
       this.queue.node.insert(current, 0);
   }
   back() {
@@ -587,8 +617,15 @@ var QueryType = {
   APPLE_MUSIC_SONG: "appleMusicSong",
   APPLE_MUSIC_ALBUM: "appleMusicAlbum",
   APPLE_MUSIC_PLAYLIST: "appleMusicPlaylist",
+  APPLE_MUSIC_SEARCH: "appleMusicSearch",
   FILE: "file"
 };
+var PlayerEvent = /* @__PURE__ */ ((PlayerEvent2) => {
+  PlayerEvent2["debug"] = "debug";
+  PlayerEvent2["error"] = "error";
+  PlayerEvent2["voiceStateUpdate"] = "voiceStateUpdate";
+  return PlayerEvent2;
+})(PlayerEvent || {});
 var QueueRepeatMode = /* @__PURE__ */ ((QueueRepeatMode2) => {
   QueueRepeatMode2[QueueRepeatMode2["OFF"] = 0] = "OFF";
   QueueRepeatMode2[QueueRepeatMode2["TRACK"] = 1] = "TRACK";
@@ -625,10 +662,10 @@ var QueryResolver = class {
     };
   }
   static resolve(query) {
-    query = query.trim();
-    if (soundcloud.validateURL(query, "track"))
+    query = !query.includes("youtube.com") ? query.trim() : query.replace(/(m(usic)?|gaming)\./, "").trim();
+    if ((soundcloud.validateURL || soundcloud.default.validateURL)(query, "track"))
       return QueryType.SOUNDCLOUD_TRACK;
-    if (soundcloud.validateURL(query, "playlist") || query.includes("/sets/"))
+    if ((soundcloud.validateURL || soundcloud.default.validateURL)(query, "playlist") || query.includes("/sets/"))
       return QueryType.SOUNDCLOUD_PLAYLIST;
     if (import_youtube_sr.YouTube.isPlaylist(query))
       return QueryType.YOUTUBE_PLAYLIST;
@@ -809,6 +846,7 @@ var GuildQueuePlayerNode = class {
     if (!foundTrack)
       return null;
     this.queue.tracks.removeOne((t) => t.id === foundTrack.id);
+    this.queue.player.events.emit("audioTrackRemove", this.queue, foundTrack);
     return foundTrack;
   }
   jump(track) {
@@ -835,15 +873,20 @@ var GuildQueuePlayerNode = class {
     const removed = this.remove(idx);
     if (!removed)
       return false;
+    const toRemove = this.queue.tracks.store.filter((_, i) => i <= idx);
     this.queue.tracks.store.splice(0, idx, removed);
+    this.queue.player.events.emit("audioTracksRemove", this.queue, toRemove);
     return this.skip();
   }
   insert(track, index = 0) {
     if (!(track instanceof Track))
       throw new Error("invalid track");
     this.queue.tracks.store.splice(index, 0, track);
+    this.queue.player.events.emit("audioTrackAdd", this.queue, track);
   }
   stop(force = false) {
+    this.queue.tracks.clear();
+    this.queue.history.clear();
     if (!this.queue.dispatcher)
       return false;
     this.queue.dispatcher.end();
@@ -879,7 +922,7 @@ var GuildQueuePlayerNode = class {
     );
     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);
+      return this.queue.addTrack(res);
     }
     const track = res || this.queue.tracks.dispatch();
     if (!track) {
@@ -908,7 +951,7 @@ var GuildQueuePlayerNode = class {
           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());
+          this.play(this.queue.tracks.dispatch(), { queue: false });
           return;
         }
         throw error;
@@ -1070,7 +1113,7 @@ function createFFmpegStream(stream, options) {
     args.unshift("-ss", String(options.seek));
   if (Array.isArray(options.encoderArgs))
     args.push(...options.encoderArgs);
-  const transcoder = new prism.FFmpeg({ shell: false, args });
+  const transcoder = new (prism.FFmpeg || prism.default.FFmpeg)({ shell: false, args });
   transcoder.on("close", () => transcoder.destroy());
   if (typeof stream !== "string") {
     stream.on("error", () => transcoder.destroy());
@@ -1303,7 +1346,7 @@ var GuildQueueStatistics = class {
       memoryUsage: process.memoryUsage(),
       versions: {
         node: process.version,
-        player: "6.0.0-dev.4"
+        player: "6.0.0"
       }
     };
   }
@@ -1311,6 +1354,25 @@ var GuildQueueStatistics = class {
 __name(GuildQueueStatistics, "GuildQueueStatistics");
 
 // src/Structures/GuildQueue.ts
+var GuildQueueEvent = /* @__PURE__ */ ((GuildQueueEvent2) => {
+  GuildQueueEvent2["audioTrackAdd"] = "audioTrackadd";
+  GuildQueueEvent2["audioTracksAdd"] = "audioTracksAdd";
+  GuildQueueEvent2["audioTrackRemove"] = "audioTrackRemove";
+  GuildQueueEvent2["audioTracksRemove"] = "audioTracksRemove";
+  GuildQueueEvent2["connection"] = "connection";
+  GuildQueueEvent2["disconnect"] = "disconnect";
+  GuildQueueEvent2["debug"] = "debug";
+  GuildQueueEvent2["error"] = "error";
+  GuildQueueEvent2["emptyChannel"] = "emptyChannel";
+  GuildQueueEvent2["emptyQueue"] = "emptyQueue";
+  GuildQueueEvent2["playerStart"] = "playerStart";
+  GuildQueueEvent2["playerError"] = "playerError";
+  GuildQueueEvent2["playerFinish"] = "playerFinish";
+  GuildQueueEvent2["playerSkip"] = "playerSkip";
+  GuildQueueEvent2["playerTrigger"] = "playerTrigger";
+  GuildQueueEvent2["voiceStateUpdate"] = "voiceStateUpdate";
+  return GuildQueueEvent2;
+})(GuildQueueEvent || {});
 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) {
@@ -1365,6 +1427,12 @@ var GuildQueue = class {
     }
     this.debug(`GuildQueue initialized for guild ${this.options.guild.name} (ID: ${this.options.guild.id})`);
   }
+  get estimatedDuration() {
+    return this.tracks.store.reduce((a, c) => a + c.durationMS, 0);
+  }
+  get durationFormatted() {
+    return Util.buildTimeCode(Util.parseMS(this.estimatedDuration));
+  }
   get voiceReceiver() {
     return this.dispatcher?.receiver ?? null;
   }
@@ -1424,18 +1492,27 @@ var GuildQueue = class {
   setRepeatMode(mode) {
     this.repeatMode = mode;
   }
+  get size() {
+    return this.tracks.size;
+  }
+  getSize() {
+    return this.size;
+  }
+  clear() {
+    this.tracks.clear();
+    this.history.clear();
+  }
   isEmpty() {
     return this.tracks.size < 1;
   }
   isPlaying() {
-    return this.dispatcher?.audioResource != null;
+    return this.dispatcher?.audioResource != null && !this.dispatcher.audioResource.ended;
   }
   addTrack(track) {
     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);
@@ -1531,7 +1608,14 @@ removeListeners_fn = /* @__PURE__ */ __name(function(dispatcher) {
 _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");
+  const reason = this.isTransitioning() ? "filters" : "normal";
+  this.debug(
+    `Player triggered for Track ${JSON.stringify({
+      title: track?.title,
+      reason
+    })}`
+  );
+  this.player.events.emit("playerTrigger", this, track, reason);
   if (track && !this.isTransitioning())
     this.player.events.emit("playerStart", this, track);
   this.setTransitioning(false);
@@ -1540,25 +1624,38 @@ performStart_fn = /* @__PURE__ */ __name(function(resource) {
 _performFinish = new WeakSet();
 performFinish_fn = /* @__PURE__ */ __name(function(resource) {
   const track = resource?.metadata || this.currentTrack;
+  this.debug(
+    `Track ${JSON.stringify({
+      title: track?.title,
+      isTransitionMode: this.isTransitioning()
+    })} was marked as finished`
+  );
   if (track && !this.isTransitioning()) {
+    this.debug("Adding track to history and emitting finish event since transition mode is disabled...");
     this.history.push(track);
     this.node.resetProgress();
     this.player.events.emit("playerFinish", this, track);
     if (this.tracks.size < 1 && this.repeatMode === 0 /* OFF */) {
+      this.debug("No more tracks left in the queue to play and repeat mode is off, initiating #emitEnd()");
       __privateMethod(this, _emitEnd, emitEnd_fn).call(this);
     } else {
       if (this.repeatMode === 1 /* TRACK */) {
+        this.debug("Repeat mode is set to track, repeating last track from the history...");
         this.__current = this.history.tracks.dispatch() || track;
         return this.node.play(this.__current, { queue: false });
       }
-      if (this.repeatMode === 2 /* QUEUE */)
+      if (this.repeatMode === 2 /* QUEUE */) {
+        this.debug("Repeat mode is set to queue, moving last track from the history to current queue...");
         this.tracks.add(this.history.tracks.dispatch() || track);
+      }
       if (!this.tracks.size) {
         if (this.repeatMode === 3 /* AUTOPLAY */) {
+          this.debug("Repeat mode is set to autoplay, initiating autoplay handler...");
           __privateMethod(this, _handleAutoplay, handleAutoplay_fn).call(this, track);
           return;
         }
       } else {
+        this.debug("Initializing next track of the queue...");
         this.__current = this.tracks.dispatch();
         this.node.play(this.__current, {
           queue: false
@@ -1581,9 +1678,9 @@ emitEnd_fn = /* @__PURE__ */ __name(function() {
 }, "#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);
+  let info = await import_youtube_sr2.YouTube.getVideo(track.url).then((x) => Util.randomChoice(x.videos.slice(0, 5))).catch(Util.noop);
   if (!info)
-    info = await import_youtube_sr2.YouTube.search(track.author).then((x) => x[0]).catch(Util.noop);
+    info = await import_youtube_sr2.YouTube.search(track.author, { limit: 5, type: "video" }).then((x) => Util.randomChoice(x)).catch(Util.noop);
   if (!info) {
     return __privateMethod(this, _emitEnd, emitEnd_fn).call(this);
   }
@@ -1757,7 +1854,7 @@ var VoiceReceiverNode = class {
         setImmediate(async () => {
           if (options.mode === "pcm") {
             const pcm = receiveStream.pipe(
-              new prism2.opus.Decoder({
+              new (prism2.opus || prism2.default.opus).Decoder({
                 channels: 2,
                 frameSize: 960,
                 rate: 48e3
@@ -1784,6 +1881,30 @@ var SearchResult = class {
       track.extractor = this._data.extractor || null;
     });
   }
+  setQueryType(type) {
+    this._data.queryType = type;
+    return this;
+  }
+  setRequestedBy(user) {
+    this._data.requestedBy = user;
+    return this;
+  }
+  setExtractor(extractor) {
+    this._data.extractor = extractor;
+    return this;
+  }
+  setTracks(tracks) {
+    this._data.tracks = tracks;
+    return this;
+  }
+  setQuery(query) {
+    this._data.query = query;
+    return this;
+  }
+  setPlaylist(playlist) {
+    this._data.playlist = playlist;
+    return this;
+  }
   get query() {
     return this._data.query;
   }
@@ -1884,6 +2005,14 @@ var import_voice5 = require("@discordjs/voice");
 var import_voice4 = require("@discordjs/voice");
 var import_utils6 = require("@discord-player/utils");
 var import_equalizer2 = require("@discord-player/equalizer");
+var needsKeepAlivePatch = (() => {
+  if ("DP_NO_KEEPALIVE_PATCH" in process.env)
+    return false;
+  if (import_voice4.version.includes("-dev") || import_voice4.version.startsWith("1"))
+    return false;
+  const [_major, minor, patch] = import_voice4.version.split(".").map((n) => parseInt(n));
+  return minor > 14 ? false : minor < 15 && patch < 1;
+})();
 var StreamDispatcher = class extends import_utils6.EventEmitter {
   constructor(connection, channel, queue, connectionTimeout = 2e4) {
     super();
@@ -1895,6 +2024,10 @@ var StreamDispatcher = class extends import_utils6.EventEmitter {
     this.voiceConnection = connection;
     this.audioPlayer = (0, import_voice4.createAudioPlayer)();
     this.channel = channel;
+    this.voiceConnection.on("debug", (m) => void this.emit("debug", m));
+    this.voiceConnection.on("error", (error) => void this.emit("error", error));
+    this.audioPlayer.on("debug", (m) => void this.emit("debug", m));
+    this.audioPlayer.on("error", (error) => void this.emit("error", error));
     this.dsp.onUpdate = () => {
       if (!this.dsp)
         return;
@@ -1910,14 +2043,26 @@ var StreamDispatcher = class extends import_utils6.EventEmitter {
         this.emit("sampleRate", this.dsp.resampler.targetSampleRate);
     };
     this.dsp.onError = (e) => this.emit("error", e);
-    this.voiceConnection.on("stateChange", async (_, newState) => {
+    this.voiceConnection.on("stateChange", async (oldState, newState) => {
+      if (needsKeepAlivePatch) {
+        this.queue.debug(`Detected @discordjs/voice version ${import_voice4.version} which needs keepAlive patch, applying patch...`);
+        const oldNetworking = Reflect.get(oldState, "networking");
+        const newNetworking = Reflect.get(newState, "networking");
+        const networkStateChangeHandler = /* @__PURE__ */ __name((_, newNetworkState) => {
+          const newUdp = Reflect.get(newNetworkState, "udp");
+          clearInterval(newUdp?.keepAliveInterval);
+        }, "networkStateChangeHandler");
+        oldNetworking?.off("stateChange", networkStateChangeHandler);
+        newNetworking?.on("stateChange", networkStateChangeHandler);
+      }
       if (newState.status === import_voice4.VoiceConnectionStatus.Disconnected) {
         if (newState.reason === import_voice4.VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
           try {
             await (0, import_voice4.entersState)(this.voiceConnection, import_voice4.VoiceConnectionStatus.Connecting, this.connectionTimeout);
           } catch {
             try {
-              this.voiceConnection.destroy();
+              if (this.voiceConnection.state.status !== import_voice4.VoiceConnectionStatus.Destroyed)
+                this.voiceConnection.destroy();
             } catch (err) {
               this.emit("error", err);
             }
@@ -1927,7 +2072,8 @@ var StreamDispatcher = class extends import_utils6.EventEmitter {
           this.voiceConnection.rejoin();
         } else {
           try {
-            this.voiceConnection.destroy();
+            if (this.voiceConnection.state.status !== import_voice4.VoiceConnectionStatus.Destroyed)
+              this.voiceConnection.destroy();
           } catch (err) {
             this.emit("error", err);
           }
@@ -1962,8 +2108,6 @@ var StreamDispatcher = class extends import_utils6.EventEmitter {
         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() {
@@ -1984,6 +2128,21 @@ var StreamDispatcher = class extends import_utils6.EventEmitter {
   isIdle() {
     return this.audioPlayer.state.status === import_voice4.AudioPlayerStatus.Idle;
   }
+  isDestroyed() {
+    return this.voiceConnection.state.status === import_voice4.VoiceConnectionStatus.Destroyed;
+  }
+  isDisconnected() {
+    return this.voiceConnection.state.status === import_voice4.VoiceConnectionStatus.Disconnected;
+  }
+  isReady() {
+    return this.voiceConnection.state.status === import_voice4.VoiceConnectionStatus.Ready;
+  }
+  isSignalling() {
+    return this.voiceConnection.state.status === import_voice4.VoiceConnectionStatus.Signalling;
+  }
+  isConnecting() {
+    return this.voiceConnection.state.status === import_voice4.VoiceConnectionStatus.Connecting;
+  }
   async createStream(src, ops) {
     if (!ops?.disableFilters)
       this.queue.debug("Initiating DSP filters pipeline...");
@@ -2043,12 +2202,16 @@ var StreamDispatcher = class extends import_utils6.EventEmitter {
     try {
       if (this.audioPlayer)
         this.audioPlayer.stop(true);
-      this.voiceConnection.destroy();
+      if (this.voiceConnection.state.status !== import_voice4.VoiceConnectionStatus.Destroyed)
+        this.voiceConnection.destroy();
     } catch {
     }
   }
   end() {
-    this.audioPlayer.stop();
+    try {
+      this.audioPlayer.stop();
+    } catch {
+    }
   }
   pause(interpolateSilence) {
     const success = this.audioPlayer.pause(interpolateSilence);
@@ -2101,7 +2264,8 @@ __name(StreamDispatcher, "StreamDispatcher");
 // src/VoiceInterface/VoiceUtils.ts
 var import_utils7 = require("@discord-player/utils");
 var VoiceUtils = class {
-  constructor() {
+  constructor(player) {
+    this.player = player;
     this.cache = new import_utils7.Collection();
   }
   async connect(channel, options) {
@@ -2117,14 +2281,19 @@ var VoiceUtils = class {
       guildId: channel.guild.id,
       channelId: channel.id,
       adapterCreator: channel.guild.voiceAdapterCreator,
-      selfDeaf: Boolean(options?.deaf)
+      selfDeaf: Boolean(options?.deaf),
+      debug: this.player.events.eventNames().includes("debug")
     });
     return conn;
   }
   disconnect(connection) {
     if (connection instanceof StreamDispatcher)
-      return connection.voiceConnection.destroy();
-    return connection.destroy();
+      connection = connection.voiceConnection;
+    try {
+      if (connection.state.status !== import_voice5.VoiceConnectionStatus.Destroyed)
+        return connection.destroy();
+    } catch {
+    }
   }
   getConnection(guild) {
     return this.cache.get(guild) || (0, import_voice5.getVoiceConnection)(guild);
@@ -2133,7 +2302,6 @@ var VoiceUtils = class {
 __name(VoiceUtils, "VoiceUtils");
 
 // src/utils/QueryCache.ts
-var import_fuse = __toESM(require("fuse.js"));
 var DEFAULT_EXPIRY_TIMEOUT = 18e6;
 var _defaultCache;
 var QueryCache = class {
@@ -2143,11 +2311,6 @@ var QueryCache = class {
     this.player = player;
     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();
   }
   get checkInterval() {
@@ -2174,10 +2337,8 @@ var QueryCache = class {
     });
   }
   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)
+    const result = __privateGet(this, _defaultCache).get(context.query);
+    if (!result)
       return new SearchResult(this.player, {
         query: context.query,
         requestedBy: context.requestedBy,
@@ -2185,7 +2346,7 @@ var QueryCache = class {
       });
     return new SearchResult(this.player, {
       query: context.query,
-      tracks: result.map((m) => m.item),
+      tracks: [result.data],
       playlist: null,
       queryType: context.queryType,
       requestedBy: context.requestedBy
@@ -2215,7 +2376,8 @@ var import_discord3 = require("discord.js");
 var import_voice6 = require("@discordjs/voice");
 
 // src/utils/__internal__/_container.ts
-var instances = /* @__PURE__ */ new Map();
+var import_utils8 = require("@discord-player/utils");
+var instances = new import_utils8.Collection();
 
 // src/utils/__internal__/addPlayer.ts
 function addPlayer(player) {
@@ -2234,7 +2396,7 @@ __name(clearPlayer, "clearPlayer");
 
 // src/utils/__internal__/getPlayers.ts
 function getPlayers() {
-  return [...instances.values()];
+  return instances.array();
 }
 __name(getPlayers, "getPlayers");
 
@@ -2243,6 +2405,8 @@ var kSingleton = Symbol("InstanceDiscordPlayerSingleton");
 var _lastLatency, _voiceStateUpdateListener, _lagMonitorTimeout, _lagMonitorInterval;
 var _Player = class extends PlayerEventsEmitter {
   constructor(client, options = {}) {
+    if (!options.ignoreInstance && kSingleton in _Player)
+      return _Player[kSingleton];
     super(["error"]);
     __privateAdd(this, _lastLatency, -1);
     __privateAdd(this, _voiceStateUpdateListener, this.handleVoiceState.bind(this));
@@ -2250,7 +2414,7 @@ var _Player = class extends PlayerEventsEmitter {
     __privateAdd(this, _lagMonitorInterval, void 0);
     this.id = import_discord3.SnowflakeUtil.generate().toString();
     this.nodes = new GuildNodeManager(this);
-    this.voiceUtils = new VoiceUtils();
+    this.voiceUtils = new VoiceUtils(this);
     this.extractors = new ExtractorExecutionContext(this);
     this.events = new PlayerEventsEmitter(["error", "playerError"]);
     this.client = client;
@@ -2294,20 +2458,23 @@ ${this.scanDeps()}`);
       }, 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, {
-        value: new _Player(client, options),
+        value: this,
         writable: true,
         configurable: true,
         enumerable: false
       });
     }
-    return _Player[kSingleton];
+  }
+  debug(m) {
+    return this.emit("debug", m);
+  }
+  static singleton(client, options = {}) {
+    return new _Player(client, {
+      ...options,
+      ignoreInstance: false
+    });
   }
   static getAllPlayers() {
     return getPlayers();
@@ -2351,20 +2518,20 @@ ${this.scanDeps()}`);
     const wasHandled = this.events.emit("voiceStateUpdate", queue, oldState, newState);
     if (wasHandled && !this.options.lockVoiceStateHandler)
       return;
-    if (oldState.channelId && !newState.channelId && newState.member.id === newState.guild.members.me.id) {
+    if (oldState.channelId && !newState.channelId && newState.member?.id === newState.guild.members.me?.id) {
       try {
         queue.delete();
       } catch {
       }
       return void this.events.emit("disconnect", queue);
     }
-    if (!oldState.channelId && newState.channelId && newState.member.id === newState.guild.members.me.id) {
+    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_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);
+          newState.guild.members.me?.voice.setRequestToSpeak(true).catch(Util.noop);
         }
       }
     }
@@ -2391,8 +2558,8 @@ ${this.scanDeps()}`);
       }
     }
     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)
+      if (newState.member?.id === newState.guild.members.me?.id) {
+        if (queue.connection && newState.member?.id === newState.guild.members.me?.id)
           queue.channel = newState.channel;
         const emptyTimeout = queue.timeouts.get(`empty_${oldState.guild.id}`);
         const channelEmpty = Util.isVoiceEmpty(queue.channel);
@@ -2454,19 +2621,21 @@ ${this.scanDeps()}`);
     const vc = this.client.channels.resolve(channel);
     if (!vc?.isVoiceBased())
       throw new Error("Expected a voice channel");
-    const result = query instanceof SearchResult ? query : await this.search(query, options);
+    const originalResult = query instanceof SearchResult ? query : await this.search(query, options);
+    const result = await options.afterSearch?.(originalResult) || originalResult;
     if (result.isEmpty()) {
       throw new Error(`No results found for "${query}" (Extractor: ${result.extractor?.identifier || "N/A"})`);
     }
     const queue = this.nodes.create(vc.guild, options.nodeOptions);
     if (!queue.channel)
       await queue.connect(vc, options.connectionOptions);
-    if (!result.hasPlaylist()) {
-      await queue.node.play(result.tracks[0]);
+    if (!result.playlist) {
+      queue.addTrack(result.tracks[0]);
     } else {
       queue.addTrack(result.playlist);
-      await queue.node.play();
     }
+    if (!queue.isPlaying())
+      await queue.node.play();
     return {
       track: result.tracks[0],
       extractor: result.extractor,
@@ -2475,20 +2644,42 @@ ${this.scanDeps()}`);
     };
   }
   async search(query, options = {}) {
+    if (query instanceof SearchResult)
+      return query;
     if (options.requestedBy != null)
       options.requestedBy = this.client.users.resolve(options.requestedBy);
     options.blockExtractors ?? (options.blockExtractors = this.options.blockExtractors);
     if (query instanceof Track) {
-      this.debug(`Searching ${query.title}`);
       return new SearchResult(this, {
         playlist: query.playlist || null,
         tracks: [query],
-        query: query.toString(),
+        query: query.title,
         extractor: null,
         queryType: query.queryType,
         requestedBy: options.requestedBy
       });
     }
+    if (query instanceof Playlist) {
+      return new SearchResult(this, {
+        playlist: query,
+        tracks: query.tracks,
+        query: query.title,
+        extractor: null,
+        queryType: QueryType.AUTO,
+        requestedBy: options.requestedBy
+      });
+    }
+    if (Array.isArray(query)) {
+      const tracks = query.filter((t) => t instanceof Track);
+      return new SearchResult(this, {
+        playlist: null,
+        tracks,
+        query: "@@#%{{UserLoadedContent}}%#@@",
+        extractor: null,
+        queryType: QueryType.AUTO,
+        requestedBy: options.requestedBy
+      });
+    }
     this.debug(`Searching ${query}`);
     let extractor = null;
     options.searchEngine ?? (options.searchEngine = QueryType.AUTO);
@@ -2596,11 +2787,55 @@ _lagMonitorTimeout = new WeakMap();
 _lagMonitorInterval = new WeakMap();
 Player._singletonKey = kSingleton;
 
+// src/hooks/common.ts
+var getPlayer = /* @__PURE__ */ __name(() => {
+  return instances.first() || null;
+}, "getPlayer");
+var getQueue = /* @__PURE__ */ __name((node) => {
+  const player = getPlayer();
+  if (!player)
+    return null;
+  return player.nodes.resolve(node) || null;
+}, "getQueue");
+
+// src/hooks/useHistory.ts
+function useHistory(node) {
+  const queue = getQueue(node);
+  if (!queue)
+    return null;
+  return queue.history;
+}
+__name(useHistory, "useHistory");
+
+// src/hooks/usePlayer.ts
+function usePlayer(node) {
+  const queue = getQueue(node);
+  if (!queue)
+    return null;
+  return queue.node;
+}
+__name(usePlayer, "usePlayer");
+
+// src/hooks/useQueue.ts
+function useQueue(node) {
+  const queue = getQueue(node);
+  if (!queue)
+    return null;
+  return queue;
+}
+__name(useQueue, "useQueue");
+
+// src/hooks/useMasterPlayer.ts
+function useMasterPlayer() {
+  return getPlayer();
+}
+__name(useMasterPlayer, "useMasterPlayer");
+
 // src/index.ts
 var import_equalizer3 = require("@discord-player/equalizer");
-var version = "6.0.0-dev.4";
+var version2 = "6.0.0";
 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`);
+  process.emitWarning(`Discord.js v${import_discord4.version} is incompatible with Discord Player v${version2}! Please use >=v14.x of Discord.js`);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2623,15 +2858,18 @@ if (!import_discord4.version.startsWith("14")) {
   GuildNodeManager,
   GuildQueue,
   GuildQueueAudioFilters,
+  GuildQueueEvent,
   GuildQueueHistory,
   GuildQueuePlayerNode,
   PCMAudioFilters,
   Player,
   PlayerError,
+  PlayerEvent,
   PlayerEventsEmitter,
   Playlist,
   Q_BUTTERWORTH,
   QueryCache,
+  QueryResolver,
   QueryType,
   QueueRepeatMode,
   SearchResult,
@@ -2642,6 +2880,10 @@ if (!import_discord4.version.startsWith("14")) {
   VoiceUtils,
   VolumeTransformer,
   createFFmpegStream,
+  useHistory,
+  useMasterPlayer,
+  usePlayer,
+  useQueue,
   version
 });
 //# sourceMappingURL=index.js.map