distube 4.0.0-dev.3 → 4.0.0-dev.6

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.3",
+      version: "4.0.0-dev.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",
       module: "./dist/index.mjs",
@@ -65,7 +65,7 @@ var require_package = __commonJS({
         docs: "docgen -s src/*.ts src/**/*.ts -o docs.json -c pages/index.yml -g -j jsdoc.config.json",
         lint: "prettier --check . && eslint .",
         "lint:fix": "eslint . --fix",
-        prettier: "prettier --write **/*.{ts,json,yml,yaml,md}",
+        prettier: 'prettier --write "**/*.{ts,json,yml,yaml,md}"',
         build: "tsup",
         "build:check": "tsc --noEmit",
         update: "ncu -u --dep dev,prod && yarn up '**' -R",
@@ -108,43 +108,43 @@ var require_package = __commonJS({
       ],
       homepage: "https://distube.js.org/",
       dependencies: {
-        "@distube/ytdl-core": "^4.11.1",
+        "@distube/ytdl-core": "^4.11.3",
         "@distube/ytpl": "^1.1.1",
-        "@distube/ytsr": "^1.1.5",
+        "@distube/ytsr": "^1.1.7",
         "prism-media": "https://codeload.github.com/distubejs/prism-media/tar.gz/main#workaround.tar.gz",
         "tiny-typed-emitter": "^2.1.0",
-        tslib: "^2.3.1"
+        tslib: "^2.4.0"
       },
       devDependencies: {
-        "@babel/core": "^7.17.8",
-        "@babel/plugin-proposal-class-properties": "^7.16.7",
-        "@babel/plugin-proposal-object-rest-spread": "^7.17.3",
-        "@babel/preset-env": "^7.16.11",
-        "@babel/preset-typescript": "^7.16.7",
-        "@commitlint/cli": "^16.2.3",
-        "@commitlint/config-conventional": "^16.2.1",
+        "@babel/core": "^7.18.6",
+        "@babel/plugin-proposal-class-properties": "^7.18.6",
+        "@babel/plugin-proposal-object-rest-spread": "^7.18.6",
+        "@babel/preset-env": "^7.18.6",
+        "@babel/preset-typescript": "^7.18.6",
+        "@commitlint/cli": "^17.0.3",
+        "@commitlint/config-conventional": "^17.0.3",
         "@discordjs/voice": "dev",
         "@distube/docgen": "distubejs/docgen",
-        "@types/jest": "^27.4.1",
-        "@types/node": "^17.0.23",
-        "@typescript-eslint/eslint-plugin": "^5.17.0",
-        "@typescript-eslint/parser": "^5.17.0",
-        "babel-jest": "^27.5.1",
+        "@types/jest": "^28.1.5",
+        "@types/node": "^18.0.4",
+        "@typescript-eslint/eslint-plugin": "^5.30.6",
+        "@typescript-eslint/parser": "^5.30.6",
+        "babel-jest": "^28.1.3",
         "discord.js": "dev",
-        eslint: "^8.12.0",
+        eslint: "^8.19.0",
         "eslint-config-distube": "^1.6.4",
         "eslint-config-prettier": "^8.5.0",
         "eslint-plugin-deprecation": "^1.3.2",
-        "eslint-plugin-jsdoc": "^38.1.4",
-        husky: "^7.0.4",
-        jest: "^27.5.1",
+        "eslint-plugin-jsdoc": "^39.3.3",
+        husky: "^8.0.1",
+        jest: "^28.1.3",
         "jsdoc-babel": "^0.5.0",
-        "nano-staged": "^0.6.0",
-        "npm-check-updates": "^12.5.4",
+        "nano-staged": "^0.8.0",
+        "npm-check-updates": "^15.3.0",
         pinst: "^3.0.0",
-        prettier: "^2.6.1",
-        tsup: "^5.12.1",
-        typescript: "^4.6.3"
+        prettier: "^2.7.1",
+        tsup: "^6.1.3",
+        typescript: "^4.7.4"
       },
       peerDependencies: {
         "@discordjs/opus": "*",
@@ -191,6 +191,11 @@ var SearchResultType = /* @__PURE__ */ ((SearchResultType2) => {
   SearchResultType2["PLAYLIST"] = "playlist";
   return SearchResultType2;
 })(SearchResultType || {});
+var StreamType = /* @__PURE__ */ ((StreamType2) => {
+  StreamType2[StreamType2["OPUS"] = 0] = "OPUS";
+  StreamType2[StreamType2["RAW"] = 1] = "RAW";
+  return StreamType2;
+})(StreamType || {});
 
 // src/constant.ts
 var defaultFilters = {
@@ -224,13 +229,14 @@ var defaultOptions = {
   nsfw: false,
   emitAddSongWhenCreatingQueue: true,
   emitAddListWhenCreatingQueue: true,
-  joinNewVoiceChannel: true
+  joinNewVoiceChannel: true,
+  streamType: 0 /* OPUS */
 };
 
 // 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`,
@@ -246,7 +252,8 @@ var ERROR_MESSAGES = {
   VOICE_CONNECT_FAILED: (s) => `Cannot connect to the voice channel after ${s} seconds`,
   VOICE_MISSING_PERMS: "I do not have permission to join this voice channel",
   VOICE_RECONNECT_FAILED: "Cannot reconnect to the voice channel",
-  VOICE_DIFFERENT_GUILD: "Cannot join a channel in a different guild",
+  VOICE_DIFFERENT_GUILD: "Cannot join a voice channel in a different guild",
+  VOICE_DIFFERENT_CLIENT: "Cannot join a voice channel created by a different client",
   NO_QUEUE: "There is no playing queue in this guild",
   QUEUE_EXIST: "This guild has a Queue already",
   PAUSED: "The queue has been paused already",
@@ -285,6 +292,7 @@ var DisTubeError = class extends Error {
     return this.errorCode;
   }
 };
+__name(DisTubeError, "DisTubeError");
 
 // src/struct/TaskQueue.ts
 var Task = class {
@@ -298,6 +306,7 @@ var Task = class {
     });
   }
 };
+__name(Task, "Task");
 var _tasks;
 var TaskQueue = class {
   constructor() {
@@ -318,6 +327,7 @@ var TaskQueue = class {
     return !!__privateGet(this, _tasks).find((t) => t.resolveInfo);
   }
 };
+__name(TaskQueue, "TaskQueue");
 _tasks = new WeakMap();
 
 // src/struct/Playlist.ts
@@ -332,26 +342,33 @@ 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;
+    } 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.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;
+    this.member = member;
     this.metadata = metadata;
   }
   get duration() {
@@ -380,44 +397,69 @@ var Playlist = class {
     this.songs.map((s) => s.constructor.name === "Song" && (s.metadata = metadata));
   }
 };
+__name(Playlist, "Playlist");
 _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(SearchResultPlaylist, "SearchResultPlaylist");
 
 // src/struct/Song.ts
 var _metadata2, _member2, _playlist;
@@ -552,112 +594,11 @@ var _Song = class {
   }
 };
 var Song = _Song;
+__name(Song, "Song");
 _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");
-    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;
-    checkInvalidKey(opts, this, "DisTubeOptions");
-    __privateMethod(this, _validateOptions, validateOptions_fn).call(this);
-  }
-};
-_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");
-  }
-}, "#validateOptions");
-
 // src/core/DisTubeBase.ts
 var DisTubeBase = class {
   constructor(distube) {
@@ -686,75 +627,206 @@ var DisTubeBase = class {
     return this.distube.handler;
   }
 };
+__name(DisTubeBase, "DisTubeBase");
 
-// src/core/DisTubeStream.ts
-import { FFmpeg } from "prism-media";
-import { StreamType } 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 = StreamType.Raw;
-    const args = [
-      "-reconnect",
-      "1",
-      "-reconnect_streamed",
-      "1",
-      "-reconnect_delay_max",
-      "5",
-      "-i",
-      url,
-      "-analyzeduration",
-      "0",
-      "-loglevel",
-      "0",
-      "-ar",
-      "48000",
-      "-ac",
-      "2",
-      "-f",
-      "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");
-    }
-    if (typeof url !== "string" || !isURL(url)) {
-      throw new DisTubeError("INVALID_TYPE", "an URL", url);
+  set channel(channel) {
+    if (!isSupportedVoiceChannel(channel)) {
+      throw new DisTubeError("INVALID_TYPE", "BaseGuildVoiceChannel", channel, "DisTubeVoice#channel");
     }
-    return new DisTubeStream(url, options);
-  }
-};
-
-// src/core/manager/BaseManager.ts
+    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 this.channel?.guild?.members?.me?.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/manager/BaseManager.ts
 import { Collection } from "discord.js";
 var BaseManager = class extends DisTubeBase {
   constructor() {
@@ -765,6 +837,7 @@ var BaseManager = class extends DisTubeBase {
     return this.collection.size;
   }
 };
+__name(BaseManager, "BaseManager");
 
 // src/core/manager/GuildIdManager.ts
 var GuildIdManager = class extends BaseManager {
@@ -785,6 +858,124 @@ var GuildIdManager = class extends BaseManager {
     return this.collection.has(resolveGuildId(idOrInstance));
   }
 };
+__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;
@@ -817,7 +1008,7 @@ var QueueManager = class extends GuildIdManager {
     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 };
+    const streamOptions = { ffmpegArgs, seek, isLive, type: this.options.streamType };
     if (source === "youtube")
       return DisTubeStream.YouTube(formats, streamOptions);
     return DisTubeStream.DirectLink(streamURL, streamOptions);
@@ -831,8 +1022,8 @@ var QueueManager = class extends GuildIdManager {
     }
     if (queue.stopped)
       return false;
-    const song = queue.songs[0];
     try {
+      const song = queue.songs[0];
       const { url, source, formats, streamURL } = song;
       if (source === "youtube" && !formats)
         song._patchYouTube(await this.handler.getYouTubeInfo(url));
@@ -861,6 +1052,7 @@ var QueueManager = class extends GuildIdManager {
     }
   }
 };
