distube 4.1.1 → 4.2.1

package/dist/index.js

@@ -60,10 +60,10 @@ var __privateMethod = (obj, member, method) => {
 
 // package.json
 var require_package = __commonJS({
-  "package.json"(exports, module2) {
+  "package.json"(exports2, module2) {
     module2.exports = {
       name: "distube",
-      version: "4.1.1",
+      version: "4.2.1",
       description: "A Discord.js module to simplify your music commands and play songs with audio filters on Discord without any API key.",
       main: "./dist/index.js",
       types: "./dist/index.d.ts",
@@ -77,16 +77,16 @@ var require_package = __commonJS({
       ],
       scripts: {
         test: "jest",
-        docs: "docgen -s src/**/*.ts -o docs.json -c pages/index.yml -g -j jsdoc.config.json",
+        docs: "typedoc",
         lint: "prettier --check . && eslint .",
         "lint:fix": "eslint . --fix",
         prettier: 'prettier --write "**/*.{ts,json,yml,yaml,md}"',
         build: "tsup",
         "build:check": "tsc --noEmit",
-        update: "ncu -u && yarn up '**' -R",
-        postinstall: "husky install",
-        prepublishOnly: "yarn lint && yarn test",
-        prepack: "yarn build && pinst --disable",
+        update: "pnpm up -L",
+        postinstall: "husky",
+        prepublishOnly: "pnpm run lint && pnpm run test",
+        prepack: "pnpm run build && pinst --disable",
         postpack: "pinst --enable",
         "dev:add-docs-to-worktree": "git worktree add --track -b docs docs origin/docs"
       },
@@ -112,70 +112,50 @@ var require_package = __commonJS({
       bugs: {
         url: "https://github.com/skick1234/DisTube/issues"
       },
-      funding: [
-        {
-          type: "individual",
-          url: "https://paypal.me/Skickkk"
-        },
-        {
-          type: "patreon",
-          url: "https://patreon.com/DisTube"
-        }
-      ],
+      funding: "https://github.com/skick1234/DisTube?sponsor=1",
       homepage: "https://distube.js.org/",
       dependencies: {
-        "@distube/ytdl-core": "^4.13.2",
+        "@distube/ytdl-core": "^4.13.3",
         "@distube/ytpl": "^1.2.1",
-        "@distube/ytsr": "^1.2.0",
-        "prism-media": "npm:@distube/prism-media@latest",
+        "@distube/ytsr": "^2.0.0",
         "tiny-typed-emitter": "^2.1.0",
         "tough-cookie": "^4.1.3",
         tslib: "^2.6.2",
-        undici: "^5.27.2"
+        undici: "^6.13.0"
       },
       devDependencies: {
-        "@babel/core": "^7.23.2",
-        "@babel/plugin-proposal-class-properties": "^7.18.6",
-        "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
-        "@babel/plugin-transform-private-methods": "^7.22.5",
-        "@babel/preset-env": "^7.23.2",
-        "@babel/preset-typescript": "^7.23.2",
-        "@commitlint/cli": "^18.2.0",
-        "@commitlint/config-conventional": "^18.1.0",
-        "@discordjs/voice": "^0.16.0",
-        "@distubejs/docgen": "distubejs/docgen",
-        "@types/jest": "^29.5.8",
-        "@types/node": "^20.9.0",
+        "@babel/core": "^7.24.4",
+        "@babel/plugin-transform-class-properties": "^7.24.1",
+        "@babel/plugin-transform-object-rest-spread": "^7.24.1",
+        "@babel/plugin-transform-private-methods": "^7.24.1",
+        "@babel/preset-env": "^7.24.4",
+        "@babel/preset-typescript": "^7.24.1",
+        "@commitlint/cli": "^19.2.2",
+        "@commitlint/config-conventional": "^19.2.2",
+        "@discordjs/voice": "^0.16.1",
+        "@types/jest": "^29.5.12",
+        "@types/node": "^20.12.7",
         "@types/tough-cookie": "^4.0.5",
-        "@typescript-eslint/eslint-plugin": "^6.10.0",
-        "@typescript-eslint/parser": "^6.10.0",
+        "@typescript-eslint/eslint-plugin": "^7.7.0",
+        "@typescript-eslint/parser": "^7.7.0",
         "babel-jest": "^29.7.0",
-        "discord.js": "^14.13.0",
-        eslint: "^8.53.0",
-        "eslint-config-distube": "^1.6.4",
-        "eslint-config-prettier": "^9.0.0",
-        "eslint-plugin-deprecation": "^2.0.0",
-        "eslint-plugin-jsdoc": "^46.8.2",
-        husky: "^8.0.3",
+        "discord.js": "^14.14.1",
+        eslint: "^8.57.0",
+        "eslint-config-distube": "^1.7.0",
+        husky: "^9.0.11",
         jest: "^29.7.0",
-        "jsdoc-babel": "^0.5.0",
         "nano-staged": "^0.8.0",
-        "npm-check-updates": "^16.14.6",
         pinst: "^3.0.0",
-        prettier: "^3.0.3",
-        tsup: "^7.2.0",
-        typescript: "^5.2.2"
+        prettier: "^3.2.5",
+        tsup: "^8.0.2",
+        typedoc: "^0.25.13",
+        "typedoc-material-theme": "^1.0.2",
+        typescript: "^5.4.5"
       },
       peerDependencies: {
-        "@discordjs/opus": "*",
         "@discordjs/voice": "*",
         "discord.js": "14"
       },
-      peerDependenciesMeta: {
-        "@discordjs/opus": {
-          optional: true
-        }
-      },
       "nano-staged": {
         "*.ts": [
           "prettier --write",
@@ -186,9 +166,8 @@ var require_package = __commonJS({
         ]
       },
       engines: {
-        node: ">=16.9.0"
-      },
-      packageManager: "yarn@3.6.1"
+        node: ">=18.17"
+      }
     };
   }
 });
@@ -223,6 +202,7 @@ __export(src_exports, {
   Song: () => Song,
   StreamType: () => StreamType,
   TaskQueue: () => TaskQueue,
+  checkFFmpeg: () => checkFFmpeg,
   checkIntents: () => checkIntents,
   checkInvalidKey: () => checkInvalidKey,
   chooseBestVideoFormat: () => chooseBestVideoFormat,
@@ -290,6 +270,7 @@ var Events = /* @__PURE__ */ ((Events2) => {
   Events2["SEARCH_DONE"] = "searchDone";
   Events2["SEARCH_INVALID_ANSWER"] = "searchInvalidAnswer";
   Events2["SEARCH_RESULT"] = "searchResult";
+  Events2["FFMPEG_DEBUG"] = "ffmpegDebug";
   return Events2;
 })(Events || {});
 
@@ -351,6 +332,8 @@ var ERROR_MESSAGES = {
   VOICE_RECONNECT_FAILED: "Cannot reconnect to the voice channel",
   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",
+  FFMPEG_EXITED: (code) => `ffmpeg exited with code ${code}`,
+  FFMPEG_NOT_INSTALLED: (path) => `ffmpeg is not installed at '${path}' path`,
   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",
@@ -411,15 +394,13 @@ var _TaskQueue = class _TaskQueue {
   constructor() {
     /**
      * The task array
-     * @type {Task[]}
-     * @private
      */
     __privateAdd(this, _tasks, []);
   }
   /**
    * Waits for last task finished and queues a new task
-   * @param {boolean} [resolveInfo=false] Whether the task is a resolving info task
-   * @returns {Promise<void>}
+   *
+   * @param resolveInfo - Whether the task is a resolving info task
    */
   queuing(resolveInfo = false) {
     const next = this.remaining ? __privateGet(this, _tasks)[__privateGet(this, _tasks).length - 1].promise : Promise.resolve();
@@ -434,14 +415,12 @@ var _TaskQueue = class _TaskQueue {
   }
   /**
    * The remaining number of tasks
-   * @type {number}
    */
   get remaining() {
     return __privateGet(this, _tasks).length;
   }
   /**
    * Whether or not having a resolving info task
-   * @type {boolean}
    */
   get hasResolveTask() {
     return __privateGet(this, _tasks).some((t) => t.resolveInfo);
@@ -456,11 +435,9 @@ var _metadata, _member;
 var _Playlist = class _Playlist {
   /**
    * Create a playlist
-   * @param {Song[]|PlaylistInfo} playlist Playlist
-   * @param {Object} [options] Optional options
-   * @param {Discord.GuildMember} [options.member] Requested user
-   * @param {Object} [options.properties] Custom properties
-   * @param {T} [options.metadata] Playlist metadata
+   *
+   * @param playlist           - Playlist
+   * @param options            - Optional options
    */
   constructor(playlist, options = {}) {
     __publicField(this, "source");
@@ -504,21 +481,18 @@ var _Playlist = class _Playlist {
   }
   /**
    * Playlist duration in second.
-   * @type {number}
    */
   get duration() {
     return this.songs.reduce((prev, next) => prev + next.duration, 0);
   }
   /**
    * Formatted duration string `hh:mm:ss`.
-   * @type {string}
    */
   get formattedDuration() {
     return formatDuration(this.duration);
   }
   /**
    * User requested.
-   * @type {Discord.GuildMember?}
    */
   get member() {
     return __privateGet(this, _member);
@@ -531,7 +505,6 @@ var _Playlist = class _Playlist {
   }
   /**
    * User requested.
-   * @type {Discord.User?}
    */
   get user() {
     return this.member?.user;
@@ -553,7 +526,8 @@ var Playlist = _Playlist;
 var _ISearchResult = class _ISearchResult {
   /**
    * Create a search result
-   * @param {Object} info ytsr result
+   *
+   * @param info - ytsr result
    */
   constructor(info) {
     __publicField(this, "source");
@@ -621,11 +595,9 @@ var _metadata2, _member2, _playlist;
 var _Song = class _Song {
   /**
    * Create a Song
-   * @param {ytdl.videoInfo|SearchResult|OtherSongInfo} info Raw info
-   * @param {Object} [options] Optional options
-   * @param {Discord.GuildMember} [options.member] Requested user
-   * @param {string} [options.source="youtube"] Song source
-   * @param {T} [options.metadata] Song metadata
+   *
+   * @param info             - Raw info
+   * @param options          - Optional options
    */
   constructor(info, options = {}) {
     __publicField(this, "source");
@@ -702,8 +674,8 @@ var _Song = class _Song {
   }
   /**
    * Patch data from other source
-   * @param {OtherSongInfo} info Video info
-   * @private
+   *
+   * @param info - Video info
    */
   _patchOther(info) {
     this.id = info.id;
@@ -737,7 +709,6 @@ var _Song = class _Song {
   }
   /**
    * The playlist added this song
-   * @type {Playlist?}
    */
   get playlist() {
     return __privateGet(this, _playlist);
@@ -750,7 +721,6 @@ var _Song = class _Song {
   }
   /**
    * User requested.
-   * @type {Discord.GuildMember?}
    */
   get member() {
     return __privateGet(this, _member2);
@@ -761,7 +731,6 @@ var _Song = class _Song {
   }
   /**
    * User requested.
-   * @type {Discord.User?}
    */
   get user() {
     return this.member?.user;
@@ -787,57 +756,48 @@ var _DisTubeBase = class _DisTubeBase {
   }
   /**
    * Emit the {@link DisTube} of this base
-   * @param {string} eventName Event name
-   * @param {...any} args arguments
-   * @returns {boolean}
+   *
+   * @param eventName - Event name
+   * @param args      - arguments
    */
   emit(eventName, ...args) {
     return this.distube.emit(eventName, ...args);
   }
   /**
    * Emit error event
-   * @param {Error} error error
-   * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
+   *
+   * @param error   - error
+   * @param channel - Text channel where the error is encountered.
    */
   emitError(error, channel) {
     this.distube.emitError(error, channel);
   }
   /**
    * The queue manager
-   * @type {QueueManager}
-   * @readonly
    */
   get queues() {
     return this.distube.queues;
   }
   /**
    * The voice manager
-   * @type {DisTubeVoiceManager}
-   * @readonly
    */
   get voices() {
     return this.distube.voices;
   }
   /**
    * Discord.js client
-   * @type {Discord.Client}
-   * @readonly
    */
   get client() {
     return this.distube.client;
   }
   /**
    * DisTube options
-   * @type {DisTubeOptions}
-   * @readonly
    */
   get options() {
     return this.distube.options;
   }
   /**
    * DisTube handler
-   * @type {DisTubeHandler}
-   * @readonly
    */
   get handler() {
     return this.distube.handler;
@@ -863,6 +823,7 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
     __publicField(this, "audioResource");
     __publicField(this, "emittedError");
     __publicField(this, "isDisconnected", false);
+    __publicField(this, "stream");
     __privateAdd(this, _channel, void 0);
     __privateAdd(this, _volume, 100);
     this.voices = voiceManager;
@@ -906,7 +867,6 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
   }
   /**
    * The voice channel id the bot is in
-   * @type {Snowflake?}
    */
   get channelId() {
     return this.connection?.joinConfig?.channelId ?? void 0;
@@ -949,8 +909,8 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
   }
   /**
    * Join a voice channel with this connection
-   * @param {Discord.BaseGuildVoiceChannel} [channel] A voice channel
-   * @returns {Promise<DisTubeVoice>}
+   *
+   * @param channel - A voice channel
    */
   async join(channel) {
     const TIMEOUT = 3e4;
@@ -970,7 +930,8 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
   }
   /**
    * Leave the voice channel of this connection
-   * @param {Error} [error] Optional, an error to emit with 'error' event.
+   *
+   * @param error - Optional, an error to emit with 'error' event.
    */
   leave(error) {
     this.stop(true);
@@ -984,33 +945,36 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
   }
   /**
    * Stop the playing stream
-   * @param {boolean} [force=false] If true, will force the {@link DisTubeVoice#audioPlayer} to enter the Idle state
-   * even if the {@link DisTubeVoice#audioResource} has silence padding frames.
-   * @private
+   *
+   * @param force - If true, will force the {@link DisTubeVoice#audioPlayer} to enter the Idle state even
+   *                if the {@link DisTubeVoice#audioResource} has silence padding frames.
    */
   stop(force = false) {
     this.audioPlayer.stop(force);
+    this.stream?.kill?.();
   }
   /**
-   * Play a readable stream
-   * @private
-   * @param {DisTubeStream} stream Readable stream
+   * Play a {@link DisTubeStream}
+   *
+   * @param dtStream - DisTubeStream
    */
-  play(stream) {
+  play(dtStream) {
     this.emittedError = false;
-    stream.stream.on("error", (error) => {
+    dtStream.on("error", (error) => {
       if (this.emittedError || error.code === "ERR_STREAM_PREMATURE_CLOSE")
         return;
       this.emittedError = true;
       this.emit("error", error);
     });
-    this.audioResource = (0, import_voice.createAudioResource)(stream.stream, {
-      inputType: stream.type,
+    this.audioResource = (0, import_voice.createAudioResource)(dtStream.stream, {
+      inputType: dtStream.type,
       inlineVolume: true
     });
     this.volume = __privateGet(this, _volume);
     if (this.audioPlayer.state.status !== import_voice.AudioPlayerStatus.Paused)
       this.audioPlayer.play(this.audioResource);
+    this.stream?.kill?.();
+    this.stream = dtStream;
   }
   set volume(volume) {
     if (typeof volume !== "number" || isNaN(volume)) {
@@ -1027,7 +991,6 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
   }
   /**
    * Playback duration of the audio resource in seconds
-   * @type {number}
    */
   get playbackDuration() {
     return (this.audioResource?.playbackDuration ?? 0) / 1e3;
@@ -1046,22 +1009,22 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
   }
   /**
    * Whether the bot is self-deafened
-   * @type {boolean}
    */
   get selfDeaf() {
     return this.connection.joinConfig.selfDeaf;
   }
   /**
    * Whether the bot is self-muted
-   * @type {boolean}
    */
   get selfMute() {
     return this.connection.joinConfig.selfMute;
   }
   /**
    * Self-deafens/undeafens the bot.
-   * @param {boolean} selfDeaf Whether or not the bot should be self-deafened
-   * @returns {boolean} true if the voice state was successfully updated, otherwise false
+   *
+   * @param selfDeaf - Whether or not the bot should be self-deafened
+   *
+   * @returns true if the voice state was successfully updated, otherwise false
    */
   setSelfDeaf(selfDeaf) {
     if (typeof selfDeaf !== "boolean") {
@@ -1074,8 +1037,10 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
   }
   /**
    * Self-mutes/unmutes the bot.
-   * @param {boolean} selfMute Whether or not the bot should be self-muted
-   * @returns {boolean} true if the voice state was successfully updated, otherwise false
+   *
+   * @param selfMute - Whether or not the bot should be self-muted
+   *
+   * @returns true if the voice state was successfully updated, otherwise false
    */
   setSelfMute(selfMute) {
     if (typeof selfMute !== "boolean") {
@@ -1088,7 +1053,6 @@ var _DisTubeVoice = class _DisTubeVoice extends import_tiny_typed_emitter.TypedE
   }
   /**
    * The voice state of this connection
-   * @type {Discord.VoiceState?}
    */
   get voiceState() {
     return this.channel?.guild?.members?.me?.voice;
@@ -1114,60 +1078,134 @@ __name(_DisTubeVoice, "DisTubeVoice");
 var DisTubeVoice = _DisTubeVoice;
 
 // src/core/DisTubeStream.ts
-var import_prism_media = require("prism-media");
+var import_node_stream = require("stream");
+var import_child_process = require("child_process");
+var import_tiny_typed_emitter2 = require("tiny-typed-emitter");
 var import_voice2 = require("@discordjs/voice");
 var chooseBestVideoFormat = /* @__PURE__ */ __name(({ duration, formats, isLive }) => formats && formats.filter((f) => f.hasAudio && (duration < 10 * 60 || f.hasVideo) && (!isLive || f.isHLS)).sort((a, b) => Number(b.audioBitrate) - Number(a.audioBitrate) || Number(a.bitrate) - Number(b.bitrate))[0], "chooseBestVideoFormat");
-var _DisTubeStream = class _DisTubeStream {
+var checked = process.env.NODE_ENV === "test";
+var checkFFmpeg = /* @__PURE__ */ __name((distube) => {
+  if (checked)
+    return;
+  const path = distube.options.ffmpeg.path;
+  const debug = /* @__PURE__ */ __name((str) => distube.emit("ffmpegDebug" /* FFMPEG_DEBUG */, str), "debug");
+  try {
+    debug(`[test] spawn ffmpeg at '${path}' path`);
+    const process2 = (0, import_child_process.spawnSync)(path, ["-h"], { windowsHide: true, shell: true, encoding: "utf-8" });
+    if (process2.error)
+      throw process2.error;
+    if (process2.stderr && !process2.stdout)
+      throw new Error(process2.stderr);
+    const result = process2.output.join("\n");
+    const version2 = /ffmpeg version (\S+)/iu.exec(result)?.[1];
+    if (!version2)
+      throw new Error("Invalid FFmpeg version");
+    debug(`[test] ffmpeg version: ${version2}`);
+    if (result.includes("--enable-libopus")) {
+      debug("[test] ffmpeg supports libopus");
+    } else {
+      debug("[test] ffmpeg does not support libopus");
+      distube.options.streamType = 1 /* RAW */;
+    }
+  } catch (e) {
+    debug(`[test] failed to spawn ffmpeg at '${path}': ${e?.stack ?? e}`);
+    throw new DisTubeError("FFMPEG_NOT_INSTALLED", path);
+  }
+  checked = true;
+}, "checkFFmpeg");
+var _DisTubeStream = class _DisTubeStream extends import_tiny_typed_emitter2.TypedEmitter {
   /**
    * Create a DisTubeStream to play with {@link DisTubeVoice}
-   * @param {string} url Stream URL
-   * @param {StreamOptions} options Stream options
-   * @private
+   *
+   * @param url     - Stream URL
+   * @param options - Stream options
    */
-  constructor(url, options) {
-    __publicField(this, "type");
+  constructor(url, { ffmpeg, seek, type }) {
+    super();
+    __publicField(this, "killed", false);
+    __publicField(this, "process");
     __publicField(this, "stream");
+    __publicField(this, "type");
     __publicField(this, "url");
     this.url = url;
-    this.type = !options.type ? import_voice2.StreamType.OggOpus : import_voice2.StreamType.Raw;
-    const args = [
-      "-reconnect",
-      "1",
-      "-reconnect_streamed",
-      "1",
-      "-reconnect_delay_max",
-      "5",
-      "-i",
-      url,
-      "-analyzeduration",
-      "0",
-      "-loglevel",
-      "0",
-      "-ar",
-      "48000",
-      "-ac",
-      "2",
-      "-f"
-    ];
-    if (!options.type)
-      args.push("opus", "-acodec", "libopus");
-    else
-      args.push("s16le");
-    if (typeof options.seek === "number" && options.seek > 0)
-      args.unshift("-ss", options.seek.toString());
-    if (Array.isArray(options.ffmpegArgs) && options.ffmpegArgs.length)
-      args.push(...options.ffmpegArgs);
-    this.stream = new import_prism_media.FFmpeg({ args, shell: false });
-    this.stream._readableState && (this.stream._readableState.highWaterMark = 1 << 25);
-  }
-  /**
-   * Create a stream from ytdl video formats
-   * @param {Song} song A YouTube Song
-   * @param {StreamOptions} options options
-   * @returns {DisTubeStream}
-   * @private
-   */
-  static YouTube(song, options = {}) {
+    this.type = !type ? import_voice2.StreamType.OggOpus : import_voice2.StreamType.Raw;
+    const opts = {
+      reconnect: 1,
+      reconnect_streamed: 1,
+      reconnect_delay_max: 5,
+      analyzeduration: 0,
+      hide_banner: true,
+      ...ffmpeg.args.global,
+      ...ffmpeg.args.input,
+      i: url,
+      ar: 48e3,
+      ac: 2,
+      ...ffmpeg.args.output
+    };
+    if (!type) {
+      opts.f = "opus";
+      opts.acodec = "libopus";
+    } else {
+      opts.f = "s16le";
+    }
+    if (typeof seek === "number" && seek > 0)
+      opts.ss = seek.toString();
+    if (typeof ffmpeg.args === "object")
+      Object.assign(opts, ffmpeg.args);
+    this.process = (0, import_child_process.spawn)(
+      ffmpeg.path,
+      [
+        ...Object.entries(opts).flatMap(
+          ([key, value]) => Array.isArray(value) ? value.filter(Boolean).map((v) => [`-${key}`, String(v)]) : value == null || value === false ? [] : [value === true ? `-${key}` : [`-${key}`, String(value)]]
+        ).flat(),
+        "pipe:1"
+      ],
+      { stdio: ["ignore", "pipe", "pipe"], shell: false, windowsHide: true }
+    ).on("error", (err) => {
+      this.debug(`[process] error: ${err.message}`);
+      this.emit("error", err);
+    }).on("exit", (code, signal) => {
+      this.debug(`[process] exit: code=${code ?? "unknown"} signal=${signal ?? "unknown"}`);
+      if (!code || [0, 255].includes(code))
+        return;
+      this.debug(`[process] error: ffmpeg exited with code ${code}`);
+      this.emit("error", new DisTubeError("FFMPEG_EXITED", code));
+    });
+    if (!this.process.stdout || !this.process.stderr) {
+      this.kill();
+      throw new Error("Failed to create ffmpeg process");
+    }
+    this.stream = new import_node_stream.PassThrough();
+    this.stream.on("close", () => this.kill()).on("error", (err) => {
+      this.debug(`[stream] error: ${err.message}`);
+      this.emit("error", err);
+    }).on("finish", () => this.debug("[stream] log: stream finished"));
+    this.process.stdout.pipe(this.stream);
+    this.process.stderr.setEncoding("utf8")?.on("data", (data) => {
+      const lines = data.split(/\r\n|\r|\n/u);
+      for (const line of lines) {
+        if (/^\s*$/.test(line))
+          continue;
+        this.debug(`[ffmpeg] log: ${line}`);
+      }
+    });
+  }
+  debug(debug) {
+    this.emit("debug", debug);
+  }
+  kill() {
+    if (this.killed)
+      return;
+    this.process.kill("SIGKILL");
+    this.killed = true;
+  }
+  /**
+   * Create a stream from a YouTube {@link Song}
+   *
+   * @param song    - A YouTube Song
+   * @param options - options
+   */
+  static YouTube(song, options) {
     if (song.source !== "youtube")
       throw new DisTubeError("INVALID_TYPE", "youtube", song.source, "Song#source");
     if (!song.formats?.length)
@@ -1182,18 +1220,17 @@ var _DisTubeStream = class _DisTubeStream {
   }
   /**
    * Create a stream from a stream url
-   * @param {string} url stream url
-   * @param {StreamOptions} options options
-   * @returns {DisTubeStream}
-   * @private
+   *
+   * @param url     - stream url
+   * @param options - options
    */
-  static DirectLink(url, options = {}) {
-    if (!options || typeof options !== "object" || Array.isArray(options)) {
-      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
-    }
+  static DirectLink(url, options) {
     if (typeof url !== "string" || !isURL(url)) {
       throw new DisTubeError("INVALID_TYPE", "an URL", url);
     }
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
+      throw new DisTubeError("INVALID_TYPE", "object", options, "options");
+    }
     return new _DisTubeStream(url, options);
   }
 };
@@ -1233,7 +1270,7 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
             delete queue._emptyTimeout;
             if (isVoiceChannelEmpty(oldState)) {
               queue.voice.leave();
-              this.emit("empty", queue);
+              this.emit("empty" /* EMPTY */, queue);
               if (queue.stopped)
                 queue.remove();
             }
@@ -1248,7 +1285,7 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
       const cookies = __privateSet(this, _cookie, this.options.youtubeCookie);
       if (typeof cookies === "string") {
         console.warn(
-          "\x1B[33mWARNING:\x1B[0m You are using the old YouTube cookie format, please use the new one instead. (https://distube.js.org/#/docs/DisTube/main/general/cookie)"
+          "\x1B[33mWARNING:\x1B[0m You are using the old YouTube cookie format, please use the new one instead. (https://github.com/skick1234/DisTube/wiki/YouTube-Cookies)"
         );
         options.agent = import_ytdl_core.default.createAgent(
           cookies.split(";").map((c) => import_tough_cookie.Cookie.parse(c)).filter(isTruthy)
@@ -1267,9 +1304,8 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
     return jar.getCookieStringSync("https://www.youtube.com");
   }
   /**
-   * @param {string} url url
-   * @param {boolean} [basic=false] getBasicInfo?
-   * @returns {Promise<ytdl.videoInfo>}
+   * @param url   - url
+   * @param basic - getBasicInfo?
    */
   getYouTubeInfo(url, basic = false) {
     if (basic)
@@ -1278,10 +1314,13 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
   }
   /**
    * Resolve a url or a supported object to a {@link Song} or {@link Playlist}
-   * @param {string|Song|SearchResult|Playlist} song URL | {@link Song}| {@link SearchResult} | {@link Playlist}
-   * @param {ResolveOptions} [options] Optional options
-   * @returns {Promise<Song|Playlist|null>} Resolved
-   * @throws {DisTubeError}
+   *
+   * @throws {@link DisTubeError}
+   *
+   * @param song    - URL | {@link Song}| {@link SearchResult} | {@link Playlist}
+   * @param options - Optional options
+   *
+   * @returns Resolved
    */
   async resolve(song, options = {}) {
     if (song instanceof Song || song instanceof Playlist) {
@@ -1315,9 +1354,9 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
   }
   /**
    * Resolve Song[] or YouTube playlist url to a Playlist
-   * @param {Playlist|Song[]|string} playlist Resolvable playlist
-   * @param {ResolvePlaylistOptions} options Optional options
-   * @returns {Promise<Playlist>}
+   *
+   * @param playlist - Resolvable playlist
+   * @param options  - Optional options
    */
   async resolvePlaylist(playlist, options = {}) {
     const { member, source, metadata } = { source: "youtube", ...options };
@@ -1346,11 +1385,14 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
     return new Playlist(playlist, { member, properties: { source }, metadata });
   }
   /**
-   * Search for a song, fire {@link DisTube#event:error} if not found.
-   * @param {Discord.Message} message The original message from an user
-   * @param {string} query The query string
-   * @returns {Promise<SearchResult?>} Song info
-   * @throws {DisTubeError}
+   * Search for a song, fire {@link DisTube#error} if not found.
+   *
+   * @throws {@link DisTubeError}
+   *
+   * @param message - The original message from an user
+   * @param query   - The query string
+   *
+   * @returns Song info
    */
   async searchSong(message, query) {
     if (!isMessageInstance(message))
@@ -1364,7 +1406,7 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
       limit,
       safeSearch: this.options.nsfw ? false : !isNsfwChannel(message.channel)
     }).catch(() => {
-      if (!this.emit("searchNoResult", message, query)) {
+      if (!this.emit("searchNoResult" /* SEARCH_NO_RESULT */, message, query)) {
         console.warn("searchNoResult event does not have any listeners! Emits `error` event instead.");
         throw new DisTubeError("NO_RESULT");
       }
@@ -1376,13 +1418,16 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
   /**
    * Create a message collector for selecting search results.
    *
-   * Needed events: {@link DisTube#event:searchResult}, {@link DisTube#event:searchCancel},
-   * {@link DisTube#event:searchInvalidAnswer}, {@link DisTube#event:searchDone}.
-   * @param {Discord.Message} message The original message from an user
-   * @param {Array<SearchResult|Song|Playlist>} results The search results
-   * @param {string?} [query] The query string
-   * @returns {Promise<SearchResult|Song|Playlist|null>} Selected result
-   * @throws {DisTubeError}
+   * Needed events: {@link DisTube#searchResult}, {@link DisTube#searchCancel},
+   * {@link DisTube#searchInvalidAnswer}, {@link DisTube#searchDone}.
+   *
+   * @throws {@link DisTubeError}
+   *
+   * @param message - The original message from an user
+   * @param results - The search results
+   * @param query   - The query string
+   *
+   * @returns Selected result
    */
   async createSearchMessageCollector(message, results, query) {
     if (!isMessageInstance(message))
@@ -1392,11 +1437,11 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
     }
     if (this.options.searchSongs > 1) {
       const searchEvents = [
-        "searchNoResult",
-        "searchResult",
-        "searchCancel",
-        "searchInvalidAnswer",
-        "searchDone"
+        "searchNoResult" /* SEARCH_NO_RESULT */,
+        "searchResult" /* SEARCH_RESULT */,
+        "searchCancel" /* SEARCH_CANCEL */,
+        "searchInvalidAnswer" /* SEARCH_INVALID_ANSWER */,
+        "searchDone" /* SEARCH_DONE */
       ];
       for (const evn of searchEvents) {
         if (this.distube.listenerCount(evn) === 0) {
@@ -1413,7 +1458,7 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
     let result = results[0];
     if (limit > 1) {
       results.splice(limit);
-      this.emit("searchResult", message, results, query);
+      this.emit("searchResult" /* SEARCH_RESULT */, message, results, query);
       const answers = await message.channel.awaitMessages({
         filter: (m) => m.author.id === message.author.id,
         max: 1,
@@ -1422,26 +1467,27 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
       }).catch(() => void 0);
       const ans = answers?.first();
       if (!ans) {
-        this.emit("searchCancel", message, query);
+        this.emit("searchCancel" /* SEARCH_CANCEL */, message, query);
         return null;
       }
       const index = parseInt(ans.content, 10);
       if (isNaN(index) || index > results.length || index < 1) {
-        this.emit("searchInvalidAnswer", message, ans, query);
+        this.emit("searchInvalidAnswer" /* SEARCH_INVALID_ANSWER */, message, ans, query);
         return null;
       }
-      this.emit("searchDone", message, ans, query);
+      this.emit("searchDone" /* SEARCH_DONE */, message, ans, query);
       result = results[index - 1];
     }
     return result;
   }
   /**
    * Play or add a {@link Playlist} to the queue.
-   * @param {Discord.BaseGuildVoiceChannel} voiceChannel A voice channel
-   * @param {Playlist|string} playlist A YouTube playlist url | a Playlist
-   * @param {PlayHandlerOptions} [options] Optional options
-   * @returns {Promise<void>}
-   * @throws {DisTubeError}
+   *
+   * @throws {@link DisTubeError}
+   *
+   * @param voiceChannel - A voice channel
+   * @param playlist     - A YouTube playlist url | a Playlist
+   * @param options      - Optional options
    */
   async playPlaylist(voiceChannel, playlist, options = {}) {
     const { textChannel, skip } = { skip: false, ...options };
@@ -1464,23 +1510,24 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
       if (skip)
         queue.skip();
       else
-        this.emit("addList", queue, playlist);
+        this.emit("addList" /* ADD_LIST */, 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]);
+          this.emit("addList" /* ADD_LIST */, newQueue, playlist);
+        this.emit("playSong" /* PLAY_SONG */, newQueue, newQueue.songs[0]);
       }
     }
   }
   /**
    * Play or add a {@link Song} to the queue.
-   * @param {Discord.BaseGuildVoiceChannel} voiceChannel A voice channel
-   * @param {Song} song A YouTube playlist url | a Playlist
-   * @param {PlayHandlerOptions} [options] Optional options
-   * @returns {Promise<void>}
-   * @throws {DisTubeError}
+   *
+   * @throws {@link DisTubeError}
+   *
+   * @param voiceChannel - A voice channel
+   * @param song         - A YouTube playlist url | a Playlist
+   * @param options      - Optional options
    */
   async playSong(voiceChannel, song, options = {}) {
     if (!(song instanceof Song))
@@ -1498,27 +1545,26 @@ var _DisTubeHandler = class _DisTubeHandler extends DisTubeBase {
       if (skip)
         queue.skip();
       else
-        this.emit("addSong", queue, song);
+        this.emit("addSong" /* ADD_SONG */, queue, song);
     } else {
       const newQueue = await this.queues.create(voiceChannel, song, textChannel);
       if (newQueue instanceof Queue) {
         if (this.options.emitAddSongWhenCreatingQueue)
-          this.emit("addSong", newQueue, song);
-        this.emit("playSong", newQueue, song);
+          this.emit("addSong" /* ADD_SONG */, newQueue, song);
+        this.emit("playSong" /* PLAY_SONG */, newQueue, song);
       }
     }
   }
   /**
    * Get {@link Song}'s stream info and attach it to the song.
-   * @param {Song} song A Song
+   *
+   * @param song - A Song
    */
   async attachStreamInfo(song) {
-    const { url, source, formats, streamURL } = song;
+    const { url, source } = song;
     if (source === "youtube") {
-      if (!formats || !chooseBestVideoFormat(song)) {
-        song._patchYouTube(await this.handler.getYouTubeInfo(url));
-      }
-    } else if (!streamURL) {
+      song._patchYouTube(await this.handler.getYouTubeInfo(url));
+    } else {
       for (const plugin of [...this.distube.extractorPlugins, ...this.distube.customPlugins]) {
         if (await plugin.validate(url)) {
           const info = [plugin.getStreamURL(url), plugin.getRelatedSongs(url)];
@@ -1536,10 +1582,11 @@ __name(_DisTubeHandler, "DisTubeHandler");
 var DisTubeHandler = _DisTubeHandler;
 
 // src/core/DisTubeOptions.ts
-var _validateOptions, validateOptions_fn;
+var _validateOptions, validateOptions_fn, _ffmpegOption, ffmpegOption_fn;
 var _Options = class _Options {
   constructor(options) {
     __privateAdd(this, _validateOptions);
+    __privateAdd(this, _ffmpegOption);
     __publicField(this, "plugins");
     __publicField(this, "emitNewSongOnly");
     __publicField(this, "leaveOnFinish");
@@ -1558,6 +1605,11 @@ var _Options = class _Options {
     __publicField(this, "joinNewVoiceChannel");
     __publicField(this, "streamType");
     __publicField(this, "directLink");
+    /** @deprecated */
+    __publicField(this, "ffmpegPath");
+    /** @deprecated */
+    __publicField(this, "ffmpegDefaultArgs");
+    __publicField(this, "ffmpeg");
     if (typeof options !== "object" || Array.isArray(options)) {
       throw new DisTubeError("INVALID_TYPE", "object", options, "DisTubeOptions");
     }
@@ -1580,6 +1632,7 @@ var _Options = class _Options {
     this.joinNewVoiceChannel = opts.joinNewVoiceChannel;
     this.streamType = opts.streamType;
     this.directLink = opts.directLink;
+    this.ffmpeg = __privateMethod(this, _ffmpegOption, ffmpegOption_fn).call(this, options);
     checkInvalidKey(opts, this, "DisTubeOptions");
     __privateMethod(this, _validateOptions, validateOptions_fn).call(this);
   }
@@ -1600,7 +1653,7 @@ validateOptions_fn = /* @__PURE__ */ __name(function(options = this) {
   ]);
   const numberOptions = /* @__PURE__ */ new Set(["searchCooldown", "emptyCooldown", "searchSongs"]);
   const stringOptions = /* @__PURE__ */ new Set();
-  const objectOptions = /* @__PURE__ */ new Set(["customFilters", "ytdlOptions"]);
+  const objectOptions = /* @__PURE__ */ new Set(["customFilters", "ytdlOptions", "ffmpeg"]);
   const optionalOptions = /* @__PURE__ */ new Set(["youtubeCookie", "customFilters"]);
   for (const [key, value] of Object.entries(options)) {
     if (value === void 0 && optionalOptions.has(key))
@@ -1630,6 +1683,29 @@ validateOptions_fn = /* @__PURE__ */ __name(function(options = this) {
     }
   }
 }, "#validateOptions");
+_ffmpegOption = new WeakSet();
+ffmpegOption_fn = /* @__PURE__ */ __name(function(opts) {
+  let path;
+  const args = { global: {}, input: {}, output: {} };
+  if (opts.ffmpegPath) {
+    console.warn("`DisTubeOptions.ffmpegPath` is deprecated. Use `ffmpeg.path` instead.");
+    path = opts.ffmpegPath;
+  }
+  if (opts.ffmpegDefaultArgs) {
+    console.warn("`DisTubeOptions.ffmpegDefaultArgs` is deprecated. Use `ffmpeg.args` instead.");
+    args.global = opts.ffmpegDefaultArgs;
+  }
+  path ??= opts.ffmpeg?.path ?? `ffmpeg${process.platform === "win32" ? ".exe" : ""}`;
+  if (opts.ffmpeg?.args) {
+    if (opts.ffmpeg.args.global)
+      args.global = opts.ffmpeg.args.global;
+    if (opts.ffmpeg.args.input)
+      args.input = opts.ffmpeg.args.input;
+    if (opts.ffmpeg.args.output)
+      args.output = opts.ffmpeg.args.output;
+  }
+  return { path, args };
+}, "#ffmpegOption");
 __name(_Options, "Options");
 var Options = _Options;
 
@@ -1640,14 +1716,11 @@ var _BaseManager = class _BaseManager extends DisTubeBase {
     super(...arguments);
     /**
      * The collection of items for this manager.
-     * @type {Collection}
-     * @name BaseManager#collection
      */
     __publicField(this, "collection", new import_discord2.Collection());
   }
   /**
    * The size of the collection.
-   * @type {number}
    */
   get size() {
     return this.collection.size;
@@ -1663,7 +1736,8 @@ var _GuildIdManager = class _GuildIdManager extends BaseManager {
     const existing = this.get(id);
     if (existing)
       return this;
-    return this.collection.set(id, data);
+    this.collection.set(id, data);
+    return this;
   }
   get(idOrInstance) {
     return this.collection.get(resolveGuildId(idOrInstance));
@@ -1683,21 +1757,16 @@ var import_voice3 = require("@discordjs/voice");
 var _DisTubeVoiceManager = class _DisTubeVoiceManager extends GuildIdManager {
   /**
    * Get a {@link DisTubeVoice}.
-   * @method get
-   * @memberof DisTubeVoiceManager#
-   * @param {GuildIdResolvable} guild The queue resolvable to resolve
-   * @returns {DisTubeVoice?}
+   *
+   * @param guild - The queue resolvable to resolve
    */
   /**
    * Collection of {@link DisTubeVoice}.
-   * @name DisTubeVoiceManager#collection
-   * @type {Discord.Collection<string, DisTubeVoice>}
    */
   /**
    * Create a {@link DisTubeVoice}
-   * @param {Discord.BaseGuildVoiceChannel} channel A voice channel to join
-   * @returns {DisTubeVoice}
-   * @private
+   *
+   * @param channel - A voice channel to join
    */
   create(channel) {
     const existing = this.get(channel.guildId);
@@ -1709,8 +1778,8 @@ var _DisTubeVoiceManager = class _DisTubeVoiceManager extends GuildIdManager {
   }
   /**
    * Join a voice channel
-   * @param {Discord.BaseGuildVoiceChannel} channel A voice channel to join
-   * @returns {Promise<DisTubeVoice>}
+   *
+   * @param channel - A voice channel to join
    */
   join(channel) {
     const existing = this.get(channel.guildId);
@@ -1720,7 +1789,8 @@ var _DisTubeVoiceManager = class _DisTubeVoiceManager extends GuildIdManager {
   }
   /**
    * Leave the connected voice channel in a guild
-   * @param {GuildIdResolvable} guild Queue Resolvable
+   *
+   * @param guild - Queue Resolvable
    */
   leave(guild) {
     const voice = this.get(guild);
@@ -1747,17 +1817,15 @@ var _FilterManager = class _FilterManager extends BaseManager {
     __privateAdd(this, _removeFn);
     /**
      * Collection of {@link Filter}.
-     * @name FilterManager#collection
-     * @type {Discord.Collection<string, DisTubeVoice>}
      */
     __publicField(this, "queue");
     this.queue = queue;
   }
   /**
    * Enable a filter or multiple filters to the manager
-   * @param {FilterResolvable|FilterResolvable[]} filterOrFilters The filter or filters to enable
-   * @param {boolean} [override=false] Wether or not override the applied filter with new filter value
-   * @returns {FilterManager}
+   *
+   * @param filterOrFilters - The filter or filters to enable
+   * @param override        - Wether or not override the applied filter with new filter value
    */
   add(filterOrFilters, override = false) {
     if (Array.isArray(filterOrFilters)) {
@@ -1776,15 +1844,14 @@ var _FilterManager = class _FilterManager extends BaseManager {
   }
   /**
    * Clear enabled filters of the manager
-   * @returns {FilterManager}
    */
   clear() {
     return this.set([]);
   }
   /**
    * Set the filters applied to the manager
-   * @param {FilterResolvable[]} filters The filters to apply
-   * @returns {FilterManager}
+   *
+   * @param filters - The filters to apply
    */
   set(filters) {
     if (!Array.isArray(filters))
@@ -1799,8 +1866,8 @@ var _FilterManager = class _FilterManager extends BaseManager {
   }
   /**
    * Disable a filter or multiple filters
-   * @param {FilterResolvable|FilterResolvable[]} filterOrFilters The filter or filters to disable
-   * @returns {FilterManager}
+   *
+   * @param filterOrFilters - The filter or filters to disable
    */
   remove(filterOrFilters) {
     if (Array.isArray(filterOrFilters))
@@ -1812,30 +1879,26 @@ var _FilterManager = class _FilterManager extends BaseManager {
   }
   /**
    * Check whether a filter enabled or not
-   * @param {FilterResolvable} filter The filter to check
-   * @returns {boolean}
+   *
+   * @param filter - The filter to check
    */
   has(filter) {
     return this.collection.has(typeof filter === "string" ? filter : __privateMethod(this, _resolve, resolve_fn).call(this, filter).name);
   }
   /**
    * Array of enabled filter names
-   * @type {Array<string>}
-   * @readonly
    */
   get names() {
     return [...this.collection.keys()];
   }
   /**
    * Array of enabled filters
-   * @type {Array<Filter>}
-   * @readonly
    */
   get values() {
     return [...this.collection.values()];
   }
   get ffmpegArgs() {
-    return this.size ? ["-af", this.values.map((f) => f.value).join(",")] : [];
+    return this.size ? { af: this.values.map((f) => f.value).join(",") } : {};
   }
   toString() {
     return this.names.toString();
@@ -1873,51 +1936,46 @@ var _QueueManager = class _QueueManager extends GuildIdManager {
     super(...arguments);
     /**
      * Get a Queue from this QueueManager.
-     * @method get
-     * @memberof QueueManager#
-     * @param {GuildIdResolvable} guild Resolvable thing from a guild
-     * @returns {Queue?}
+     *
+     * @param guild - Resolvable thing from a guild
      */
     /**
      * Listen to DisTubeVoice events and handle the Queue
-     * @private
-     * @param {Queue} queue Queue
+     *
+     * @param queue - Queue
      */
     __privateAdd(this, _voiceEventHandler);
     /**
      * Whether or not emit playSong event
-     * @param {Queue} queue Queue
-     * @private
-     * @returns {boolean}
+     *
+     * @param queue - Queue
      */
     __privateAdd(this, _emitPlaySong);
     /**
      * Handle the queue when a Song finish
-     * @private
-     * @param {Queue} queue queue
-     * @returns {Promise<void>}
+     *
+     * @param queue - queue
      */
     __privateAdd(this, _handleSongFinish);
     /**
      * Handle error while playing
-     * @private
-     * @param {Queue} queue queue
-     * @param {Error} error error
+     *
+     * @param queue - queue
+     * @param error - error
      */
     __privateAdd(this, _handlePlayingError);
   }
   /**
    * Collection of {@link Queue}.
-   * @name QueueManager#collection
-   * @type {Discord.Collection<string, Queue>}
    */
   /**
    * Create a {@link Queue}
-   * @private
-   * @param {Discord.BaseGuildVoiceChannel} channel A voice channel
-   * @param {Song|Song[]} song First song
-   * @param {Discord.BaseGuildTextChannel} textChannel Default text channel
-   * @returns {Promise<Queue|true>} Returns `true` if encounter an error
+   *
+   * @param channel     - A voice channel
+   * @param song        - First song
+   * @param textChannel - Default text channel
+   *
+   * @returns Returns `true` if encounter an error
    */
   async create(channel, song, textChannel) {
     if (this.has(channel.guildId))
@@ -1926,10 +1984,11 @@ var _QueueManager = class _QueueManager extends GuildIdManager {
     const queue = new Queue(this.distube, voice, song, textChannel);
     await queue._taskQueue.queuing();
     try {
+      checkFFmpeg(this.distube);
       await voice.join();
       __privateMethod(this, _voiceEventHandler, voiceEventHandler_fn).call(this, queue);
       this.add(queue.id, queue);
-      this.emit("initQueue", queue);
+      this.emit("initQueue" /* INIT_QUEUE */, queue);
       const err = await this.playSong(queue);
       return err || queue;
     } finally {
@@ -1938,26 +1997,36 @@ var _QueueManager = class _QueueManager extends GuildIdManager {
   }
   /**
    * Create a ytdl stream
-   * @param {Queue} queue Queue
-   * @returns {DisTubeStream}
+   *
+   * @param queue - Queue
    */
   createStream(queue) {
     const song = queue.songs[0];
     const { duration, source, streamURL } = song;
     const streamOptions = {
-      ffmpegArgs: queue.filters.ffmpegArgs,
+      ffmpeg: {
+        path: this.options.ffmpeg.path,
+        args: {
+          global: { ...this.options.ffmpeg.args.global },
+          input: { ...this.options.ffmpeg.args.input },
+          output: { ...this.options.ffmpeg.args.output, ...queue.filters.ffmpegArgs }
+        }
+      },
       seek: duration ? queue.beginTime : void 0,
       type: this.options.streamType
     };
     if (source === "youtube")
       return DisTubeStream.YouTube(song, streamOptions);
+    if (!streamURL)
+      throw new Error("No streamURL, something went wrong");
     return DisTubeStream.DirectLink(streamURL, streamOptions);
   }
   /**
    * Play a song on voice connection
-   * @private
-   * @param {Queue} queue The guild queue
-   * @returns {Promise<boolean>} error?
+   *
+   * @param queue - The guild queue
+   *
+   * @returns error?
    */
   async playSong(queue) {
     if (!queue)
@@ -1974,6 +2043,7 @@ var _QueueManager = class _QueueManager extends GuildIdManager {
         return true;
       }
       const stream = this.createStream(queue);
+      stream.on("debug", (data) => this.emit("ffmpegDebug" /* FFMPEG_DEBUG */, `[${queue.id}]: ${data}`));
       queue.voice.play(stream);
       song.streamURL = stream.url;
       return false;
@@ -1988,7 +2058,7 @@ voiceEventHandler_fn = /* @__PURE__ */ __name(function(queue) {
   queue._listeners = {
     disconnect: (error) => {
       queue.remove();
-      this.emit("disconnect", queue);
+      this.emit("disconnect" /* DISCONNECT */, queue);
       if (error)
         this.emitError(error, queue.textChannel);
     },
@@ -2005,7 +2075,7 @@ emitPlaySong_fn = /* @__PURE__ */ __name(function(queue) {
 }, "#emitPlaySong");
 _handleSongFinish = new WeakSet();
 handleSongFinish_fn = /* @__PURE__ */ __name(async function(queue) {
-  this.emit("finishSong", queue, queue.songs[0]);
+  this.emit("finishSong" /* FINISH_SONG */, queue, queue.songs[0]);
   await queue._taskQueue.queuing();
   try {
     if (queue.stopped)
@@ -2023,14 +2093,14 @@ handleSongFinish_fn = /* @__PURE__ */ __name(async function(queue) {
         try {
           await queue.addRelatedSong();
         } catch {
-          this.emit("noRelated", queue);
+          this.emit("noRelated" /* NO_RELATED */, queue);
         }
       }
       if (queue.songs.length <= 1) {
         if (this.options.leaveOnFinish)
           queue.voice.leave();
         if (!queue.autoplay)
-          this.emit("finish", queue);
+          this.emit("finish" /* FINISH */, queue);
         queue.remove();
         return;
       }
@@ -2049,7 +2119,7 @@ handleSongFinish_fn = /* @__PURE__ */ __name(async function(queue) {
     queue.beginTime = 0;
     const err = await this.playSong(queue);
     if (!err && emitPlaySong)
-      this.emit("playSong", queue, queue.songs[0]);
+      this.emit("playSong" /* PLAY_SONG */, queue, queue.songs[0]);
   } finally {
     queue._taskQueue.resolve();
   }
@@ -2070,7 +2140,7 @@ Name: ${song.name}`;
     queue.beginTime = 0;
     this.playSong(queue).then((e) => {
       if (!e)
-        this.emit("playSong", queue, queue.songs[0]);
+        this.emit("playSong" /* PLAY_SONG */, queue, queue.songs[0]);
     });
   } else {
     queue.stop();
@@ -2084,10 +2154,11 @@ var _filters;
 var _Queue = class _Queue extends DisTubeBase {
   /**
    * Create a queue for the guild
-   * @param {DisTube} distube DisTube
-   * @param {DisTubeVoice} voice Voice connection
-   * @param {Song|Song[]} song First song(s)
-   * @param {Discord.BaseGuildTextChannel?} textChannel Default text channel
+   *
+   * @param distube     - DisTube
+   * @param voice       - Voice connection
+   * @param song        - First song(s)
+   * @param textChannel - Default text channel
    */
   constructor(distube, voice, song, textChannel) {
     super(distube);
@@ -2129,55 +2200,42 @@ var _Queue = class _Queue extends DisTubeBase {
   }
   /**
    * The client user as a `GuildMember` of this queue's guild
-   * @type {Discord.GuildMember?}
    */
   get clientMember() {
     return this.voice.channel.guild.members.me ?? void 0;
   }
   /**
    * The filter manager of the queue
-   * @type {FilterManager}
-   * @readonly
    */
   get filters() {
     return __privateGet(this, _filters);
   }
   /**
    * Formatted duration string.
-   * @type {string}
-   * @readonly
    */
   get formattedDuration() {
     return formatDuration(this.duration);
   }
   /**
    * Queue's duration.
-   * @type {number}
-   * @readonly
    */
   get duration() {
     return this.songs.length ? this.songs.reduce((prev, next) => prev + next.duration, 0) : 0;
   }
   /**
    * What time in the song is playing (in seconds).
-   * @type {number}
-   * @readonly
    */
   get currentTime() {
     return this.voice.playbackDuration + this.beginTime;
   }
   /**
    * Formatted {@link Queue#currentTime} string.
-   * @type {string}
-   * @readonly
    */
   get formattedCurrentTime() {
     return formatDuration(this.currentTime);
   }
   /**
    * The voice channel playing in.
-   * @type {Discord.VoiceChannel|Discord.StageChannel|null}
-   * @readonly
    */
   get voiceChannel() {
     return this.clientMember?.voice?.channel ?? null;
@@ -2189,12 +2247,12 @@ var _Queue = class _Queue extends DisTubeBase {
     this.voice.volume = value;
   }
   /**
-   * @private
-   * Add a Song or an array of Song to the queue
-   * @param {Song|Song[]} song Song to add
-   * @param {number} [position=0] Position to add, <= 0 to add to the end of the queue
-   * @throws {Error}
-   * @returns {Queue} The guild queue
+   * @throws {DisTubeError}
+   *
+   * @param song     - Song to add
+   * @param position - Position to add, \<= 0 to add to the end of the queue
+   *
+   * @returns The guild queue
    */
   addToQueue(song, position = 0) {
     if (!song || Array.isArray(song) && !song.length) {
@@ -2221,7 +2279,8 @@ var _Queue = class _Queue extends DisTubeBase {
   }
   /**
    * Pause the guild stream
-   * @returns {Queue} The guild queue
+   *
+   * @returns The guild queue
    */
   pause() {
     if (this.paused)
@@ -2233,7 +2292,8 @@ var _Queue = class _Queue extends DisTubeBase {
   }
   /**
    * Resume the guild stream
-   * @returns {Queue} The guild queue
+   *
+   * @returns The guild queue
    */
   resume() {
     if (this.playing)
@@ -2245,19 +2305,21 @@ var _Queue = class _Queue extends DisTubeBase {
   }
   /**
    * Set the guild stream's volume
-   * @param {number} percent The percentage of volume you want to set
-   * @returns {Queue} The guild queue
+   *
+   * @param percent - The percentage of volume you want to set
+   *
+   * @returns The guild queue
    */
   setVolume(percent) {
     this.volume = percent;
     return this;
   }
   /**
-   * Skip the playing song if there is a next song in the queue.
-   * <info>If {@link Queue#autoplay} is `true` and there is no up next song,
-   * DisTube will add and play a related song.</info>
-   * @returns {Promise<Song>} The song will skip to
-   * @throws {Error}
+   * Skip the playing song if there is a next song in the queue. <info>If {@link
+   * Queue#autoplay} is `true` and there is no up next song, DisTube will add and
+   * play a related song.</info>
+   *
+   * @returns The song will skip to
    */
   async skip() {
     await this._taskQueue.queuing();
@@ -2278,8 +2340,8 @@ var _Queue = class _Queue extends DisTubeBase {
   }
   /**
    * Play the previous song if exists
-   * @returns {Promise<Song>} The guild queue
-   * @throws {Error}
+   *
+   * @returns The guild queue
    */
   async previous() {
     await this._taskQueue.queuing();
@@ -2299,7 +2361,8 @@ var _Queue = class _Queue extends DisTubeBase {
   }
   /**
    * Shuffle the queue's songs
-   * @returns {Promise<Queue>} The guild queue
+   *
+   * @returns The guild queue
    */
   async shuffle() {
     await this._taskQueue.queuing();
@@ -2318,12 +2381,13 @@ var _Queue = class _Queue extends DisTubeBase {
     }
   }
   /**
-   * Jump to the song position in the queue.
-   * The next one is 1, 2,...
-   * The previous one is -1, -2,...
-   * @param {number} position The song position to play
-   * @returns {Promise<Song>} The new Song will be played
-   * @throws {Error} if `num` is invalid number
+   * Jump to the song position in the queue. The next one is 1, 2,... The previous
+   * one is -1, -2,...
+   * if `num` is invalid number
+   *
+   * @param position - The song position to play
+   *
+   * @returns The new Song will be played
    */
   async jump(position) {
     await this._taskQueue.queuing();
@@ -2359,10 +2423,12 @@ var _Queue = class _Queue extends DisTubeBase {
     }
   }
   /**
-   * Set the repeat mode of the guild queue.\
+   * Set the repeat mode of the guild queue.
    * Toggle mode `(Disabled -> Song -> Queue -> Disabled ->...)` if `mode` is `undefined`
-   * @param {RepeatMode?} [mode] The repeat modes (toggle if `undefined`)
-   * @returns {RepeatMode} The new repeat mode
+   *
+   * @param mode - The repeat modes (toggle if `undefined`)
+   *
+   * @returns The new repeat mode
    */
   setRepeatMode(mode) {
     if (mode !== void 0 && !Object.values(RepeatMode).includes(mode)) {
@@ -2378,8 +2444,10 @@ var _Queue = class _Queue extends DisTubeBase {
   }
   /**
    * Set the playing time to another position
-   * @param {number} time Time in seconds
-   * @returns {Queue} The guild queue
+   *
+   * @param time - Time in seconds
+   *
+   * @returns The guild queue
    */
   seek(time) {
     if (typeof time !== "number")
@@ -2392,8 +2460,8 @@ var _Queue = class _Queue extends DisTubeBase {
   }
   /**
    * Add a related song of the playing song to the queue
-   * @returns {Promise<Song>} The added song
-   * @throws {Error}
+   *
+   * @returns The added song
    */
   async addRelatedSong() {
     if (!this.songs?.[0])
@@ -2426,9 +2494,8 @@ var _Queue = class _Queue extends DisTubeBase {
     }
   }
   /**
-   * Remove the queue from the manager
-   * (This does not leave the voice channel even if {@link DisTubeOptions|DisTubeOptions.leaveOnStop} is enabled)
-   * @private
+   * Remove the queue from the manager (This does not leave the voice channel even if
+   * {@link DisTubeOptions | DisTubeOptions.leaveOnStop} is enabled)
    */
   remove() {
     this.stopped = true;
@@ -2440,11 +2507,12 @@ var _Queue = class _Queue extends DisTubeBase {
       }
     }
     this.queues.remove(this.id);
-    this.emit("deleteQueue", this);
+    this.emit("deleteQueue" /* DELETE_QUEUE */, this);
   }
   /**
    * Toggle autoplay mode
-   * @returns {boolean} Autoplay mode state
+   *
+   * @returns Autoplay mode state
    */
   toggleAutoplay() {
     this.autoplay = !this.autoplay;
@@ -2465,70 +2533,59 @@ var _Plugin = class _Plugin {
   }
   /**
    * Type of the plugin
-   * @name Plugin#type
-   * @type {PluginType}
    */
   /**
    * Emit an event to the {@link DisTube} class
-   * @param {string} eventName Event name
-   * @param {...any} args arguments
-   * @returns {boolean}
+   *
+   * @param eventName - Event name
+   * @param args      - arguments
    */
   emit(eventName, ...args) {
     return this.distube.emit(eventName, ...args);
   }
   /**
    * Emit error event to the {@link DisTube} class
-   * @param {Error} error error
-   * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
+   *
+   * @param error   - error
+   * @param channel - Text channel where the error is encountered.
    */
   emitError(error, channel) {
     this.distube.emitError(error, channel);
   }
   /**
    * The queue manager
-   * @type {QueueManager}
-   * @readonly
    */
   get queues() {
     return this.distube.queues;
   }
   /**
    * The voice manager
-   * @type {DisTubeVoiceManager}
-   * @readonly
    */
   get voices() {
     return this.distube.voices;
   }
   /**
    * Discord.js client
-   * @type {Discord.Client}
-   * @readonly
    */
   get client() {
     return this.distube.client;
   }
   /**
    * DisTube options
-   * @type {DisTubeOptions}
-   * @readonly
    */
   get options() {
     return this.distube.options;
   }
   /**
    * DisTube handler
-   * @type {DisTubeHandler}
-   * @readonly
    */
   get handler() {
     return this.distube.handler;
   }
   /**
    * Check if the string is working with this plugin
-   * @param {string} _string Input string
-   * @returns {boolean|Promise<boolean>}
+   *
+   * @param _string - Input string
    */
   validate(_string) {
     return false;
@@ -2536,17 +2593,18 @@ var _Plugin = class _Plugin {
   /**
    * Get the stream url from {@link Song#url}. Returns {@link Song#url} by default.
    * Not needed if the plugin plays song from YouTube.
-   * @param {string} url Input url
-   * @returns {string|Promise<string>}
+   *
+   * @param url - Input url
    */
   getStreamURL(url) {
     return url;
   }
   /**
-   * Get related songs from a supported url. {@link Song#member} should be `undefined`.
-   * Not needed to add {@link Song#related} because it will be added with this function later.
-   * @param {string} _url Input url
-   * @returns {Song[]|Promise<Song[]>}
+   * Get related songs from a supported url. {@link Song#member} should be
+   * `undefined`. Not needed to add {@link Song#related} because it will be added
+   * with this function later.
+   *
+   * @param _url - Input url
    */
   getRelatedSongs(_url) {
     return [];
@@ -2747,15 +2805,9 @@ var _DirectLinkPlugin = class _DirectLinkPlugin extends ExtractorPlugin {
     return false;
   }
   resolve(url, options = {}) {
-    url = url.replace(/\/+$/, "");
-    return new Song(
-      {
-        name: url.substring(url.lastIndexOf("/") + 1).replace(/((\?|#).*)?$/, "") || url,
-        url,
-        src: "direct_link"
-      },
-      options
-    );
+    const u = new URL(url);
+    const name = u.pathname.split("/").pop() || u.href;
+    return new Song({ name, url, src: "direct_link" }, options);
   }
 };
 __name(_DirectLinkPlugin, "DirectLinkPlugin");
@@ -2763,11 +2815,11 @@ var DirectLinkPlugin = _DirectLinkPlugin;
 
 // src/DisTube.ts
 var import_ytsr = __toESM(require("@distube/ytsr"));
-var import_tiny_typed_emitter2 = require("tiny-typed-emitter");
+var import_tiny_typed_emitter3 = require("tiny-typed-emitter");
 var { version } = require_package();
 var _getQueue, getQueue_fn;
-var _DisTube = class _DisTube extends import_tiny_typed_emitter2.TypedEmitter {
-  constructor(client, otp = {}) {
+var _DisTube = class _DisTube extends import_tiny_typed_emitter3.TypedEmitter {
+  constructor(client, opts = {}) {
     super();
     __privateAdd(this, _getQueue);
     __publicField(this, "handler");
@@ -2783,7 +2835,7 @@ var _DisTube = class _DisTube extends import_tiny_typed_emitter2.TypedEmitter {
       throw new DisTubeError("INVALID_TYPE", "Discord.Client", client, "client");
     this.client = client;
     checkIntents(client.options);
-    this.options = new Options(otp);
+    this.options = new Options(opts);
     this.voices = new DisTubeVoiceManager(this);
     this.handler = new DisTubeHandler(this);
     this.queues = new QueueManager(this);
@@ -2799,21 +2851,16 @@ var _DisTube = class _DisTube extends import_tiny_typed_emitter2.TypedEmitter {
   }
   /**
    * DisTube version
-   * @type {string}
    */
   get version() {
     return version;
   }
   /**
-   * Play / add a song or playlist from url. Search and play a song if it is not a valid url.
+   * Play / add a song or playlist from url. Search and play a song if it is not a
+   * valid url.
    *
-   * @param {Discord.BaseGuildVoiceChannel} voiceChannel The channel will be joined if the bot isn't in any channels,
-   * the bot will be moved to this channel if {@link DisTubeOptions}.joinNewVoiceChannel is `true`
-   * @param {string|Song|SearchResult|Playlist} song URL | Search string |
-   * {@link Song} | {@link SearchResult} | {@link Playlist}
-   * @param {PlayOptions} [options] Optional options
-   * @throws {DisTubeError}
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -2825,7 +2872,14 @@ var _DisTube = class _DisTube extends import_tiny_typed_emitter2.TypedEmitter {
    *             message
    *         });
    * });
-   * @returns {Promise<void>}
+   * ```ts
+   *
+   * @throws {@link DisTubeError}
+   *
+   * @param voiceChannel - The channel will be joined if the bot isn't in any channels, the bot will be
+   *                       moved to this channel if {@link DisTubeOptions}.joinNewVoiceChannel is `true`
+   * @param song         - URL | Search string | {@link Song} | {@link SearchResult} | {@link Playlist}
+   * @param options      - Optional options
    */
   async play(voiceChannel, song, options = {}) {
     if (!isSupportedVoiceChannel(voiceChannel)) {
@@ -2895,10 +2949,9 @@ ${e.message}`;
   }
   /**
    * Create a custom playlist
-   * @returns {Promise<Playlist>}
-   * @param {Array<string|Song|SearchResult>} songs Array of url, Song or SearchResult
-   * @param {CustomPlaylistOptions} [options] Optional options
+   *
    * @example
+   * ```ts
    * const songs = ["https://www.youtube.com/watch?v=xxx", "https://www.youtube.com/watch?v=yyy"];
    * const playlist = await distube.createCustomPlaylist(songs, {
    *     member: message.member,
@@ -2906,6 +2959,10 @@ ${e.message}`;
    *     parallel: true
    * });
    * distube.play(voiceChannel, playlist, { ... });
+   * ```ts
+   *
+   * @param songs   - Array of url, Song or SearchResult
+   * @param options - Optional options
    */
   async createCustomPlaylist(songs, options = {}) {
     const { member, properties, parallel, metadata } = { parallel: true, ...options };
@@ -2926,13 +2983,14 @@ ${e.message}`;
       const promises = filteredSongs.map(
         (song) => this.handler.resolve(song, { member, metadata }).catch(() => void 0)
       );
-      resolvedSongs = (await Promise.all(promises)).filter((s) => Boolean(s));
+      resolvedSongs = (await Promise.all(promises)).filter((s) => s instanceof Song);
     } else {
-      const resolved = [];
+      resolvedSongs = [];
       for (const song of filteredSongs) {
-        resolved.push(await this.handler.resolve(song, { member, metadata }).catch(() => void 0));
+        const resolved = await this.handler.resolve(song, { member, metadata }).catch(() => void 0);
+        if (resolved instanceof Song)
+          resolvedSongs.push(resolved);
       }
-      resolvedSongs = resolved.filter((s) => Boolean(s));
     }
     return new Playlist(resolvedSongs, { member, properties, metadata });
   }
@@ -2940,13 +2998,13 @@ ${e.message}`;
    * Search for a song. You can customize how user answers instead of send a number.
    * Then use {@link DisTube#play} to play it.
    *
-   * @param {string} string The string search for
-   * @param {Object} options Search options
-   * @param {number} [options.limit=10] Limit the results
-   * @param {SearchResultType} [options.type=SearchResultType.VIDEO] Type of results (`video` or `playlist`).
-   * @param {boolean} [options.safeSearch=false] Whether or not use safe search (YouTube restricted mode)
-   * @throws {Error}
-   * @returns {Promise<Array<SearchResult>>} Array of results
+   * @param string             - The string search for
+   * @param options            - Search options
+   * @param options.limit      - Limit the results
+   * @param options.type       - Type of results (`video` or `playlist`).
+   * @param options.safeSearch - Whether or not use safe search (YouTube restricted mode)
+   *
+   * @returns Array of results
    */
   async search(string, options = {}) {
     const opts = { type: "video" /* VIDEO */, limit: 10, safeSearch: false, ...options };
@@ -2979,10 +3037,9 @@ ${e.message}`;
   }
   /**
    * Get the guild queue
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {Queue?}
-   * @throws {Error}
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -2994,34 +3051,38 @@ ${e.message}`;
    *         ).join("\n"));
    *     }
    * });
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
    */
   getQueue(guild) {
     return this.queues.get(guild);
   }
   /**
    * Pause the guild stream
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {Queue} The guild queue
-   * @throws {Error}
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   *
+   * @returns The guild queue
    */
   pause(guild) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).pause();
   }
   /**
    * Resume the guild stream
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {Queue} The guild queue
-   * @throws {Error}
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   *
+   * @returns The guild queue
    */
   resume(guild) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).resume();
   }
   /**
    * Stop the guild stream
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {Promise<void>}
-   * @throws {Error}
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3031,17 +3092,18 @@ ${e.message}`;
    *         message.channel.send("Stopped the queue!");
    *     }
    * });
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
    */
   stop(guild) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).stop();
   }
   /**
    * Set the guild stream's volume
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @param {number} percent The percentage of volume you want to set
-   * @returns {Queue} The guild queue
-   * @throws {Error}
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3049,18 +3111,23 @@ ${e.message}`;
    *     if (command == "volume")
    *         distube.setVolume(message, Number(args[0]));
    * });
+   * ```ts
+   *
+   * @param guild   - The type can be resolved to give a {@link Queue}
+   * @param percent - The percentage of volume you want to set
+   *
+   * @returns The guild queue
    */
   setVolume(guild, percent) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).setVolume(percent);
   }
   /**
-   * Skip the playing song if there is a next song in the queue.
-   * <info>If {@link Queue#autoplay} is `true` and there is no up next song,
-   * DisTube will add and play a related song.</info>
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {Promise<Song>} The new Song will be played
-   * @throws {Error}
+   * Skip the playing song if there is a next song in the queue. <info>If {@link
+   * Queue#autoplay} is `true` and there is no up next song, DisTube will add and
+   * play a related song.</info>
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3068,16 +3135,20 @@ ${e.message}`;
    *     if (command == "skip")
    *         distube.skip(message);
    * });
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   *
+   * @returns The new Song will be played
    */
   skip(guild) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).skip();
   }
   /**
    * Play the previous song
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {Promise<Song>} The new Song will be played
-   * @throws {Error}
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3085,15 +3156,20 @@ ${e.message}`;
    *     if (command == "previous")
    *         distube.previous(message);
    * });
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   *
+   * @returns The new Song will be played
    */
   previous(guild) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).previous();
   }
   /**
    * Shuffle the guild queue songs
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {Promise<Queue>} The guild queue
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3101,19 +3177,21 @@ ${e.message}`;
    *     if (command == "shuffle")
    *         distube.shuffle(message);
    * });
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   *
+   * @returns The guild queue
    */
   shuffle(guild) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).shuffle();
   }
   /**
-   * Jump to the song number in the queue.
-   * The next one is 1, 2,...
-   * The previous one is -1, -2,...
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @param {number} num The song number to play
-   * @returns {Promise<Song>} The new Song will be played
-   * @throws {Error} if `num` is invalid number (0 < num < {@link Queue#songs}.length)
+   * Jump to the song number in the queue. The next one is 1, 2,... The previous one
+   * is -1, -2,...
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3122,17 +3200,22 @@ ${e.message}`;
    *         distube.jump(message, parseInt(args[0]))
    *             .catch(err => message.channel.send("Invalid song number."));
    * });
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   * @param num   - The song number to play
+   *
+   * @returns The new Song will be played
    */
   jump(guild, num) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).jump(num);
   }
   /**
-   * Set the repeat mode of the guild queue.\
+   * Set the repeat mode of the guild queue.
    * Toggle mode `(Disabled -> Song -> Queue -> Disabled ->...)` if `mode` is `undefined`
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @param {RepeatMode?} [mode] The repeat modes (toggle if `undefined`)
-   * @returns {RepeatMode} The new repeat mode
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3143,7 +3226,9 @@ ${e.message}`;
    *         message.channel.send("Set repeat mode to `" + mode + "`");
    *     }
    * });
+   * ```ts
    * @example
+   * ```ts
    * const { RepeatMode } = require("distube");
    * let mode;
    * switch(distube.setRepeatMode(message, parseInt(args[0]))) {
@@ -3158,16 +3243,21 @@ ${e.message}`;
    *         break;
    * }
    * message.channel.send("Set repeat mode to `" + mode + "`");
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   * @param mode  - The repeat modes (toggle if `undefined`)
+   *
+   * @returns The new repeat mode
    */
   setRepeatMode(guild, mode) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).setRepeatMode(mode);
   }
   /**
    * Toggle autoplay mode
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {boolean} Autoplay mode state
-   * @throws {Error}
+   *
    * @example
+   * ```ts
    * client.on('message', (message) => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3177,6 +3267,11 @@ ${e.message}`;
    *         message.channel.send("Set autoplay mode to `" + (mode ? "On" : "Off") + "`");
    *     }
    * });
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   *
+   * @returns Autoplay mode state
    */
   toggleAutoplay(guild) {
     const queue = __privateMethod(this, _getQueue, getQueue_fn).call(this, guild);
@@ -3185,18 +3280,19 @@ ${e.message}`;
   }
   /**
    * Add related song to the queue
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @returns {Promise<Song>} The guild queue
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   *
+   * @returns The guild queue
    */
   addRelatedSong(guild) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).addRelatedSong();
   }
   /**
    * Set the playing time to another position
-   * @param {GuildIdResolvable} guild The type can be resolved to give a {@link Queue}
-   * @param {number} time Time in seconds
-   * @returns {Queue} Seeked queue
+   *
    * @example
+   * ```ts
    * client.on('message', message => {
    *     if (!message.content.startsWith(config.prefix)) return;
    *     const args = message.content.slice(config.prefix.length).trim().split(/ +/g);
@@ -3204,24 +3300,30 @@ ${e.message}`;
    *     if (command = 'seek')
    *         distube.seek(message, Number(args[0]));
    * });
+   * ```ts
+   *
+   * @param guild - The type can be resolved to give a {@link Queue}
+   * @param time  - Time in seconds
+   *
+   * @returns Seeked queue
    */
   seek(guild, time) {
     return __privateMethod(this, _getQueue, getQueue_fn).call(this, guild).seek(time);
   }
   /**
    * Emit error event
-   * @param {Error} error error
-   * @param {Discord.BaseGuildTextChannel} [channel] Text channel where the error is encountered.
-   * @private
+   *
+   * @param error   - error
+   * @param channel - Text channel where the error is encountered.
    */
   emitError(error, channel) {
-    if (this.listeners("error").length) {
-      this.emit("error", channel, error);
+    if (this.listeners("error" /* ERROR */).length) {
+      this.emit("error" /* ERROR */, channel, error);
     } 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"
+        "See: https://distube.js.org/classes/DisTube.html#error and https://nodejs.org/api/events.html#events_error_events"
       );
     }
   }
@@ -3264,6 +3366,7 @@ var DisTube = _DisTube;
   Song,
   StreamType,
   TaskQueue,
+  checkFFmpeg,
   checkIntents,
   checkInvalidKey,
   chooseBestVideoFormat,