distube 4.0.0-dev.5 → 4.0.1

package/dist/index.mjs

@@ -44,7 +44,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "distube",
-      version: "4.0.0-dev.5",
+      version: "4.0.1",
       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",
       module: "./dist/index.mjs",
@@ -110,46 +110,47 @@ var require_package = __commonJS({
       dependencies: {
         "@distube/ytdl-core": "^4.11.3",
         "@distube/ytpl": "^1.1.1",
-        "@distube/ytsr": "^1.1.5",
+        "@distube/ytsr": "^1.1.8",
         "prism-media": "https://codeload.github.com/distubejs/prism-media/tar.gz/main#workaround.tar.gz",
         "tiny-typed-emitter": "^2.1.0",
-        tslib: "^2.4.0"
+        tslib: "^2.4.0",
+        undici: "^5.8.0"
       },
       devDependencies: {
-        "@babel/core": "^7.18.0",
-        "@babel/plugin-proposal-class-properties": "^7.17.12",
-        "@babel/plugin-proposal-object-rest-spread": "^7.18.0",
-        "@babel/preset-env": "^7.18.0",
-        "@babel/preset-typescript": "^7.17.12",
-        "@commitlint/cli": "^17.0.0",
-        "@commitlint/config-conventional": "^17.0.0",
-        "@discordjs/voice": "dev",
+        "@babel/core": "^7.18.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",
         "@distube/docgen": "distubejs/docgen",
-        "@types/jest": "^27.5.1",
-        "@types/node": "^17.0.35",
-        "@typescript-eslint/eslint-plugin": "^5.25.0",
-        "@typescript-eslint/parser": "^5.25.0",
-        "babel-jest": "^28.1.0",
-        "discord.js": "dev",
-        eslint: "^8.15.0",
+        "@types/jest": "^28.1.6",
+        "@types/node": "^18.0.6",
+        "@typescript-eslint/eslint-plugin": "^5.30.7",
+        "@typescript-eslint/parser": "^5.30.7",
+        "babel-jest": "^28.1.3",
+        "discord.js": "^14.0.2",
+        eslint: "^8.20.0",
         "eslint-config-distube": "^1.6.4",
         "eslint-config-prettier": "^8.5.0",
         "eslint-plugin-deprecation": "^1.3.2",
-        "eslint-plugin-jsdoc": "^39.3.0",
+        "eslint-plugin-jsdoc": "^39.3.3",
         husky: "^8.0.1",
-        jest: "^28.1.0",
+        jest: "^28.1.3",
         "jsdoc-babel": "^0.5.0",
         "nano-staged": "^0.8.0",
-        "npm-check-updates": "^13.0.1",
+        "npm-check-updates": "^15.3.4",
         pinst: "^3.0.0",
-        prettier: "^2.6.2",
-        tsup: "^5.12.8",
-        typescript: "^4.6.4"
+        prettier: "^2.7.1",
+        tsup: "^6.1.3",
+        typescript: "^4.7.4"
       },
       peerDependencies: {
         "@discordjs/opus": "*",
         "@discordjs/voice": "*",
-        "discord.js": "14||^14.0.0-dev"
+        "discord.js": "14"
       },
       peerDependenciesMeta: {
         "@discordjs/opus": {
@@ -168,8 +169,7 @@ var require_package = __commonJS({
       engines: {
         node: ">=16.9.0"
       },
-      packageManager: "yarn@3.2.0",
-      stableVersion: "4.0.0-dev"
+      packageManager: "yarn@3.2.0"
     };
   }
 });
@@ -236,7 +236,7 @@ var defaultOptions = {
 // src/struct/DisTubeError.ts
 import { inspect } from "node:util";
 var ERROR_MESSAGES = {
-  INVALID_TYPE: (expected, got, name) => `Expected ${Array.isArray(expected) ? expected.map((e) => typeof e === "number" ? e : `'${e}'`).join(" or ") : `'${expected}'`}${name ? ` for '${name}'` : ""}, but got ${inspect(got)}`,
+  INVALID_TYPE: (expected, got, name) => `Expected ${Array.isArray(expected) ? expected.map((e) => typeof e === "number" ? e : `'${e}'`).join(" or ") : `'${expected}'`}${name ? ` for '${name}'` : ""}, but got ${inspect(got)} (${typeof got})`,
   NUMBER_COMPARE: (name, expected, value) => `'${name}' must be ${expected} ${value}`,
   EMPTY_ARRAY: (name) => `'${name}' is an empty array`,
   EMPTY_FILTERED_ARRAY: (name, type) => `There is no valid '${type}' in the '${name}' array`,
@@ -342,23 +342,31 @@ var Playlist = class {
     __publicField(this, "url");
     __publicField(this, "thumbnail");
     const { member, properties, metadata } = options;
-    if (typeof playlist !== "object") {
-      throw new DisTubeError("INVALID_TYPE", ["Array<Song>", "object"], playlist, "playlist");
+    if (typeof playlist !== "object" || !Array.isArray(playlist) && ["source", "songs"].some((key) => !(key in playlist))) {
+      throw new DisTubeError("INVALID_TYPE", ["Array<Song>", "PlaylistInfo"], playlist, "playlist");
     }
     if (typeof properties !== "undefined" && !isRecord(properties)) {
       throw new DisTubeError("INVALID_TYPE", "object", properties, "properties");
     }
-    const info = playlist;
-    this.source = (info.source || properties?.source || "youtube").toLowerCase();
-    this.songs = Array.isArray(info) ? info : info.items || info.songs;
-    if (!Array.isArray(this.songs) || !this.songs.length) {
-      throw new DisTubeError("EMPTY_PLAYLIST");
+    if (Array.isArray(playlist)) {
+      this.source = "youtube";
+      if (!playlist.length)
+        throw new DisTubeError("EMPTY_PLAYLIST");
+      this.songs = playlist;
+      this.name = this.songs[0].name ? `${this.songs[0].name} and ${this.songs.length - 1} more songs.` : `${this.songs.length} songs playlist`;
+      this.thumbnail = this.songs[0].thumbnail;
+      this.member = member || void 0;
+    } else {
+      this.source = (playlist.source || "youtube").toLowerCase();
+      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.url = playlist.url || playlist.webpage_url;
+      this.thumbnail = playlist.thumbnail || this.songs[0].thumbnail;
+      this.member = member || playlist.member || void 0;
     }
     this.songs.map((s) => s.constructor.name === "Song" && (s.playlist = this));
-    this.member = member || info.member || void 0;
-    this.name = info.name || info.title || (this.songs[0].name ? `${this.songs[0].name} and ${this.songs.length - 1} more songs.` : `${this.songs.length} songs playlist`);
-    this.url = info.url || info.webpage_url;
-    this.thumbnail = info.thumbnail?.url || info.thumbnail || this.songs[0].thumbnail;
     if (properties)
       for (const [key, value] of Object.entries(properties))
         this[key] = value;
@@ -395,41 +403,64 @@ _metadata = new WeakMap();
 _member = new WeakMap();
 
 // src/struct/SearchResult.ts
-var SearchResult = class {
+var ISearchResult = class {
   constructor(info) {
     __publicField(this, "source");
-    __publicField(this, "type");
     __publicField(this, "id");
     __publicField(this, "name");
     __publicField(this, "url");
-    __publicField(this, "views");
-    __publicField(this, "isLive");
-    __publicField(this, "duration");
-    __publicField(this, "formattedDuration");
-    __publicField(this, "thumbnail");
     __publicField(this, "uploader");
     this.source = "youtube";
-    this.type = info.type === "video" ? "video" /* VIDEO */ : "playlist" /* PLAYLIST */;
     this.id = info.id;
     this.name = info.name;
     this.url = info.url;
-    if (this.type === "video" /* VIDEO */) {
-      info = info;
-      this.views = info.views;
-      this.isLive = info.isLive;
-      this.duration = this.isLive ? 0 : toSecond(info.duration);
-      this.formattedDuration = this.isLive ? "Live" : formatDuration(this.duration);
-      this.thumbnail = info.thumbnail;
-    } else if (this.type !== "playlist") {
-      throw new DisTubeError("INVALID_TYPE", ["video", "playlist"], this.type, "SearchResult.type");
-    }
     this.uploader = {
-      name: (info.author || info.owner)?.name,
-      url: (info.author || info.owner)?.url
+      name: void 0,
+      url: void 0
+    };
+  }
+};
+__name(ISearchResult, "ISearchResult");
+var SearchResultVideo = class extends ISearchResult {
+  constructor(info) {
+    super(info);
+    __publicField(this, "type");
+    __publicField(this, "views");
+    __publicField(this, "isLive");
+    __publicField(this, "duration");
+    __publicField(this, "formattedDuration");
+    __publicField(this, "thumbnail");
+    if (info.type !== "video")
+      throw new DisTubeError("INVALID_TYPE", "video", info.type, "type");
+    this.type = "video" /* VIDEO */;
+    this.views = info.views;
+    this.isLive = info.isLive;
+    this.duration = this.isLive ? 0 : toSecond(info.duration);
+    this.formattedDuration = this.isLive ? "Live" : formatDuration(this.duration);
+    this.thumbnail = info.thumbnail;
+    this.uploader = {
+      name: info.author?.name,
+      url: info.author?.url
+    };
+  }
+};
+__name(SearchResultVideo, "SearchResultVideo");
+var SearchResultPlaylist = class extends ISearchResult {
+  constructor(info) {
+    super(info);
+    __publicField(this, "type");
+    __publicField(this, "length");
+    if (info.type !== "playlist")
+      throw new DisTubeError("INVALID_TYPE", "playlist", info.type, "type");
+    this.type = "playlist" /* PLAYLIST */;
+    this.length = info.length;
+    this.uploader = {
+      name: info.owner?.name,
+      url: info.owner?.url
     };
   }
 };
-__name(SearchResult, "SearchResult");
+__name(SearchResultPlaylist, "SearchResultPlaylist");
 
 // src/struct/Song.ts
 var _metadata2, _member2, _playlist;
@@ -569,114 +600,6 @@ _metadata2 = new WeakMap();
 _member2 = new WeakMap();
 _playlist = new WeakMap();
 
-// src/core/DisTubeOptions.ts
-var _validateOptions, validateOptions_fn;
-var Options = class {
-  constructor(options) {
-    __privateAdd(this, _validateOptions);
-    __publicField(this, "plugins");
-    __publicField(this, "emitNewSongOnly");
-    __publicField(this, "leaveOnFinish");
-    __publicField(this, "leaveOnStop");
-    __publicField(this, "leaveOnEmpty");
-    __publicField(this, "emptyCooldown");
-    __publicField(this, "savePreviousSongs");
-    __publicField(this, "searchSongs");
-    __publicField(this, "searchCooldown");
-    __publicField(this, "youtubeCookie");
-    __publicField(this, "youtubeIdentityToken");
-    __publicField(this, "customFilters");
-    __publicField(this, "ytdlOptions");
-    __publicField(this, "nsfw");
-    __publicField(this, "emitAddSongWhenCreatingQueue");
-    __publicField(this, "emitAddListWhenCreatingQueue");
-    __publicField(this, "joinNewVoiceChannel");
-    __publicField(this, "streamType");
-    if (typeof options !== "object" || Array.isArray(options)) {
-      throw new DisTubeError("INVALID_TYPE", "object", options, "DisTubeOptions");
-    }
-    const opts = { ...defaultOptions, ...options };
-    this.plugins = opts.plugins;
-    this.emitNewSongOnly = opts.emitNewSongOnly;
-    this.leaveOnEmpty = opts.leaveOnEmpty;
-    this.leaveOnFinish = opts.leaveOnFinish;
-    this.leaveOnStop = opts.leaveOnStop;
-    this.savePreviousSongs = opts.savePreviousSongs;
-    this.searchSongs = opts.searchSongs;
-    this.youtubeCookie = opts.youtubeCookie;
-    this.youtubeIdentityToken = opts.youtubeIdentityToken;
-    this.customFilters = opts.customFilters;
-    this.ytdlOptions = opts.ytdlOptions;
-    this.searchCooldown = opts.searchCooldown;
-    this.emptyCooldown = opts.emptyCooldown;
-    this.nsfw = opts.nsfw;
-    this.emitAddSongWhenCreatingQueue = opts.emitAddSongWhenCreatingQueue;
-    this.emitAddListWhenCreatingQueue = opts.emitAddListWhenCreatingQueue;
-    this.joinNewVoiceChannel = opts.joinNewVoiceChannel;
-    this.streamType = opts.streamType;
-    checkInvalidKey(opts, this, "DisTubeOptions");
-    __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") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.emitNewSongOnly, "DisTubeOptions.emitNewSongOnly");
-  }
-  if (typeof options.leaveOnEmpty !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.leaveOnEmpty, "DisTubeOptions.leaveOnEmpty");
-  }
-  if (typeof options.leaveOnFinish !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.leaveOnFinish, "DisTubeOptions.leaveOnFinish");
-  }
-  if (typeof options.leaveOnStop !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.leaveOnStop, "DisTubeOptions.leaveOnStop");
-  }
-  if (typeof options.savePreviousSongs !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.savePreviousSongs, "DisTubeOptions.savePreviousSongs");
-  }
-  if (typeof options.joinNewVoiceChannel !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.joinNewVoiceChannel, "DisTubeOptions.joinNewVoiceChannel");
-  }
-  if (typeof options.youtubeCookie !== "undefined" && typeof options.youtubeCookie !== "string") {
-    throw new DisTubeError("INVALID_TYPE", "string", options.youtubeCookie, "DisTubeOptions.youtubeCookie");
-  }
-  if (typeof options.youtubeIdentityToken !== "undefined" && typeof options.youtubeIdentityToken !== "string") {
-    throw new DisTubeError("INVALID_TYPE", "string", options.youtubeIdentityToken, "DisTubeOptions.youtubeIdentityToken");
-  }
-  if (typeof options.customFilters !== "undefined" && typeof options.customFilters !== "object" || Array.isArray(options.customFilters)) {
-    throw new DisTubeError("INVALID_TYPE", "object", options.customFilters, "DisTubeOptions.customFilters");
-  }
-  if (typeof options.ytdlOptions !== "object" || Array.isArray(options.ytdlOptions)) {
-    throw new DisTubeError("INVALID_TYPE", "object", options.ytdlOptions, "DisTubeOptions.ytdlOptions");
-  }
-  if (typeof options.searchCooldown !== "number" || isNaN(options.searchCooldown)) {
-    throw new DisTubeError("INVALID_TYPE", "number", options.searchCooldown, "DisTubeOptions.searchCooldown");
-  }
-  if (typeof options.emptyCooldown !== "number" || isNaN(options.emptyCooldown)) {
-    throw new DisTubeError("INVALID_TYPE", "number", options.emptyCooldown, "DisTubeOptions.emptyCooldown");
-  }
-  if (typeof options.searchSongs !== "number" || isNaN(options.searchSongs)) {
-    throw new DisTubeError("INVALID_TYPE", "number", options.searchSongs, "DisTubeOptions.searchSongs");
-  }
-  if (!Array.isArray(options.plugins)) {
-    throw new DisTubeError("INVALID_TYPE", "Array<Plugin>", options.plugins, "DisTubeOptions.plugins");
-  }
-  if (typeof options.nsfw !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.nsfw, "DisTubeOptions.nsfw");
-  }
-  if (typeof options.emitAddSongWhenCreatingQueue !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.emitAddSongWhenCreatingQueue, "DisTubeOptions.emitAddSongWhenCreatingQueue");
-  }
-  if (typeof options.emitAddListWhenCreatingQueue !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.emitAddListWhenCreatingQueue, "DisTubeOptions.emitAddListWhenCreatingQueue");
-  }
-  if (typeof options.streamType !== "number" || isNaN(options.streamType) || !StreamType[options.streamType]) {
-    throw new DisTubeError("INVALID_TYPE", "StreamType", options.streamType, "DisTubeOptions.streamType");
-  }
-}, "#validateOptions");
-
 // src/core/DisTubeBase.ts
 var DisTubeBase = class {
   constructor(distube) {
@@ -707,77 +630,202 @@ var DisTubeBase = class {
 };
 __name(DisTubeBase, "DisTubeBase");
 
-// src/core/DisTubeStream.ts
-import { FFmpeg } from "prism-media";
-import { StreamType as DiscordVoiceStreamType } from "@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 ? DiscordVoiceStreamType.Opus : DiscordVoiceStreamType.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 FFmpeg({ args, shell: false });
+// src/core/DisTubeVoice.ts
+import { TypedEmitter } from "tiny-typed-emitter";
+import {
+  AudioPlayerStatus,
+  VoiceConnectionDisconnectReason,
+  VoiceConnectionStatus,
+  createAudioPlayer,
+  createAudioResource,
+  entersState,
+  joinVoiceChannel
+} from "@discordjs/voice";
+var _channel, _volume, _br, br_fn, _join, join_fn;
+var DisTubeVoice = class extends TypedEmitter {
+  constructor(voiceManager, channel) {
+    super();
+    __privateAdd(this, _br);
+    __privateAdd(this, _join);
+    __publicField(this, "id");
+    __publicField(this, "voices");
+    __publicField(this, "audioPlayer");
+    __publicField(this, "connection");
+    __publicField(this, "audioResource");
+    __publicField(this, "emittedError");
+    __publicField(this, "isDisconnected", false);
+    __privateAdd(this, _channel, void 0);
+    __privateAdd(this, _volume, 100);
+    this.voices = voiceManager;
+    this.id = channel.guildId;
+    this.channel = channel;
+    this.voices.add(this.id, this);
+    this.audioPlayer = createAudioPlayer().on(AudioPlayerStatus.Idle, (oldState) => {
+      if (oldState.status !== AudioPlayerStatus.Idle) {
+        delete this.audioResource;
+        this.emit("finish");
+      }
+    }).on(AudioPlayerStatus.Playing, () => __privateMethod(this, _br, br_fn).call(this)).on("error", (error) => {
+      if (this.emittedError)
+        return;
+      this.emittedError = true;
+      this.emit("error", error);
+    });
+    this.connection.on(VoiceConnectionStatus.Disconnected, (_, newState) => {
+      if (newState.reason === VoiceConnectionDisconnectReason.Manual) {
+        this.leave();
+      } else if (newState.reason === VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
+        entersState(this.connection, VoiceConnectionStatus.Connecting, 5e3).catch(() => {
+          if (![VoiceConnectionStatus.Ready, 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 !== VoiceConnectionStatus.Destroyed) {
+        this.leave(new DisTubeError("VOICE_RECONNECT_FAILED"));
+      }
+    }).on(VoiceConnectionStatus.Destroyed, () => {
+      this.leave();
+    }).on("error", () => void 0);
+    this.connection.subscribe(this.audioPlayer);
   }
-  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);
+  get channel() {
+    return __privateGet(this, _channel);
   }
-  static DirectLink(url, options = {}) {
-    if (!options || typeof options !== "object" || Array.isArray(options)) {
-      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
+  set channel(channel) {
+    if (!isSupportedVoiceChannel(channel)) {
+      throw new DisTubeError("INVALID_TYPE", "BaseGuildVoiceChannel", channel, "DisTubeVoice#channel");
     }
-    if (typeof url !== "string" || !isURL(url)) {
-      throw new DisTubeError("INVALID_TYPE", "an URL", url);
+    if (channel.guildId !== this.id)
+      throw new DisTubeError("VOICE_DIFFERENT_GUILD");
+    if (channel.client.user?.id !== this.voices.client.user?.id)
+      throw new DisTubeError("VOICE_DIFFERENT_CLIENT");
+    if (channel.id === __privateGet(this, _channel)?.id)
+      return;
+    if (!channel.joinable) {
+      if (channel.full)
+        throw new DisTubeError("VOICE_FULL");
+      else
+        throw new DisTubeError("VOICE_MISSING_PERMS");
     }
-    return new DisTubeStream(url, options);
+    this.connection = __privateMethod(this, _join, join_fn).call(this, channel);
+    __privateSet(this, _channel, channel);
+    __privateMethod(this, _br, br_fn).call(this);
+  }
+  async join(channel) {
+    const TIMEOUT = 3e4;
+    if (channel)
+      this.channel = channel;
+    try {
+      await entersState(this.connection, VoiceConnectionStatus.Ready, TIMEOUT);
+    } catch {
+      if (this.connection.state.status === VoiceConnectionStatus.Ready)
+        return this;
+      if (this.connection.state.status !== VoiceConnectionStatus.Destroyed)
+        this.connection.destroy();
+      this.voices.remove(this.id);
+      throw new DisTubeError("VOICE_CONNECT_FAILED", TIMEOUT / 1e3);
+    }
+    return this;
+  }
+  leave(error) {
+    this.stop(true);
+    if (!this.isDisconnected) {
+      this.emit("disconnect", error);
+      this.isDisconnected = true;
+    }
+    if (this.connection.state.status !== VoiceConnectionStatus.Destroyed)
+      this.connection.destroy();
+    this.voices.remove(this.id);
+  }
+  stop(force = false) {
+    this.audioPlayer.stop(force);
+  }
+  play(stream) {
+    this.emittedError = false;
+    stream.stream.on("error", (error) => {
+      if (this.emittedError || error.code === "ERR_STREAM_PREMATURE_CLOSE")
+        return;
+      this.emittedError = true;
+      this.emit("error", error);
+    });
+    this.audioResource = createAudioResource(stream.stream, {
+      inputType: stream.type,
+      inlineVolume: true
+    });
+    this.volume = __privateGet(this, _volume);
+    this.audioPlayer.play(this.audioResource);
+  }
+  set volume(volume) {
+    if (typeof volume !== "number" || isNaN(volume)) {
+      throw new DisTubeError("INVALID_TYPE", "number", volume, "volume");
+    }
+    if (volume < 0) {
+      throw new DisTubeError("NUMBER_COMPARE", "Volume", "bigger or equal to", 0);
+    }
+    __privateSet(this, _volume, volume);
+    this.audioResource?.volume?.setVolume(Math.pow(__privateGet(this, _volume) / 100, 0.5 / Math.log10(2)));
+  }
+  get volume() {
+    return __privateGet(this, _volume);
+  }
+  get playbackDuration() {
+    return (this.audioResource?.playbackDuration ?? 0) / 1e3;
+  }
+  pause() {
+    this.audioPlayer.pause();
+  }
+  unpause() {
+    this.audioPlayer.unpause();
+  }
+  get selfDeaf() {
+    return this.connection.joinConfig.selfDeaf;
+  }
+  get selfMute() {
+    return this.connection.joinConfig.selfMute;
+  }
+  setSelfDeaf(selfDeaf) {
+    if (typeof selfDeaf !== "boolean") {
+      throw new DisTubeError("INVALID_TYPE", "boolean", selfDeaf, "selfDeaf");
+    }
+    return this.connection.rejoin({
+      ...this.connection.joinConfig,
+      selfDeaf
+    });
+  }
+  setSelfMute(selfMute) {
+    if (typeof selfMute !== "boolean") {
+      throw new DisTubeError("INVALID_TYPE", "boolean", selfMute, "selfMute");
+    }
+    return this.connection.rejoin({
+      ...this.connection.joinConfig,
+      selfMute
+    });
+  }
+  get voiceState() {
+    return this.channel?.guild?.members?.me?.voice;
   }
 };
-__name(DisTubeStream, "DisTubeStream");
+__name(DisTubeVoice, "DisTubeVoice");
+_channel = new WeakMap();
+_volume = new WeakMap();
+_br = new WeakSet();
+br_fn = /* @__PURE__ */ __name(function() {
+  if (this.audioResource?.encoder?.encoder)
+    this.audioResource.encoder.setBitrate(this.channel.bitrate);
+}, "#br");
+_join = new WeakSet();
+join_fn = /* @__PURE__ */ __name(function(channel) {
+  return joinVoiceChannel({
+    channelId: channel.id,
+    guildId: this.id,
+    adapterCreator: channel.guild.voiceAdapterCreator,
+    group: channel.client.user?.id
+  });
+}, "#join");
 
 // src/core/manager/BaseManager.ts
 import { Collection } from "discord.js";
@@ -813,6 +861,123 @@ var GuildIdManager = class extends BaseManager {
 };
 __name(GuildIdManager, "GuildIdManager");
 
+// src/core/manager/DisTubeVoiceManager.ts
+import { VoiceConnectionStatus as VoiceConnectionStatus2, getVoiceConnection } from "@discordjs/voice";
+var DisTubeVoiceManager = class extends GuildIdManager {
+  create(channel) {
+    const existing = this.get(channel.guildId);
+    if (existing) {
+      existing.channel = channel;
+      return existing;
+    }
+    return new DisTubeVoice(this, channel);
+  }
+  join(channel) {
+    const existing = this.get(channel.guildId);
+    if (existing)
+      return existing.join(channel);
+    return this.create(channel).join();
+  }
+  leave(guild) {
+    const voice = this.get(guild);
+    if (voice) {
+      voice.leave();
+    } else {
+      const connection = getVoiceConnection(resolveGuildId(guild), this.client.user?.id) ?? getVoiceConnection(resolveGuildId(guild));
+      if (connection && connection.state.status !== VoiceConnectionStatus2.Destroyed) {
+        connection.destroy();
+      }
+    }
+  }
+};
+__name(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 {
+  constructor(queue) {
+    super(queue.distube);
+    __privateAdd(this, _validate);
+    __privateAdd(this, _resolveName);
+    __privateAdd(this, _resolveValue);
+    __privateAdd(this, _apply);
+    __publicField(this, "queue");
+    this.queue = queue;
+  }
+  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]);
+    }
+    return this.set([...this.collection.values(), filterOrFilters]);
+  }
+  clear() {
+    return this.set([]);
+  }
+  set(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);
+    }
+    __privateMethod(this, _apply, apply_fn).call(this);
+    return this;
+  }
+  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);
+    else
+      remove(filterOrFilters);
+    __privateMethod(this, _apply, apply_fn).call(this);
+    return this;
+  }
+  has(filter) {
+    return this.collection.has(__privateMethod(this, _resolveName, resolveName_fn).call(this, filter));
+  }
+  get names() {
+    return this.collection.map((f) => __privateMethod(this, _resolveName, resolveName_fn).call(this, f));
+  }
+  get values() {
+    return this.collection.map((f) => __privateMethod(this, _resolveValue, resolveValue_fn).call(this, f));
+  }
+  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") {
+    return 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");
+_apply = new WeakSet();
+apply_fn = /* @__PURE__ */ __name(function() {
+  this.queue.beginTime = this.queue.currentTime;
+  this.queues.playSong(this.queue);
+}, "#apply");
+
 // src/core/manager/QueueManager.ts
 var _voiceEventHandler, voiceEventHandler_fn, _handleSongFinish, handleSongFinish_fn, _handlePlayingError, handlePlayingError_fn, _emitPlaySong, emitPlaySong_fn;
 var QueueManager = class extends GuildIdManager {
@@ -943,360 +1108,49 @@ handleSongFinish_fn = /* @__PURE__ */ __name(async function(queue) {
       delete prev.formats;
       delete prev.streamURL;
       if (this.options.savePreviousSongs)
-        queue.previousSongs.push(prev);
-      else
-        queue.previousSongs.push({ id: prev.id });
-    }
-    queue._next = queue._prev = false;
-    queue.beginTime = 0;
-    const err = await this.playSong(queue);
-    if (!err && emitPlaySong)
-      this.emit("playSong", queue, queue.songs[0]);
-  } finally {
-    queue._taskQueue.resolve();
-  }
-}, "#handleSongFinish");
-_handlePlayingError = new WeakSet();
-handlePlayingError_fn = /* @__PURE__ */ __name(function(queue, error) {
-  const song = queue.songs.shift();
-  try {
-    error.name = "PlayingError";
-    error.message = `${error.message}
-Id: ${song.id}
-Name: ${song.name}`;
-  } catch {
-  }
-  this.emitError(error, queue.textChannel);
-  if (queue.songs.length > 0) {
-    this.playSong(queue).then((e) => {
-      if (!e)
-        this.emit("playSong", queue, queue.songs[0]);
-    });
-  } else {
-    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");
-
-// src/core/manager/FilterManager.ts
-var _validate, validate_fn, _resolveName, resolveName_fn, _resolveValue, resolveValue_fn, _apply, apply_fn;
-var FilterManager = class extends BaseManager {
-  constructor(queue) {
-    super(queue.distube);
-    __privateAdd(this, _validate);
-    __privateAdd(this, _resolveName);
-    __privateAdd(this, _resolveValue);
-    __privateAdd(this, _apply);
-    __publicField(this, "queue");
-    this.queue = queue;
-  }
-  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]);
-    }
-    return this.set([...this.collection.values(), filterOrFilters]);
-  }
-  clear() {
-    return this.set([]);
-  }
-  set(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);
-    }
-    __privateMethod(this, _apply, apply_fn).call(this);
-    return this;
-  }
-  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);
-    else
-      remove(filterOrFilters);
-    __privateMethod(this, _apply, apply_fn).call(this);
-    return this;
-  }
-  has(filter) {
-    return this.collection.has(__privateMethod(this, _resolveName, resolveName_fn).call(this, filter));
-  }
-  get names() {
-    return this.collection.map((f) => __privateMethod(this, _resolveName, resolveName_fn).call(this, f));
-  }
-  get values() {
-    return this.collection.map((f) => __privateMethod(this, _resolveValue, resolveValue_fn).call(this, f));
-  }
-  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") {
-    return 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");
-_apply = new WeakSet();
-apply_fn = /* @__PURE__ */ __name(function() {
-  this.queue.beginTime = this.queue.currentTime;
-  this.queues.playSong(this.queue);
-}, "#apply");
-
-// src/core/voice/DisTubeVoice.ts
-import { TypedEmitter } from "tiny-typed-emitter";
-import {
-  AudioPlayerStatus,
-  VoiceConnectionDisconnectReason,
-  VoiceConnectionStatus,
-  createAudioPlayer,
-  createAudioResource,
-  joinVoiceChannel
-} from "@discordjs/voice";
-var _channel, _volume, _br, br_fn, _join, join_fn;
-var DisTubeVoice = class extends TypedEmitter {
-  constructor(voiceManager, channel) {
-    super();
-    __privateAdd(this, _br);
-    __privateAdd(this, _join);
-    __publicField(this, "id");
-    __publicField(this, "voices");
-    __publicField(this, "audioPlayer");
-    __publicField(this, "connection");
-    __publicField(this, "audioResource");
-    __publicField(this, "emittedError");
-    __publicField(this, "isDisconnected", false);
-    __privateAdd(this, _channel, void 0);
-    __privateAdd(this, _volume, 100);
-    this.voices = voiceManager;
-    this.id = channel.guildId;
-    this.channel = channel;
-    this.voices.add(this.id, this);
-    this.audioPlayer = createAudioPlayer().on(AudioPlayerStatus.Idle, (oldState) => {
-      if (oldState.status !== AudioPlayerStatus.Idle) {
-        delete this.audioResource;
-        this.emit("finish");
-      }
-    }).on(AudioPlayerStatus.Playing, () => __privateMethod(this, _br, br_fn).call(this)).on("error", (error) => {
-      if (this.emittedError)
-        return;
-      this.emittedError = true;
-      this.emit("error", error);
-    });
-    this.connection.on(VoiceConnectionStatus.Disconnected, (_, newState) => {
-      if (newState.reason === VoiceConnectionDisconnectReason.Manual) {
-        this.leave();
-      } else if (newState.reason === VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
-        entersState(this.connection, VoiceConnectionStatus.Connecting, 5e3).catch(() => {
-          if (![VoiceConnectionStatus.Ready, 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 !== VoiceConnectionStatus.Destroyed) {
-        this.leave(new DisTubeError("VOICE_RECONNECT_FAILED"));
-      }
-    }).on(VoiceConnectionStatus.Destroyed, () => {
-      this.leave(new DisTubeError("VOICE_RECONNECT_FAILED"));
-    }).on("error", () => void 0);
-    this.connection.subscribe(this.audioPlayer);
-  }
-  get channel() {
-    return __privateGet(this, _channel);
-  }
-  set channel(channel) {
-    if (!isSupportedVoiceChannel(channel)) {
-      throw new DisTubeError("INVALID_TYPE", "BaseGuildVoiceChannel", channel, "DisTubeVoice#channel");
-    }
-    if (channel.guildId !== this.id)
-      throw new DisTubeError("VOICE_DIFFERENT_GUILD");
-    if (channel.client.user?.id !== this.voices.client.user?.id)
-      throw new DisTubeError("VOICE_DIFFERENT_CLIENT");
-    if (channel.id === __privateGet(this, _channel)?.id)
-      return;
-    if (!channel.joinable) {
-      if (channel.full)
-        throw new DisTubeError("VOICE_FULL");
-      else
-        throw new DisTubeError("VOICE_MISSING_PERMS");
-    }
-    this.connection = __privateMethod(this, _join, join_fn).call(this, channel);
-    __privateSet(this, _channel, channel);
-    __privateMethod(this, _br, br_fn).call(this);
-  }
-  async join(channel) {
-    const TIMEOUT = 3e4;
-    if (channel)
-      this.channel = channel;
-    try {
-      await entersState(this.connection, VoiceConnectionStatus.Ready, TIMEOUT);
-    } catch {
-      if (this.connection.state.status === VoiceConnectionStatus.Ready)
-        return this;
-      if (this.connection.state.status !== VoiceConnectionStatus.Destroyed)
-        this.connection.destroy();
-      this.voices.remove(this.id);
-      throw new DisTubeError("VOICE_CONNECT_FAILED", TIMEOUT / 1e3);
-    }
-    return this;
-  }
-  leave(error) {
-    this.stop(true);
-    if (!this.isDisconnected) {
-      this.emit("disconnect", error);
-      this.isDisconnected = true;
-    }
-    if (this.connection.state.status !== VoiceConnectionStatus.Destroyed)
-      this.connection.destroy();
-    this.voices.remove(this.id);
-  }
-  stop(force = false) {
-    this.audioPlayer.stop(force);
-  }
-  play(stream) {
-    this.emittedError = false;
-    stream.stream.on("error", (error) => {
-      if (this.emittedError || error.code === "ERR_STREAM_PREMATURE_CLOSE")
-        return;
-      this.emittedError = true;
-      this.emit("error", error);
-    });
-    this.audioResource = createAudioResource(stream.stream, {
-      inputType: stream.type,
-      inlineVolume: true
-    });
-    this.volume = __privateGet(this, _volume);
-    this.audioPlayer.play(this.audioResource);
-  }
-  set volume(volume) {
-    if (typeof volume !== "number" || isNaN(volume)) {
-      throw new DisTubeError("INVALID_TYPE", "number", volume, "volume");
-    }
-    if (volume < 0) {
-      throw new DisTubeError("NUMBER_COMPARE", "Volume", "bigger or equal to", 0);
-    }
-    __privateSet(this, _volume, volume);
-    this.audioResource?.volume?.setVolume(Math.pow(__privateGet(this, _volume) / 100, 0.5 / Math.log10(2)));
-  }
-  get volume() {
-    return __privateGet(this, _volume);
-  }
-  get playbackDuration() {
-    return (this.audioResource?.playbackDuration ?? 0) / 1e3;
-  }
-  pause() {
-    this.audioPlayer.pause();
-  }
-  unpause() {
-    this.audioPlayer.unpause();
-  }
-  get selfDeaf() {
-    return this.connection.joinConfig.selfDeaf;
-  }
-  get selfMute() {
-    return this.connection.joinConfig.selfMute;
-  }
-  setSelfDeaf(selfDeaf) {
-    if (typeof selfDeaf !== "boolean") {
-      throw new DisTubeError("INVALID_TYPE", "boolean", selfDeaf, "selfDeaf");
-    }
-    return this.connection.rejoin({
-      ...this.connection.joinConfig,
-      selfDeaf
-    });
-  }
-  setSelfMute(selfMute) {
-    if (typeof selfMute !== "boolean") {
-      throw new DisTubeError("INVALID_TYPE", "boolean", selfMute, "selfMute");
-    }
-    return this.connection.rejoin({
-      ...this.connection.joinConfig,
-      selfMute
-    });
-  }
-  get voiceState() {
-    return getClientMember(this.channel?.guild)?.voice;
-  }
-};
-__name(DisTubeVoice, "DisTubeVoice");
-_channel = new WeakMap();
-_volume = new WeakMap();
-_br = new WeakSet();
-br_fn = /* @__PURE__ */ __name(function() {
-  if (this.audioResource?.encoder?.encoder)
-    this.audioResource.encoder.setBitrate(this.channel.bitrate);
-}, "#br");
-_join = new WeakSet();
-join_fn = /* @__PURE__ */ __name(function(channel) {
-  return joinVoiceChannel({
-    channelId: channel.id,
-    guildId: this.id,
-    adapterCreator: channel.guild.voiceAdapterCreator,
-    group: channel.client.user?.id
-  });
-}, "#join");
-
-// src/core/voice/DisTubeVoiceManager.ts
-import { VoiceConnectionStatus as VoiceConnectionStatus2, getVoiceConnection } from "@discordjs/voice";
-var DisTubeVoiceManager = class extends GuildIdManager {
-  create(channel) {
-    const existing = this.get(channel.guildId);
-    if (existing) {
-      existing.channel = channel;
-      return existing;
+        queue.previousSongs.push(prev);
+      else
+        queue.previousSongs.push({ id: prev.id });
     }
-    return new DisTubeVoice(this, channel);
+    queue._next = queue._prev = false;
+    queue.beginTime = 0;
+    const err = await this.playSong(queue);
+    if (!err && emitPlaySong)
+      this.emit("playSong", queue, queue.songs[0]);
+  } finally {
+    queue._taskQueue.resolve();
   }
-  join(channel) {
-    const existing = this.get(channel.guildId);
-    if (existing)
-      return existing.join(channel);
-    return this.create(channel).join();
+}, "#handleSongFinish");
+_handlePlayingError = new WeakSet();
+handlePlayingError_fn = /* @__PURE__ */ __name(function(queue, error) {
+  const song = queue.songs.shift();
+  try {
+    error.name = "PlayingError";
+    error.message = `${error.message}
+Id: ${song.id}
+Name: ${song.name}`;
+  } catch {
   }
-  leave(guild) {
-    const voice = this.get(guild);
-    if (voice) {
-      voice.leave();
-    } else {
-      const connection = getVoiceConnection(resolveGuildId(guild), this.client.user?.id) ?? getVoiceConnection(resolveGuildId(guild));
-      if (connection && connection.state.status !== VoiceConnectionStatus2.Destroyed) {
-        connection.destroy();
-      }
-    }
+  this.emitError(error, queue.textChannel);
+  if (queue.songs.length > 0) {
+    queue._next = queue._prev = false;
+    queue.beginTime = 0;
+    this.playSong(queue).then((e) => {
+      if (!e)
+        this.emit("playSong", queue, queue.songs[0]);
+    });
+  } else {
+    queue.stop();
   }
-};
-__name(DisTubeVoiceManager, "DisTubeVoiceManager");
+}, "#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");
 
 // src/core/DisTubeHandler.ts
-import ytdl from "@distube/ytdl-core";
 import ytpl from "@distube/ytpl";
+import ytdl from "@distube/ytdl-core";
 var DisTubeHandler = class extends DisTubeBase {
   constructor(distube) {
     super(distube);
@@ -1360,13 +1214,15 @@ var DisTubeHandler = class extends DisTubeBase {
         song.member = options.member;
       return song;
     }
-    if (song instanceof SearchResult) {
-      if (song.type === "video" /* VIDEO */)
-        return new Song(song, options);
+    if (song instanceof SearchResultVideo)
+      return new Song(song, options);
+    if (song instanceof SearchResultPlaylist)
       return this.resolvePlaylist(song.url, options);
-    }
-    if (isObject(song))
+    if (isObject(song)) {
+      if (!("url" in song) && !("id" in song))
+        throw new DisTubeError("CANNOT_RESOLVE_SONG", song);
       return new Song(song, options);
+    }
     if (ytpl.validateID(song))
       return this.resolvePlaylist(song, options);
     if (ytdl.validateURL(song))
@@ -1389,14 +1245,19 @@ var DisTubeHandler = class extends DisTubeBase {
         playlist.member = member;
       return playlist;
     }
-    let solvablePlaylist;
     if (typeof playlist === "string") {
-      solvablePlaylist = await ytpl(playlist, { limit: Infinity });
-      solvablePlaylist.items = solvablePlaylist.items.filter((v) => !v.thumbnail.includes("no_thumbnail")).map((v) => new Song(v, { member, metadata }));
-    } else {
-      solvablePlaylist = playlist;
-    }
-    return new Playlist(solvablePlaylist, { member, properties: { source }, metadata });
+      const info = await ytpl(playlist, { limit: Infinity });
+      const songs = info.items.filter((v) => !v.thumbnail.includes("no_thumbnail")).map((v) => new Song(v, { member, metadata }));
+      return new Playlist({
+        source,
+        songs,
+        member,
+        name: info.title,
+        url: info.url,
+        thumbnail: songs[0].thumbnail
+      }, { metadata });
+    }
+    return new Playlist(playlist, { member, properties: { source }, metadata });
   }
   async searchSong(message, query) {
     if (!isMessageInstance(message))
@@ -1530,6 +1391,186 @@ var DisTubeHandler = class extends DisTubeBase {
 };
 __name(DisTubeHandler, "DisTubeHandler");
 
+// src/core/DisTubeOptions.ts
+var _validateOptions, validateOptions_fn;
+var Options = class {
+  constructor(options) {
+    __privateAdd(this, _validateOptions);
+    __publicField(this, "plugins");
+    __publicField(this, "emitNewSongOnly");
+    __publicField(this, "leaveOnFinish");
+    __publicField(this, "leaveOnStop");
+    __publicField(this, "leaveOnEmpty");
+    __publicField(this, "emptyCooldown");
+    __publicField(this, "savePreviousSongs");
+    __publicField(this, "searchSongs");
+    __publicField(this, "searchCooldown");
+    __publicField(this, "youtubeCookie");
+    __publicField(this, "youtubeIdentityToken");
+    __publicField(this, "customFilters");
+    __publicField(this, "ytdlOptions");
+    __publicField(this, "nsfw");
+    __publicField(this, "emitAddSongWhenCreatingQueue");
+    __publicField(this, "emitAddListWhenCreatingQueue");
+    __publicField(this, "joinNewVoiceChannel");
+    __publicField(this, "streamType");
+    if (typeof options !== "object" || Array.isArray(options)) {
+      throw new DisTubeError("INVALID_TYPE", "object", options, "DisTubeOptions");
+    }
+    const opts = { ...defaultOptions, ...options };
+    this.plugins = opts.plugins;
+    this.emitNewSongOnly = opts.emitNewSongOnly;
+    this.leaveOnEmpty = opts.leaveOnEmpty;
+    this.leaveOnFinish = opts.leaveOnFinish;
+    this.leaveOnStop = opts.leaveOnStop;
+    this.savePreviousSongs = opts.savePreviousSongs;
+    this.searchSongs = opts.searchSongs;
+    this.youtubeCookie = opts.youtubeCookie;
+    this.youtubeIdentityToken = opts.youtubeIdentityToken;
+    this.customFilters = opts.customFilters;
+    this.ytdlOptions = opts.ytdlOptions;
+    this.searchCooldown = opts.searchCooldown;
+    this.emptyCooldown = opts.emptyCooldown;
+    this.nsfw = opts.nsfw;
+    this.emitAddSongWhenCreatingQueue = opts.emitAddSongWhenCreatingQueue;
+    this.emitAddListWhenCreatingQueue = opts.emitAddListWhenCreatingQueue;
+    this.joinNewVoiceChannel = opts.joinNewVoiceChannel;
+    this.streamType = opts.streamType;
+    checkInvalidKey(opts, this, "DisTubeOptions");
+    __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") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.emitNewSongOnly, "DisTubeOptions.emitNewSongOnly");
+  }
+  if (typeof options.leaveOnEmpty !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.leaveOnEmpty, "DisTubeOptions.leaveOnEmpty");
+  }
+  if (typeof options.leaveOnFinish !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.leaveOnFinish, "DisTubeOptions.leaveOnFinish");
+  }
+  if (typeof options.leaveOnStop !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.leaveOnStop, "DisTubeOptions.leaveOnStop");
+  }
+  if (typeof options.savePreviousSongs !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.savePreviousSongs, "DisTubeOptions.savePreviousSongs");
+  }
+  if (typeof options.joinNewVoiceChannel !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.joinNewVoiceChannel, "DisTubeOptions.joinNewVoiceChannel");
+  }
+  if (typeof options.youtubeCookie !== "undefined" && typeof options.youtubeCookie !== "string") {
+    throw new DisTubeError("INVALID_TYPE", "string", options.youtubeCookie, "DisTubeOptions.youtubeCookie");
+  }
+  if (typeof options.youtubeIdentityToken !== "undefined" && typeof options.youtubeIdentityToken !== "string") {
+    throw new DisTubeError("INVALID_TYPE", "string", options.youtubeIdentityToken, "DisTubeOptions.youtubeIdentityToken");
+  }
+  if (typeof options.customFilters !== "undefined" && typeof options.customFilters !== "object" || Array.isArray(options.customFilters)) {
+    throw new DisTubeError("INVALID_TYPE", "object", options.customFilters, "DisTubeOptions.customFilters");
+  }
+  if (typeof options.ytdlOptions !== "object" || Array.isArray(options.ytdlOptions)) {
+    throw new DisTubeError("INVALID_TYPE", "object", options.ytdlOptions, "DisTubeOptions.ytdlOptions");
+  }
+  if (typeof options.searchCooldown !== "number" || isNaN(options.searchCooldown)) {
+    throw new DisTubeError("INVALID_TYPE", "number", options.searchCooldown, "DisTubeOptions.searchCooldown");
+  }
+  if (typeof options.emptyCooldown !== "number" || isNaN(options.emptyCooldown)) {
+    throw new DisTubeError("INVALID_TYPE", "number", options.emptyCooldown, "DisTubeOptions.emptyCooldown");
+  }
+  if (typeof options.searchSongs !== "number" || isNaN(options.searchSongs)) {
+    throw new DisTubeError("INVALID_TYPE", "number", options.searchSongs, "DisTubeOptions.searchSongs");
+  }
+  if (!Array.isArray(options.plugins)) {
+    throw new DisTubeError("INVALID_TYPE", "Array<Plugin>", options.plugins, "DisTubeOptions.plugins");
+  }
+  if (typeof options.nsfw !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.nsfw, "DisTubeOptions.nsfw");
+  }
+  if (typeof options.emitAddSongWhenCreatingQueue !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.emitAddSongWhenCreatingQueue, "DisTubeOptions.emitAddSongWhenCreatingQueue");
+  }
+  if (typeof options.emitAddListWhenCreatingQueue !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.emitAddListWhenCreatingQueue, "DisTubeOptions.emitAddListWhenCreatingQueue");
+  }
+  if (typeof options.streamType !== "number" || isNaN(options.streamType) || !StreamType[options.streamType]) {
+    throw new DisTubeError("INVALID_TYPE", "StreamType", options.streamType, "DisTubeOptions.streamType");
+  }
+}, "#validateOptions");
+
+// src/core/DisTubeStream.ts
+import { FFmpeg } from "prism-media";
+import { StreamType as DiscordVoiceStreamType } from "@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 ? DiscordVoiceStreamType.OggOpus : DiscordVoiceStreamType.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 FFmpeg({ args, shell: false });
+  }
+  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");
+
 // src/struct/Queue.ts
 var _filters;
 var Queue = class extends DisTubeBase {
@@ -1572,7 +1613,7 @@ var Queue = class extends DisTubeBase {
     this._listeners = void 0;
   }
   get clientMember() {
-    return getClientMember(this.voice.channel.guild);
+    return this.voice.channel.guild.members.me ?? void 0;
   }
   get filters() {
     return __privateGet(this, _filters);
@@ -1916,7 +1957,7 @@ function isVoiceChannelEmpty(voiceState) {
   const clientId = voiceState.client.user?.id;
   if (!guild || !clientId)
     return false;
-  const voiceChannel = guild.members.resolve(clientId)?.voice?.channel;
+  const voiceChannel = guild.members.me?.voice?.channel;
   if (!voiceChannel)
     return false;
   const members = voiceChannel.members.filter((m) => !m.user.bot);
@@ -1936,7 +1977,7 @@ function isMemberInstance(member) {
 }
 __name(isMemberInstance, "isMemberInstance");
 function isTextChannelInstance(channel) {
-  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && typeof channel.name === "string" && Constants.TextBasedChannelTypes.includes(channel.type) && typeof channel.messages?.cache === "object";
+  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && typeof channel.name === "string" && Constants.TextBasedChannelTypes.includes(channel.type) && typeof channel.nsfw === "boolean" && "messages" in channel && typeof channel.send === "function";
 }
 __name(isTextChannelInstance, "isTextChannelInstance");
 function isMessageInstance(message) {
@@ -1982,34 +2023,6 @@ function checkInvalidKey(target, source, sourceName) {
     throw new DisTubeError("INVALID_KEY", sourceName, invalidKey);
 }
 __name(checkInvalidKey, "checkInvalidKey");
-async function waitEvent(target, status, maxTime) {
-  let cleanup = /* @__PURE__ */ __name(() => {
-  }, "cleanup");
-  try {
-    await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error(`Didn't trigger ${status} within ${maxTime}ms`)), maxTime);
-      target.once(status, resolve);
-      target.once("error", reject);
-      cleanup = /* @__PURE__ */ __name(() => {
-        clearTimeout(timeout);
-        target.off(status, resolve);
-        target.off("error", reject);
-      }, "cleanup");
-      if (target?.state?.status === status)
-        resolve(0);
-    });
-    return target;
-  } finally {
-    cleanup();
-  }
-}
-__name(waitEvent, "waitEvent");
-async function entersState(target, status, maxTime) {
-  if (target.state.status === status)
-    return target;
-  return waitEvent(target, status, maxTime);
-}
-__name(entersState, "entersState");
 function isObject(obj) {
   return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 }