+__name(QueueManager, "QueueManager");
 _voiceEventHandler = new WeakSet();
 voiceEventHandler_fn = /* @__PURE__ */ __name(function(queue) {
   queue._listeners = {
@@ -893,377 +1085,69 @@ handleSongFinish_fn = /* @__PURE__ */ __name(async function(queue) {
         queue.songs.unshift(queue.previousSongs.pop());
     }
     if (queue.songs.length <= 1 && (queue._next || queue.repeatMode === 0 /* DISABLED */)) {
-      if (queue.autoplay) {
-        try {
-          await queue.addRelatedSong();
-        } catch {
-          this.emit("noRelated", queue);
-        }
-      }
-      if (queue.songs.length <= 1) {
-        if (this.options.leaveOnFinish)
-          queue.voice.leave();
-        if (!queue.autoplay)
-          this.emit("finish", queue);
-        queue.remove();
-        return;
-      }
-    }
-    const emitPlaySong = __privateMethod(this, _emitPlaySong, emitPlaySong_fn).call(this, queue);
-    if (!queue._prev && (queue.repeatMode !== 1 /* SONG */ || queue._next)) {
-      const prev = queue.songs.shift();
-      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();
-  }
-};
-_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.id = channel.guildId;
-    this.channel = channel;
-    this.voices = voiceManager;
-    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.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 this.channel?.guild?.me?.voice;
-  }
-};
-_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;
+      if (queue.autoplay) {
+        try {
+          await queue.addRelatedSong();
+        } catch {
+          this.emit("noRelated", queue);
+        }
+      }
+      if (queue.songs.length <= 1) {
+        if (this.options.leaveOnFinish)
+          queue.voice.leave();
+        if (!queue.autoplay)
+          this.emit("finish", queue);
+        queue.remove();
+        return;
+      }
     }
