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

package/dist/index.d.ts

@@ -8,7 +8,6 @@ import * as _discord_player_equalizer from '@discord-player/equalizer';
 import { PCMFilters, EqualizerBand, BiquadFilters, FiltersChain } from '@discord-player/equalizer';
 export { AF_NIGHTCORE_RATE, AF_VAPORWAVE_RATE, BASS_EQ_BANDS, FilterType as BiquadFilterType, BiquadFilters, FiltersChain, AudioFilters as PCMAudioFilters, PCMFilters, Q_BUTTERWORTH, VolumeTransformer } from '@discord-player/equalizer';
 import { RequestOptions } from 'http';
-import Fuse from 'fuse.js';
 import { downloadOptions } from 'ytdl-core';
 
 declare class PlayerEventsEmitter<L extends ListenerSignature<L> = DefaultListener> extends EventEmitter<L> {
@@ -39,6 +38,14 @@ declare class Playlist {
      */
     constructor(player: Player, data: PlaylistInitData);
     [Symbol.iterator](): Generator<Track, void, undefined>;
+    /**
+     * Estimated duration of this playlist
+     */
+    get estimatedDuration(): number;
+    /**
+     * Formatted estimated duration of this playlist
+     */
+    get durationFormatted(): string;
     /**
      * JSON representation of this playlist
      * @param {boolean} [withTracks=true] If it should build json with tracks
@@ -258,6 +265,26 @@ declare class StreamDispatcher extends EventEmitter<VoiceEvents> {
      * Whether or not the player is currently idle
      */
     isIdle(): boolean;
+    /**
+     * Whether or not the voice connection has been destroyed
+     */
+    isDestroyed(): boolean;
+    /**
+     * Whether or not the voice connection has been destroyed
+     */
+    isDisconnected(): boolean;
+    /**
+     * Whether or not the voice connection is ready to play
+     */
+    isReady(): boolean;
+    /**
+     * Whether or not the voice connection is signalling
+     */
+    isSignalling(): boolean;
+    /**
+     * Whether or not the voice connection is connecting
+     */
+    isConnecting(): boolean;
     /**
      * Creates stream
      * @param {Readable} src The stream source
@@ -363,6 +390,11 @@ declare class GuildQueueHistory<Meta = unknown> {
      * If history is disabled
      */
     get disabled(): boolean;
+    /**
+     * Gets the size of the queue
+     */
+    get size(): number;
+    getSize(): number;
     /**
      * If history is empty
      */
@@ -383,7 +415,7 @@ declare class GuildQueueHistory<Meta = unknown> {
     /**
      * Play the previous track in the queue
      */
-    previous(): Promise<void>;
+    previous(preserveCurrent?: boolean): Promise<void>;
     /**
      * Alias to [GuildQueueHistory].previous()
      */
@@ -772,6 +804,18 @@ interface GuildQueueEvents<Meta = unknown> {
      * @param tracks The tracks array
      */
     audioTracksAdd: (queue: GuildQueue<Meta>, track: Track[]) => unknown;
+    /**
+     * Emitted when audio track is removed from the queue
+     * @param queue The queue where this event occurred
+     * @param track The track
+     */
+    audioTrackRemove: (queue: GuildQueue<Meta>, track: Track) => unknown;
+    /**
+     * Emitted when audio tracks are removed from the queue
+     * @param queue The queue where this event occurred
+     * @param track The track
+     */
+    audioTracksRemove: (queue: GuildQueue<Meta>, track: Track[]) => unknown;
     /**
      * Emitted when a connection is created
      * @param queue The queue where this event occurred
@@ -859,6 +903,14 @@ declare class GuildQueue<Meta = unknown> {
     timeouts: Collection<string, NodeJS.Timeout>;
     stats: GuildQueueStatistics<Meta>;
     constructor(player: Player, options: GuildNodeInit<Meta>);
+    /**
+     * Estimated duration of this queue in ms
+     */
+    get estimatedDuration(): number;
+    /**
+     * Formatted duration of this queue
+     */
+    get durationFormatted(): string;
     /**
      * The voice receiver for this queue
      */
@@ -922,6 +974,18 @@ declare class GuildQueue<Meta = unknown> {
      * @param mode The repeat mode to apply
      */
     setRepeatMode(mode: QueueRepeatMode): void;
+    /**
+     * Gets the size of the queue
+     */
+    get size(): number;
+    /**
+     * The size of this queue
+     */
+    getSize(): number;
+    /**
+     * Clear this queue
+     */
+    clear(): void;
     /**
      * Check if this queue has no tracks left in it
      */
@@ -931,7 +995,7 @@ declare class GuildQueue<Meta = unknown> {
      */
     isPlaying(): boolean;
     /**
-     * Add track to the queue
+     * Add track to the queue. This will emit `audioTracksAdd` when multiple tracks are added, otherwise `audioTrackAdd`.
      * @param track Track or playlist or array of tracks to add
      */
     addTrack(track: Track | Track[] | Playlist): void;
@@ -1067,6 +1131,12 @@ declare class SearchResult {
     player: Player;
     private _data;
     constructor(player: Player, _data: SearchResultData);
+    setQueryType(type: SearchQueryType | QueryExtractorSearch): this;
+    setRequestedBy(user: User): this;
+    setExtractor(extractor: BaseExtractor): this;
+    setTracks(tracks: Track[]): this;
+    setQuery(query: string): this;
+    setPlaylist(playlist: Playlist): this;
     /**
      * The search query
      */
@@ -1128,7 +1198,6 @@ declare class QueryCache {
     player: Player;
     options: QueryCacheOptions;
     timer: NodeJS.Timer;
-    fuse: Fuse<Track>;
     constructor(player: Player, options?: QueryCacheOptions);
     get checkInterval(): number;
     cleanup(): Promise<void>;
@@ -1663,6 +1732,7 @@ interface PlaylistJSON {
  * @property {string[]} [blockExtractors] List of extractors to disable querying metadata from
  * @property {string[]} [blockStreamFrom] List of extractors to disable streaming from
  * @property {QueryCache | null} [queryCache] Query cache provider
+ * @property {boolean} [ignoreInstance] Ignore player instance
  */
 interface PlayerInitOptions {
     autoRegisterExtractor?: boolean;
@@ -1674,6 +1744,7 @@ interface PlayerInitOptions {
     blockExtractors?: string[];
     blockStreamFrom?: string[];
     queryCache?: QueryCache | null;
+    ignoreInstance?: boolean;
 }
 
 declare class AudioFilters {
@@ -1775,6 +1846,44 @@ declare class Util {
     static warn(message: string, code?: string, detail?: string): void;
 }
 
+declare class QueryResolver {
+    /**
+     * Query resolver
+     */
+    private constructor();
+    static get regex(): {
+        spotifyAlbumRegex: RegExp;
+        spotifyPlaylistRegex: RegExp;
+        spotifySongRegex: RegExp;
+        vimeoRegex: RegExp;
+        reverbnationRegex: RegExp;
+        attachmentRegex: RegExp;
+        appleMusicAlbumRegex: RegExp;
+        appleMusicPlaylistRegex: RegExp;
+        appleMusicSongRegex: RegExp;
+    };
+    /**
+     * Resolves the given search query
+     * @param {string} query The query
+     * @returns {QueryType}
+     */
+    static resolve(query: string): (typeof QueryType)[keyof typeof QueryType];
+    /**
+     * Parses vimeo id from url
+     * @param {string} query The query
+     * @returns {string}
+     */
+    static getVimeoID(query: string): string | null | undefined;
+    static validateId(q: string): boolean;
+    static validateURL(q: string): boolean;
+}
+
+declare function useHistory<Meta = unknown>(node: NodeResolvable): GuildQueueHistory<Meta> | null;
+
+declare function usePlayer<Meta = unknown>(node: NodeResolvable): GuildQueuePlayerNode<Meta> | null;
+
+declare function useQueue<Meta = unknown>(node: NodeResolvable): GuildQueue<Meta> | null;
+
 declare const version: string;
 
-export { AFilterGraph, AudioFilters, BaseExtractor, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerError, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamDispatcher, TimeData, Track, TrackJSON, TrackResolvable, TrackSource, Util, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceUtils, createFFmpegStream, version };
+export { AFilterGraph, AudioFilters, BaseExtractor, DiscordPlayerQueryResultCache, EqualizerConfigurationPreset, ErrorStatusCode, ExtractorExecutionContext, ExtractorExecutionFN, ExtractorExecutionResult, ExtractorInfo, ExtractorSearchContext, FFMPEG_ARGS_PIPED, FFMPEG_ARGS_STRING, FFMPEG_SRATE_REGEX, FFmpegFilterer, FFmpegStreamOptions, FilterGraph, FiltersName, GuildNodeCreateOptions, GuildNodeInit, GuildNodeManager, GuildQueue, GuildQueueAFiltersCache, GuildQueueAudioFilters, GuildQueueEvents, GuildQueueHistory, GuildQueuePlayerNode, NextFunction, NodeResolvable, OnAfterCreateStreamHandler, OnBeforeCreateStreamHandler, PlayOptions, Player, PlayerError, PlayerEvents, PlayerEventsEmitter, PlayerInitOptions, PlayerProgressbarOptions, PlayerSearchResult, PlayerTimestamp, PlayerTriggeredReason, Playlist, PlaylistInitData, PlaylistJSON, PostProcessedResult, QueryCache, QueryCacheOptions, QueryCacheResolverContext, QueryExtractorSearch, QueryResolver, QueryType, QueueFilters, QueueRepeatMode, RawTrackData, RawTrackInit, ResourcePlayOptions, SearchOptions, SearchQueryType, SearchResult, SearchResultData, StreamDispatcher, TimeData, Track, TrackJSON, TrackResolvable, TrackSource, Util, VoiceConnectConfig, VoiceEvents, VoiceReceiverNode, VoiceReceiverOptions, VoiceUtils, createFFmpegStream, useHistory, usePlayer, useQueue, version };

package/dist/index.js

@@ -77,6 +77,7 @@ __export(src_exports, {
   Playlist: () => Playlist,
   Q_BUTTERWORTH: () => import_equalizer3.Q_BUTTERWORTH,
   QueryCache: () => QueryCache,
+  QueryResolver: () => QueryResolver,
   QueryType: () => QueryType,
   QueueRepeatMode: () => QueueRepeatMode,
   SearchResult: () => SearchResult,
@@ -87,6 +88,9 @@ __export(src_exports, {
   VoiceUtils: () => VoiceUtils,
   VolumeTransformer: () => import_equalizer3.VolumeTransformer,
   createFFmpegStream: () => createFFmpegStream,
+  useHistory: () => useHistory,
+  usePlayer: () => usePlayer,
+  useQueue: () => useQueue,
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
@@ -487,6 +491,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 +535,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 +560,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() {
@@ -809,6 +825,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 +852,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 +901,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 +930,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;
@@ -1303,7 +1325,7 @@ var GuildQueueStatistics = class {
       memoryUsage: process.memoryUsage(),
       versions: {
         node: process.version,
-        player: "6.0.0-dev.4"
+        player: "6.0.0-dev.5"
       }
     };
   }
@@ -1365,6 +1387,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,6 +1452,16 @@ 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;
   }
@@ -1435,7 +1473,6 @@ var GuildQueue = class {
     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);
@@ -1784,6 +1821,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;
   }
@@ -1917,7 +1978,8 @@ var StreamDispatcher = class extends import_utils6.EventEmitter {
             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 +1989,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);
           }
@@ -1964,6 +2027,8 @@ var StreamDispatcher = class extends import_utils6.EventEmitter {
     });
     this.audioPlayer.on("debug", (m) => void this.emit("debug", m));
     this.audioPlayer.on("error", (error) => void this.emit("error", error));
+    this.voiceConnection.on("debug", (m) => void this.emit("debug", m));
+    this.voiceConnection.on("error", (error) => void this.emit("error", error));
     this.voiceConnection.subscribe(this.audioPlayer);
   }
   get paused() {
@@ -1984,6 +2049,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 +2123,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);
@@ -2123,8 +2207,12 @@ var VoiceUtils = class {
   }
   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 +2221,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 +2230,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 +2256,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 +2265,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
@@ -2243,6 +2323,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));
@@ -2294,20 +2376,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 +2436,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 +2476,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);
@@ -2461,12 +2546,13 @@ ${this.scanDeps()}`);
     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.node.isPlaying())
+      await queue.node.play();
     return {
       track: result.tracks[0],
       extractor: result.extractor,
@@ -2596,9 +2682,47 @@ _lagMonitorTimeout = new WeakMap();
 _lagMonitorInterval = new WeakMap();
 Player._singletonKey = kSingleton;
 
+// src/hooks/common.ts
+var getPlayer = /* @__PURE__ */ __name(() => {
+  return getPlayers()[0];
+}, "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/index.ts
 var import_equalizer3 = require("@discord-player/equalizer");
-var version = "6.0.0-dev.4";
+var version = "6.0.0-dev.5";
 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`);
 }
@@ -2632,6 +2756,7 @@ if (!import_discord4.version.startsWith("14")) {
   Playlist,
   Q_BUTTERWORTH,
   QueryCache,
+  QueryResolver,
   QueryType,
   QueueRepeatMode,
   SearchResult,
@@ -2642,6 +2767,9 @@ if (!import_discord4.version.startsWith("14")) {
   VoiceUtils,
   VolumeTransformer,
   createFFmpegStream,
+  useHistory,
+  usePlayer,
+  useQueue,
   version
 });
 //# sourceMappingURL=index.js.map