@@ -2018,63 +2031,26 @@ function isRecord(obj) {
   return isObject(obj);
 }
 __name(isRecord, "isRecord");
-function getClientMember(guild) {
-  const clientUser = guild.client.user;
-  if (!clientUser)
-    return void 0;
-  const clientMember = guild.members.resolve(clientUser);
-  if (!clientMember)
-    return void 0;
-  return clientMember;
-}
-__name(getClientMember, "getClientMember");
 
-// src/plugin/http.ts
-import http from "http";
-var HTTPPlugin = class extends ExtractorPlugin {
+// src/plugin/DirectLink.ts
+import { request } from "undici";
+var DirectLinkPlugin = class extends ExtractorPlugin {
   async validate(url) {
-    return validateAudioURL(http, "http:", url);
-  }
-  async resolve(url, options = {}) {
-    return resolveHttpSong(url, { ...options, source: "http" });
-  }
-};
-__name(HTTPPlugin, "HTTPPlugin");
-
-// src/plugin/https.ts
-import https from "https";
-import { URL as URL2 } from "url";
-var getResponseHeaders = /* @__PURE__ */ __name(async (httpModule, url) => new Promise((resolve, reject) => {
-  httpModule.get(url).on("response", (res) => {
-    resolve(res.headers);
-  }).on("error", reject);
-}), "getResponseHeaders");
-var validateAudioURL = /* @__PURE__ */ __name(async (httpModule, protocol, url) => {
-  if (new URL2(url).protocol.toLowerCase() !== protocol) {
+    const headers = await request(url, { method: "HEAD" }).then((res) => res.headers);
+    const type = headers["content-type"];
+    if (type?.startsWith("audio"))
+      return true;
     return false;
   }
-  const headers = await getResponseHeaders(httpModule, url), type = headers["content-type"];
-  if (type?.startsWith("audio")) {
-    return true;
-  }
-  return false;
-}, "validateAudioURL");
-var resolveHttpSong = /* @__PURE__ */ __name(async (url, options) => {
-  url = url.replace(/\/+$/, "");
-  return new Song({
-    name: url.substring(url.lastIndexOf("/") + 1).replace(/((\?|#).*)?$/, "") || url,
-    url
-  }, options);
-}, "resolveHttpSong");
-var HTTPSPlugin = class extends ExtractorPlugin {
-  async validate(url) {
-    return validateAudioURL(https, "https:", url);
-  }
   async resolve(url, options = {}) {
-    return resolveHttpSong(url, { ...options, source: "https" });
+    url = url.replace(/\/+$/, "");
+    return new Song({
+      name: url.substring(url.lastIndexOf("/") + 1).replace(/((\?|#).*)?$/, "") || url,
+      url
+    }, options);
   }
 };
-__name(HTTPSPlugin, "HTTPSPlugin");
+__name(DirectLinkPlugin, "DirectLinkPlugin");
 
 // src/DisTube.ts
 import ytsr from "@distube/ytsr";
@@ -2101,7 +2077,7 @@ var DisTube = class extends TypedEmitter2 {
     this.handler = new DisTubeHandler(this);
     this.queues = new QueueManager(this);
     this.filters = { ...defaultFilters, ...this.options.customFilters };
-    this.options.plugins.push(new HTTPPlugin(), new HTTPSPlugin());
+    this.options.plugins.push(new DirectLinkPlugin());
     this.options.plugins.map((p) => p.init(this));
     this.extractorPlugins = this.options.plugins.filter((p) => p.type === "extractor");
     this.customPlugins = this.options.plugins.filter((p) => p.type === "custom");
@@ -2119,7 +2095,7 @@ var DisTube = class extends TypedEmitter2 {
     if (!isObject(options))
       throw new DisTubeError("INVALID_TYPE", "object", options, "options");
     const { textChannel, member, skip, message, metadata } = {
-      member: getClientMember(voiceChannel.guild),
+      member: voiceChannel.guild.members.me ?? void 0,
       textChannel: options?.message?.channel,
       skip: false,
       ...options
@@ -2167,12 +2143,12 @@ var DisTube = class extends TypedEmitter2 {
       if (!(e instanceof DisTubeError)) {
         try {
           e.name = "PlayError";
-          e.message = `${song?.url || song}
+          e.message = `${typeof song === "string" ? song : song.url}
 ${e.message}`;
         } catch {
         }
       }
-      this.emitError(e, textChannel);
+      throw e;
     } finally {
       if (queuing)
         queue?._taskQueue.resolve();
@@ -2184,7 +2160,7 @@ ${e.message}`;
       throw new DisTubeError("INVALID_TYPE", "Array", songs, "songs");
     if (!songs.length)
       throw new DisTubeError("EMPTY_ARRAY", "songs");
-    const filteredSongs = songs.filter((song) => song instanceof Song || song instanceof SearchResult && song.type === "video" || isURL(song));
+    const filteredSongs = songs.filter((song) => song instanceof Song || isURL(song) || typeof song !== "string" && song.type === "video" /* VIDEO */);
     if (!filteredSongs.length)
       throw new DisTubeError("NO_VALID_SONG");
     if (member && !isMemberInstance(member)) {
@@ -2206,7 +2182,7 @@ ${e.message}`;
     return new Playlist(resolvedSongs, { member, properties, metadata });
   }
   async search(string, options = {}) {
-    const opts = { type: "video", limit: 10, safeSearch: false, ...options };
+    const opts = { type: "video" /* VIDEO */, limit: 10, safeSearch: false, ...options };
     if (typeof opts.type !== "string" || !["video", "playlist"].includes(opts.type)) {
       throw new DisTubeError("INVALID_TYPE", ["video", "playlist"], opts.type, "options.type");
     }
@@ -2219,7 +2195,11 @@ ${e.message}`;
     }
     try {
       const search = await ytsr(string, opts);
-      const results = search.items.map((i) => new SearchResult(i));
+      const results = search.items.map((i) => {
+        if (i.type === "video")
+          return new SearchResultVideo(i);
+        return new SearchResultPlaylist(i);
+      });
       if (results.length === 0)
         throw new DisTubeError("NO_RESULT");
       return results;
@@ -2320,6 +2300,7 @@ __name(DisTube, "DisTube");
 export {
   BaseManager,
   CustomPlugin,
+  DirectLinkPlugin,
   DisTube,
   DisTubeBase,
   DisTubeError,
@@ -2330,8 +2311,6 @@ export {
   ExtractorPlugin,
   FilterManager,
   GuildIdManager,
-  HTTPPlugin,
-  HTTPSPlugin,
   Options,
   Playlist,
   Plugin,
@@ -2339,8 +2318,9 @@ export {
   Queue,
   QueueManager,
   RepeatMode,
-  SearchResult,
+  SearchResultPlaylist,
   SearchResultType,
+  SearchResultVideo,
   Song,
   StreamType,
   TaskQueue,
@@ -2350,10 +2330,7 @@ export {
   DisTube as default,
   defaultFilters,
   defaultOptions,
-  entersState,
   formatDuration,
-  getClientMember,
-  getResponseHeaders,
   isClientInstance,
   isGuildInstance,
   isMemberInstance,
@@ -2367,9 +2344,7 @@ export {
   isVoiceChannelEmpty,
   parseNumber,
   resolveGuildId,
-  resolveHttpSong,
   toSecond,
-  validateAudioURL,
   version
 };
 //# sourceMappingURL=index.mjs.map