-    return new DisTubeVoice(this, channel);
+    const emitPlaySong = __privateMethod(this, _emitPlaySong, emitPlaySong_fn).call(this, queue);
+    if (!queue._prev && (queue.repeatMode !== 1 /* SONG */ || queue._next)) {
+      const prev = queue.songs.shift();
+      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();
   }
-  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) {
+    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/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);
@@ -1327,11 +1211,10 @@ 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))
       return new Song(song, options);
     if (ytpl.validateID(song))
@@ -1356,14 +1239,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))
@@ -1495,6 +1383,187 @@ 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;
@@ -1516,12 +1585,8 @@ var Queue = class extends DisTubeBase {
     __publicField(this, "beginTime");
     __publicField(this, "textChannel");
     __publicField(this, "_emptyTimeout");
-    __publicField(this, "clientMember");
     __publicField(this, "_taskQueue");
     __publicField(this, "_listeners");
-    this.clientMember = voice.channel.guild?.me ?? (() => {
-      throw new DisTubeError("INVALID_TYPE", "GuildMember", null, "<VoiceChannel>.guild.me");
-    })();
     this.voice = voice;
     this.id = voice.id;
     this.volume = 50;
@@ -1541,6 +1606,9 @@ var Queue = class extends DisTubeBase {
     this._taskQueue = new TaskQueue();
     this._listeners = void 0;
   }
+  get clientMember() {
+    return this.voice.channel.guild.members.me ?? void 0;
+  }
   get filters() {
     return __privateGet(this, _filters);
   }
@@ -1557,7 +1625,7 @@ var Queue = class extends DisTubeBase {
     return formatDuration(this.currentTime);
   }
   get voiceChannel() {
-    return this.clientMember.voice.channel;
+    return this.clientMember?.voice?.channel ?? null;
   }
   get volume() {
     return this.voice.volume;
@@ -1755,6 +1823,7 @@ var Queue = class extends DisTubeBase {
     return this.autoplay;
   }
 };
+__name(Queue, "Queue");
 _filters = new WeakMap();
 
 // src/struct/Plugin.ts
@@ -1796,6 +1865,7 @@ var Plugin = class {
     return [];
   }
 };
