distube 4.0.4 → 4.0.6

package/dist/index.js

@@ -23,6 +23,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -59,7 +63,7 @@ var require_package = __commonJS({
   "package.json"(exports, module2) {
     module2.exports = {
       name: "distube",
-      version: "4.0.4",
+      version: "4.0.6",
       description: "A Discord.js module to simplify your music commands and play songs with audio filters on Discord without any API key.",
       main: "./dist/index.js",
       types: "./dist/index.d.ts",
@@ -83,7 +87,8 @@ var require_package = __commonJS({
         postinstall: "husky install",
         prepublishOnly: "yarn lint && yarn test",
         prepack: "yarn build && pinst --disable",
-        postpack: "pinst --enable"
+        postpack: "pinst --enable",
+        "dev:add-docs-to-worktree": "git worktree add --track -b docs docs origin/docs"
       },
       repository: {
         type: "git",
@@ -119,44 +124,45 @@ var require_package = __commonJS({
       ],
       homepage: "https://distube.js.org/",
       dependencies: {
-        "@distube/ytdl-core": "^4.11.3",
+        "@distube/ytdl-core": "^4.11.17",
         "@distube/ytpl": "^1.1.1",
-        "@distube/ytsr": "^1.1.8",
-        "prism-media": "https://codeload.github.com/distubejs/prism-media/tar.gz/main#workaround.tar.gz",
+        "@distube/ytsr": "^1.1.9",
+        "prism-media": "npm:@distube/prism-media@latest",
         "tiny-typed-emitter": "^2.1.0",
-        tslib: "^2.4.0",
-        undici: "^5.8.0"
+        tslib: "^2.6.1",
+        undici: "^5.22.1"
       },
       devDependencies: {
-        "@babel/core": "^7.18.9",
+        "@babel/core": "^7.22.9",
         "@babel/plugin-proposal-class-properties": "^7.18.6",
-        "@babel/plugin-proposal-object-rest-spread": "^7.18.9",
-        "@babel/preset-env": "^7.18.9",
-        "@babel/preset-typescript": "^7.18.6",
-        "@commitlint/cli": "^17.0.3",
-        "@commitlint/config-conventional": "^17.0.3",
-        "@discordjs/voice": "^0.11.0",
+        "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+        "@babel/plugin-transform-private-methods": "^7.22.5",
+        "@babel/preset-env": "^7.22.9",
+        "@babel/preset-typescript": "^7.22.5",
+        "@commitlint/cli": "^17.6.7",
+        "@commitlint/config-conventional": "^17.6.7",
+        "@discordjs/voice": "^0.16.0",
         "@distubejs/docgen": "distubejs/docgen",
-        "@types/jest": "^28.1.6",
-        "@types/node": "^18.6.1",
-        "@typescript-eslint/eslint-plugin": "^5.31.0",
-        "@typescript-eslint/parser": "^5.31.0",
-        "babel-jest": "^28.1.3",
-        "discord.js": "^14.0.3",
-        eslint: "^8.20.0",
+        "@types/jest": "^29.5.3",
+        "@types/node": "^20.4.5",
+        "@typescript-eslint/eslint-plugin": "^6.2.0",
+        "@typescript-eslint/parser": "^6.2.0",
+        "babel-jest": "^29.6.2",
+        "discord.js": "^14.11.0",
+        eslint: "^8.45.0",
         "eslint-config-distube": "^1.6.4",
-        "eslint-config-prettier": "^8.5.0",
-        "eslint-plugin-deprecation": "^1.3.2",
-        "eslint-plugin-jsdoc": "^39.3.3",
-        husky: "^8.0.1",
-        jest: "^28.1.3",
+        "eslint-config-prettier": "^8.9.0",
+        "eslint-plugin-deprecation": "^1.5.0",
+        "eslint-plugin-jsdoc": "^46.4.5",
+        husky: "^8.0.3",
+        jest: "^29.6.2",
         "jsdoc-babel": "^0.5.0",
         "nano-staged": "^0.8.0",
-        "npm-check-updates": "^16.0.0",
+        "npm-check-updates": "^16.10.17",
         pinst: "^3.0.0",
-        prettier: "^2.7.1",
-        tsup: "^6.2.0",
-        typescript: "^4.7.4"
+        prettier: "^3.0.0",
+        tsup: "^7.1.0",
+        typescript: "^5.1.6"
       },
       peerDependencies: {
         "@discordjs/opus": "*",
@@ -180,7 +186,7 @@ var require_package = __commonJS({
       engines: {
         node: ">=16.9.0"
       },
-      packageManager: "yarn@3.2.0"
+      packageManager: "yarn@3.6.1"
     };
   }
 });
@@ -226,6 +232,7 @@ __export(src_exports, {
   isGuildInstance: () => isGuildInstance,
   isMemberInstance: () => isMemberInstance,
   isMessageInstance: () => isMessageInstance,
+  isNsfwChannel: () => isNsfwChannel,
   isObject: () => isObject,
   isRecord: () => isRecord,
   isSnowflake: () => isSnowflake,
@@ -364,13 +371,13 @@ var ERROR_MESSAGES = {
 var haveCode = /* @__PURE__ */ __name((code) => Object.keys(ERROR_MESSAGES).includes(code), "haveCode");
 var parseMessage = /* @__PURE__ */ __name((m, ...args) => typeof m === "string" ? m : m(...args), "parseMessage");
 var getErrorMessage = /* @__PURE__ */ __name((code, ...args) => haveCode(code) ? parseMessage(ERROR_MESSAGES[code], ...args) : args[0], "getErrorMessage");
-var DisTubeError = class extends Error {
+var _DisTubeError = class _DisTubeError extends Error {
   constructor(code, ...args) {
     super(getErrorMessage(code, ...args));
     __publicField(this, "errorCode");
     this.errorCode = code;
     if (Error.captureStackTrace)
-      Error.captureStackTrace(this, DisTubeError);
+      Error.captureStackTrace(this, _DisTubeError);
   }
   get name() {
     return `DisTubeError [${this.errorCode}]`;
@@ -379,10 +386,11 @@ var DisTubeError = class extends Error {
     return this.errorCode;
   }
 };
-__name(DisTubeError, "DisTubeError");
+__name(_DisTubeError, "DisTubeError");
+var DisTubeError = _DisTubeError;
 
 // src/struct/TaskQueue.ts
-var Task = class {
+var _Task = class _Task {
   constructor(resolveInfo) {
     __publicField(this, "resolve");
     __publicField(this, "promise");
@@ -393,33 +401,64 @@ var Task = class {
     });
   }
 };
-__name(Task, "Task");
+__name(_Task, "Task");
+var Task = _Task;
 var _tasks;
-var TaskQueue = class {
+var _TaskQueue = class _TaskQueue {
   constructor() {
+    /**
+     * The task array
+     * @type {Task[]}
+     * @private
+     */
     __privateAdd(this, _tasks, []);
   }
+  /**
+   * Waits for last task finished and queues a new task
+   * @param {boolean} [resolveInfo=false] Whether the task is a resolving info task
+   * @returns {Promise<void>}
+   */
   queuing(resolveInfo = false) {
     const next = this.remaining ? __privateGet(this, _tasks)[__privateGet(this, _tasks).length - 1].promise : Promise.resolve();
     __privateGet(this, _tasks).push(new Task(resolveInfo));
     return next;
   }
+  /**
+   * Removes the finished task and processes the next task
+   */
   resolve() {
     __privateGet(this, _tasks).shift()?.resolve();
   }
+  /**
+   * The remaining number of tasks
+   * @type {number}
+   */
   get remaining() {
     return __privateGet(this, _tasks).length;
   }
+  /**
+   * Whether or not having a resolving info task
+   * @type {boolean}
+   */
   get hasResolveTask() {
     return !!__privateGet(this, _tasks).find((t) => t.resolveInfo);
   }
 };
-__name(TaskQueue, "TaskQueue");
 _tasks = new WeakMap();
+__name(_TaskQueue, "TaskQueue");
+var TaskQueue = _TaskQueue;
 
 // src/struct/Playlist.ts
 var _metadata, _member;
-var Playlist = class {
+var _Playlist = class _Playlist {
+  /**
+   * Create a playlist
+   * @param {Song[]|PlaylistInfo} playlist Playlist
+   * @param {Object} [options] Optional options
+   * @param {Discord.GuildMember} [options.member] Requested user
+   * @param {Object} [options.properties] Custom properties
+   * @param {T} [options.metadata] Playlist metadata
+   */
   constructor(playlist, options = {}) {
     __publicField(this, "source");
     __publicField(this, "songs");
@@ -448,7 +487,8 @@ var Playlist = class {
       if (!Array.isArray(playlist.songs) || !playlist.songs.length)
         throw new DisTubeError("EMPTY_PLAYLIST");
       this.songs = playlist.songs;
-      this.name = playlist.name || playlist.title || (this.songs[0].name ? `${this.songs[0].name} and ${this.songs.length - 1} more songs.` : `${this.songs.length} songs playlist`);
+      this.name = playlist.name || // eslint-disable-next-line deprecation/deprecation
+      playlist.title || (this.songs[0].name ? `${this.songs[0].name} and ${this.songs.length - 1} more songs.` : `${this.songs.length} songs playlist`);
       this.url = playlist.url || playlist.webpage_url;
       this.thumbnail = playlist.thumbnail || this.songs[0].thumbnail;
       this.member = member || playlist.member || void 0;
@@ -459,12 +499,24 @@ var Playlist = class {
         this[key] = value;
     this.metadata = metadata;
   }
+  /**
+   * Playlist duration in second.
+   * @type {number}
+   */
   get duration() {
     return this.songs?.reduce((prev, next) => prev + (next.duration || 0), 0) || 0;
   }
+  /**
+   * Formatted duration string `hh:mm:ss`.
+   * @type {string}
+   */
   get formattedDuration() {
     return formatDuration(this.duration);
   }
+  /**
+   * User requested.
+   * @type {Discord.GuildMember?}
+   */
   get member() {
     return __privateGet(this, _member);
   }
@@ -474,6 +526,10 @@ var Playlist = class {
     __privateSet(this, _member, member);
     this.songs.map((s) => s.constructor.name === "Song" && (s.member = this.member));
   }
+  /**
+   * User requested.
+   * @type {Discord.User?}
+   */
   get user() {
     return this.member?.user;
   }
@@ -485,12 +541,17 @@ var Playlist = class {
     this.songs.map((s) => s.constructor.name === "Song" && (s.metadata = metadata));
   }
 };
-__name(Playlist, "Playlist");
 _metadata = new WeakMap();
 _member = new WeakMap();
+__name(_Playlist, "Playlist");
+var Playlist = _Playlist;
 
 // src/struct/SearchResult.ts
-var ISearchResult = class {
+var _ISearchResult = class _ISearchResult {
+  /**
+   * Create a search result
+   * @param {Object} info ytsr result
+   */
   constructor(info) {
     __publicField(this, "source");
     __publicField(this, "id");
@@ -507,8 +568,9 @@ var ISearchResult = class {
     };
   }
 };
-__name(ISearchResult, "ISearchResult");
-var SearchResultVideo = class extends ISearchResult {
+__name(_ISearchResult, "ISearchResult");
+var ISearchResult = _ISearchResult;
+var _SearchResultVideo = class _SearchResultVideo extends ISearchResult {
   constructor(info) {
     super(info);
     __publicField(this, "type");
@@ -531,8 +593,9 @@ var SearchResultVideo = class extends ISearchResult {
     };
   }
 };
-__name(SearchResultVideo, "SearchResultVideo");
-var SearchResultPlaylist = class extends ISearchResult {
+__name(_SearchResultVideo, "SearchResultVideo");
+var SearchResultVideo = _SearchResultVideo;
+var _SearchResultPlaylist = class _SearchResultPlaylist extends ISearchResult {
   constructor(info) {
     super(info);
     __publicField(this, "type");
@@ -547,11 +610,20 @@ var SearchResultPlaylist = class extends ISearchResult {
     };
   }
 };
-__name(SearchResultPlaylist, "SearchResultPlaylist");
+__name(_SearchResultPlaylist, "SearchResultPlaylist");
+var SearchResultPlaylist = _SearchResultPlaylist;
 
 // src/struct/Song.ts
 var _metadata2, _member2, _playlist;
-var _Song = class {
+var _Song = class _Song {
+  /**
+   * Create a Song
+   * @param {ytdl.videoInfo|SearchResult|OtherSongInfo} info Raw info
+   * @param {Object} [options] Optional options
+   * @param {Discord.GuildMember} [options.member] Requested user
+   * @param {string} [options.source="youtube"] Song source
+   * @param {T} [options.metadata] Song metadata
+   */
   constructor(info, options = {}) {
     __publicField(this, "source");
     __privateAdd(this, _metadata2, void 0);
@@ -625,6 +697,11 @@ var _Song = class {
     this.chapters = details.chapters || [];
     this.reposts = 0;
   }
+  /**
+   * Patch data from other source
+   * @param {OtherSongInfo} info Video info
+   * @private
+   */
   _patchOther(info) {
     this.id = info.id;
     this.name = info.title || info.name;
@@ -655,6 +732,10 @@ var _Song = class {
     this.age_restricted = info.age_restricted || !!info.age_limit && parseNumber(info.age_limit) >= 18;
     this.chapters = info.chapters || [];
   }
+  /**
+   * The playlist added this song
+   * @type {Playlist?}
+   */
   get playlist() {
     return __privateGet(this, _playlist);
   }
@@ -664,6 +745,10 @@ var _Song = class {
     __privateSet(this, _playlist, playlist);
     this.member = playlist.member;
   }
+  /**
+   * User requested.
+   * @type {Discord.GuildMember?}
+   */
   get member() {
     return __privateGet(this, _member2);
   }
@@ -671,6 +756,10 @@ var _Song = class {
     if (isMemberInstance(member))
       __privateSet(this, _member2, member);
   }
+  /**
+   * User requested.
+   * @type {Discord.User?}
+   */
   get user() {
     return this.member?.user;
   }
@@ -681,48 +770,85 @@ var _Song = class {
     __privateSet(this, _metadata2, metadata);
   }
 };
-var Song = _Song;
-__name(Song, "Song");
 _metadata2 = new WeakMap();
 _member2 = new WeakMap();
 _playlist = new WeakMap();
+__name(_Song, "Song");
+var Song = _Song;
 
 // src/core/DisTubeBase.ts
-var DisTubeBase = class {
+var _DisTubeBase = class _DisTubeBase {
   constructor(distube) {
     __publicField(this, "distube");
     this.distube = distube;
   }
+  /**
+   * Emit the {@link DisTube} of this base
+   * @param {string} eventName Event name
+   * @param {...any} args arguments
+   * @returns {boolean}
+   */
   emit(eventName, ...args) {
     return this.distube.emit(eventName, ...args);
   }
+  /**
+   * Emit error event
+   * @param {Error} error error
+   * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
+   */
   emitError(error, channel) {
     this.distube.emitError(error, channel);
   }
+  /**
+   * The queue manager
+   * @type {QueueManager}
+   * @readonly
+   */
   get queues() {
     return this.distube.queues;
   }
+  /**
+   * The voice manager
+   * @type {DisTubeVoiceManager}
+   * @readonly
+   */
   get voices() {
     return this.distube.voices;
   }
+  /**
+   * Discord.js client
+   * @type {Discord.Client}
+   * @readonly
+   */
   get client() {
     return this.distube.client;
   }
+  /**
+   * DisTube options
+   * @type {DisTubeOptions}
+   * @readonly
+   */
   get options() {
     return this.distube.options;
   }
+  /**
+   * DisTube handler
+   * @type {DisTubeHandler}
+   * @readonly
+   */
   get handler() {
     return this.distube.handler;
   }
 };
-__name(DisTubeBase, "DisTubeBase");
+__name(_DisTubeBase, "DisTubeBase");
+var DisTubeBase = _DisTubeBase;
 
 // src/core/DisTubeVoice.ts
 var import_discord = require("discord.js");
 var import_tiny_typed_emitter = require("tiny-typed-emitter");
 var import_voice = require("@discordjs/voice");
 var _channel, _volume, _br, br_fn, _join, join_fn;
-var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
+var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedEmitter {
   constructor(voiceManager, channel) {
     super();
     __privateAdd(this, _br);
@@ -752,26 +878,37 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
       this.emit("error", error);
     });
     this.connection.on(import_voice.VoiceConnectionStatus.Disconnected, (_, newState) => {
-      if (newState.reason === import_voice.VoiceConnectionDisconnectReason.Manual) {
-        this.leave();
-      } else if (newState.reason === import_voice.VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
+      if (newState.reason === import_voice.VoiceConnectionDisconnectReason.Manual)
+        return this.leave();
+      if (newState.reason === import_voice.VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
         (0, import_voice.entersState)(this.connection, import_voice.VoiceConnectionStatus.Connecting, 5e3).catch(() => {
           if (![import_voice.VoiceConnectionStatus.Ready, import_voice.VoiceConnectionStatus.Connecting].includes(this.connection.state.status)) {
             this.leave();
           }
         });
-      } else if (this.connection.rejoinAttempts < 5) {
-        setTimeout(() => {
-          this.connection.rejoin();
-        }, (this.connection.rejoinAttempts + 1) * 5e3).unref();
-      } else if (this.connection.state.status !== import_voice.VoiceConnectionStatus.Destroyed) {
-        this.leave(new DisTubeError("VOICE_RECONNECT_FAILED"));
+        return;
+      }
+      if (this.connection.rejoinAttempts < 5) {
+        setTimeout(
+          () => {
+            this.connection.rejoin();
+          },
+          (this.connection.rejoinAttempts + 1) * 5e3
+        ).unref();
+        return;
+      }
+      if (this.connection.state.status !== import_voice.VoiceConnectionStatus.Destroyed) {
+        return this.leave(new DisTubeError("VOICE_RECONNECT_FAILED"));
       }
     }).on(import_voice.VoiceConnectionStatus.Destroyed, () => {
       this.leave();
     }).on("error", () => void 0);
     this.connection.subscribe(this.audioPlayer);
   }
+  /**
+   * The voice channel id the bot is in
+   * @type {Snowflake?}
+   */
   get channelId() {
     return this.connection?.joinConfig?.channelId ?? void 0;
   }
@@ -811,6 +948,11 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
     __privateSet(this, _channel, channel);
     __privateMethod(this, _br, br_fn).call(this);
   }
+  /**
+   * Join a voice channel with this connection
+   * @param {Discord.BaseGuildVoiceChannel} [channel] A voice channel
+   * @returns {Promise<DisTubeVoice>}
+   */
   async join(channel) {
     const TIMEOUT = 3e4;
     if (channel)
@@ -827,6 +969,10 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
     }
     return this;
   }
+  /**
+   * Leave the voice channel of this connection
+   * @param {Error} [error] Optional, an error to emit with 'error' event.
+   */
   leave(error) {
     this.stop(true);
     if (!this.isDisconnected) {
@@ -837,9 +983,20 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
       this.connection.destroy();
     this.voices.remove(this.id);
   }
+  /**
+   * Stop the playing stream
+   * @param {boolean} [force=false] If true, will force the {@link DisTubeVoice#audioPlayer} to enter the Idle state
+   * even if the {@link DisTubeVoice#audioResource} has silence padding frames.
+   * @private
+   */
   stop(force = false) {
     this.audioPlayer.stop(force);
   }
+  /**
+   * Play a readable stream
+   * @private
+   * @param {DisTubeStream} stream Readable stream
+   */
   play(stream) {
     this.emittedError = false;
     stream.stream.on("error", (error) => {
@@ -853,7 +1010,8 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
       inlineVolume: true
     });
     this.volume = __privateGet(this, _volume);
-    this.audioPlayer.play(this.audioResource);
+    if (this.audioPlayer.state.status !== import_voice.AudioPlayerStatus.Paused)
+      this.audioPlayer.play(this.audioResource);
   }
   set volume(volume) {
     if (typeof volume !== "number" || isNaN(volume)) {
@@ -868,6 +1026,10 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
   get volume() {
     return __privateGet(this, _volume);
   }
+  /**
+   * Playback duration of the audio resource in seconds
+   * @type {number}
+   */
   get playbackDuration() {
     return (this.audioResource?.playbackDuration ?? 0) / 1e3;
   }
@@ -875,14 +1037,32 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
     this.audioPlayer.pause();
   }
   unpause() {
+    const state = this.audioPlayer.state;
+    if (state.status !== import_voice.AudioPlayerStatus.Paused)
+      return;
+    if (this.audioResource && state.resource !== this.audioResource)
+      return this.audioPlayer.play(this.audioResource);
     this.audioPlayer.unpause();
   }
+  /**
+   * Whether the bot is self-deafened
+   * @type {boolean}
+   */
   get selfDeaf() {
     return this.connection.joinConfig.selfDeaf;
   }
+  /**
+   * Whether the bot is self-muted
+   * @type {boolean}
+   */
   get selfMute() {
     return this.connection.joinConfig.selfMute;
   }
+  /**
+   * Self-deafens/undeafens the bot.
+   * @param {boolean} selfDeaf Whether or not the bot should be self-deafened
+   * @returns {boolean} true if the voice state was successfully updated, otherwise false
+   */
   setSelfDeaf(selfDeaf) {
     if (typeof selfDeaf !== "boolean") {
       throw new DisTubeError("INVALID_TYPE", "boolean", selfDeaf, "selfDeaf");
@@ -892,6 +1072,11 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
       selfDeaf
     });
   }
+  /**
+   * Self-mutes/unmutes the bot.
+   * @param {boolean} selfMute Whether or not the bot should be self-muted
+   * @returns {boolean} true if the voice state was successfully updated, otherwise false
+   */
   setSelfMute(selfMute) {
     if (typeof selfMute !== "boolean") {
       throw new DisTubeError("INVALID_TYPE", "boolean", selfMute, "selfMute");
@@ -901,11 +1086,14 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
       selfMute
     });
   }
+  /**
+   * The voice state of this connection
+   * @type {Discord.VoiceState?}
+   */
   get voiceState() {
     return this.channel?.guild?.members?.me?.voice;
   }
 };
-__name(DisTubeVoice, "DisTubeVoice");
 _channel = new WeakMap();
 _volume = new WeakMap();
 _br = new WeakSet();
@@ -922,11 +1110,104 @@ join_fn = /* @__PURE__ */ __name(function(channel) {
     group: channel.client.user?.id
   });
 }, "#join");
+__name(_DisTubeVoice, "DisTubeVoice");
+var DisTubeVoice = _DisTubeVoice;
+
+// src/core/DisTubeStream.ts
+var import_prism_media = require("prism-media");
+var import_voice2 = require("@discordjs/voice");
+var chooseBestVideoFormat = /* @__PURE__ */ __name((formats, isLive = false) => {
+  let filter = /* @__PURE__ */ __name((format) => format.hasAudio, "filter");
+  if (isLive)
+    filter = /* @__PURE__ */ __name((format) => format.hasAudio && format.isHLS, "filter");
+  formats = formats.filter(filter).sort((a, b) => Number(b.audioBitrate) - Number(a.audioBitrate) || Number(a.bitrate) - Number(b.bitrate));
+  return formats.find((format) => !format.hasVideo) || formats.sort((a, b) => Number(a.bitrate) - Number(b.bitrate))[0];
+}, "chooseBestVideoFormat");
+var _DisTubeStream = class _DisTubeStream {
+  /**
+   * Create a DisTubeStream to play with {@link DisTubeVoice}
+   * @param {string} url Stream URL
+   * @param {StreamOptions} options Stream options
+   * @private
+   */
+  constructor(url, options) {
+    __publicField(this, "type");
+    __publicField(this, "stream");
+    __publicField(this, "url");
+    this.url = url;
+    this.type = !options.type ? import_voice2.StreamType.OggOpus : import_voice2.StreamType.Raw;
+    const args = [
+      "-reconnect",
+      "1",
+      "-reconnect_streamed",
+      "1",
+      "-reconnect_delay_max",
+      "5",
+      "-i",
+      url,
+      "-analyzeduration",
+      "0",
+      "-loglevel",
+      "0",
+      "-ar",
+      "48000",
+      "-ac",
+      "2",
+      "-f"
+    ];
+    if (!options.type)
+      args.push("opus", "-acodec", "libopus");
+    else
+      args.push("s16le");
+    if (typeof options.seek === "number" && options.seek > 0)
+      args.unshift("-ss", options.seek.toString());
+    if (Array.isArray(options.ffmpegArgs) && options.ffmpegArgs.length)
+      args.push(...options.ffmpegArgs);
+    this.stream = new import_prism_media.FFmpeg({ args, shell: false });
+    this.stream._readableState && (this.stream._readableState.highWaterMark = 1 << 25);
+  }
+  /**
+   * Create a stream from ytdl video formats
+   * @param {ytdl.videoFormat[]} formats ytdl video formats
+   * @param {StreamOptions} options options
+   * @returns {DisTubeStream}
+   * @private
+   */
+  static YouTube(formats, options = {}) {
+    if (!formats || !formats.length)
+      throw new DisTubeError("UNAVAILABLE_VIDEO");
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
+      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
+    }
+    const bestFormat = chooseBestVideoFormat(formats, options.isLive);
+    if (!bestFormat)
+      throw new DisTubeError("UNPLAYABLE_FORMATS");
+    return new _DisTubeStream(bestFormat.url, options);
+  }
+  /**
+   * Create a stream from a stream url
+   * @param {string} url stream url
+   * @param {StreamOptions} options options
+   * @returns {DisTubeStream}
+   * @private
+   */
+  static DirectLink(url, options = {}) {
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
+      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
+    }
+    if (typeof url !== "string" || !isURL(url)) {
+      throw new DisTubeError("INVALID_TYPE", "an URL", url);
+    }
+    return new _DisTubeStream(url, options);
+  }
+};
+__name(_DisTubeStream, "DisTubeStream");
+var DisTubeStream = _DisTubeStream;
 
 // src/core/DisTubeHandler.ts
 var import_ytpl = __toESM(require("@distube/ytpl"));
 var import_ytdl_core = __toESM(require("@distube/ytdl-core"));
-var DisTubeHandler = class extends DisTubeBase {
+var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
   constructor(distube) {
     super(distube);
     const client = this.client;
@@ -976,11 +1257,23 @@ var DisTubeHandler = class extends DisTubeBase {
     }
     return options;
   }
+  /**
+   * @param {string} url url
+   * @param {boolean} [basic=false] getBasicInfo?
+   * @returns {Promise<ytdl.videoInfo>}
+   */
   getYouTubeInfo(url, basic = false) {
     if (basic)
       return import_ytdl_core.default.getBasicInfo(url, this.ytdlOptions);
     return import_ytdl_core.default.getInfo(url, this.ytdlOptions);
   }
+  /**
+   * Resolve a url or a supported object to a {@link Song} or {@link Playlist}
+   * @param {string|Song|SearchResult|Playlist} song URL | {@link Song}| {@link SearchResult} | {@link Playlist}
+   * @param {ResolveOptions} [options] Optional options
+   * @returns {Promise<Song|Playlist|null>} Resolved
+   * @throws {DisTubeError}
+   */
   async resolve(song, options = {}) {
     if (song instanceof Song || song instanceof Playlist) {
       if ("metadata" in options)
@@ -1011,6 +1304,12 @@ var DisTubeHandler = class extends DisTubeBase {
     }
     throw new DisTubeError("CANNOT_RESOLVE_SONG", song);
   }
+  /**
+   * Resolve Song[] or YouTube playlist url to a Playlist
+   * @param {Playlist|Song[]|string} playlist Resolvable playlist
+   * @param {ResolvePlaylistOptions} options Optional options
+   * @returns {Promise<Playlist>}
+   */
   async resolvePlaylist(playlist, options = {}) {
     const { member, source, metadata } = { source: "youtube", ...options };
     if (playlist instanceof Playlist) {
@@ -1037,6 +1336,13 @@ var DisTubeHandler = class extends DisTubeBase {
     }
     return new Playlist(playlist, { member, properties: { source }, metadata });
   }
+  /**
+   * Search for a song, fire {@link DisTube#event:error} if not found.
+   * @param {Discord.Message} message The original message from an user
+   * @param {string} query The query string
+   * @returns {Promise<SearchResult?>} Song info
+   * @throws {DisTubeError}
+   */
   async searchSong(message, query) {
     if (!isMessageInstance(message))
       throw new DisTubeError("INVALID_TYPE", "Discord.Message", message, "message");
@@ -1047,7 +1353,7 @@ var DisTubeHandler = class extends DisTubeBase {
     const limit = this.options.searchSongs > 1 ? this.options.searchSongs : 1;
     const results = await this.distube.search(query, {
       limit,
-      safeSearch: this.options.nsfw ? false : !message.channel?.nsfw
+      safeSearch: this.options.nsfw ? false : !isNsfwChannel(message.channel)
     }).catch(() => {
       if (!this.emit("searchNoResult", message, query)) {
         console.warn("searchNoResult event does not have any listeners! Emits `error` event instead.");
@@ -1058,6 +1364,17 @@ var DisTubeHandler = class extends DisTubeBase {
       return null;
     return this.createSearchMessageCollector(message, results, query);
   }
+  /**
+   * Create a message collector for selecting search results.
+   *
+   * Needed events: {@link DisTube#event:searchResult}, {@link DisTube#event:searchCancel},
+   * {@link DisTube#event:searchInvalidAnswer}, {@link DisTube#event:searchDone}.
+   * @param {Discord.Message} message The original message from an user
+   * @param {Array<SearchResult|Song|Playlist>} results The search results
+   * @param {string?} [query] The query string
+   * @returns {Promise<SearchResult|Song|Playlist|null>} Selected result
+   * @throws {DisTubeError}
+   */
   async createSearchMessageCollector(message, results, query) {
     if (!isMessageInstance(message))
       throw new DisTubeError("INVALID_TYPE", "Discord.Message", message, "message");
@@ -1110,19 +1427,26 @@ var DisTubeHandler = class extends DisTubeBase {
     }
     return result;
   }
+  /**
+   * Play or add a {@link Playlist} to the queue.
+   * @param {Discord.BaseGuildVoiceChannel} voiceChannel A voice channel
+   * @param {Playlist|string} playlist A YouTube playlist url | a Playlist
+   * @param {PlayHandlerOptions} [options] Optional options
+   * @returns {Promise<void>}
+   * @throws {DisTubeError}
+   */
   async playPlaylist(voiceChannel, playlist, options = {}) {
     const { textChannel, skip } = { skip: false, ...options };
     const position = Number(options.position) || (skip ? 1 : 0);
     if (!(playlist instanceof Playlist))
       throw new DisTubeError("INVALID_TYPE", "Playlist", playlist, "playlist");
     const queue = this.queues.get(voiceChannel);
-    if (!this.options.nsfw && !(queue?.textChannel || textChannel)?.nsfw) {
+    const isNsfw = isNsfwChannel(queue?.textChannel || textChannel);
+    if (!this.options.nsfw && !isNsfw)
       playlist.songs = playlist.songs.filter((s) => !s.age_restricted);
-    }
     if (!playlist.songs.length) {
-      if (!this.options.nsfw && !textChannel?.nsfw) {
+      if (!this.options.nsfw && !isNsfw)
         throw new DisTubeError("EMPTY_FILTERED_PLAYLIST");
-      }
       throw new DisTubeError("EMPTY_PLAYLIST");
     }
     if (queue) {
@@ -1142,13 +1466,21 @@ var DisTubeHandler = class extends DisTubeBase {
       }
     }
   }
+  /**
+   * Play or add a {@link Song} to the queue.
+   * @param {Discord.BaseGuildVoiceChannel} voiceChannel A voice channel
+   * @param {Song} song A YouTube playlist url | a Playlist
+   * @param {PlayHandlerOptions} [options] Optional options
+   * @returns {Promise<void>}
+   * @throws {DisTubeError}
+   */
   async playSong(voiceChannel, song, options = {}) {
     if (!(song instanceof Song))
       throw new DisTubeError("INVALID_TYPE", "Song", song, "song");
     const { textChannel, skip } = { skip: false, ...options };
     const position = Number(options.position) || (skip ? 1 : 0);
     const queue = this.queues.get(voiceChannel);
-    if (!this.options.nsfw && song.age_restricted && !(queue?.textChannel || textChannel)?.nsfw) {
+    if (!this.options.nsfw && song.age_restricted && !isNsfwChannel(queue?.textChannel || textChannel)) {
       throw new DisTubeError("NON_NSFW");
     }
     if (queue) {
@@ -1168,12 +1500,35 @@ var DisTubeHandler = class extends DisTubeBase {
       }
     }
   }
+  /**
+   * Get {@link Song}'s stream info and attach it to the song.
+   * @param {Song} song A Song
+   */
+  async attachStreamInfo(song) {
+    const { url, source, formats, streamURL, isLive } = song;
+    if (source === "youtube") {
+      if (!formats || !chooseBestVideoFormat(formats, isLive)) {
+        song._patchYouTube(await this.handler.getYouTubeInfo(url));
+      }
+    } else if (!streamURL) {
+      for (const plugin of [...this.distube.extractorPlugins, ...this.distube.customPlugins]) {
+        if (await plugin.validate(url)) {
+          const info = [plugin.getStreamURL(url), plugin.getRelatedSongs(url)];
+          const result = await Promise.all(info);
+          song.streamURL = result[0];
+          song.related = result[1];
+          break;
+        }
+      }
+    }
+  }
 };
-__name(DisTubeHandler, "DisTubeHandler");
+__name(_DisTubeHandler, "DisTubeHandler");
+var DisTubeHandler = _DisTubeHandler;
 
 // src/core/DisTubeOptions.ts
 var _validateOptions, validateOptions_fn;
-var Options = class {
+var _Options = class _Options {
   constructor(options) {
     __privateAdd(this, _validateOptions);
     __publicField(this, "plugins");
@@ -1222,7 +1577,6 @@ var Options = class {
     __privateMethod(this, _validateOptions, validateOptions_fn).call(this);
   }
 };
-__name(Options, "Options");
 _validateOptions = new WeakSet();
 validateOptions_fn = /* @__PURE__ */ __name(function(options = this) {
   if (typeof options.emitNewSongOnly !== "boolean") {
@@ -1303,95 +1657,34 @@ validateOptions_fn = /* @__PURE__ */ __name(function(options = this) {
     throw new DisTubeError("INVALID_TYPE", "boolean", options.directLink, "DisTubeOptions.directLink");
   }
 }, "#validateOptions");
-
-// src/core/DisTubeStream.ts
-var import_prism_media = require("prism-media");
-var import_voice2 = require("@discordjs/voice");
-var chooseBestVideoFormat = /* @__PURE__ */ __name((formats, isLive = false) => {
-  let filter = /* @__PURE__ */ __name((format) => format.hasAudio, "filter");
-  if (isLive)
-    filter = /* @__PURE__ */ __name((format) => format.hasAudio && format.isHLS, "filter");
-  formats = formats.filter(filter).sort((a, b) => Number(b.audioBitrate) - Number(a.audioBitrate) || Number(a.bitrate) - Number(b.bitrate));
-  return formats.find((format) => !format.hasVideo) || formats.sort((a, b) => Number(a.bitrate) - Number(b.bitrate))[0];
-}, "chooseBestVideoFormat");
-var DisTubeStream = class {
-  constructor(url, options) {
-    __publicField(this, "type");
-    __publicField(this, "stream");
-    __publicField(this, "url");
-    this.url = url;
-    this.type = !options.type ? import_voice2.StreamType.OggOpus : import_voice2.StreamType.Raw;
-    const args = [
-      "-reconnect",
-      "1",
-      "-reconnect_streamed",
-      "1",
-      "-reconnect_delay_max",
-      "5",
-      "-i",
-      url,
-      "-analyzeduration",
-      "0",
-      "-loglevel",
-      "0",
-      "-ar",
-      "48000",
-      "-ac",
-      "2",
-      "-f"
-    ];
-    if (!options.type) {
-      args.push("opus", "-acodec", "libopus");
-    } else {
-      args.push("s16le");
-    }
-    if (typeof options.seek === "number" && options.seek > 0) {
-      args.unshift("-ss", options.seek.toString());
-    }
-    if (Array.isArray(options.ffmpegArgs)) {
-      args.push(...options.ffmpegArgs);
-    }
-    this.stream = new import_prism_media.FFmpeg({ args, shell: false });
-    this.stream._readableState && (this.stream._readableState.highWaterMark = 1 << 25);
-  }
-  static YouTube(formats, options = {}) {
-    if (!formats || !formats.length)
-      throw new DisTubeError("UNAVAILABLE_VIDEO");
-    if (!options || typeof options !== "object" || Array.isArray(options)) {
-      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
-    }
-    const bestFormat = chooseBestVideoFormat(formats, options.isLive);
-    if (!bestFormat)
-      throw new DisTubeError("UNPLAYABLE_FORMATS");
-    return new DisTubeStream(bestFormat.url, options);
-  }
-  static DirectLink(url, options = {}) {
-    if (!options || typeof options !== "object" || Array.isArray(options)) {
-      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
-    }
-    if (typeof url !== "string" || !isURL(url)) {
-      throw new DisTubeError("INVALID_TYPE", "an URL", url);
-    }
-    return new DisTubeStream(url, options);
-  }
-};
-__name(DisTubeStream, "DisTubeStream");
+__name(_Options, "Options");
+var Options = _Options;
 
 // src/core/manager/BaseManager.ts
 var import_discord2 = require("discord.js");
-var BaseManager = class extends DisTubeBase {
+var _BaseManager = class _BaseManager extends DisTubeBase {
   constructor() {
     super(...arguments);
+    /**
+     * The collection of items for this manager.
+     * @type {Collection}
+     * @name BaseManager#collection
+     */
     __publicField(this, "collection", new import_discord2.Collection());
   }
+  /**
+   * The size of the collection.
+   * @type {number}
+   */
   get size() {
     return this.collection.size;
   }
 };
-__name(BaseManager, "BaseManager");
+__name(_BaseManager, "BaseManager");
+var BaseManager = _BaseManager;
 
 // src/core/manager/GuildIdManager.ts
-var GuildIdManager = class extends BaseManager {
+var _GuildIdManager = class _GuildIdManager extends BaseManager {
   add(idOrInstance, data) {
     const id = resolveGuildId(idOrInstance);
     const existing = this.get(id);
@@ -1409,11 +1702,30 @@ var GuildIdManager = class extends BaseManager {
     return this.collection.has(resolveGuildId(idOrInstance));
   }
 };
-__name(GuildIdManager, "GuildIdManager");
+__name(_GuildIdManager, "GuildIdManager");
+var GuildIdManager = _GuildIdManager;
 
 // src/core/manager/DisTubeVoiceManager.ts
 var import_voice3 = require("@discordjs/voice");
-var DisTubeVoiceManager = class extends GuildIdManager {
+var _DisTubeVoiceManager = class _DisTubeVoiceManager extends GuildIdManager {
+  /**
+   * Get a {@link DisTubeVoice}.
+   * @method get
+   * @memberof DisTubeVoiceManager#
+   * @param {GuildIdResolvable} guild The queue resolvable to resolve
+   * @returns {DisTubeVoice?}
+   */
+  /**
+   * Collection of {@link DisTubeVoice}.
+   * @name DisTubeVoiceManager#collection
+   * @type {Discord.Collection<string, DisTubeVoice>}
+   */
+  /**
+   * Create a {@link DisTubeVoice}
+   * @param {Discord.BaseGuildVoiceChannel} channel A voice channel to join
+   * @returns {DisTubeVoice}
+   * @private
+   */
   create(channel) {
     const existing = this.get(channel.guildId);
     if (existing) {
@@ -1422,12 +1734,21 @@ var DisTubeVoiceManager = class extends GuildIdManager {
     }
     return new DisTubeVoice(this, channel);
   }
+  /**
+   * Join a voice channel
+   * @param {Discord.BaseGuildVoiceChannel} channel A voice channel to join
+   * @returns {Promise<DisTubeVoice>}
+   */
   join(channel) {
     const existing = this.get(channel.guildId);
     if (existing)
       return existing.join(channel);
     return this.create(channel).join();
   }
+  /**
+   * Leave the connected voice channel in a guild
+   * @param {GuildIdResolvable} guild Queue Resolvable
+   */
   leave(guild) {
     const voice = this.get(guild);
     if (voice) {
@@ -1440,104 +1761,191 @@ var DisTubeVoiceManager = class extends GuildIdManager {
     }
   }
 };
-__name(DisTubeVoiceManager, "DisTubeVoiceManager");
+__name(_DisTubeVoiceManager, "DisTubeVoiceManager");
+var DisTubeVoiceManager = _DisTubeVoiceManager;
 
 // src/core/manager/FilterManager.ts
-var _validate, validate_fn, _resolveName, resolveName_fn, _resolveValue, resolveValue_fn, _apply, apply_fn;
-var FilterManager = class extends BaseManager {
+var _resolve, resolve_fn, _apply, apply_fn, _removeFn, removeFn_fn;
+var _FilterManager = class _FilterManager extends BaseManager {
   constructor(queue) {
     super(queue.distube);
-    __privateAdd(this, _validate);
-    __privateAdd(this, _resolveName);
-    __privateAdd(this, _resolveValue);
+    __privateAdd(this, _resolve);
     __privateAdd(this, _apply);
+    __privateAdd(this, _removeFn);
+    /**
+     * Collection of {@link Filter}.
+     * @name FilterManager#collection
+     * @type {Discord.Collection<string, DisTubeVoice>}
+     */
     __publicField(this, "queue");
     this.queue = queue;
   }
+  /**
+   * Enable a filter or multiple filters to the manager
+   * @param {FilterResolvable|FilterResolvable[]} filterOrFilters The filter or filters to enable
+   * @param {boolean} [override=false] Wether or not override the applied filter with new filter value
+   * @returns {FilterManager}
+   */
   add(filterOrFilters, override = false) {
     if (Array.isArray(filterOrFilters)) {
-      const resolvedFilters = filterOrFilters.map((f) => __privateMethod(this, _validate, validate_fn).call(this, f));
-      const newFilters = resolvedFilters.reduceRight((unique, o) => {
-        if (!unique.some((obj) => obj === o && obj.name === o) && !unique.some((obj) => obj !== o.name && obj.name !== o.name)) {
-          if (!this.has(o))
-            unique.push(o);
-          if (this.has(o) && override) {
-            this.remove(o);
-            unique.push(o);
-          }
-        }
-        return unique;
-      }, []).reverse();
-      return this.set([...this.collection.values(), ...newFilters]);
+      for (const filter of filterOrFilters) {
+        const f = __privateMethod(this, _resolve, resolve_fn).call(this, filter);
+        if (override || !this.has(f))
+          this.collection.set(f.name, f);
+      }
+    } else {
+      const f = __privateMethod(this, _resolve, resolve_fn).call(this, filterOrFilters);
+      if (override || !this.has(f))
+        this.collection.set(f.name, f);
     }
-    return this.set([...this.collection.values(), filterOrFilters]);
+    __privateMethod(this, _apply, apply_fn).call(this);
+    return this;
   }
+  /**
+   * Clear enabled filters of the manager
+   * @returns {FilterManager}
+   */
   clear() {
     return this.set([]);
   }
+  /**
+   * Set the filters applied to the manager
+   * @param {FilterResolvable[]} filters The filters to apply
+   * @returns {FilterManager}
+   */
   set(filters) {
+    if (!Array.isArray(filters))
+      throw new DisTubeError("INVALID_TYPE", "Array<FilterResolvable>", filters, "filters");
     this.collection.clear();
-    for (const filter of filters) {
-      const resolved = __privateMethod(this, _validate, validate_fn).call(this, filter);
-      this.collection.set(__privateMethod(this, _resolveName, resolveName_fn).call(this, resolved), resolved);
+    for (const f of filters) {
+      const filter = __privateMethod(this, _resolve, resolve_fn).call(this, f);
+      this.collection.set(filter.name, filter);
     }
     __privateMethod(this, _apply, apply_fn).call(this);
     return this;
   }
+  /**
+   * Disable a filter or multiple filters
+   * @param {FilterResolvable|FilterResolvable[]} filterOrFilters The filter or filters to disable
+   * @returns {FilterManager}
+   */
   remove(filterOrFilters) {
-    const remove = /* @__PURE__ */ __name((f) => this.collection.delete(__privateMethod(this, _resolveName, resolveName_fn).call(this, __privateMethod(this, _validate, validate_fn).call(this, f))), "remove");
     if (Array.isArray(filterOrFilters))
-      filterOrFilters.map(remove);
+      filterOrFilters.map((f) => __privateMethod(this, _removeFn, removeFn_fn).call(this, f));
     else
-      remove(filterOrFilters);
+      __privateMethod(this, _removeFn, removeFn_fn).call(this, filterOrFilters);
     __privateMethod(this, _apply, apply_fn).call(this);
     return this;
   }
+  /**
+   * Check whether a filter enabled or not
+   * @param {FilterResolvable} filter The filter to check
+   * @returns {boolean}
+   */
   has(filter) {
-    return this.collection.has(__privateMethod(this, _resolveName, resolveName_fn).call(this, filter));
+    return this.collection.has(typeof filter === "string" ? filter : __privateMethod(this, _resolve, resolve_fn).call(this, filter).name);
   }
+  /**
+   * Array of enabled filter names
+   * @type {Array<string>}
+   * @readonly
+   */
   get names() {
-    return this.collection.map((f) => __privateMethod(this, _resolveName, resolveName_fn).call(this, f));
+    return [...this.collection.keys()];
   }
+  /**
+   * Array of enabled filters
+   * @type {Array<Filter>}
+   * @readonly
+   */
   get values() {
-    return this.collection.map((f) => __privateMethod(this, _resolveValue, resolveValue_fn).call(this, f));
+    return [...this.collection.values()];
+  }
+  get ffmpegArgs() {
+    return this.size ? ["-af", this.values.map((f) => f.value).join(",")] : [];
   }
   toString() {
     return this.names.toString();
   }
 };
-__name(FilterManager, "FilterManager");
-_validate = new WeakSet();
-validate_fn = /* @__PURE__ */ __name(function(filter) {
-  if (typeof filter === "string" && Object.prototype.hasOwnProperty.call(this.distube.filters, filter) || typeof filter === "object" && typeof filter.name === "string" && typeof filter.value === "string") {
+_resolve = new WeakSet();
+resolve_fn = /* @__PURE__ */ __name(function(filter) {
+  if (typeof filter === "object" && typeof filter.name === "string" && typeof filter.value === "string") {
     return filter;
   }
+  if (typeof filter === "string" && Object.prototype.hasOwnProperty.call(this.distube.filters, filter)) {
+    return {
+      name: filter,
+      value: this.distube.filters[filter]
+    };
+  }
   throw new DisTubeError("INVALID_TYPE", "FilterResolvable", filter, "filter");
-}, "#validate");
-_resolveName = new WeakSet();
-resolveName_fn = /* @__PURE__ */ __name(function(filter) {
-  return typeof filter === "string" ? filter : filter.name;
-}, "#resolveName");
-_resolveValue = new WeakSet();
-resolveValue_fn = /* @__PURE__ */ __name(function(filter) {
-  return typeof filter === "string" ? this.distube.filters[filter] : filter.value;
-}, "#resolveValue");
+}, "#resolve");
 _apply = new WeakSet();
 apply_fn = /* @__PURE__ */ __name(function() {
   this.queue.beginTime = this.queue.currentTime;
   this.queues.playSong(this.queue);
 }, "#apply");
+_removeFn = new WeakSet();
+removeFn_fn = /* @__PURE__ */ __name(function(f) {
+  return this.collection.delete(__privateMethod(this, _resolve, resolve_fn).call(this, f).name);
+}, "#removeFn");
+__name(_FilterManager, "FilterManager");
+var FilterManager = _FilterManager;
 
 // src/core/manager/QueueManager.ts
-var _voiceEventHandler, voiceEventHandler_fn, _handleSongFinish, handleSongFinish_fn, _handlePlayingError, handlePlayingError_fn, _emitPlaySong, emitPlaySong_fn;
-var QueueManager = class extends GuildIdManager {
+var _voiceEventHandler, voiceEventHandler_fn, _emitPlaySong, emitPlaySong_fn, _handleSongFinish, handleSongFinish_fn, _handlePlayingError, handlePlayingError_fn;
+var _QueueManager = class _QueueManager extends GuildIdManager {
   constructor() {
     super(...arguments);
+    /**
+     * Get a Queue from this QueueManager.
+     * @method get
+     * @memberof QueueManager#
+     * @param {GuildIdResolvable} guild Resolvable thing from a guild
+     * @returns {Queue?}
+     */
+    /**
+     * Listen to DisTubeVoice events and handle the Queue
+     * @private
+     * @param {Queue} queue Queue
+     */
     __privateAdd(this, _voiceEventHandler);
+    /**
+     * Whether or not emit playSong event
+     * @param {Queue} queue Queue
+     * @private
+     * @returns {boolean}
+     */
+    __privateAdd(this, _emitPlaySong);
+    /**
+     * Handle the queue when a Song finish
+     * @private
+     * @param {Queue} queue queue
+     * @returns {Promise<void>}
+     */
     __privateAdd(this, _handleSongFinish);
+    /**
+     * Handle error while playing
+     * @private
+     * @param {Queue} queue queue
+     * @param {Error} error error
+     */
     __privateAdd(this, _handlePlayingError);
-    __privateAdd(this, _emitPlaySong);
   }
+  /**
+   * Collection of {@link Queue}.
+   * @name QueueManager#collection
+   * @type {Discord.Collection<string, Queue>}
+   */
+  /**
+   * Create a {@link Queue}
+   * @private
+   * @param {Discord.BaseGuildVoiceChannel} channel A voice channel
+   * @param {Song|Song[]} song First song
+   * @param {Discord.BaseGuildTextChannel} textChannel Default text channel
+   * @returns {Promise<Queue|true>} Returns `true` if encounter an error
+   */
   async create(channel, song, textChannel) {
     if (this.has(channel.guildId))
       throw new DisTubeError("QUEUE_EXIST");
@@ -1555,49 +1963,46 @@ var QueueManager = class extends GuildIdManager {
       queue._taskQueue.resolve();
     }
   }
+  /**
+   * Create a ytdl stream
+   * @param {Queue} queue Queue
+   * @returns {DisTubeStream}
+   */
   createStream(queue) {
     const { duration, formats, isLive, source, streamURL } = queue.songs[0];
-    const ffmpegArgs = queue.filters.size ? ["-af", queue.filters.values.join(",")] : void 0;
-    const seek = duration ? queue.beginTime : void 0;
-    const streamOptions = { ffmpegArgs, seek, isLive, type: this.options.streamType };
+    const streamOptions = {
+      ffmpegArgs: queue.filters.ffmpegArgs,
+      seek: duration ? queue.beginTime : void 0,
+      isLive,
+      type: this.options.streamType
+    };
     if (source === "youtube")
       return DisTubeStream.YouTube(formats, streamOptions);
     return DisTubeStream.DirectLink(streamURL, streamOptions);
   }
+  /**
+   * Play a song on voice connection
+   * @private
+   * @param {Queue} queue The guild queue
+   * @returns {Promise<boolean>} error?
+   */
   async playSong(queue) {
     if (!queue)
       return true;
-    if (!queue.songs.length) {
+    if (queue.stopped || !queue.songs.length) {
       queue.stop();
       return true;
     }
-    if (queue.stopped)
-      return false;
     try {
       const song = queue.songs[0];
-      const { url, source, formats, streamURL, isLive } = song;
-      if (source === "youtube") {
-        if (!formats || !chooseBestVideoFormat(formats, isLive)) {
-          song._patchYouTube(await this.handler.getYouTubeInfo(url));
-        }
-      } else if (!streamURL) {
-        for (const plugin of [...this.distube.extractorPlugins, ...this.distube.customPlugins]) {
-          if (await plugin.validate(url)) {
-            const info = [plugin.getStreamURL(url), plugin.getRelatedSongs(url)];
-            const result = await Promise.all(info);
-            song.streamURL = result[0];
-            song.related = result[1];
-            break;
-          }
-        }
+      await this.handler.attachStreamInfo(song);
+      if (queue.stopped || !queue.songs.length) {
+        queue.stop();
+        return true;
       }
       const stream = this.createStream(queue);
       queue.voice.play(stream);
       song.streamURL = stream.url;
-      if (queue.stopped)
-        queue.stop();
-      else if (queue.paused)
-        queue.voice.pause();
       return false;
     } catch (e) {
       __privateMethod(this, _handlePlayingError, handlePlayingError_fn).call(this, queue, e);
@@ -1605,7 +2010,6 @@ var QueueManager = class extends GuildIdManager {
     }
   }
 };
-__name(QueueManager, "QueueManager");
 _voiceEventHandler = new WeakSet();
 voiceEventHandler_fn = /* @__PURE__ */ __name(function(queue) {
   queue._listeners = {
@@ -1622,6 +2026,10 @@ voiceEventHandler_fn = /* @__PURE__ */ __name(function(queue) {
     queue.voice.on(event, queue._listeners[event]);
   }
 }, "#voiceEventHandler");
+_emitPlaySong = new WeakSet();
+emitPlaySong_fn = /* @__PURE__ */ __name(function(queue) {
+  return !this.options.emitNewSongOnly || queue.repeatMode === 1 /* SONG */ && queue._next || queue.repeatMode !== 1 /* SONG */ && queue.songs[0]?.id !== queue.songs[1]?.id;
+}, "#emitPlaySong");
 _handleSongFinish = new WeakSet();
 handleSongFinish_fn = /* @__PURE__ */ __name(async function(queue) {
   this.emit("finishSong", queue, queue.songs[0]);
@@ -1695,14 +2103,19 @@ Name: ${song.name}`;
     queue.stop();
   }
 }, "#handlePlayingError");
-_emitPlaySong = new WeakSet();
-emitPlaySong_fn = /* @__PURE__ */ __name(function(queue) {
-  return !this.options.emitNewSongOnly || queue.repeatMode === 1 /* SONG */ && queue._next || queue.repeatMode !== 1 /* SONG */ && queue.songs[0]?.id !== queue.songs[1]?.id;
-}, "#emitPlaySong");
+__name(_QueueManager, "QueueManager");
+var QueueManager = _QueueManager;
 
 // src/struct/Queue.ts
 var _filters;
-var Queue = class extends DisTubeBase {
+var _Queue = class _Queue extends DisTubeBase {
+  /**
+   * Create a queue for the guild
+   * @param {DisTube} distube DisTube
+   * @param {DisTubeVoice} voice Voice connection
+   * @param {Song|Song[]} song First song(s)
+   * @param {Discord.BaseGuildTextChannel?} textChannel Default text channel
+   */
   constructor(distube, voice, song, textChannel) {
     super(distube);
     __publicField(this, "id");
@@ -1741,24 +2154,58 @@ var Queue = class extends DisTubeBase {
     this._taskQueue = new TaskQueue();
     this._listeners = void 0;
   }
+  /**
+   * The client user as a `GuildMember` of this queue's guild
+   * @type {Discord.GuildMember?}
+   */
   get clientMember() {
     return this.voice.channel.guild.members.me ?? void 0;
   }
+  /**
+   * The filter manager of the queue
+   * @type {FilterManager}
+   * @readonly
+   */
   get filters() {
     return __privateGet(this, _filters);
   }
+  /**
+   * Formatted duration string.
+   * @type {string}
+   * @readonly
+   */
   get formattedDuration() {
     return formatDuration(this.duration);
   }
+  /**
+   * Queue's duration.
+   * @type {number}
+   * @readonly
+   */
   get duration() {
     return this.songs.length ? this.songs.reduce((prev, next) => prev + next.duration, 0) : 0;
   }
+  /**
+   * What time in the song is playing (in seconds).
+   * @type {number}
+   * @readonly
+   */
   get currentTime() {
     return this.voice.playbackDuration + this.beginTime;
   }
+  /**
+   * Formatted {@link Queue#currentTime} string.
+   * @type {string}
+   * @readonly
+   */
   get formattedCurrentTime() {
     return formatDuration(this.currentTime);
   }
+  /**
+   * The voice channel playing in.
+   * @type {Discord.VoiceChannel|Discord.StageChannel|null}
+   * @readonly
+   */
   get voiceChannel() {
     return this.clientMember?.voice?.channel ?? null;
   }
@@ -1768,6 +2215,14 @@ var Queue = class extends DisTubeBase {
   set volume(value) {
     this.voice.volume = value;
   }
+  /**
+   * @private
+   * Add a Song or an array of Song to the queue
+   * @param {Song|Song[]} song Song to add
+   * @param {number} [position=0] Position to add, <= 0 to add to the end of the queue
+   * @throws {Error}
+   * @returns {Queue} The guild queue
+   */
   addToQueue(song, position = 0) {
     if (!song || Array.isArray(song) && !song.length) {
       throw new DisTubeError("INVALID_TYPE", ["Song", "Array<Song>"], song, "song");
@@ -1791,6 +2246,10 @@ var Queue = class extends DisTubeBase {
       delete song.formats;
     return this;
   }
+  /**
+   * Pause the guild stream
+   * @returns {Queue} The guild queue
+   */
   pause() {
     if (this.paused)
       throw new DisTubeError("PAUSED");
@@ -1799,6 +2258,10 @@ var Queue = class extends DisTubeBase {
     this.voice.pause();
     return this;
   }
+  /**
+   * Resume the guild stream
+   * @returns {Queue} The guild queue
+   */
   resume() {
     if (this.playing)
       throw new DisTubeError("RESUMED");
@@ -1807,10 +2270,22 @@ var Queue = class extends DisTubeBase {
     this.voice.unpause();
     return this;
   }
+  /**
+   * Set the guild stream's volume
+   * @param {number} percent The percentage of volume you want to set
+   * @returns {Queue} The guild queue
+   */
   setVolume(percent) {
     this.volume = percent;
     return this;
   }
+  /**
+   * Skip the playing song if there is a next song in the queue.
+   * <info>If {@link Queue#autoplay} is `true` and there is no up next song,
+   * DisTube will add and play a related song.</info>
+   * @returns {Promise<Song>} The song will skip to
+   * @throws {Error}
+   */
   async skip() {
     await this._taskQueue.queuing();
     try {
@@ -1828,6 +2303,11 @@ var Queue = class extends DisTubeBase {
       this._taskQueue.resolve();
     }
   }
+  /**
+   * Play the previous song if exists
+   * @returns {Promise<Song>} The guild queue
+   * @throws {Error}
+   */
   async previous() {
     await this._taskQueue.queuing();
     try {
@@ -1844,6 +2324,10 @@ var Queue = class extends DisTubeBase {
       this._taskQueue.resolve();
     }
   }
+  /**
+   * Shuffle the queue's songs
+   * @returns {Promise<Queue>} The guild queue
+   */
   async shuffle() {
     await this._taskQueue.queuing();
     try {
@@ -1860,6 +2344,14 @@ var Queue = class extends DisTubeBase {
       this._taskQueue.resolve();
     }
   }
+  /**
+   * Jump to the song position in the queue.
+   * The next one is 1, 2,...
+   * The previous one is -1, -2,...
+   * @param {number} position The song position to play
+   * @returns {Promise<Song>} The new Song will be played
+   * @throws {Error} if `num` is invalid number
+   */
   async jump(position) {
     await this._taskQueue.queuing();
     try {
@@ -1893,6 +2385,12 @@ var Queue = class extends DisTubeBase {
       this._taskQueue.resolve();
     }
   }
+  /**
+   * Set the repeat mode of the guild queue.\
+   * Toggle mode `(Disabled -> Song -> Queue -> Disabled ->...)` if `mode` is `undefined`
+   * @param {RepeatMode?} [mode] The repeat modes (toggle if `undefined`)
+   * @returns {RepeatMode} The new repeat mode
+   */
   setRepeatMode(mode) {
     if (mode !== void 0 && !Object.values(RepeatMode).includes(mode)) {
       throw new DisTubeError("INVALID_TYPE", ["RepeatMode", "undefined"], mode, "mode");
@@ -1905,6 +2403,11 @@ var Queue = class extends DisTubeBase {
       this.repeatMode = mode;
     return this.repeatMode;
   }
+  /**
+   * Set the playing time to another position
+   * @param {number} time Time in seconds
+   * @returns {Queue} The guild queue
+   */
   seek(time) {
     if (typeof time !== "number")
       throw new DisTubeError("INVALID_TYPE", "number", time, "time");
@@ -1914,6 +2417,11 @@ var Queue = class extends DisTubeBase {
     this.queues.playSong(this);
     return this;
   }
+  /**
+   * Add a related song of the playing song to the queue
+   * @returns {Promise<Song>} The added song
+   * @throws {Error}
+   */
   async addRelatedSong() {
     if (!this.songs?.[0])
       throw new DisTubeError("NO_PLAYING");
@@ -1926,6 +2434,9 @@ var Queue = class extends DisTubeBase {
     this.addToQueue(song);
     return song;
   }
+  /**
+   * Stop the guild stream and delete the queue
+   */
   async stop() {
     await this._taskQueue.queuing();
     try {
@@ -1941,6 +2452,11 @@ var Queue = class extends DisTubeBase {
       this._taskQueue.resolve();
     }
   }
+  /**
+   * Remove the queue from the manager
+   * (This does not leave the voice channel even if {@link DisTubeOptions|DisTubeOptions.leaveOnStop} is enabled)
+   * @private
+   */
   remove() {
     this.stopped = true;
     this.songs = [];
@@ -1953,72 +2469,138 @@ var Queue = class extends DisTubeBase {
     this.queues.remove(this.id);
     this.emit("deleteQueue", this);
   }
+  /**
+   * Toggle autoplay mode
+   * @returns {boolean} Autoplay mode state
+   */
   toggleAutoplay() {
     this.autoplay = !this.autoplay;
     return this.autoplay;
   }
 };
-__name(Queue, "Queue");
 _filters = new WeakMap();
+__name(_Queue, "Queue");
+var Queue = _Queue;
 
 // src/struct/Plugin.ts
-var Plugin = class {
+var _Plugin = class _Plugin {
   constructor() {
     __publicField(this, "distube");
   }
   init(distube) {
     this.distube = distube;
   }
+  /**
+   * Type of the plugin
+   * @name Plugin#type
+   * @type {PluginType}
+   */
+  /**
+   * Emit an event to the {@link DisTube} class
+   * @param {string} eventName Event name
+   * @param {...any} args arguments
+   * @returns {boolean}
+   */
   emit(eventName, ...args) {
     return this.distube.emit(eventName, ...args);
   }
+  /**
+   * Emit error event to the {@link DisTube} class
+   * @param {Error} error error
+   * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
+   */
   emitError(error, channel) {
     this.distube.emitError(error, channel);
   }
+  /**
+   * The queue manager
+   * @type {QueueManager}
+   * @readonly
+   */
   get queues() {
     return this.distube.queues;
   }
+  /**
+   * The voice manager
+   * @type {DisTubeVoiceManager}
+   * @readonly
+   */
   get voices() {
     return this.distube.voices;
   }
+  /**
+   * Discord.js client
+   * @type {Discord.Client}
+   * @readonly
+   */
   get client() {
     return this.distube.client;
   }
+  /**
+   * DisTube options
+   * @type {DisTubeOptions}
+   * @readonly
+   */
   get options() {
     return this.distube.options;
   }
+  /**
+   * DisTube handler
+   * @type {DisTubeHandler}
+   * @readonly
+   */
   get handler() {
     return this.distube.handler;
   }
+  /**
+   * Check if the string is working with this plugin
+   * @param {string} _string Input string
+   * @returns {boolean|Promise<boolean>}
+   */
   validate(_string) {
     return false;
   }
+  /**
+   * Get the stream url from {@link Song#url}. Returns {@link Song#url} by default.
+   * Not needed if the plugin plays song from YouTube.
+   * @param {string} url Input url
+   * @returns {string|Promise<string>}
+   */
   getStreamURL(url) {
     return url;
   }
+  /**
+   * Get related songs from a supported url. {@link Song#member} should be `undefined`.
+   * Not needed to add {@link Song#related} because it will be added with this function later.
+   * @param {string} _url Input url
+   * @returns {Song[]|Promise<Song[]>}
+   */
   getRelatedSongs(_url) {
     return [];
   }
 };
-__name(Plugin, "Plugin");
+__name(_Plugin, "Plugin");
+var Plugin = _Plugin;
 
 // src/struct/CustomPlugin.ts
-var CustomPlugin = class extends Plugin {
+var _CustomPlugin = class _CustomPlugin extends Plugin {
   constructor() {
     super(...arguments);
     __publicField(this, "type", "custom" /* CUSTOM */);
   }
 };
-__name(CustomPlugin, "CustomPlugin");
+__name(_CustomPlugin, "CustomPlugin");
+var CustomPlugin = _CustomPlugin;
 
 // src/struct/ExtractorPlugin.ts
-var ExtractorPlugin = class extends Plugin {
+var _ExtractorPlugin = class _ExtractorPlugin extends Plugin {
   constructor() {
     super(...arguments);
     __publicField(this, "type", "extractor" /* EXTRACTOR */);
   }
 };
-__name(ExtractorPlugin, "ExtractorPlugin");
+__name(_ExtractorPlugin, "ExtractorPlugin");
+var ExtractorPlugin = _ExtractorPlugin;
 
 // src/util.ts
 var import_url = require("url");
@@ -2027,7 +2609,7 @@ var formatInt = /* @__PURE__ */ __name((int) => int < 10 ? `0${int}` : int, "for
 function formatDuration(sec) {
   if (!sec || !Number(sec))
     return "00:00";
-  const seconds = Math.round(sec % 60);
+  const seconds = Math.floor(sec % 60);
   const minutes = Math.floor(sec % 3600 / 60);
   const hours = Math.floor(sec / 3600);
   if (hours > 0)
@@ -2062,12 +2644,13 @@ function parseNumber(input) {
   return Number(input) || 0;
 }
 __name(parseNumber, "parseNumber");
+var SUPPORTED_PROTOCOL = ["https:", "http:", "file:"];
 function isURL(input) {
   if (typeof input !== "string" || input.includes(" "))
     return false;
   try {
     const url = new import_url.URL(input);
-    if (!["https:", "http:"].includes(url.protocol) || !url.host)
+    if (!SUPPORTED_PROTOCOL.some((p) => p === url.protocol))
       return false;
   } catch {
     return false;
@@ -2106,7 +2689,7 @@ function isMemberInstance(member) {
 }
 __name(isMemberInstance, "isMemberInstance");
 function isTextChannelInstance(channel) {
-  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && typeof channel.name === "string" && import_discord3.Constants.TextBasedChannelTypes.includes(channel.type) && typeof channel.nsfw === "boolean" && "messages" in channel && typeof channel.send === "function";
+  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && typeof channel.name === "string" && import_discord3.Constants.TextBasedChannelTypes.includes(channel.type) && "messages" in channel && typeof channel.send === "function";
 }
 __name(isTextChannelInstance, "isTextChannelInstance");
 function isMessageInstance(message) {
@@ -2166,20 +2749,30 @@ function objectKeys(obj) {
   return Object.keys(obj);
 }
 __name(objectKeys, "objectKeys");
+function isNsfwChannel(channel) {
+  if (!isTextChannelInstance(channel))
+    return false;
+  if (channel.isThread())
+    return channel.parent?.nsfw ?? false;
+  return channel.nsfw;
+}
+__name(isNsfwChannel, "isNsfwChannel");
 
 // src/plugin/DirectLink.ts
 var import_undici = require("undici");
-var DirectLinkPlugin = class extends ExtractorPlugin {
+var _DirectLinkPlugin = class _DirectLinkPlugin extends ExtractorPlugin {
   async validate(url) {
     try {
       const headers = await (0, import_undici.request)(url, { method: "HEAD" }).then((res) => res.headers);
-      const type = headers["content-type"];
-      if (type?.startsWith("audio"))
+      const types = headers["content-type"];
+      const type = Array.isArray(types) ? types[0] : types;
+      if (["audio/", "video/", "application/ogg"].some((s) => type?.startsWith(s)))
         return true;
     } catch {
     }
     return false;
   }
+  // eslint-disable-next-line @typescript-eslint/require-await
   async resolve(url, options = {}) {
     url = url.replace(/\/+$/, "");
     return new Song(
@@ -2192,13 +2785,28 @@ var DirectLinkPlugin = class extends ExtractorPlugin {
     );
   }
 };
-__name(DirectLinkPlugin, "DirectLinkPlugin");
+__name(_DirectLinkPlugin, "DirectLinkPlugin");
+var DirectLinkPlugin = _DirectLinkPlugin;
 
 // src/DisTube.ts
 var import_ytsr = __toESM(require("@distube/ytsr"));
 var import_tiny_typed_emitter2 = require("tiny-typed-emitter");
 var { version } = require_package();
-var DisTube = class extends import_tiny_typed_emitter2.TypedEmitter {
+var _DisTube = class _DisTube extends import_tiny_typed_emitter2.TypedEmitter {
+  /**
+   * Create a new DisTube class.
+   * @param {Discord.Client} client Discord.JS client
+   * @param {DisTubeOptions} [otp] Custom DisTube options
+   * @throws {DisTubeError}
+   * @example
+   * const Discord = require('discord.js'),
+   *     DisTube = require('distube'),
+   *     client = new Discord.Client();
+   * // Create a new DisTube
+   * const distube = new DisTube.default(client, { searchSongs: 10 });
+   * // client.DisTube = distube // make it access easily
+   * client.login("Your Discord Bot Token")
+   */
   constructor(client, otp = {}) {
     super();
     __publicField(this, "handler");
@@ -2228,9 +2836,36 @@ var DisTube = class extends import_tiny_typed_emitter2.TypedEmitter {
   static get version() {
     return version;
   }
+  /**
+   * DisTube version
+   * @type {string}
+   */
   get version() {
     return version;
   }
+  /**
+   * Play / add a song or playlist from url. Search and play a song if it is not a valid url.
+   *
+   * @param {Discord.BaseGuildVoiceChannel} voiceChannel The channel will be joined if the bot isn't in any channels,
+   * the bot will be moved to this channel if {@link DisTubeOptions}.joinNewVoiceChannel is `true`
+   * @param {string|Song|SearchResult|Playlist} song URL | Search string |
+   * {@link Song} | {@link SearchResult} | {@link Playlist}
+   * @param {PlayOptions} [options] Optional options
+   * @throws {DisTubeError}
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "play")
+   *         distube.play(message.member.voice.channel, args.join(" "), {
+   *             member: message.member,
+   *             textChannel: message.channel,
+   *             message
+   *         });
+   * });
+   * @returns {Promise<void>}
+   */
   async play(voiceChannel, song, options = {}) {
     if (!isSupportedVoiceChannel(voiceChannel)) {
       throw new DisTubeError("INVALID_TYPE", "BaseGuildVoiceChannel", voiceChannel, "voiceChannel");
@@ -2297,6 +2932,20 @@ ${e.message}`;
         queue?._taskQueue.resolve();
     }
   }
+  /**
+   * Create a custom playlist
+   * @returns {Promise<Playlist>}
+   * @param {Array<string|Song|SearchResult>} songs Array of url, Song or SearchResult
+   * @param {CustomPlaylistOptions} [options] Optional options
+   * @example
+   * const songs = ["https://www.youtube.com/watch?v=xxx", "https://www.youtube.com/watch?v=yyy"];
+   * const playlist = await distube.createCustomPlaylist(songs, {
+   *     member: message.member,
+   *     properties: { name: "My playlist name", source: "custom" },
+   *     parallel: true
+   * });
+   * distube.play(voiceChannel, playlist, { ... });
+   */
   async createCustomPlaylist(songs, options = {}) {
     const { member, properties, parallel, metadata } = { parallel: true, ...options };
     if (!Array.isArray(songs))
@@ -2311,8 +2960,6 @@ ${e.message}`;
     if (member && !isMemberInstance(member)) {
       throw new DisTubeError("INVALID_TYPE", "Discord.Member", member, "options.member");
     }
-    if (!filteredSongs.length)
-      throw new DisTubeError("NO_VALID_SONG");
     let resolvedSongs;
     if (parallel) {
       const promises = filteredSongs.map(
@@ -2328,6 +2975,18 @@ ${e.message}`;
     }
     return new Playlist(resolvedSongs, { member, properties, metadata });
   }
+  /**
+   * Search for a song. You can customize how user answers instead of send a number.
+   * Then use {@link DisTube#play} to play it.
+   *
+   * @param {string} string The string search for
+   * @param {Object} options Search options
+   * @param {number} [options.limit=10] Limit the results
+   * @param {SearchResultType} [options.type=SearchResultType.VIDEO] Type of results (`video` or `playlist`).
+   * @param {boolean} [options.safeSearch=false] Whether or not use safe search (YouTube restricted mode)
+   * @throws {Error}
+   * @returns {Promise<Array<SearchResult>>} Array of results
+   */
   async search(string, options = {}) {
     const opts = { type: "video" /* VIDEO */, limit: 10, safeSearch: false, ...options };
     if (typeof opts.type !== "string" || !["video", "playlist"].includes(opts.type)) {
@@ -2357,63 +3016,234 @@ ${e.message}`;
       return this.search(string, options);
     }
   }
+  /**
+   * Get the guild queue
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {Queue?}
+   * @throws {Error}
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "queue") {
+   *         const queue = distube.getQueue(message);
+   *         message.channel.send('Current queue:\n' + queue.songs.map((song, id) =>
+   *             `**${id+1}**. [${song.name}](${song.url}) - \`${song.formattedDuration}\``
+   *         ).join("\n"));
+   *     }
+   * });
+   */
   getQueue(guild) {
     return this.queues.get(guild);
   }
+  /**
+   * Pause the guild stream
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {Queue} The guild queue
+   * @throws {Error}
+   */
   pause(guild) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.pause();
   }
+  /**
+   * Resume the guild stream
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {Queue} The guild queue
+   * @throws {Error}
+   */
   resume(guild) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.resume();
   }
+  /**
+   * Stop the guild stream
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {Promise<void>}
+   * @throws {Error}
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "stop") {
+   *         distube.stop(message);
+   *         message.channel.send("Stopped the queue!");
+   *     }
+   * });
+   */
   stop(guild) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.stop();
   }
+  /**
+   * Set the guild stream's volume
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @param {number} percent The percentage of volume you want to set
+   * @returns {Queue} The guild queue
+   * @throws {Error}
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "volume")
+   *         distube.setVolume(message, Number(args[0]));
+   * });
+   */
   setVolume(guild, percent) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.setVolume(percent);
   }
+  /**
+   * Skip the playing song if there is a next song in the queue.
+   * <info>If {@link Queue#autoplay} is `true` and there is no up next song,
+   * DisTube will add and play a related song.</info>
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {Promise<Song>} The new Song will be played
+   * @throws {Error}
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "skip")
+   *         distube.skip(message);
+   * });
+   */
   skip(guild) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.skip();
   }
+  /**
+   * Play the previous song
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {Promise<Song>} The new Song will be played
+   * @throws {Error}
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "previous")
+   *         distube.previous(message);
+   * });
+   */
   previous(guild) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.previous();
   }
+  /**
+   * Shuffle the guild queue songs
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {Promise<Queue>} The guild queue
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "shuffle")
+   *         distube.shuffle(message);
+   * });
+   */
   shuffle(guild) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.shuffle();
   }
+  /**
+   * Jump to the song number in the queue.
+   * The next one is 1, 2,...
+   * The previous one is -1, -2,...
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @param {number} num The song number to play
+   * @returns {Promise<Song>} The new Song will be played
+   * @throws {Error} if `num` is invalid number (0 < num < {@link Queue#songs}.length)
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "jump")
+   *         distube.jump(message, parseInt(args[0]))
+   *             .catch(err => message.channel.send("Invalid song number."));
+   * });
+   */
   jump(guild, num) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.jump(num);
   }
+  /**
+   * Set the repeat mode of the guild queue.\
+   * Toggle mode `(Disabled -> Song -> Queue -> Disabled ->...)` if `mode` is `undefined`
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @param {RepeatMode?} [mode] The repeat modes (toggle if `undefined`)
+   * @returns {RepeatMode} The new repeat mode
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "repeat") {
+   *         let mode = distube.setRepeatMode(message, parseInt(args[0]));
+   *         mode = mode ? mode == 2 ? "Repeat queue" : "Repeat song" : "Off";
+   *         message.channel.send("Set repeat mode to `" + mode + "`");
+   *     }
+   * });
+   * @example
+   * const { RepeatMode } = require("distube");
+   * let mode;
+   * switch(distube.setRepeatMode(message, parseInt(args[0]))) {
+   *     case RepeatMode.DISABLED:
+   *         mode = "Off";
+   *         break;
+   *     case RepeatMode.SONG:
+   *         mode = "Repeat a song";
+   *         break;
+   *     case RepeatMode.QUEUE:
+   *         mode = "Repeat all queue";
+   *         break;
+   * }
+   * message.channel.send("Set repeat mode to `" + mode + "`");
+   */
   setRepeatMode(guild, mode) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.setRepeatMode(mode);
   }
+  /**
+   * Toggle autoplay mode
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {boolean} Autoplay mode state
+   * @throws {Error}
+   * @example
+   * client.on('message', (message) => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command == "autoplay") {
+   *         const mode = distube.toggleAutoplay(message);
+   *         message.channel.send("Set autoplay mode to `" + (mode ? "On" : "Off") + "`");
+   *     }
+   * });
+   */
   toggleAutoplay(guild) {
     const q = this.getQueue(guild);
     if (!q)
@@ -2421,18 +3251,43 @@ ${e.message}`;
     q.autoplay = !q.autoplay;
     return q.autoplay;
   }
+  /**
+   * Add related song to the queue
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @returns {Promise<Song>} The guild queue
+   */
   addRelatedSong(guild) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.addRelatedSong();
   }
+  /**
+   * Set the playing time to another position
+   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
+   * @param {number} time Time in seconds
+   * @returns {Queue} Seeked queue
+   * @example
+   * client.on('message', message => {
+   *     if (!message.content.startsWith(config.prefix)) return;
+   *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
+   *     const command = args.shift();
+   *     if (command = 'seek')
+   *         distube.seek(message, Number(args[0]));
+   * });
+   */
   seek(guild, time) {
     const q = this.getQueue(guild);
     if (!q)
       throw new DisTubeError("NO_QUEUE");
     return q.seek(time);
   }
+  /**
+   * Emit error event
+   * @param {Error} error error
+   * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
+   * @private
+   */
   emitError(error, channel) {
     if (this.listeners("error").length) {
       this.emit("error", channel, error);
@@ -2445,7 +3300,8 @@ ${e.message}`;
     }
   }
 };
-__name(DisTube, "DisTube");
+__name(_DisTube, "DisTube");
+var DisTube = _DisTube;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseManager,
@@ -2485,6 +3341,7 @@ __name(DisTube, "DisTube");
   isGuildInstance,
   isMemberInstance,
   isMessageInstance,
+  isNsfwChannel,
   isObject,
   isRecord,
   isSnowflake,