distube 4.0.2 → 4.0.4

package/dist/index.js

@@ -22,7 +22,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -56,15 +59,11 @@ var require_package = __commonJS({
   "package.json"(exports, module2) {
     module2.exports = {
       name: "distube",
-      version: "4.0.2",
+      version: "4.0.4",
       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",
       types: "./dist/index.d.ts",
-      exports: {
-        import: "./dist/index.mjs",
-        require: "./dist/index.js"
-      },
+      exports: "./dist/index.js",
       directories: {
         lib: "src",
         test: "tests"
@@ -74,7 +73,7 @@ var require_package = __commonJS({
       ],
       scripts: {
         test: "jest",
-        docs: "docgen -s src/*.ts src/**/*.ts -o docs.json -c pages/index.yml -g -j jsdoc.config.json",
+        docs: "docgen -s 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}"',
@@ -137,13 +136,13 @@ var require_package = __commonJS({
         "@commitlint/cli": "^17.0.3",
         "@commitlint/config-conventional": "^17.0.3",
         "@discordjs/voice": "^0.11.0",
-        "@distube/docgen": "distubejs/docgen",
+        "@distubejs/docgen": "distubejs/docgen",
         "@types/jest": "^28.1.6",
-        "@types/node": "^18.0.6",
-        "@typescript-eslint/eslint-plugin": "^5.30.7",
-        "@typescript-eslint/parser": "^5.30.7",
+        "@types/node": "^18.6.1",
+        "@typescript-eslint/eslint-plugin": "^5.31.0",
+        "@typescript-eslint/parser": "^5.31.0",
         "babel-jest": "^28.1.3",
-        "discord.js": "^14.0.2",
+        "discord.js": "^14.0.3",
         eslint: "^8.20.0",
         "eslint-config-distube": "^1.6.4",
         "eslint-config-prettier": "^8.5.0",
@@ -153,10 +152,10 @@ var require_package = __commonJS({
         jest: "^28.1.3",
         "jsdoc-babel": "^0.5.0",
         "nano-staged": "^0.8.0",
-        "npm-check-updates": "^15.3.4",
+        "npm-check-updates": "^16.0.0",
         pinst: "^3.0.0",
         prettier: "^2.7.1",
-        tsup: "^6.1.3",
+        tsup: "^6.2.0",
         typescript: "^4.7.4"
       },
       peerDependencies: {
@@ -199,6 +198,7 @@ __export(src_exports, {
   DisTubeStream: () => DisTubeStream,
   DisTubeVoice: () => DisTubeVoice,
   DisTubeVoiceManager: () => DisTubeVoiceManager,
+  Events: () => Events,
   ExtractorPlugin: () => ExtractorPlugin,
   FilterManager: () => FilterManager,
   GuildIdManager: () => GuildIdManager,
@@ -233,6 +233,7 @@ __export(src_exports, {
   isTextChannelInstance: () => isTextChannelInstance,
   isURL: () => isURL,
   isVoiceChannelEmpty: () => isVoiceChannelEmpty,
+  objectKeys: () => objectKeys,
   parseNumber: () => parseNumber,
   resolveGuildId: () => resolveGuildId,
   toSecond: () => toSecond,
@@ -262,6 +263,25 @@ var StreamType = /* @__PURE__ */ ((StreamType2) => {
   StreamType2[StreamType2["RAW"] = 1] = "RAW";
   return StreamType2;
 })(StreamType || {});
+var Events = /* @__PURE__ */ ((Events2) => {
+  Events2["ERROR"] = "error";
+  Events2["ADD_LIST"] = "addList";
+  Events2["ADD_SONG"] = "addSong";
+  Events2["PLAY_SONG"] = "playSong";
+  Events2["FINISH_SONG"] = "finishSong";
+  Events2["EMPTY"] = "empty";
+  Events2["FINISH"] = "finish";
+  Events2["INIT_QUEUE"] = "initQueue";
+  Events2["NO_RELATED"] = "noRelated";
+  Events2["DISCONNECT"] = "disconnect";
+  Events2["DELETE_QUEUE"] = "deleteQueue";
+  Events2["SEARCH_CANCEL"] = "searchCancel";
+  Events2["SEARCH_NO_RESULT"] = "searchNoResult";
+  Events2["SEARCH_DONE"] = "searchDone";
+  Events2["SEARCH_INVALID_ANSWER"] = "searchInvalidAnswer";
+  Events2["SEARCH_RESULT"] = "searchResult";
+  return Events2;
+})(Events || {});
 
 // src/constant.ts
 var defaultFilters = {
@@ -698,6 +718,7 @@ var DisTubeBase = class {
 __name(DisTubeBase, "DisTubeBase");
 
 // src/core/DisTubeVoice.ts
+var import_discord = require("discord.js");
 var import_tiny_typed_emitter = require("tiny-typed-emitter");
 var import_voice = require("@discordjs/voice");
 var _channel, _volume, _br, br_fn, _join, join_fn;
@@ -751,7 +772,23 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
     }).on("error", () => void 0);
     this.connection.subscribe(this.audioPlayer);
   }
+  get channelId() {
+    return this.connection?.joinConfig?.channelId ?? void 0;
+  }
   get channel() {
+    if (!this.channelId)
+      return __privateGet(this, _channel);
+    if (__privateGet(this, _channel)?.id === this.channelId)
+      return __privateGet(this, _channel);
+    const channel = this.voices.client.channels.cache.get(this.channelId);
+    if (!channel)
+      return __privateGet(this, _channel);
+    for (const type of import_discord.Constants.VoiceBasedChannelTypes) {
+      if (channel.type === type) {
+        __privateSet(this, _channel, channel);
+        return channel;
+      }
+    }
     return __privateGet(this, _channel);
   }
   set channel(channel) {
@@ -762,7 +799,7 @@ var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
       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)
+    if (channel.id === this.channelId)
       return;
     if (!channel.joinable) {
       if (channel.full)
@@ -886,538 +923,222 @@ join_fn = /* @__PURE__ */ __name(function(channel) {
   });
 }, "#join");
 
-// src/core/manager/BaseManager.ts
-var import_discord = require("discord.js");
-var BaseManager = class extends DisTubeBase {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "collection", new import_discord.Collection());
+// src/core/DisTubeHandler.ts
+var import_ytpl = __toESM(require("@distube/ytpl"));
+var import_ytdl_core = __toESM(require("@distube/ytdl-core"));
+var DisTubeHandler = class extends DisTubeBase {
+  constructor(distube) {
+    super(distube);
+    const client = this.client;
+    if (this.options.leaveOnEmpty) {
+      client.on("voiceStateUpdate", (oldState) => {
+        if (!oldState?.channel)
+          return;
+        const queue = this.queues.get(oldState);
+        if (!queue) {
+          if (isVoiceChannelEmpty(oldState)) {
+            setTimeout(() => {
+              if (!this.queues.get(oldState) && isVoiceChannelEmpty(oldState))
+                this.voices.leave(oldState);
+            }, this.options.emptyCooldown * 1e3).unref();
+          }
+          return;
+        }
+        if (queue._emptyTimeout) {
+          clearTimeout(queue._emptyTimeout);
+          delete queue._emptyTimeout;
+        }
+        if (isVoiceChannelEmpty(oldState)) {
+          queue._emptyTimeout = setTimeout(() => {
+            delete queue._emptyTimeout;
+            if (isVoiceChannelEmpty(oldState)) {
+              queue.voice.leave();
+              this.emit("empty", queue);
+              if (queue.stopped)
+                queue.remove();
+            }
+          }, this.options.emptyCooldown * 1e3).unref();
+        }
+      });
+    }
   }
-  get size() {
-    return this.collection.size;
+  get ytdlOptions() {
+    const options = this.options.ytdlOptions;
+    if (this.options.youtubeCookie) {
+      if (!options.requestOptions)
+        options.requestOptions = {};
+      if (!options.requestOptions.headers)
+        options.requestOptions.headers = {};
+      options.requestOptions.headers.cookie = this.options.youtubeCookie;
+      if (this.options.youtubeIdentityToken) {
+        options.requestOptions.headers["x-youtube-identity-token"] = this.options.youtubeIdentityToken;
+      }
+    }
+    return options;
   }
-};
-__name(BaseManager, "BaseManager");
-
-// src/core/manager/GuildIdManager.ts
-var GuildIdManager = class extends BaseManager {
-  add(idOrInstance, data) {
-    const id = resolveGuildId(idOrInstance);
-    const existing = this.get(id);
-    if (existing)
-      return this;
-    return this.collection.set(id, data);
+  getYouTubeInfo(url, basic = false) {
+    if (basic)
+      return import_ytdl_core.default.getBasicInfo(url, this.ytdlOptions);
+    return import_ytdl_core.default.getInfo(url, this.ytdlOptions);
   }
-  get(idOrInstance) {
-    return this.collection.get(resolveGuildId(idOrInstance));
+  async resolve(song, options = {}) {
+    if (song instanceof Song || song instanceof Playlist) {
+      if ("metadata" in options)
+        song.metadata = options.metadata;
+      if ("member" in options)
+        song.member = options.member;
+      return song;
+    }
+    if (song instanceof SearchResultVideo)
+      return new Song(song, options);
+    if (song instanceof SearchResultPlaylist)
+      return this.resolvePlaylist(song.url, options);
+    if (isObject(song)) {
+      if (!("url" in song) && !("id" in song))
+        throw new DisTubeError("CANNOT_RESOLVE_SONG", song);
+      return new Song(song, options);
+    }
+    if (import_ytpl.default.validateID(song))
+      return this.resolvePlaylist(song, options);
+    if (import_ytdl_core.default.validateURL(song))
+      return new Song(await this.getYouTubeInfo(song, true), options);
+    if (isURL(song)) {
+      for (const plugin of this.distube.extractorPlugins) {
+        if (await plugin.validate(song))
+          return plugin.resolve(song, options);
+      }
+      throw new DisTubeError("NOT_SUPPORTED_URL");
+    }
+    throw new DisTubeError("CANNOT_RESOLVE_SONG", song);
   }
-  remove(idOrInstance) {
-    return this.collection.delete(resolveGuildId(idOrInstance));
+  async resolvePlaylist(playlist, options = {}) {
+    const { member, source, metadata } = { source: "youtube", ...options };
+    if (playlist instanceof Playlist) {
+      if ("metadata" in options)
+        playlist.metadata = metadata;
+      if ("member" in options)
+        playlist.member = member;
+      return playlist;
+    }
+    if (typeof playlist === "string") {
+      const info = await (0, import_ytpl.default)(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 });
   }
-  has(idOrInstance) {
-    return this.collection.has(resolveGuildId(idOrInstance));
+  async searchSong(message, query) {
+    if (!isMessageInstance(message))
+      throw new DisTubeError("INVALID_TYPE", "Discord.Message", message, "message");
+    if (typeof query !== "string")
+      throw new DisTubeError("INVALID_TYPE", "string", query, "query");
+    if (query.length === 0)
+      throw new DisTubeError("EMPTY_STRING", "query");
+    const limit = this.options.searchSongs > 1 ? this.options.searchSongs : 1;
+    const results = await this.distube.search(query, {
+      limit,
+      safeSearch: this.options.nsfw ? false : !message.channel?.nsfw
+    }).catch(() => {
+      if (!this.emit("searchNoResult", message, query)) {
+        console.warn("searchNoResult event does not have any listeners! Emits `error` event instead.");
+        throw new DisTubeError("NO_RESULT");
+      }
+    });
+    if (!results)
+      return null;
+    return this.createSearchMessageCollector(message, results, query);
   }
-};
-__name(GuildIdManager, "GuildIdManager");
-
-// src/core/manager/DisTubeVoiceManager.ts
-var import_voice2 = require("@discordjs/voice");
-var DisTubeVoiceManager = class extends GuildIdManager {
-  create(channel) {
-    const existing = this.get(channel.guildId);
-    if (existing) {
-      existing.channel = channel;
-      return existing;
+  async createSearchMessageCollector(message, results, query) {
+    if (!isMessageInstance(message))
+      throw new DisTubeError("INVALID_TYPE", "Discord.Message", message, "message");
+    if (!Array.isArray(results) || results.length == 0) {
+      throw new DisTubeError("INVALID_TYPE", "Array<SearchResult|Song|Playlist>", results, "results");
     }
-    return new DisTubeVoice(this, channel);
-  }
-  join(channel) {
-    const existing = this.get(channel.guildId);
-    if (existing)
-      return existing.join(channel);
-    return this.create(channel).join();
+    if (this.options.searchSongs > 1) {
+      const searchEvents = [
+        "searchNoResult",
+        "searchResult",
+        "searchCancel",
+        "searchInvalidAnswer",
+        "searchDone"
+      ];
+      for (const evn of searchEvents) {
+        if (this.distube.listenerCount(evn) === 0) {
+          console.warn(`"searchSongs" option is disabled due to missing "${evn}" listener.`);
+          console.warn(
+            `If you don't want to use "${evn}" event, simply add an empty listener (not recommended):
+<DisTube>.on("${evn}", () => {})`
+          );
+          this.options.searchSongs = 0;
+        }
+      }
+    }
+    const limit = this.options.searchSongs > 1 ? this.options.searchSongs : 1;
+    let result = results[0];
+    if (limit > 1) {
+      results.splice(limit);
+      this.emit("searchResult", message, results, query);
+      const c = message.channel;
+      const answers = await c.awaitMessages({
+        filter: (m) => m.author.id === message.author.id,
+        max: 1,
+        time: this.options.searchCooldown * 1e3,
+        errors: ["time"]
+      }).catch(() => void 0);
+      const ans = answers?.first();
+      if (!ans) {
+        this.emit("searchCancel", message, query);
+        return null;
+      }
+      const index = parseInt(ans.content, 10);
+      if (isNaN(index) || index > results.length || index < 1) {
+        this.emit("searchInvalidAnswer", message, ans, query);
+        return null;
+      }
+      this.emit("searchDone", message, ans, query);
+      result = results[index - 1];
+    }
+    return result;
   }
-  leave(guild) {
-    const voice = this.get(guild);
-    if (voice) {
-      voice.leave();
+  async playPlaylist(voiceChannel, playlist, options = {}) {
+    const { textChannel, skip } = { skip: false, ...options };
+    const position = Number(options.position) || (skip ? 1 : 0);
+    if (!(playlist instanceof Playlist))
+      throw new DisTubeError("INVALID_TYPE", "Playlist", playlist, "playlist");
+    const queue = this.queues.get(voiceChannel);
+    if (!this.options.nsfw && !(queue?.textChannel || textChannel)?.nsfw) {
+      playlist.songs = playlist.songs.filter((s) => !s.age_restricted);
+    }
+    if (!playlist.songs.length) {
+      if (!this.options.nsfw && !textChannel?.nsfw) {
+        throw new DisTubeError("EMPTY_FILTERED_PLAYLIST");
+      }
+      throw new DisTubeError("EMPTY_PLAYLIST");
+    }
+    if (queue) {
+      if (this.options.joinNewVoiceChannel)
+        queue.voice.channel = voiceChannel;
+      queue.addToQueue(playlist.songs, position);
+      if (skip)
+        queue.skip();
+      else
+        this.emit("addList", queue, playlist);
     } else {
-      const connection = (0, import_voice2.getVoiceConnection)(resolveGuildId(guild), this.client.user?.id) ?? (0, import_voice2.getVoiceConnection)(resolveGuildId(guild));
-      if (connection && connection.state.status !== import_voice2.VoiceConnectionStatus.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 {
-  constructor() {
-    super(...arguments);
-    __privateAdd(this, _voiceEventHandler);
-    __privateAdd(this, _handleSongFinish);
-    __privateAdd(this, _handlePlayingError);
-    __privateAdd(this, _emitPlaySong);
-  }
-  async create(channel, song, textChannel) {
-    if (this.has(channel.guildId))
-      throw new DisTubeError("QUEUE_EXIST");
-    const voice = this.voices.create(channel);
-    const queue = new Queue(this.distube, voice, song, textChannel);
-    await queue._taskQueue.queuing();
-    try {
-      await voice.join();
-      __privateMethod(this, _voiceEventHandler, voiceEventHandler_fn).call(this, queue);
-      this.add(queue.id, queue);
-      this.emit("initQueue", queue);
-      const err = await this.playSong(queue);
-      return err || queue;
-    } finally {
-      queue._taskQueue.resolve();
-    }
-  }
-  createStream(queue) {
-    const { duration, formats, isLive, source, streamURL } = queue.songs[0];
-    const ffmpegArgs = queue.filters.size ? ["-af", queue.filters.values.join(",")] : void 0;
-    const seek = duration ? queue.beginTime : void 0;
-    const streamOptions = { ffmpegArgs, seek, isLive, type: this.options.streamType };
-    if (source === "youtube")
-      return DisTubeStream.YouTube(formats, streamOptions);
-    return DisTubeStream.DirectLink(streamURL, streamOptions);
-  }
-  async playSong(queue) {
-    if (!queue)
-      return true;
-    if (!queue.songs.length) {
-      queue.stop();
-      return true;
-    }
-    if (queue.stopped)
-      return false;
-    try {
-      const song = queue.songs[0];
-      const { url, source, formats, streamURL } = song;
-      if (source === "youtube" && !formats)
-        song._patchYouTube(await this.handler.getYouTubeInfo(url));
-      if (source !== "youtube" && !streamURL) {
-        for (const plugin of [...this.distube.extractorPlugins, ...this.distube.customPlugins]) {
-          if (await plugin.validate(url)) {
-            const info = [plugin.getStreamURL(url), plugin.getRelatedSongs(url)];
-            const result = await Promise.all(info);
-            song.streamURL = result[0];
-            song.related = result[1];
-            break;
-          }
-        }
-      }
-      const stream = this.createStream(queue);
-      queue.voice.play(stream);
-      song.streamURL = stream.url;
-      if (queue.stopped)
-        queue.stop();
-      else if (queue.paused)
-        queue.voice.pause();
-      return false;
-    } catch (e) {
-      __privateMethod(this, _handlePlayingError, handlePlayingError_fn).call(this, queue, e);
-      return true;
-    }
-  }
-};
-__name(QueueManager, "QueueManager");
-_voiceEventHandler = new WeakSet();
-voiceEventHandler_fn = /* @__PURE__ */ __name(function(queue) {
-  queue._listeners = {
-    disconnect: (error) => {
-      queue.remove();
-      this.emit("disconnect", queue);
-      if (error)
-        this.emitError(error, queue.textChannel);
-    },
-    error: (error) => __privateMethod(this, _handlePlayingError, handlePlayingError_fn).call(this, queue, error),
-    finish: () => __privateMethod(this, _handleSongFinish, handleSongFinish_fn).call(this, queue)
-  };
-  for (const event of Object.keys(queue._listeners)) {
-    queue.voice.on(event, queue._listeners[event]);
-  }
-}, "#voiceEventHandler");
-_handleSongFinish = new WeakSet();
-handleSongFinish_fn = /* @__PURE__ */ __name(async function(queue) {
-  this.emit("finishSong", queue, queue.songs[0]);
-  await queue._taskQueue.queuing();
-  try {
-    if (queue.stopped)
-      return;
-    if (queue.repeatMode === 2 /* QUEUE */ && !queue._prev)
-      queue.songs.push(queue.songs[0]);
-    if (queue._prev) {
-      if (queue.repeatMode === 2 /* QUEUE */)
-        queue.songs.unshift(queue.songs.pop());
-      else
-        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) {
-    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();
-  }
-}, "#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
-var import_ytpl = __toESM(require("@distube/ytpl"));
-var import_ytdl_core = __toESM(require("@distube/ytdl-core"));
-var DisTubeHandler = class extends DisTubeBase {
-  constructor(distube) {
-    super(distube);
-    const client = this.client;
-    if (this.options.leaveOnEmpty) {
-      client.on("voiceStateUpdate", (oldState) => {
-        if (!oldState?.channel)
-          return;
-        const queue = this.queues.get(oldState);
-        if (!queue) {
-          if (isVoiceChannelEmpty(oldState)) {
-            setTimeout(() => {
-              if (!this.queues.get(oldState) && isVoiceChannelEmpty(oldState))
-                this.voices.leave(oldState);
-            }, this.options.emptyCooldown * 1e3).unref();
-          }
-          return;
-        }
-        if (queue._emptyTimeout) {
-          clearTimeout(queue._emptyTimeout);
-          delete queue._emptyTimeout;
-        }
-        if (isVoiceChannelEmpty(oldState)) {
-          queue._emptyTimeout = setTimeout(() => {
-            delete queue._emptyTimeout;
-            if (isVoiceChannelEmpty(oldState)) {
-              queue.voice.leave();
-              this.emit("empty", queue);
-              if (queue.stopped)
-                queue.remove();
-            }
-          }, this.options.emptyCooldown * 1e3).unref();
-        }
-      });
-    }
-  }
-  get ytdlOptions() {
-    const options = this.options.ytdlOptions;
-    if (this.options.youtubeCookie) {
-      if (!options.requestOptions)
-        options.requestOptions = {};
-      if (!options.requestOptions.headers)
-        options.requestOptions.headers = {};
-      options.requestOptions.headers.cookie = this.options.youtubeCookie;
-      if (this.options.youtubeIdentityToken) {
-        options.requestOptions.headers["x-youtube-identity-token"] = this.options.youtubeIdentityToken;
-      }
-    }
-    return options;
-  }
-  getYouTubeInfo(url, basic = false) {
-    if (basic)
-      return import_ytdl_core.default.getBasicInfo(url, this.ytdlOptions);
-    return import_ytdl_core.default.getInfo(url, this.ytdlOptions);
-  }
-  async resolve(song, options = {}) {
-    if (song instanceof Song || song instanceof Playlist) {
-      if ("metadata" in options)
-        song.metadata = options.metadata;
-      if ("member" in options)
-        song.member = options.member;
-      return song;
-    }
-    if (song instanceof SearchResultVideo)
-      return new Song(song, options);
-    if (song instanceof SearchResultPlaylist)
-      return this.resolvePlaylist(song.url, options);
-    if (isObject(song)) {
-      if (!("url" in song) && !("id" in song))
-        throw new DisTubeError("CANNOT_RESOLVE_SONG", song);
-      return new Song(song, options);
-    }
-    if (import_ytpl.default.validateID(song))
-      return this.resolvePlaylist(song, options);
-    if (import_ytdl_core.default.validateURL(song))
-      return new Song(await this.getYouTubeInfo(song), options);
-    if (isURL(song)) {
-      for (const plugin of this.distube.extractorPlugins) {
-        if (await plugin.validate(song))
-          return plugin.resolve(song, options);
-      }
-      throw new DisTubeError("NOT_SUPPORTED_URL");
-    }
-    throw new DisTubeError("CANNOT_RESOLVE_SONG", song);
-  }
-  async resolvePlaylist(playlist, options = {}) {
-    const { member, source, metadata } = { source: "youtube", ...options };
-    if (playlist instanceof Playlist) {
-      if ("metadata" in options)
-        playlist.metadata = metadata;
-      if ("member" in options)
-        playlist.member = member;
-      return playlist;
-    }
-    if (typeof playlist === "string") {
-      const info = await (0, import_ytpl.default)(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))
-      throw new DisTubeError("INVALID_TYPE", "Discord.Message", message, "message");
-    if (typeof query !== "string")
-      throw new DisTubeError("INVALID_TYPE", "string", query, "query");
-    if (query.length === 0)
-      throw new DisTubeError("EMPTY_STRING", "query");
-    const limit = this.options.searchSongs > 1 ? this.options.searchSongs : 1;
-    const results = await this.distube.search(query, {
-      limit,
-      safeSearch: this.options.nsfw ? false : !message.channel?.nsfw
-    }).catch(() => {
-      if (!this.emit("searchNoResult", message, query)) {
-        console.warn("searchNoResult event does not have any listeners! Emits `error` event instead.");
-        throw new DisTubeError("NO_RESULT");
-      }
-    });
-    if (!results)
-      return null;
-    return this.createSearchMessageCollector(message, results, query);
-  }
-  async createSearchMessageCollector(message, results, query) {
-    if (!isMessageInstance(message))
-      throw new DisTubeError("INVALID_TYPE", "Discord.Message", message, "message");
-    if (!Array.isArray(results) || results.length == 0) {
-      throw new DisTubeError("INVALID_TYPE", "Array<SearchResult|Song|Playlist>", results, "results");
-    }
-    if (this.options.searchSongs > 1) {
-      const searchEvents = [
-        "searchNoResult",
-        "searchResult",
-        "searchCancel",
-        "searchInvalidAnswer",
-        "searchDone"
-      ];
-      for (const evn of searchEvents) {
-        if (this.distube.listenerCount(evn) === 0) {
-          console.warn(`"searchSongs" option is disabled due to missing "${evn}" listener.`);
-          console.warn(`If you don't want to use "${evn}" event, simply add an empty listener (not recommended):
-<DisTube>.on("${evn}", () => {})`);
-          this.options.searchSongs = 0;
-        }
-      }
-    }
-    const limit = this.options.searchSongs > 1 ? this.options.searchSongs : 1;
-    let result = results[0];
-    if (limit > 1) {
-      results.splice(limit);
-      this.emit("searchResult", message, results, query);
-      const c = message.channel;
-      const answers = await c.awaitMessages({
-        filter: (m) => m.author.id === message.author.id,
-        max: 1,
-        time: this.options.searchCooldown * 1e3,
-        errors: ["time"]
-      }).catch(() => void 0);
-      const ans = answers?.first();
-      if (!ans) {
-        this.emit("searchCancel", message, query);
-        return null;
-      }
-      const index = parseInt(ans.content, 10);
-      if (isNaN(index) || index > results.length || index < 1) {
-        this.emit("searchInvalidAnswer", message, ans, query);
-        return null;
-      }
-      this.emit("searchDone", message, ans, query);
-      result = results[index - 1];
-    }
-    return result;
-  }
-  async playPlaylist(voiceChannel, playlist, options = {}) {
-    const { textChannel, skip } = { skip: false, ...options };
-    const position = Number(options.position) || (skip ? 1 : 0);
-    if (!(playlist instanceof Playlist))
-      throw new DisTubeError("INVALID_TYPE", "Playlist", playlist, "playlist");
-    const queue = this.queues.get(voiceChannel);
-    if (!this.options.nsfw && !(queue?.textChannel || textChannel)?.nsfw) {
-      playlist.songs = playlist.songs.filter((s) => !s.age_restricted);
-    }
-    if (!playlist.songs.length) {
-      if (!this.options.nsfw && !textChannel?.nsfw) {
-        throw new DisTubeError("EMPTY_FILTERED_PLAYLIST");
-      }
-      throw new DisTubeError("EMPTY_PLAYLIST");
-    }
-    if (queue) {
-      if (this.options.joinNewVoiceChannel)
-        queue.voice.channel = voiceChannel;
-      queue.addToQueue(playlist.songs, position);
-      if (skip)
-        queue.skip();
-      else
-        this.emit("addList", queue, playlist);
-    } else {
-      const newQueue = await this.queues.create(voiceChannel, playlist.songs, textChannel);
-      if (newQueue instanceof Queue) {
-        if (this.options.emitAddListWhenCreatingQueue)
-          this.emit("addList", newQueue, playlist);
-        this.emit("playSong", newQueue, newQueue.songs[0]);
+      const newQueue = await this.queues.create(voiceChannel, playlist.songs, textChannel);
+      if (newQueue instanceof Queue) {
+        if (this.options.emitAddListWhenCreatingQueue)
+          this.emit("addList", newQueue, playlist);
+        this.emit("playSong", newQueue, newQueue.songs[0]);
       }
     }
   }
@@ -1520,13 +1241,23 @@ validateOptions_fn = /* @__PURE__ */ __name(function(options = this) {
     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");
+    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");
+    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");
@@ -1550,90 +1281,424 @@ validateOptions_fn = /* @__PURE__ */ __name(function(options = this) {
     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");
+    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");
+  }
+  if (typeof options.directLink !== "boolean") {
+    throw new DisTubeError("INVALID_TYPE", "boolean", options.directLink, "DisTubeOptions.directLink");
+  }
+}, "#validateOptions");
+
+// src/core/DisTubeStream.ts
+var import_prism_media = require("prism-media");
+var import_voice2 = require("@discordjs/voice");
+var chooseBestVideoFormat = /* @__PURE__ */ __name((formats, isLive = false) => {
+  let filter = /* @__PURE__ */ __name((format) => format.hasAudio, "filter");
+  if (isLive)
+    filter = /* @__PURE__ */ __name((format) => format.hasAudio && format.isHLS, "filter");
+  formats = formats.filter(filter).sort((a, b) => Number(b.audioBitrate) - Number(a.audioBitrate) || Number(a.bitrate) - Number(b.bitrate));
+  return formats.find((format) => !format.hasVideo) || formats.sort((a, b) => Number(a.bitrate) - Number(b.bitrate))[0];
+}, "chooseBestVideoFormat");
+var DisTubeStream = class {
+  constructor(url, options) {
+    __publicField(this, "type");
+    __publicField(this, "stream");
+    __publicField(this, "url");
+    this.url = url;
+    this.type = !options.type ? import_voice2.StreamType.OggOpus : import_voice2.StreamType.Raw;
+    const args = [
+      "-reconnect",
+      "1",
+      "-reconnect_streamed",
+      "1",
+      "-reconnect_delay_max",
+      "5",
+      "-i",
+      url,
+      "-analyzeduration",
+      "0",
+      "-loglevel",
+      "0",
+      "-ar",
+      "48000",
+      "-ac",
+      "2",
+      "-f"
+    ];
+    if (!options.type) {
+      args.push("opus", "-acodec", "libopus");
+    } else {
+      args.push("s16le");
+    }
+    if (typeof options.seek === "number" && options.seek > 0) {
+      args.unshift("-ss", options.seek.toString());
+    }
+    if (Array.isArray(options.ffmpegArgs)) {
+      args.push(...options.ffmpegArgs);
+    }
+    this.stream = new import_prism_media.FFmpeg({ args, shell: false });
+    this.stream._readableState && (this.stream._readableState.highWaterMark = 1 << 25);
+  }
+  static YouTube(formats, options = {}) {
+    if (!formats || !formats.length)
+      throw new DisTubeError("UNAVAILABLE_VIDEO");
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
+      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
+    }
+    const bestFormat = chooseBestVideoFormat(formats, options.isLive);
+    if (!bestFormat)
+      throw new DisTubeError("UNPLAYABLE_FORMATS");
+    return new DisTubeStream(bestFormat.url, options);
+  }
+  static DirectLink(url, options = {}) {
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
+      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
+    }
+    if (typeof url !== "string" || !isURL(url)) {
+      throw new DisTubeError("INVALID_TYPE", "an URL", url);
+    }
+    return new DisTubeStream(url, options);
+  }
+};
+__name(DisTubeStream, "DisTubeStream");
+
+// src/core/manager/BaseManager.ts
+var import_discord2 = require("discord.js");
+var BaseManager = class extends DisTubeBase {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "collection", new import_discord2.Collection());
+  }
+  get size() {
+    return this.collection.size;
+  }
+};
+__name(BaseManager, "BaseManager");
+
+// src/core/manager/GuildIdManager.ts
+var GuildIdManager = class extends BaseManager {
+  add(idOrInstance, data) {
+    const id = resolveGuildId(idOrInstance);
+    const existing = this.get(id);
+    if (existing)
+      return this;
+    return this.collection.set(id, data);
+  }
+  get(idOrInstance) {
+    return this.collection.get(resolveGuildId(idOrInstance));
+  }
+  remove(idOrInstance) {
+    return this.collection.delete(resolveGuildId(idOrInstance));
+  }
+  has(idOrInstance) {
+    return this.collection.has(resolveGuildId(idOrInstance));
+  }
+};
+__name(GuildIdManager, "GuildIdManager");
+
+// src/core/manager/DisTubeVoiceManager.ts
+var import_voice3 = require("@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 = (0, import_voice3.getVoiceConnection)(resolveGuildId(guild), this.client.user?.id) ?? (0, import_voice3.getVoiceConnection)(resolveGuildId(guild));
+      if (connection && connection.state.status !== import_voice3.VoiceConnectionStatus.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));
   }
-  if (typeof options.emitAddListWhenCreatingQueue !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.emitAddListWhenCreatingQueue, "DisTubeOptions.emitAddListWhenCreatingQueue");
+  get values() {
+    return this.collection.map((f) => __privateMethod(this, _resolveValue, resolveValue_fn).call(this, f));
   }
-  if (typeof options.streamType !== "number" || isNaN(options.streamType) || !StreamType[options.streamType]) {
-    throw new DisTubeError("INVALID_TYPE", "StreamType", options.streamType, "DisTubeOptions.streamType");
+  toString() {
+    return this.names.toString();
   }
-  if (typeof options.directLink !== "boolean") {
-    throw new DisTubeError("INVALID_TYPE", "boolean", options.directLink, "DisTubeOptions.directLink");
+};
+__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;
   }
-}, "#validateOptions");
+  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/DisTubeStream.ts
-var import_prism_media = require("prism-media");
-var import_voice3 = require("@discordjs/voice");
-var chooseBestVideoFormat = /* @__PURE__ */ __name((formats, isLive = false) => {
-  let filter = /* @__PURE__ */ __name((format) => format.hasAudio, "filter");
-  if (isLive)
-    filter = /* @__PURE__ */ __name((format) => format.hasAudio && format.isHLS, "filter");
-  formats = formats.filter(filter).sort((a, b) => Number(b.audioBitrate) - Number(a.audioBitrate) || Number(a.bitrate) - Number(b.bitrate));
-  return formats.find((format) => !format.hasVideo) || formats.sort((a, b) => Number(a.bitrate) - Number(b.bitrate))[0];
-}, "chooseBestVideoFormat");
-var DisTubeStream = class {
-  constructor(url, options) {
-    __publicField(this, "type");
-    __publicField(this, "stream");
-    __publicField(this, "url");
-    this.url = url;
-    this.type = !options.type ? import_voice3.StreamType.OggOpus : import_voice3.StreamType.Raw;
-    const args = [
-      "-reconnect",
-      "1",
-      "-reconnect_streamed",
-      "1",
-      "-reconnect_delay_max",
-      "5",
-      "-i",
-      url,
-      "-analyzeduration",
-      "0",
-      "-loglevel",
-      "0",
-      "-ar",
-      "48000",
-      "-ac",
-      "2",
-      "-f"
-    ];
-    if (!options.type) {
-      args.push("opus", "-acodec", "libopus");
-    } else {
-      args.push("s16le");
+// src/core/manager/QueueManager.ts
+var _voiceEventHandler, voiceEventHandler_fn, _handleSongFinish, handleSongFinish_fn, _handlePlayingError, handlePlayingError_fn, _emitPlaySong, emitPlaySong_fn;
+var QueueManager = class extends GuildIdManager {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _voiceEventHandler);
+    __privateAdd(this, _handleSongFinish);
+    __privateAdd(this, _handlePlayingError);
+    __privateAdd(this, _emitPlaySong);
+  }
+  async create(channel, song, textChannel) {
+    if (this.has(channel.guildId))
+      throw new DisTubeError("QUEUE_EXIST");
+    const voice = this.voices.create(channel);
+    const queue = new Queue(this.distube, voice, song, textChannel);
+    await queue._taskQueue.queuing();
+    try {
+      await voice.join();
+      __privateMethod(this, _voiceEventHandler, voiceEventHandler_fn).call(this, queue);
+      this.add(queue.id, queue);
+      this.emit("initQueue", queue);
+      const err = await this.playSong(queue);
+      return err || queue;
+    } finally {
+      queue._taskQueue.resolve();
     }
-    if (typeof options.seek === "number" && options.seek > 0) {
-      args.unshift("-ss", options.seek.toString());
+  }
+  createStream(queue) {
+    const { duration, formats, isLive, source, streamURL } = queue.songs[0];
+    const ffmpegArgs = queue.filters.size ? ["-af", queue.filters.values.join(",")] : void 0;
+    const seek = duration ? queue.beginTime : void 0;
+    const streamOptions = { ffmpegArgs, seek, isLive, type: this.options.streamType };
+    if (source === "youtube")
+      return DisTubeStream.YouTube(formats, streamOptions);
+    return DisTubeStream.DirectLink(streamURL, streamOptions);
+  }
+  async playSong(queue) {
+    if (!queue)
+      return true;
+    if (!queue.songs.length) {
+      queue.stop();
+      return true;
     }
-    if (Array.isArray(options.ffmpegArgs)) {
-      args.push(...options.ffmpegArgs);
+    if (queue.stopped)
+      return false;
+    try {
+      const song = queue.songs[0];
+      const { url, source, formats, streamURL, isLive } = song;
+      if (source === "youtube") {
+        if (!formats || !chooseBestVideoFormat(formats, isLive)) {
+          song._patchYouTube(await this.handler.getYouTubeInfo(url));
+        }
+      } else if (!streamURL) {
+        for (const plugin of [...this.distube.extractorPlugins, ...this.distube.customPlugins]) {
+          if (await plugin.validate(url)) {
+            const info = [plugin.getStreamURL(url), plugin.getRelatedSongs(url)];
+            const result = await Promise.all(info);
+            song.streamURL = result[0];
+            song.related = result[1];
+            break;
+          }
+        }
+      }
+      const stream = this.createStream(queue);
+      queue.voice.play(stream);
+      song.streamURL = stream.url;
+      if (queue.stopped)
+        queue.stop();
+      else if (queue.paused)
+        queue.voice.pause();
+      return false;
+    } catch (e) {
+      __privateMethod(this, _handlePlayingError, handlePlayingError_fn).call(this, queue, e);
+      return true;
     }
-    this.stream = new import_prism_media.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);
+};
+__name(QueueManager, "QueueManager");
+_voiceEventHandler = new WeakSet();
+voiceEventHandler_fn = /* @__PURE__ */ __name(function(queue) {
+  queue._listeners = {
+    disconnect: (error) => {
+      queue.remove();
+      this.emit("disconnect", queue);
+      if (error)
+        this.emitError(error, queue.textChannel);
+    },
+    error: (error) => __privateMethod(this, _handlePlayingError, handlePlayingError_fn).call(this, queue, error),
+    finish: () => __privateMethod(this, _handleSongFinish, handleSongFinish_fn).call(this, queue)
+  };
+  for (const event of objectKeys(queue._listeners)) {
+    queue.voice.on(event, queue._listeners[event]);
   }
-  static DirectLink(url, options = {}) {
-    if (!options || typeof options !== "object" || Array.isArray(options)) {
-      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
+}, "#voiceEventHandler");
+_handleSongFinish = new WeakSet();
+handleSongFinish_fn = /* @__PURE__ */ __name(async function(queue) {
+  this.emit("finishSong", queue, queue.songs[0]);
+  await queue._taskQueue.queuing();
+  try {
+    if (queue.stopped)
+      return;
+    if (queue.repeatMode === 2 /* QUEUE */ && !queue._prev)
+      queue.songs.push(queue.songs[0]);
+    if (queue._prev) {
+      if (queue.repeatMode === 2 /* QUEUE */)
+        queue.songs.unshift(queue.songs.pop());
+      else
+        queue.songs.unshift(queue.previousSongs.pop());
     }
-    if (typeof url !== "string" || !isURL(url)) {
-      throw new DisTubeError("INVALID_TYPE", "an URL", url);
+    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;
+      }
     }
-    return new DisTubeStream(url, options);
+    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();
   }
-};
-__name(DisTubeStream, "DisTubeStream");
+}, "#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) {
+    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();
+  }
+}, "#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/struct/Queue.ts
 var _filters;
@@ -1881,7 +1946,7 @@ var Queue = class extends DisTubeBase {
     this.songs = [];
     this.previousSongs = [];
     if (this._listeners) {
-      for (const event of Object.keys(this._listeners)) {
+      for (const event of objectKeys(this._listeners)) {
         this.voice.removeListener(event, this._listeners[event]);
       }
     }
@@ -1957,7 +2022,7 @@ __name(ExtractorPlugin, "ExtractorPlugin");
 
 // src/util.ts
 var import_url = require("url");
-var import_discord2 = require("discord.js");
+var import_discord3 = require("discord.js");
 var formatInt = /* @__PURE__ */ __name((int) => int < 10 ? `0${int}` : int, "formatInt");
 function formatDuration(sec) {
   if (!sec || !Number(sec))
@@ -2011,8 +2076,8 @@ function isURL(input) {
 }
 __name(isURL, "isURL");
 function checkIntents(options) {
-  const intents = new import_discord2.IntentsBitField(options.intents);
-  if (!intents.has(import_discord2.GatewayIntentBits.GuildVoiceStates))
+  const intents = new import_discord3.IntentsBitField(options.intents);
+  if (!intents.has(import_discord3.GatewayIntentBits.GuildVoiceStates))
     throw new DisTubeError("MISSING_INTENTS", "GuildVoiceStates");
 }
 __name(checkIntents, "checkIntents");
@@ -2030,7 +2095,7 @@ function isVoiceChannelEmpty(voiceState) {
 __name(isVoiceChannelEmpty, "isVoiceChannelEmpty");
 function isSnowflake(id) {
   try {
-    return import_discord2.SnowflakeUtil.deconstruct(id).timestamp > import_discord2.SnowflakeUtil.epoch;
+    return import_discord3.SnowflakeUtil.deconstruct(id).timestamp > import_discord3.SnowflakeUtil.epoch;
   } catch {
     return false;
   }
@@ -2041,15 +2106,15 @@ function isMemberInstance(member) {
 }
 __name(isMemberInstance, "isMemberInstance");
 function isTextChannelInstance(channel) {
-  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && typeof channel.name === "string" && import_discord2.Constants.TextBasedChannelTypes.includes(channel.type) && typeof channel.nsfw === "boolean" && "messages" in channel && typeof channel.send === "function";
+  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && typeof channel.name === "string" && import_discord3.Constants.TextBasedChannelTypes.includes(channel.type) && typeof channel.nsfw === "boolean" && "messages" in channel && typeof channel.send === "function";
 }
 __name(isTextChannelInstance, "isTextChannelInstance");
 function isMessageInstance(message) {
-  return !!message && isSnowflake(message.id) && isSnowflake(message.guildId) && isMemberInstance(message.member) && isTextChannelInstance(message.channel) && import_discord2.Constants.NonSystemMessageTypes.includes(message.type) && message.member.id === message.author?.id;
+  return !!message && isSnowflake(message.id) && isSnowflake(message.guildId) && isMemberInstance(message.member) && isTextChannelInstance(message.channel) && import_discord3.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) && import_discord2.Constants.VoiceBasedChannelTypes.includes(channel.type);
+  return !!channel && isSnowflake(channel.id) && isSnowflake(channel.guildId) && import_discord3.Constants.VoiceBasedChannelTypes.includes(channel.type);
 }
 __name(isSupportedVoiceChannel, "isSupportedVoiceChannel");
 function isGuildInstance(guild) {
@@ -2081,8 +2146,8 @@ __name(isClientInstance, "isClientInstance");
 function checkInvalidKey(target, source, sourceName) {
   if (!isObject(target))
     throw new DisTubeError("INVALID_TYPE", "object", target, sourceName);
-  const sourceKeys = Array.isArray(source) ? source : Object.keys(source);
-  const invalidKey = Object.keys(target).find((key) => !sourceKeys.includes(key));
+  const sourceKeys = Array.isArray(source) ? source : objectKeys(source);
+  const invalidKey = objectKeys(target).find((key) => !sourceKeys.includes(key));
   if (invalidKey)
     throw new DisTubeError("INVALID_KEY", sourceName, invalidKey);
 }
@@ -2095,6 +2160,12 @@ function isRecord(obj) {
   return isObject(obj);
 }
 __name(isRecord, "isRecord");
+function objectKeys(obj) {
+  if (!isObject(obj))
+    return [];
+  return Object.keys(obj);
+}
+__name(objectKeys, "objectKeys");
 
 // src/plugin/DirectLink.ts
 var import_undici = require("undici");
@@ -2111,10 +2182,14 @@ var DirectLinkPlugin = class extends ExtractorPlugin {
   }
   async resolve(url, options = {}) {
     url = url.replace(/\/+$/, "");
-    return new Song({
-      name: url.substring(url.lastIndexOf("/") + 1).replace(/((\?|#).*)?$/, "") || url,
-      url
-    }, options);
+    return new Song(
+      {
+        name: url.substring(url.lastIndexOf("/") + 1).replace(/((\?|#).*)?$/, "") || url,
+        url,
+        src: "direct_link"
+      },
+      options
+    );
   }
 };
 __name(DirectLinkPlugin, "DirectLinkPlugin");
@@ -2228,7 +2303,9 @@ ${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 || isURL(song) || typeof song !== "string" && song.type === "video" /* VIDEO */);
+    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)) {
@@ -2238,7 +2315,9 @@ ${e.message}`;
       throw new DisTubeError("NO_VALID_SONG");
     let resolvedSongs;
     if (parallel) {
-      const promises = filteredSongs.map((song) => this.handler.resolve(song, { member, metadata }).catch(() => void 0));
+      const promises = filteredSongs.map(
+        (song) => this.handler.resolve(song, { member, metadata }).catch(() => void 0)
+      );
       resolvedSongs = (await Promise.all(promises)).filter((s) => !!s);
     } else {
       const resolved = [];
@@ -2360,7 +2439,9 @@ ${e.message}`;
     } else {
       console.error(error);
       console.warn("Unhandled 'error' event.");
-      console.warn("See: https://distube.js.org/#/docs/DisTube/stable/class/DisTube?scrollTo=e-error and https://nodejs.org/api/events.html#events_error_events");
+      console.warn(
+        "See: https://distube.js.org/#/docs/DisTube/stable/class/DisTube?scrollTo=e-error and https://nodejs.org/api/events.html#events_error_events"
+      );
     }
   }
 };
@@ -2377,6 +2458,7 @@ __name(DisTube, "DisTube");
   DisTubeStream,
   DisTubeVoice,
   DisTubeVoiceManager,
+  Events,
   ExtractorPlugin,
   FilterManager,
   GuildIdManager,
@@ -2410,6 +2492,7 @@ __name(DisTube, "DisTube");
   isTextChannelInstance,
   isURL,
   isVoiceChannelEmpty,
+  objectKeys,
   parseNumber,
   resolveGuildId,
   toSecond,