+__name(Plugin, "Plugin");
 
 // src/struct/CustomPlugin.ts
 var CustomPlugin = class extends Plugin {
@@ -1804,6 +1874,7 @@ var CustomPlugin = class extends Plugin {
     __publicField(this, "type", "custom" /* CUSTOM */);
   }
 };
+__name(CustomPlugin, "CustomPlugin");
 
 // src/struct/ExtractorPlugin.ts
 var ExtractorPlugin = class extends Plugin {
@@ -1812,6 +1883,7 @@ var ExtractorPlugin = class extends Plugin {
     __publicField(this, "type", "extractor" /* EXTRACTOR */);
   }
 };
+__name(ExtractorPlugin, "ExtractorPlugin");
 
 // src/util.ts
 import { URL } from "url";
@@ -1829,6 +1901,7 @@ function formatDuration(sec) {
     return `${formatInt(minutes)}:${formatInt(seconds)}`;
   return `00:${formatInt(seconds)}`;
 }
+__name(formatDuration, "formatDuration");
 function toSecond(input) {
   if (!input)
     return 0;
@@ -1847,11 +1920,13 @@ function toSecond(input) {
     return Number(input.replace(/[^\d.]+/g, "")) || 0;
   }
 }
+__name(toSecond, "toSecond");
 function parseNumber(input) {
   if (typeof input === "string")
     return Number(input.replace(/[^\d.]+/g, "")) || 0;
   return Number(input) || 0;
 }
+__name(parseNumber, "parseNumber");
 function isURL(input) {
   if (typeof input !== "string" || input.includes(" "))
     return false;
@@ -1864,18 +1939,25 @@ function isURL(input) {
   }
   return true;
 }
+__name(isURL, "isURL");
 function checkIntents(options) {
   const intents = new IntentsBitField(options.intents);
   if (!intents.has(GatewayIntentBits.GuildVoiceStates))
     throw new DisTubeError("MISSING_INTENTS", "GuildVoiceStates");
 }
+__name(checkIntents, "checkIntents");
 function isVoiceChannelEmpty(voiceState) {
-  const voiceChannel = voiceState.guild?.me?.voice?.channel;
+  const guild = voiceState.guild;
+  const clientId = voiceState.client.user?.id;
+  if (!guild || !clientId)
+    return false;
+  const voiceChannel = guild.members.me?.voice?.channel;
   if (!voiceChannel)
     return false;
   const members = voiceChannel.members.filter((m) => !m.user.bot);
   return !members.size;
 }
+__name(isVoiceChannelEmpty, "isVoiceChannelEmpty");
 function isSnowflake(id) {
   try {
     return SnowflakeUtil.deconstruct(id).timestamp > SnowflakeUtil.epoch;
@@ -1883,21 +1965,27 @@ function isSnowflake(id) {
     return false;
   }
 }
+__name(isSnowflake, "isSnowflake");
 function isMemberInstance(member) {
   return !!member && isSnowflake(member.id) && isSnowflake(member.guild?.id) && isSnowflake(member.user?.id) && member.id === member.user.id;
 }
+__name(isMemberInstance, "isMemberInstance");
 function isTextChannelInstance(channel) {
-  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && typeof channel.name === "string" && Constants.TextBasedChannelTypes.includes(channel.type);
+  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && typeof channel.name === "string" && Constants.TextBasedChannelTypes.includes(channel.type) && typeof channel.nsfw === "boolean" && typeof channel.messages?.cache === "object" && typeof channel.send === "function";
 }
+__name(isTextChannelInstance, "isTextChannelInstance");
 function isMessageInstance(message) {
   return !!message && isSnowflake(message.id) && isSnowflake(message.guildId) && isMemberInstance(message.member) && isTextChannelInstance(message.channel) && Constants.NonSystemMessageTypes.includes(message.type) && message.member.id === message.author?.id;
 }
+__name(isMessageInstance, "isMessageInstance");
 function isSupportedVoiceChannel(channel) {
   return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && Constants.VoiceBasedChannelTypes.includes(channel.type);
 }
+__name(isSupportedVoiceChannel, "isSupportedVoiceChannel");
 function isGuildInstance(guild) {
   return !!guild && isSnowflake(guild.id) && isSnowflake(guild.ownerId) && typeof guild.name === "string";
 }
+__name(isGuildInstance, "isGuildInstance");
 function resolveGuildId(resolvable) {
   let guildId;
   if (typeof resolvable === "string") {
@@ -1915,9 +2003,11 @@ function resolveGuildId(resolvable) {
     throw new DisTubeError("INVALID_TYPE", "GuildIdResolvable", resolvable);
   return guildId;
 }
+__name(resolveGuildId, "resolveGuildId");
 function isClientInstance(client) {
   return !!client && typeof client.login === "function";
 }
+__name(isClientInstance, "isClientInstance");
 function checkInvalidKey(target, source, sourceName) {
   if (!isObject(target))
     throw new DisTubeError("INVALID_TYPE", "object", target, sourceName);
@@ -1926,38 +2016,15 @@ function checkInvalidKey(target, source, sourceName) {
   if (invalidKey)
     throw new DisTubeError("INVALID_KEY", sourceName, invalidKey);
 }
-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();
-  }
-}
-async function entersState(target, status, maxTime) {
-  if (target.state.status === status)
-    return target;
-  return waitEvent(target, status, maxTime);
-}
+__name(checkInvalidKey, "checkInvalidKey");
 function isObject(obj) {
   return typeof obj === "object" && obj !== null && !Array.isArray(obj);
 }
+__name(isObject, "isObject");
 function isRecord(obj) {
   return isObject(obj);
 }
+__name(isRecord, "isRecord");
 
 // src/plugin/http.ts
 import http from "http";
@@ -1969,6 +2036,7 @@ var HTTPPlugin = class extends ExtractorPlugin {
     return resolveHttpSong(url, { ...options, source: "http" });
   }
 };
+__name(HTTPPlugin, "HTTPPlugin");
 
 // src/plugin/https.ts
 import https from "https";
@@ -2003,6 +2071,7 @@ var HTTPSPlugin = class extends ExtractorPlugin {
     return resolveHttpSong(url, { ...options, source: "https" });
   }
 };
+__name(HTTPSPlugin, "HTTPSPlugin");
 
 // src/DisTube.ts
 import ytsr from "@distube/ytsr";
@@ -2047,7 +2116,7 @@ var DisTube = class extends TypedEmitter2 {
     if (!isObject(options))
       throw new DisTubeError("INVALID_TYPE", "object", options, "options");
     const { textChannel, member, skip, message, metadata } = {
-      member: voiceChannel.guild.me ?? void 0,
+      member: voiceChannel.guild.members.me ?? void 0,
       textChannel: options?.message?.channel,
       skip: false,
       ...options
@@ -2095,12 +2164,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();
@@ -2112,7 +2181,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)) {
@@ -2134,7 +2203,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");
     }
@@ -2147,7 +2216,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;
@@ -2244,6 +2317,7 @@ ${e.message}`;
     }
   }
 };
+__name(DisTube, "DisTube");
 export {
   BaseManager,
   CustomPlugin,
@@ -2266,9 +2340,11 @@ export {
   Queue,
   QueueManager,
   RepeatMode,
-  SearchResult,
+  SearchResultPlaylist,
   SearchResultType,
+  SearchResultVideo,
   Song,
+  StreamType,
   TaskQueue,
   checkIntents,
   checkInvalidKey,
@@ -2276,7 +2352,6 @@ export {
   DisTube as default,
   defaultFilters,
   defaultOptions,
-  entersState,
   formatDuration,
   getResponseHeaders,
   isClientInstance,