@kattowo/distube 0.0.0-stage → 6.0.0

package/dist/index.js

@@ -0,0 +1,4028 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AUDIO_CHANNELS: () => AUDIO_CHANNELS,
+  AUDIO_SAMPLE_RATE: () => AUDIO_SAMPLE_RATE,
+  BaseManager: () => BaseManager,
+  DEFAULT_VOLUME: () => DEFAULT_VOLUME,
+  DisTube: () => DisTube,
+  DisTubeBase: () => DisTubeBase,
+  DisTubeError: () => DisTubeError,
+  DisTubeHandler: () => DisTubeHandler,
+  DisTubeStream: () => DisTubeStream,
+  DisTubeVoice: () => DisTubeVoice,
+  DisTubeVoiceManager: () => DisTubeVoiceManager,
+  Events: () => Events,
+  ExtractorPlugin: () => ExtractorPlugin,
+  FilterManager: () => FilterManager,
+  GuildIdManager: () => GuildIdManager,
+  HTTP_REDIRECT_CODES: () => HTTP_REDIRECT_CODES,
+  InfoExtractorPlugin: () => InfoExtractorPlugin,
+  JOIN_TIMEOUT_MS: () => JOIN_TIMEOUT_MS,
+  MAX_REDIRECT_DEPTH: () => MAX_REDIRECT_DEPTH,
+  Options: () => Options,
+  PlayableExtractorPlugin: () => PlayableExtractorPlugin,
+  Playlist: () => Playlist,
+  Plugin: () => Plugin,
+  PluginError: () => PluginError,
+  PluginErrorCode: () => PluginErrorCode,
+  PluginType: () => PluginType,
+  Queue: () => Queue,
+  QueueManager: () => QueueManager,
+  RECONNECT_MAX_ATTEMPTS: () => RECONNECT_MAX_ATTEMPTS,
+  RECONNECT_TIMEOUT_MS: () => RECONNECT_TIMEOUT_MS,
+  RepeatMode: () => RepeatMode,
+  STUCK_THRESHOLD_MS: () => STUCK_THRESHOLD_MS,
+  SearchResult: () => SearchResult,
+  SearchResultType: () => SearchResultType,
+  Song: () => Song,
+  StreamServer: () => StreamServer,
+  TaskQueue: () => TaskQueue,
+  checkEncryptionLibraries: () => checkEncryptionLibraries,
+  checkFFmpeg: () => checkFFmpeg,
+  checkIntents: () => checkIntents,
+  checkInvalidKey: () => checkInvalidKey,
+  default: () => DisTube,
+  defaultFilters: () => defaultFilters,
+  defaultOptions: () => defaultOptions,
+  formatDuration: () => formatDuration,
+  handleUnhandledError: () => handleUnhandledError,
+  isClientInstance: () => isClientInstance,
+  isGuildInstance: () => isGuildInstance,
+  isMemberInstance: () => isMemberInstance,
+  isMessageInstance: () => isMessageInstance,
+  isNsfwChannel: () => isNsfwChannel,
+  isObject: () => isObject,
+  isSnowflake: () => isSnowflake,
+  isSupportedVoiceChannel: () => isSupportedVoiceChannel,
+  isTextChannelInstance: () => isTextChannelInstance,
+  isTruthy: () => isTruthy,
+  isURL: () => isURL,
+  isVoiceChannelEmpty: () => isVoiceChannelEmpty,
+  objectKeys: () => objectKeys,
+  resolveGuildId: () => resolveGuildId,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constant.ts
+var version = "6.0.0";
+var AUDIO_SAMPLE_RATE = 48e3;
+var AUDIO_CHANNELS = 2;
+var DEFAULT_VOLUME = 50;
+var JOIN_TIMEOUT_MS = 3e4;
+var RECONNECT_TIMEOUT_MS = 5e3;
+var RECONNECT_MAX_ATTEMPTS = 5;
+var STUCK_THRESHOLD_MS = 1e4;
+var HTTP_REDIRECT_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var MAX_REDIRECT_DEPTH = 5;
+var defaultFilters = {
+  "3d": "apulsator=hz=0.125",
+  bassboost: "bass=g=10",
+  echo: "aecho=0.8:0.9:1000:0.3",
+  flanger: "flanger",
+  gate: "agate",
+  haas: "haas",
+  karaoke: "stereotools=mlev=0.1",
+  nightcore: "asetrate=48000*1.25,aresample=48000,bass=g=5",
+  reverse: "areverse",
+  vaporwave: "asetrate=48000*0.8,aresample=48000,atempo=1.1",
+  mcompand: "mcompand",
+  phaser: "aphaser",
+  tremolo: "tremolo",
+  surround: "surround",
+  earwax: "earwax"
+};
+var defaultOptions = {
+  plugins: [],
+  emitNewSongOnly: false,
+  savePreviousSongs: true,
+  nsfw: false,
+  emitAddSongWhenCreatingQueue: true,
+  emitAddListWhenCreatingQueue: true,
+  joinNewVoiceChannel: true,
+  unhandledError: "log",
+  stuckThreshold: STUCK_THRESHOLD_MS
+};
+
+// src/core/DisTubeBase.ts
+var DisTubeBase = class {
+  static {
+    __name(this, "DisTubeBase");
+  }
+  /**
+   * The DisTube instance this object belongs to.
+   */
+  distube;
+  /**
+   * Create a new base object.
+   * @param distube - The DisTube instance
+   */
+  constructor(distube) {
+    this.distube = distube;
+  }
+  /**
+   * Emit the {@link DisTube} of this base
+   * @param eventName - Event name
+   * @param args      - arguments
+   * @returns `true` when the event had listeners, `false` otherwise
+   */
+  emit(eventName, ...args) {
+    return this.distube.emit(eventName, ...args);
+  }
+  /**
+   * Emit error event
+   * @param error   - error
+   * @param queue   - The queue encountered the error
+   * @param song    - The playing song when encountered the error
+   * @returns Nothing
+   */
+  emitError(error, queue, song) {
+    this.distube.emitError(error, queue, song);
+  }
+  /**
+   * Emit debug event
+   * @param message - debug message
+   * @returns Nothing
+   */
+  debug(message) {
+    this.distube.debug(message);
+  }
+  /**
+   * The queue manager
+   */
+  get queues() {
+    return this.distube.queues;
+  }
+  /**
+   * The voice manager
+   */
+  get voices() {
+    return this.distube.voices;
+  }
+  /**
+   * Discord.js client
+   */
+  get client() {
+    return this.distube.client;
+  }
+  /**
+   * DisTube options
+   */
+  get options() {
+    return this.distube.options;
+  }
+  /**
+   * DisTube handler
+   */
+  get handler() {
+    return this.distube.handler;
+  }
+  /**
+   * DisTube plugins
+   */
+  get plugins() {
+    return this.distube.plugins;
+  }
+};
+
+// src/core/DisTubeHandler.ts
+var import_undici = require("undici");
+
+// src/struct/DisTubeError.ts
+var import_node_util = require("util");
+var ERROR_MESSAGES = {
+  /**
+   * A value does not have the expected type.
+   *
+   * It is raised when an argument of a public method is not of the type that
+   * the method expects, e.g. when a voice channel is not a voice channel.
+   */
+  INVALID_TYPE: /* @__PURE__ */ __name((expected, got, name) => `Expected ${Array.isArray(expected) ? expected.map((e) => typeof e === "number" ? e : `'${e}'`).join(" or ") : `'${expected}'`}${name ? ` for '${name}'` : ""}, but got ${(0, import_node_util.inspect)(got)} (${typeof got})`, "INVALID_TYPE"),
+  /**
+   * A number is not in the expected range.
+   *
+   * It is raised when a numeric argument is out of the range that the method
+   * accepts, e.g. a negative volume.
+   */
+  NUMBER_COMPARE: /* @__PURE__ */ __name((name, expected, value) => `'${name}' must be ${expected} ${value}`, "NUMBER_COMPARE"),
+  /**
+   * An array is empty.
+   *
+   * It is raised when an argument that must hold at least one element is
+   * empty, e.g. the songs of a custom playlist.
+   */
+  EMPTY_ARRAY: /* @__PURE__ */ __name((name) => `'${name}' is an empty array`, "EMPTY_ARRAY"),
+  /**
+   * An array does not have any valid element.
+   *
+   * It is raised when every element of an array was filtered out, e.g. when
+   * all the songs of an array are invalid.
+   */
+  EMPTY_FILTERED_ARRAY: /* @__PURE__ */ __name((name, type) => `There is no valid '${type}' in the '${name}' array`, "EMPTY_FILTERED_ARRAY"),
+  /**
+   * A string is empty.
+   *
+   * It is raised when a string argument that must not be empty is empty.
+   */
+  EMPTY_STRING: /* @__PURE__ */ __name((name) => `'${name}' string must not be empty`, "EMPTY_STRING"),
+  /**
+   * An object has a key that is not allowed.
+   *
+   * It is raised when an options object has a key that DisTube does not know,
+   * e.g. `{ emitNewSong: true }` instead of `{ emitNewSongOnly: true }`.
+   */
+  INVALID_KEY: /* @__PURE__ */ __name((obj, key) => `'${key}' does not need to be provided in ${obj}`, "INVALID_KEY"),
+  /**
+   * A required key is missing.
+   *
+   * It is raised when an object does not have a key that DisTube needs.
+   */
+  MISSING_KEY: /* @__PURE__ */ __name((obj, key) => `'${key}' needs to be provided in ${obj}`, "MISSING_KEY"),
+  /**
+   * Several required keys are missing.
+   *
+   * It is raised when an object does not have the keys that DisTube needs.
+   */
+  MISSING_KEYS: /* @__PURE__ */ __name((obj, key, all) => `${key.map((k) => `'${k}'`).join(all ? " and " : " or ")} need to be provided in ${obj}`, "MISSING_KEYS"),
+  /**
+   * The Discord.js client does not have the required intents.
+   *
+   * It is raised when the `GuildVoiceStates` intent is missing: DisTube
+   * cannot work without it.
+   */
+  MISSING_INTENTS: /* @__PURE__ */ __name((i) => `${i} intent must be provided for the Client`, "MISSING_INTENTS"),
+  /**
+   * A DisTube option that is needed is disabled.
+   *
+   * It is raised when a feature cannot work because one of its options is
+   * disabled, e.g. {@link Queue#previous} when
+   * {@link DisTubeOptions.savePreviousSongs} is `false`.
+   */
+  DISABLED_OPTION: /* @__PURE__ */ __name((o) => `DisTubeOptions.${o} is disabled`, "DISABLED_OPTION"),
+  /**
+   * A DisTube option that must be disabled is enabled.
+   *
+   * It is raised when a feature cannot work because one of its options is
+   * enabled.
+   */
+  ENABLED_OPTION: /* @__PURE__ */ __name((o) => `DisTubeOptions.${o} is enabled`, "ENABLED_OPTION"),
+  /**
+   * The user is not in any voice channel.
+   *
+   * It is raised when a command needs the voice channel of the user, but the
+   * user is not connected to any voice channel.
+   */
+  NOT_IN_VOICE: "User is not in any voice channel",
+  /**
+   * The voice channel is full.
+   *
+   * It is raised when the bot cannot join a voice channel because it is
+   * full.
+   */
+  VOICE_FULL: "The voice channel is full",
+  /**
+   * The guild already has a voice connection that DisTube does not manage.
+   *
+   * It is raised when DisTube cannot create a voice connection because
+   * another one already exists in the guild.
+   */
+  VOICE_ALREADY_CREATED: "This guild already has a voice connection which is not managed by DisTube",
+  /**
+   * The voice connection could not be established in time.
+   *
+   * It is raised when the connection did not become ready before
+   * {@link JOIN_TIMEOUT_MS}.
+   */
+  VOICE_CONNECT_FAILED: /* @__PURE__ */ __name((s) => `Cannot connect to the voice channel after ${s} seconds`, "VOICE_CONNECT_FAILED"),
+  /**
+   * The bot does not have the permission to join the voice channel.
+   *
+   * It is raised when the bot cannot join a voice channel because of a missing
+   * permission.
+   */
+  VOICE_MISSING_PERMS: "I do not have permission to join this voice channel",
+  /**
+   * The voice connection could not be restored.
+   *
+   * It is raised when every reconnection attempt of
+   * {@link RECONNECT_MAX_ATTEMPTS} failed.
+   */
+  VOICE_RECONNECT_FAILED: "Cannot reconnect to the voice channel",
+  /**
+   * The voice channel belongs to another guild.
+   *
+   * It is raised when a voice connection is asked to join a voice channel of
+   * another guild.
+   */
+  VOICE_DIFFERENT_GUILD: "Cannot join a voice channel in a different guild",
+  /**
+   * The voice channel belongs to another client.
+   *
+   * It is raised when a voice connection is asked to join a voice channel
+   * that was created by another Discord.js client.
+   */
+  VOICE_DIFFERENT_CLIENT: "Cannot join a voice channel created by a different client",
+  /**
+   * The FFmpeg process exited with an unexpected code.
+   *
+   * It is raised when the FFmpeg process that decodes the audio exits with a
+   * code that is neither `0` nor `255`.
+   */
+  FFMPEG_EXITED: /* @__PURE__ */ __name((code) => `ffmpeg exited with code ${code}`, "FFMPEG_EXITED"),
+  /**
+   * FFmpeg is not installed at the given path.
+   *
+   * It is raised when the FFmpeg executable cannot be spawned, e.g. when
+   * {@link DisTubeOptions.ffmpeg} points to a path that does not exist.
+   */
+  FFMPEG_NOT_INSTALLED: /* @__PURE__ */ __name((path) => `ffmpeg is not installed at '${path}' path`, "FFMPEG_NOT_INSTALLED"),
+  /**
+   * No encryption library is available.
+   *
+   * It is raised when Discord cannot decrypt the audio: neither the
+   * `aes-256-gcm` cipher of Node.js nor one of the supported third-party
+   * encryption libraries is available.
+   */
+  ENCRYPTION_LIBRARIES_MISSING: "Cannot play audio as no valid encryption package is installed and your node doesn't support aes-256-gcm.\nPlease install  @noble/ciphers, @stablelib/xchacha20poly1305, sodium-native or libsodium-wrappers.",
+  /**
+   * The guild does not have a playing queue.
+   *
+   * It is raised when a queue operation is used in a guild that has no
+   * {@link Queue}.
+   */
+  NO_QUEUE: "There is no playing queue in this guild",
+  /**
+   * The guild already has a queue.
+   *
+   * It is raised when a {@link Queue} is created for a guild that already
+   * has one.
+   */
+  QUEUE_EXIST: "This guild has a Queue already",
+  /**
+   * The queue has been stopped already.
+   *
+   * It is raised when an operation needs a running queue, but the queue was
+   * stopped.
+   */
+  QUEUE_STOPPED: "The queue has been stopped already",
+  /**
+   * The queue is already paused.
+   *
+   * It is raised when {@link Queue#pause} is used on a paused queue.
+   */
+  PAUSED: "The queue has been paused already",
+  /**
+   * The queue is already playing.
+   *
+   * It is raised when {@link Queue#resume} is used on a queue that is not
+   * paused.
+   */
+  RESUMED: "The queue has been playing already",
+  /**
+   * The queue does not have any previous song.
+   *
+   * It is raised when {@link Queue#previous} is used on a queue without any
+   * history.
+   */
+  NO_PREVIOUS: "There is no previous song in this queue",
+  /**
+   * The queue does not have any up next song.
+   *
+   * It is raised when a jump goes past the end of the queue while the
+   * autoplay mode is disabled.
+   */
+  NO_UP_NEXT: "There is no up next song",
+  /**
+   * The queue does not have any song at the given position.
+   *
+   * It is raised when {@link Queue#jump} is used with a position that is out
+   * of the bounds of the queue.
+   */
+  NO_SONG_POSITION: "Does not have any song at this position",
+  /**
+   * The queue does not have any playing song.
+   *
+   * It is raised when a related song is requested but the queue is empty.
+   */
+  NO_PLAYING_SONG: "There is no playing song in the queue",
+  /**
+   * The track is stuck and does not produce any audio.
+   *
+   * It is raised when a track stays in the "buffering" state for longer than
+   * {@link DisTubeOptions.stuckThreshold} milliseconds. The queue skips it.
+   */
+  TRACK_STUCK: "The track is stuck and not producing any audio",
+  /**
+   * There is no extractor plugin.
+   *
+   * It is raised when a search is requested but no {@link ExtractorPlugin} is
+   * registered in {@link DisTubeOptions.plugins}.
+   */
+  NO_EXTRACTOR_PLUGIN: "There is no extractor plugin in the DisTubeOptions.plugins, please add one for searching songs",
+  /**
+   * No related song could be found.
+   *
+   * It is raised when the autoplay mode is enabled and no plugin could find
+   * a related song for the current one.
+   */
+  NO_RELATED: "Cannot find any related songs",
+  /**
+   * The related song cannot be played.
+   *
+   * It is raised when the related song of the autoplay mode cannot be
+   * played.
+   */
+  CANNOT_PLAY_RELATED: "Cannot play the related song",
+  /**
+   * The video is unavailable.
+   *
+   * It is raised when the source of the song does not have the video anymore,
+   * e.g. when it was removed or when it is private.
+   */
+  UNAVAILABLE_VIDEO: "This video is unavailable",
+  /**
+   * No playable format was found.
+   *
+   * It is raised when the source of the song does not have any format that
+   * FFmpeg can play.
+   */
+  UNPLAYABLE_FORMATS: "No playable format found",
+  /**
+   * The content is age-restricted and cannot be played in this channel.
+   *
+   * It is raised when an age-restricted song is played in a non-NSFW channel
+   * while {@link DisTubeOptions.nsfw} is `false`.
+   */
+  NON_NSFW: "Cannot play age-restricted content in non-NSFW channel",
+  /**
+   * The url is not supported.
+   *
+   * It is raised when no plugin of {@link DisTubeOptions.plugins} can handle
+   * the url.
+   */
+  NOT_SUPPORTED_URL: "This url is not supported",
+  /**
+   * No plugin supports the song.
+   *
+   * It is raised when no plugin of {@link DisTubeOptions.plugins} can play
+   * the song.
+   */
+  NOT_SUPPORTED_SONG: /* @__PURE__ */ __name((song) => `There is no plugin supporting this song (${song})`, "NOT_SUPPORTED_SONG"),
+  /**
+   * The array does not have any valid song.
+   *
+   * It is raised when every element of the `songs` array of
+   * {@link DisTube#createCustomPlaylist} is neither a {@link Song} nor a
+   * valid url.
+   */
+  NO_VALID_SONG: "'songs' array does not have any valid Song or url",
+  /**
+   * The input cannot be resolved to a song or a playlist.
+   *
+   * It is raised when the input of {@link DisTubeHandler#resolve} is neither
+   * a url, nor a {@link Song}, nor a {@link Playlist}.
+   */
+  CANNOT_RESOLVE_SONG: /* @__PURE__ */ __name((t) => `Cannot resolve ${(0, import_node_util.inspect)(t)} to a Song`, "CANNOT_RESOLVE_SONG"),
+  /**
+   * The stream url of the song cannot be found.
+   *
+   * It is raised when the plugin of the song does not return a stream url.
+   */
+  CANNOT_GET_STREAM_URL: /* @__PURE__ */ __name((song) => `Cannot get stream url with this song (${song})`, "CANNOT_GET_STREAM_URL"),
+  /**
+   * The search query of the song cannot be built.
+   *
+   * It is raised when the plugin of the song cannot build a query to look for
+   * a playable version of it.
+   */
+  CANNOT_GET_SEARCH_QUERY: /* @__PURE__ */ __name((song) => `Cannot get search query with this song (${song})`, "CANNOT_GET_SEARCH_QUERY"),
+  /**
+   * No song was found for the query.
+   *
+   * It is raised when no plugin of {@link DisTubeOptions.plugins} has any
+   * result for the search query.
+   */
+  NO_RESULT: /* @__PURE__ */ __name((query) => `Cannot find any song with this query (${query})`, "NO_RESULT"),
+  /**
+   * The song does not have any stream url.
+   *
+   * It is raised when a song is played while it does not have a stream url
+   * attached to it.
+   */
+  NO_STREAM_URL: /* @__PURE__ */ __name((song) => `No stream url attached (${song})`, "NO_STREAM_URL"),
+  /**
+   * Every video of the playlist was filtered out.
+   *
+   * It is raised when a playlist does not have any valid video left, e.g.
+   * because all of them were age-restricted and the channel is not NSFW.
+   */
+  EMPTY_FILTERED_PLAYLIST: "There is no valid video in the playlist\nMaybe age-restricted contents is filtered because you are in non-NSFW channel",
+  /**
+   * The playlist does not have any valid video.
+   *
+   * It is raised when a playlist is empty.
+   */
+  EMPTY_PLAYLIST: "There is no valid video in the playlist"
+};
+var haveCode = /* @__PURE__ */ __name((code) => Object.keys(ERROR_MESSAGES).includes(code), "haveCode");
+var parseMessage = /* @__PURE__ */ __name((m, ...args) => typeof m === "string" ? m : m(...args), "parseMessage");
+var getErrorMessage = /* @__PURE__ */ __name((code, ...args) => {
+  if (!haveCode(code)) return args[0];
+  try {
+    return parseMessage(ERROR_MESSAGES[code], ...args);
+  } catch {
+    return args[0] ?? code;
+  }
+}, "getErrorMessage");
+var DisTubeError = class _DisTubeError extends Error {
+  static {
+    __name(this, "DisTubeError");
+  }
+  /**
+   * The code of the error, e.g. `NO_RESULT`.
+   */
+  errorCode;
+  /**
+   * Create a DisTube error.
+   * @param code - The code of the error
+   * @param args - The arguments of the message template of the code
+   */
+  constructor(code, ...args) {
+    super(getErrorMessage(code, ...args));
+    this.errorCode = code;
+    if (Error.captureStackTrace) Error.captureStackTrace(this, _DisTubeError);
+  }
+  /**
+   * Create a {@link DisTubeError} with a custom message.
+   *
+   * The default message of an error code is a generic template. Use this factory
+   * when you need to tell the user what exactly went wrong, or when you want to
+   * keep the original error as the `cause` of the error.
+   *
+   * It is polymorphic: calling it on a subclass creates an instance of that
+   * subclass.
+   *
+   * @param code    - The error code
+   * @param message - The custom message
+   * @param options - Optional options
+   * @param options.cause - The original error that caused this one
+   * @returns The created error
+   */
+  static withMessage(code, message, options) {
+    const error = new this(code, message);
+    error.message = message;
+    if (options && "cause" in options) error.cause = options.cause;
+    return error;
+  }
+  /**
+   * The name of the error, with its code.
+   * @returns The name of the error, e.g. `DisTubeError [NO_RESULT]`
+   */
+  get name() {
+    return `DisTubeError [${this.errorCode}]`;
+  }
+  /**
+   * The code of the error, e.g. `NO_RESULT`.
+   *
+   * It is an alias of {@link DisTubeError.errorCode}.
+   * @returns The code of the error
+   */
+  get code() {
+    return this.errorCode;
+  }
+};
+
+// src/util.ts
+var import_node_url = require("url");
+var import_discord3 = require("discord.js");
+
+// src/core/DisTubeVoice.ts
+var import_voice = require("@discordjs/voice");
+var import_discord = require("discord.js");
+var import_tiny_typed_emitter = require("tiny-typed-emitter");
+var DisTubeVoice = class extends import_tiny_typed_emitter.TypedEmitter {
+  static {
+    __name(this, "DisTubeVoice");
+  }
+  /**
+   * The id of the guild of this voice connection.
+   */
+  id;
+  /**
+   * The voice manager that instantiated this connection.
+   */
+  voices;
+  /**
+   * The audio player that plays the audio of this connection.
+   */
+  audioPlayer;
+  /**
+   * The Discord.js voice connection.
+   */
+  connection;
+  /**
+   * Whether or not an error was already emitted for the current stream.
+   *
+   * It prevents the same error from being emitted several times.
+   */
+  emittedError;
+  /**
+   * Whether or not the voice connection has been disconnected.
+   */
+  isDisconnected = false;
+  /**
+   * The stream that is currently playing.
+   */
+  stream;
+  /**
+   * The stream that was playing when the playback was paused.
+   */
+  pausingStream;
+  #channel;
+  #volume = 100;
+  /**
+   * Timer used to detect a track that is stuck in the "buffering" state.
+   */
+  #stuckTimer;
+  /**
+   * Create a voice connection to the voice channel.
+   * @param voiceManager - The voice manager of the DisTube instance
+   * @param channel      - The voice channel to join
+   */
+  constructor(voiceManager, channel) {
+    super();
+    this.voices = voiceManager;
+    this.id = channel.guildId;
+    this.channel = channel;
+    this.voices.add(this.id, this);
+    this.audioPlayer = (0, import_voice.createAudioPlayer)().on(import_voice.AudioPlayerStatus.Idle, (oldState) => {
+      this.#clearStuckTimer();
+      if (oldState.status !== import_voice.AudioPlayerStatus.Idle) this.emit("finish");
+    }).on(import_voice.AudioPlayerStatus.Buffering, () => {
+      this.#startStuckTimer();
+    }).on(import_voice.AudioPlayerStatus.Playing, () => {
+      this.#clearStuckTimer();
+    }).on("error", (error) => {
+      if (this.emittedError) return;
+      this.emittedError = true;
+      this.emit("error", error);
+    });
+    this.connection.on(import_voice.VoiceConnectionStatus.Disconnected, (_, newState) => {
+      if (newState.reason === import_voice.VoiceConnectionDisconnectReason.Manual) {
+        this.leave();
+      } else if (newState.reason === import_voice.VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
+        (0, import_voice.entersState)(this.connection, import_voice.VoiceConnectionStatus.Connecting, RECONNECT_TIMEOUT_MS).catch(() => {
+          if (![import_voice.VoiceConnectionStatus.Ready, import_voice.VoiceConnectionStatus.Connecting].includes(this.connection.state.status)) {
+            this.leave();
+          }
+        });
+      } else if (this.connection.rejoinAttempts < RECONNECT_MAX_ATTEMPTS) {
+        setTimeout(
+          () => {
+            this.connection.rejoin();
+          },
+          (this.connection.rejoinAttempts + 1) * RECONNECT_TIMEOUT_MS
+        ).unref();
+      } else if (this.connection.state.status !== import_voice.VoiceConnectionStatus.Destroyed) {
+        this.leave(new DisTubeError("VOICE_RECONNECT_FAILED"));
+      }
+    }).on(import_voice.VoiceConnectionStatus.Destroyed, () => {
+      this.leave();
+    }).on("error", () => void 0);
+    this.connection.subscribe(this.audioPlayer);
+  }
+  /**
+   * The voice channel id the bot is in
+   */
+  get channelId() {
+    return this.connection?.joinConfig?.channelId ?? void 0;
+  }
+  /**
+   * The voice channel the bot is in.
+   *
+   * Setting it moves the bot to another voice channel.
+   */
+  get channel() {
+    if (!this.channelId) return this.#channel;
+    if (this.#channel?.id === this.channelId) return this.#channel;
+    const channel = this.voices.client.channels.cache.get(this.channelId);
+    if (!channel) return this.#channel;
+    for (const type of import_discord.Constants.VoiceBasedChannelTypes) {
+      if (channel.type === type) {
+        this.#channel = channel;
+        return channel;
+      }
+    }
+    return this.#channel;
+  }
+  /**
+   * Move the bot to another voice channel.
+   * @param channel - The voice channel to join
+   * @throws {@link DisTubeError} When the channel is invalid, when it belongs to
+   * another guild or client, or when the bot cannot join it
+   */
+  set channel(channel) {
+    if (!isSupportedVoiceChannel(channel)) {
+      throw new DisTubeError("INVALID_TYPE", "BaseGuildVoiceChannel", channel, "DisTubeVoice#channel");
+    }
+    if (channel.guildId !== this.id) throw new DisTubeError("VOICE_DIFFERENT_GUILD");
+    if (channel.client.user?.id !== this.voices.client.user?.id) throw new DisTubeError("VOICE_DIFFERENT_CLIENT");
+    if (channel.id === this.channelId) return;
+    if (!channel.joinable) {
+      if (channel.full) throw new DisTubeError("VOICE_FULL");
+      else throw new DisTubeError("VOICE_MISSING_PERMS");
+    }
+    this.connection = this.#join(channel);
+    this.#channel = channel;
+  }
+  #join(channel) {
+    return (0, import_voice.joinVoiceChannel)({
+      channelId: channel.id,
+      guildId: this.id,
+      adapterCreator: channel.guild.voiceAdapterCreator,
+      group: channel.client.user?.id,
+      // DAVE is the end-to-end encryption protocol used by Discord.
+      // It is enabled explicitly so that a change of the upstream default
+      // can never silently disable the encryption.
+      daveEncryption: true
+    });
+  }
+  /**
+   * Join a voice channel with this connection
+   * @param channel - A voice channel
+   * @returns The voice connection
+   * @throws {@link DisTubeError} When the connection cannot be established
+   */
+  async join(channel) {
+    if (channel) this.channel = channel;
+    try {
+      await (0, import_voice.entersState)(this.connection, import_voice.VoiceConnectionStatus.Ready, JOIN_TIMEOUT_MS);
+    } catch {
+      if (this.connection.state.status === import_voice.VoiceConnectionStatus.Ready) return this;
+      if (this.connection.state.status !== import_voice.VoiceConnectionStatus.Destroyed) this.connection.destroy();
+      this.voices.remove(this.id);
+      throw new DisTubeError("VOICE_CONNECT_FAILED", JOIN_TIMEOUT_MS / 1e3);
+    }
+    return this;
+  }
+  /**
+   * Leave the voice channel of this connection
+   * @param error - Optional, an error to emit with 'error' event.
+   * @returns Nothing
+   */
+  leave(error) {
+    this.stop(true);
+    if (!this.isDisconnected) {
+      this.emit("disconnect", error);
+      this.isDisconnected = true;
+    }
+    if (this.connection.state.status !== import_voice.VoiceConnectionStatus.Destroyed) this.connection.destroy();
+    this.voices.remove(this.id);
+  }
+  /**
+   * Stop the playing stream
+   * @param force - If true, will force the {@link DisTubeVoice#audioPlayer} to enter the Idle state even
+   *                if the {@link DisTubeStream#audioResource} has silence padding frames.
+   * @returns Nothing
+   */
+  stop(force = false) {
+    this.audioPlayer.stop(force);
+  }
+  #streamErrorHandler;
+  /**
+   * Play a {@link DisTubeStream}
+   * @param dtStream - DisTubeStream
+   * @returns A promise that resolves when the stream is playing
+   * @throws {@link DisTubeError} When no encryption library is available
+   */
+  async play(dtStream) {
+    if (!await checkEncryptionLibraries()) {
+      dtStream.kill();
+      throw new DisTubeError("ENCRYPTION_LIBRARIES_MISSING");
+    }
+    this.emittedError = false;
+    if (this.stream && this.#streamErrorHandler) {
+      this.stream.off("error", this.#streamErrorHandler);
+    }
+    this.#streamErrorHandler = (error) => {
+      if (this.emittedError || error.code === "ERR_STREAM_PREMATURE_CLOSE") return;
+      this.emittedError = true;
+      this.emit("error", error);
+    };
+    dtStream.on("error", this.#streamErrorHandler);
+    if (this.audioPlayer.state.status !== import_voice.AudioPlayerStatus.Paused) {
+      this.audioPlayer.play(dtStream.audioResource);
+      this.stream?.kill();
+      dtStream.spawn();
+    } else if (!this.pausingStream) {
+      this.pausingStream = this.stream;
+    }
+    this.stream = dtStream;
+    this.volume = this.#volume;
+  }
+  /**
+   * Set the volume percentage of the stream.
+   * @param volume - The volume percentage, from `0` to `100`
+   * @throws {@link DisTubeError} When the volume is not a number, or when it is
+   * negative
+   */
+  set volume(volume) {
+    if (typeof volume !== "number" || Number.isNaN(volume)) {
+      throw new DisTubeError("INVALID_TYPE", "number", volume, "volume");
+    }
+    if (volume < 0) {
+      throw new DisTubeError("NUMBER_COMPARE", "Volume", "bigger or equal to", 0);
+    }
+    this.#volume = volume;
+    this.stream?.setVolume((this.#volume / 100) ** (0.5 / Math.log10(2)));
+  }
+  /**
+   * Get or set the volume percentage
+   */
+  get volume() {
+    return this.#volume;
+  }
+  /**
+   * Playback duration of the audio resource in seconds (time since playback started)
+   */
+  get playbackDuration() {
+    return (this.stream?.audioResource?.playbackDuration ?? 0) / 1e3;
+  }
+  /**
+   * Current playback time in seconds, accounting for seek offset
+   */
+  get playbackTime() {
+    return this.playbackDuration + (this.stream?.seekTime ?? 0);
+  }
+  /**
+   * Pause the playback of the audio player.
+   * @returns Nothing
+   */
+  pause() {
+    this.audioPlayer.pause();
+  }
+  /**
+   * Resume the playback of the audio player.
+   *
+   * The FFmpeg process is spawned again when the stream was killed while the
+   * playback was paused.
+   * @returns Nothing
+   */
+  unpause() {
+    const state = this.audioPlayer.state;
+    if (state.status !== import_voice.AudioPlayerStatus.Paused) return;
+    if (this.stream?.audioResource && state.resource !== this.stream.audioResource) {
+      this.audioPlayer.play(this.stream.audioResource);
+      this.stream.spawn();
+      this.pausingStream?.kill();
+      delete this.pausingStream;
+    } else {
+      this.audioPlayer.unpause();
+    }
+  }
+  /**
+   * Emit an event of the voice connection.
+   *
+   * The special `"error"` event never crashes the process when there is no
+   * listener for it, even when the voice connection is used outside of a
+   * {@link Queue}.
+   * @param event - The event name
+   * @param args  - The event arguments
+   * @returns `true` when the event had listeners, `false` otherwise
+   */
+  emit(event, ...args) {
+    if (event === "error" && this.listenerCount("error") === 0) {
+      handleUnhandledError(args[0], this.voices.options?.unhandledError ?? "log");
+      return false;
+    }
+    return super.emit(event, ...args);
+  }
+  /**
+   * Start the timer that detects a track stuck in the "buffering" state.
+   *
+   * When the track does not start playing within
+   * {@link DisTubeOptions.stuckThreshold} milliseconds, it is reported as an error
+   * so that the queue can skip it.
+   */
+  #startStuckTimer() {
+    const threshold = this.voices.options.stuckThreshold;
+    if (typeof threshold !== "number" || threshold <= 0) return;
+    this.#clearStuckTimer();
+    this.#stuckTimer = setTimeout(() => {
+      this.#stuckTimer = void 0;
+      if (this.emittedError) return;
+      this.emittedError = true;
+      this.emit("error", new DisTubeError("TRACK_STUCK"));
+    }, threshold);
+    this.#stuckTimer.unref?.();
+  }
+  /**
+   * Clear the stuck-track detection timer.
+   */
+  #clearStuckTimer() {
+    if (!this.#stuckTimer) return;
+    clearTimeout(this.#stuckTimer);
+    this.#stuckTimer = void 0;
+  }
+  /**
+   * Whether the bot is self-deafened
+   */
+  get selfDeaf() {
+    return this.connection.joinConfig.selfDeaf;
+  }
+  /**
+   * Whether the bot is self-muted
+   */
+  get selfMute() {
+    return this.connection.joinConfig.selfMute;
+  }
+  /**
+   * Self-deafens/undeafens the bot.
+   * @param selfDeaf - Whether or not the bot should be self-deafened
+   * @returns true if the voice state was successfully updated, otherwise false
+   * @throws {@link DisTubeError} When the value is not a boolean
+   */
+  setSelfDeaf(selfDeaf) {
+    if (typeof selfDeaf !== "boolean") {
+      throw new DisTubeError("INVALID_TYPE", "boolean", selfDeaf, "selfDeaf");
+    }
+    return this.connection.rejoin({
+      ...this.connection.joinConfig,
+      selfDeaf
+    });
+  }
+  /**
+   * Self-mutes/unmutes the bot.
+   * @param selfMute - Whether or not the bot should be self-muted
+   * @returns true if the voice state was successfully updated, otherwise false
+   * @throws {@link DisTubeError} When the value is not a boolean
+   */
+  setSelfMute(selfMute) {
+    if (typeof selfMute !== "boolean") {
+      throw new DisTubeError("INVALID_TYPE", "boolean", selfMute, "selfMute");
+    }
+    return this.connection.rejoin({
+      ...this.connection.joinConfig,
+      selfMute
+    });
+  }
+  /**
+   * The voice state of this connection
+   */
+  get voiceState() {
+    return this.channel?.guild?.members?.me?.voice;
+  }
+};
+
+// src/core/manager/BaseManager.ts
+var import_discord2 = require("discord.js");
+var BaseManager = class extends DisTubeBase {
+  static {
+    __name(this, "BaseManager");
+  }
+  /**
+   * The collection of items for this manager.
+   */
+  collection = new import_discord2.Collection();
+  /**
+   * The size of the collection.
+   */
+  get size() {
+    return this.collection.size;
+  }
+};
+
+// src/core/manager/FilterManager.ts
+var FilterManager = class extends BaseManager {
+  static {
+    __name(this, "FilterManager");
+  }
+  /**
+   * The queue to manage
+   */
+  queue;
+  /**
+   * Create a filter manager for a queue.
+   * @param queue - The queue to manage
+   */
+  constructor(queue) {
+    super(queue.distube);
+    this.queue = queue;
+  }
+  #resolve(filter) {
+    if (typeof filter === "object" && typeof filter.name === "string" && typeof filter.value === "string") {
+      return filter;
+    }
+    if (typeof filter === "string" && Object.hasOwn(this.distube.filters, filter)) {
+      return {
+        name: filter,
+        value: this.distube.filters[filter]
+      };
+    }
+    throw new DisTubeError("INVALID_TYPE", "FilterResolvable", filter, "filter");
+  }
+  #apply() {
+    void this.queue._restartStream().catch((e) => {
+      const errorMessage = e instanceof Error ? e.message : String(e);
+      this.queue.debug(`[${this.queue.id}] Failed to apply the filters: ${errorMessage}`);
+    });
+  }
+  /**
+   * Enable a filter or multiple filters to the manager
+   * @param filterOrFilters - The filter or filters to enable
+   * @param override        - Wether or not override the applied filter with new filter value
+   * @returns This manager, to allow chaining
+   * @throws {@link DisTubeError} When a filter is not a valid {@link FilterResolvable}
+   * @example
+   * ```ts
+   * queue.filters.add("bassboost");
+   * ```
+   */
+  add(filterOrFilters, override = false) {
+    if (Array.isArray(filterOrFilters)) {
+      for (const filter of filterOrFilters) {
+        const ft = this.#resolve(filter);
+        if (override || !this.has(ft)) this.collection.set(ft.name, ft);
+      }
+    } else {
+      const ft = this.#resolve(filterOrFilters);
+      if (override || !this.has(ft)) this.collection.set(ft.name, ft);
+    }
+    this.#apply();
+    return this;
+  }
+  /**
+   * Clear enabled filters of the manager
+   * @returns This manager, to allow chaining
+   */
+  clear() {
+    return this.set([]);
+  }
+  /**
+   * Set the filters applied to the manager
+   * @param filters - The filters to apply
+   * @returns This manager, to allow chaining
+   * @throws {@link DisTubeError} When the array is invalid, or when a filter is
+   * not a valid {@link FilterResolvable}
+   */
+  set(filters) {
+    if (!Array.isArray(filters)) throw new DisTubeError("INVALID_TYPE", "Array<FilterResolvable>", filters, "filters");
+    this.collection.clear();
+    for (const f of filters) {
+      const filter = this.#resolve(f);
+      this.collection.set(filter.name, filter);
+    }
+    this.#apply();
+    return this;
+  }
+  #removeFn(f) {
+    return this.collection.delete(this.#resolve(f).name);
+  }
+  /**
+   * Disable a filter or multiple filters
+   * @param filterOrFilters - The filter or filters to disable
+   * @returns This manager, to allow chaining
+   * @throws {@link DisTubeError} When a filter is not a valid {@link FilterResolvable}
+   */
+  remove(filterOrFilters) {
+    if (Array.isArray(filterOrFilters)) filterOrFilters.forEach((f) => this.#removeFn(f));
+    else this.#removeFn(filterOrFilters);
+    this.#apply();
+    return this;
+  }
+  /**
+   * Check whether a filter enabled or not
+   * @param filter - The filter to check
+   * @returns `true` when the filter is enabled
+   * @throws {@link DisTubeError} When the filter is not a valid {@link FilterResolvable}
+   */
+  has(filter) {
+    return this.collection.has(typeof filter === "string" ? filter : this.#resolve(filter).name);
+  }
+  /**
+   * Array of enabled filter names
+   */
+  get names() {
+    return [...this.collection.keys()];
+  }
+  /**
+   * Array of enabled filters
+   */
+  get values() {
+    return [...this.collection.values()];
+  }
+  /**
+   * The FFmpeg arguments of the enabled filters.
+   *
+   * It is the `af` output argument of the FFmpeg process.
+   */
+  get ffmpegArgs() {
+    return this.size ? { af: this.values.map((f) => f.value).join(",") } : {};
+  }
+  /**
+   * The names of the enabled filters, as a comma separated string.
+   * @returns The names of the enabled filters
+   */
+  toString() {
+    return this.names.toString();
+  }
+};
+
+// src/type.ts
+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["FFMPEG_DEBUG"] = "ffmpegDebug";
+  Events2["DEBUG"] = "debug";
+  return Events2;
+})(Events || {});
+var SearchResultType = /* @__PURE__ */ ((SearchResultType2) => {
+  SearchResultType2["TRACK"] = "track";
+  SearchResultType2["VIDEO"] = "video";
+  SearchResultType2["PLAYLIST"] = "playlist";
+  SearchResultType2["ALBUM"] = "album";
+  SearchResultType2["ARTIST"] = "artist";
+  return SearchResultType2;
+})(SearchResultType || {});
+var RepeatMode = /* @__PURE__ */ ((RepeatMode2) => {
+  RepeatMode2[RepeatMode2["DISABLED"] = 0] = "DISABLED";
+  RepeatMode2[RepeatMode2["SONG"] = 1] = "SONG";
+  RepeatMode2[RepeatMode2["QUEUE"] = 2] = "QUEUE";
+  return RepeatMode2;
+})(RepeatMode || {});
+var PluginType = /* @__PURE__ */ ((PluginType2) => {
+  PluginType2["EXTRACTOR"] = "extractor";
+  PluginType2["INFO_EXTRACTOR"] = "info-extractor";
+  PluginType2["PLAYABLE_EXTRACTOR"] = "playable-extractor";
+  return PluginType2;
+})(PluginType || {});
+
+// src/struct/TaskQueue.ts
+var Task = class {
+  static {
+    __name(this, "Task");
+  }
+  resolve;
+  promise;
+  isPlay;
+  constructor(isPlay) {
+    this.isPlay = isPlay;
+    this.promise = new Promise((res) => {
+      this.resolve = res;
+    });
+  }
+};
+var TaskQueue = class {
+  static {
+    __name(this, "TaskQueue");
+  }
+  /**
+   * The task array
+   */
+  #tasks = [];
+  /**
+   * Waits for last task finished and queues a new task
+   * @param isPlay - Whether the task is a play task
+   * @returns A promise that resolves when the last queued task is finished
+   */
+  queuing(isPlay = false) {
+    const next = this.remaining ? this.#tasks[this.#tasks.length - 1].promise : Promise.resolve();
+    this.#tasks.push(new Task(isPlay));
+    return next;
+  }
+  /**
+   * Removes the finished task and processes the next task
+   * @returns Nothing
+   */
+  resolve() {
+    this.#tasks.shift()?.resolve();
+  }
+  /**
+   * The remaining number of tasks
+   */
+  get remaining() {
+    return this.#tasks.length;
+  }
+  /**
+   * Whether or not having a play task
+   */
+  get hasPlayTask() {
+    return this.#tasks.some((t) => t.isPlay);
+  }
+};
+
+// src/struct/Queue.ts
+var Queue = class extends DisTubeBase {
+  static {
+    __name(this, "Queue");
+  }
+  /**
+   * Queue id (Guild id)
+   */
+  id;
+  /**
+   * Voice connection of this queue.
+   */
+  voice;
+  /**
+   * List of songs in the queue (The first one is the playing song)
+   */
+  songs;
+  /**
+   * List of the previous songs.
+   */
+  previousSongs;
+  /**
+   * Whether stream is currently stopped.
+   */
+  stopped;
+  /**
+   * Whether or not the stream is currently paused.
+   *
+   * It is also `true` once the queue has been stopped, so that `!queue.paused`
+   * stays `false` as soon as the queue is not playing anymore.
+   */
+  paused;
+  /**
+   * Type of repeat mode (`0` is disabled, `1` is repeating a song, `2` is repeating
+   * all the queue). Default value: `0` (disabled)
+   */
+  repeatMode;
+  /**
+   * Whether or not the autoplay mode is enabled. Default value: `false`
+   */
+  autoplay;
+  /**
+   * FFmpeg arguments for the current queue. Default value is defined with {@link DisTubeOptions}.ffmpeg.args.
+   * `af` output argument will be replaced with {@link Queue#filters} manager
+   */
+  ffmpegArgs;
+  /**
+   * The text channel of the Queue. (Default: where the first command is called).
+   */
+  textChannel;
+  /**
+   * What time in the song to begin (in seconds).
+   * @internal
+   */
+  _beginTime;
+  #filters;
+  /**
+   * Whether or not the queue is being updated manually (skip, jump, previous)
+   * @internal
+   */
+  _manualUpdate;
+  /**
+   * Task queuing system
+   * @internal
+   */
+  _taskQueue;
+  /**
+   * {@link DisTubeVoice} listener
+   * @internal
+   */
+  _listeners;
+  /**
+   * Create a queue for the guild
+   * @param distube     - DisTube
+   * @param voice       - Voice connection
+   * @param textChannel - Default text channel
+   */
+  constructor(distube, voice, textChannel) {
+    super(distube);
+    this.voice = voice;
+    this.id = voice.id;
+    this.volume = DEFAULT_VOLUME;
+    this.songs = [];
+    this.previousSongs = [];
+    this.stopped = false;
+    this._manualUpdate = false;
+    this.paused = false;
+    this.repeatMode = 0 /* DISABLED */;
+    this.autoplay = false;
+    this.#filters = new FilterManager(this);
+    this._beginTime = 0;
+    this.textChannel = textChannel;
+    this._taskQueue = new TaskQueue();
+    this._listeners = void 0;
+    this.ffmpegArgs = {
+      global: { ...this.options.ffmpeg.args.global },
+      input: { ...this.options.ffmpeg.args.input },
+      output: { ...this.options.ffmpeg.args.output }
+    };
+  }
+  #addToPreviousSongs(songs) {
+    if (Array.isArray(songs)) {
+      if (this.options.savePreviousSongs) {
+        this.previousSongs.push(...songs);
+      } else {
+        this.previousSongs.push(...songs.map((s) => ({ id: s.id })));
+      }
+    } else if (this.options.savePreviousSongs) {
+      this.previousSongs.push(songs);
+    } else {
+      this.previousSongs.push({ id: songs.id });
+    }
+  }
+  #stop() {
+    this._manualUpdate = true;
+    this.voice.stop();
+  }
+  /**
+   * The client user as a `GuildMember` of this queue's guild
+   */
+  get clientMember() {
+    return this.voice.channel.guild.members.me ?? void 0;
+  }
+  /**
+   * The filter manager of the queue
+   */
+  get filters() {
+    return this.#filters;
+  }
+  /**
+   * Whether or not the queue is still active.
+   *
+   * It is `false` only when the queue has been stopped. A paused queue is still
+   * active.
+   */
+  get isActive() {
+    return !this.stopped;
+  }
+  /**
+   * Formatted duration string.
+   */
+  get formattedDuration() {
+    return formatDuration(this.duration);
+  }
+  /**
+   * Queue's duration.
+   */
+  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).
+   */
+  get currentTime() {
+    return this.voice.playbackTime;
+  }
+  /**
+   * Formatted {@link Queue#currentTime} string.
+   */
+  get formattedCurrentTime() {
+    return formatDuration(this.currentTime);
+  }
+  /**
+   * The voice channel playing in.
+   */
+  get voiceChannel() {
+    return this.clientMember?.voice?.channel ?? null;
+  }
+  /**
+   * Get or set the stream volume. Default value: `50`.
+   */
+  get volume() {
+    return this.voice.volume;
+  }
+  /**
+   * Set the stream volume.
+   * @param value - The volume percentage, from `0` to `100`
+   * @throws {@link DisTubeError} When the volume is not a number, or when it is
+   * negative
+   */
+  set volume(value) {
+    this.voice.volume = value;
+  }
+  /**
+   * Add a song or a list of songs to the 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
+   * @example
+   * ```ts
+   * queue.addToQueue(song);
+   * ```
+   */
+  addToQueue(song, position = 0) {
+    if (this.stopped) throw new DisTubeError("QUEUE_STOPPED");
+    if (!song || Array.isArray(song) && !song.length) {
+      throw new DisTubeError("INVALID_TYPE", ["Song", "Array<Song>"], song, "song");
+    }
+    if (typeof position !== "number" || !Number.isInteger(position)) {
+      throw new DisTubeError("INVALID_TYPE", "integer", position, "position");
+    }
+    if (position <= 0) {
+      if (Array.isArray(song)) this.songs.push(...song);
+      else this.songs.push(song);
+    } else if (Array.isArray(song)) {
+      this.songs.splice(position, 0, ...song);
+    } else {
+      this.songs.splice(position, 0, song);
+    }
+    return this;
+  }
+  /**
+  /**
+   * Pause the guild stream
+   * @returns The guild queue
+   * @throws {@link DisTubeError} When the queue is already paused
+   * @example
+   * ```ts
+   * await queue.pause();
+   * ```
+   */
+  async pause() {
+    await this._taskQueue.queuing();
+    try {
+      if (this.paused) throw new DisTubeError("PAUSED");
+      this.paused = true;
+      this.voice.pause();
+      return this;
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+  /**
+   * Resume the guild stream
+   * @returns The guild queue
+   * @throws {@link DisTubeError} When the queue is not paused
+   * @example
+   * ```ts
+   * await queue.resume();
+   * ```
+   */
+  async resume() {
+    await this._taskQueue.queuing();
+    try {
+      if (!this.paused) throw new DisTubeError("RESUMED");
+      this.paused = false;
+      this.voice.unpause();
+      return this;
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+  /**
+   * Set the guild stream's volume
+   * @param percent - The percentage of volume you want to set
+   * @returns The guild queue
+   * @throws {@link DisTubeError} When the volume is not a number, or when it is
+   * negative
+   */
+  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>
+   * @param options - Skip options
+   * @returns The song will skip to
+   * @throws {@link DisTubeError} When there is no up next song, or when the
+   * position is out of the bounds of the queue
+   * @example
+   * ```ts
+   * await queue.skip();
+   * ```
+   */
+  async skip(options) {
+    return this.jump(1, options);
+  }
+  /**
+   * Play the previous song if exists
+   * @returns The guild queue
+   * @throws {@link DisTubeError} When {@link DisTubeOptions.savePreviousSongs} is
+   * disabled, or when the queue does not have any previous song
+   */
+  async previous() {
+    await this._taskQueue.queuing();
+    try {
+      if (!this.options.savePreviousSongs) throw new DisTubeError("DISABLED_OPTION", "savePreviousSongs");
+      const hasPrevious = this.previousSongs.length > 0;
+      if (!hasPrevious && this.repeatMode !== 2 /* QUEUE */) {
+        throw new DisTubeError("NO_PREVIOUS");
+      }
+      const song = hasPrevious ? this.previousSongs.pop() : this.songs.pop();
+      if (!song) throw new DisTubeError("NO_PREVIOUS");
+      this.songs.unshift(song);
+      this.#stop();
+      return song;
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+  /**
+   * Shuffle the queue's songs
+   * @returns The guild queue
+   */
+  async shuffle() {
+    await this._taskQueue.queuing();
+    try {
+      const playing = this.songs.shift();
+      if (playing === void 0) return this;
+      for (let i = this.songs.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [this.songs[i], this.songs[j]] = [this.songs[j], this.songs[i]];
+      }
+      this.songs.unshift(playing);
+      return this;
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+  /**
+   * 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
+   * @param options  - Skip options
+   * @returns The new Song will be played
+   * @throws {@link DisTubeError} When the position is invalid, when there is no
+   * up next song, or when {@link DisTubeOptions.savePreviousSongs} is disabled
+   * and the jump is backwards
+   */
+  async jump(position, options) {
+    await this._taskQueue.queuing();
+    try {
+      if (typeof position !== "number") throw new DisTubeError("INVALID_TYPE", "number", position, "position");
+      if (!position || position > this.songs.length || -position > this.previousSongs.length) {
+        throw new DisTubeError("NO_SONG_POSITION");
+      }
+      if (position > 0) {
+        if (position >= this.songs.length) {
+          if (this.autoplay) {
+            await this._addRelatedSong();
+          } else {
+            throw new DisTubeError("NO_UP_NEXT");
+          }
+        }
+        const skipped = this.songs.splice(0, position);
+        if (options?.requeue) {
+          this.songs.push(...skipped);
+        } else {
+          this.#addToPreviousSongs(skipped);
+        }
+      } else if (!this.options.savePreviousSongs) {
+        throw new DisTubeError("DISABLED_OPTION", "savePreviousSongs");
+      } else {
+        const skipped = this.previousSongs.splice(position);
+        this.songs.unshift(...skipped);
+      }
+      this.#stop();
+      return this.songs[0];
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+  /**
+   * Set the repeat mode of the guild queue.
+   * Toggle mode `(Disabled -> Song -> Queue -> Disabled ->...)` if `mode` is `undefined`
+   * @param mode - The repeat modes (toggle if `undefined`)
+   * @returns The new repeat mode
+   * @throws {@link DisTubeError} When the mode is not a valid {@link RepeatMode}
+   */
+  setRepeatMode(mode) {
+    if (mode !== void 0 && !Object.values(RepeatMode).includes(mode)) {
+      throw new DisTubeError("INVALID_TYPE", ["RepeatMode", "undefined"], mode, "mode");
+    }
+    if (mode === void 0) this.repeatMode = (this.repeatMode + 1) % 3;
+    else if (this.repeatMode === mode) this.repeatMode = 0 /* DISABLED */;
+    else this.repeatMode = mode;
+    return this.repeatMode;
+  }
+  /**
+   * Set the playing time to another position
+   * @param time - Time in seconds
+   * @returns The guild queue
+   * @throws {@link DisTubeError} When the time is not a number, or when it is
+   * negative
+   * @example
+   * ```ts
+   * await queue.seek(60);
+   * ```
+   */
+  async seek(time) {
+    await this._taskQueue.queuing();
+    try {
+      if (typeof time !== "number") throw new DisTubeError("INVALID_TYPE", "number", time, "time");
+      if (Number.isNaN(time) || time < 0) throw new DisTubeError("NUMBER_COMPARE", "time", "bigger or equal to", 0);
+      this._beginTime = time;
+      await this.play(false);
+      return this;
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+  async #getRelatedSong(current) {
+    const plugin = await this.handler._getPluginFromSong(current);
+    if (plugin) return plugin.getRelatedSongs(current);
+    return [];
+  }
+  /**
+   * Internal implementation of addRelatedSong without task queue protection.
+   * Used by methods that already hold the task queue lock.
+   * @param song - The song to get related songs from. Defaults to the current playing song.
+   * @returns A promise that resolves to the added song
+   * @throws {@link DisTubeError} When the queue does not have any playing song,
+   * or when no related song could be found
+   * @internal
+   */
+  async _addRelatedSong(song) {
+    const current = song ?? this.songs?.[0];
+    if (!current) throw new DisTubeError("NO_PLAYING_SONG");
+    const prevIds = this.previousSongs.map((p) => p.id);
+    const relatedSongs = (await this.#getRelatedSong(current)).filter((s) => !prevIds.includes(s.id));
+    this.debug(`[${this.id}] Getting related songs from: ${current}`);
+    if (!relatedSongs.length && !current.stream.playFromSource) {
+      const altSong = current.stream.song;
+      if (altSong) relatedSongs.push(...(await this.#getRelatedSong(altSong)).filter((s) => !prevIds.includes(s.id)));
+      this.debug(`[${this.id}] Getting related songs from streamed song: ${altSong}`);
+    }
+    const nextSong = relatedSongs[0];
+    if (!nextSong) throw new DisTubeError("NO_RELATED");
+    nextSong.metadata = current.metadata;
+    nextSong.member = this.clientMember;
+    this.addToQueue(nextSong);
+    return nextSong;
+  }
+  /**
+   * Add a related song of the playing song to the queue
+   * @param song - The song to get related songs from. Defaults to the current playing song.
+   * @returns The added song
+   * @throws {@link DisTubeError} When the queue does not have any playing song,
+   * or when no related song could be found
+   */
+  async addRelatedSong(song) {
+    await this._taskQueue.queuing();
+    try {
+      return await this._addRelatedSong(song);
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+  /**
+   * Stop the guild stream and delete the queue
+   * @returns A promise that resolves when the queue is stopped
+   */
+  async stop() {
+    await this._taskQueue.queuing();
+    try {
+      this.voice.stop();
+      this.remove();
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+  /**
+   * Remove the queue from the manager
+   * @returns Nothing
+   */
+  remove() {
+    this.paused = true;
+    this.stopped = true;
+    this.songs = [];
+    this.previousSongs = [];
+    if (this._listeners) for (const event of objectKeys(this._listeners)) this.voice.off(event, this._listeners[event]);
+    this.queues.remove(this.id);
+    this.emit("deleteQueue" /* DELETE_QUEUE */, this);
+  }
+  /**
+   * Toggle autoplay mode
+   * @returns Autoplay mode state
+   */
+  toggleAutoplay() {
+    this.autoplay = !this.autoplay;
+    return this.autoplay;
+  }
+  /**
+   * Play the first song in the queue
+   * @param emitPlaySong - Whether or not emit {@link Events.PLAY_SONG} event
+   * @returns A promise that resolves when the song is playing
+   * @throws {@link DisTubeError} When the queue has been stopped
+   */
+  play(emitPlaySong = true) {
+    if (this.stopped) throw new DisTubeError("QUEUE_STOPPED");
+    return this.queues.playSong(this, emitPlaySong);
+  }
+  /**
+   * Restart the current stream with the current FFmpeg arguments, keeping the
+   * playback position.
+   *
+   * The FFmpeg audio filters are applied when the stream is created, so the stream
+   * has to be recreated whenever the filters change.
+   *
+   * Unlike a regular playback error, a failure while restarting the stream does
+   * **not** remove the current song from the queue.
+   * @returns A promise that resolves when the stream is restarted
+   * @internal
+   */
+  async _restartStream() {
+    await this._taskQueue.queuing(true);
+    try {
+      if (this.stopped || !this.songs.length) return;
+      this._beginTime = this.currentTime;
+      await this.queues.playSong(this, false, { keepSongOnError: true });
+    } finally {
+      this._taskQueue.resolve();
+    }
+  }
+};
+
+// src/util.ts
+var formatInt = /* @__PURE__ */ __name((int) => int < 10 ? `0${int}` : int, "formatInt");
+function formatDuration(sec) {
+  if (!sec || !Number(sec)) return "00:00";
+  const seconds = Math.floor(sec % 60);
+  const minutes = Math.floor(sec % 3600 / 60);
+  const hours = Math.floor(sec / 3600);
+  if (hours > 0) return `${formatInt(hours)}:${formatInt(minutes)}:${formatInt(seconds)}`;
+  if (minutes > 0) return `${formatInt(minutes)}:${formatInt(seconds)}`;
+  return `00:${formatInt(seconds)}`;
+}
+__name(formatDuration, "formatDuration");
+var SUPPORTED_PROTOCOL = ["https:", "http:", "file:"];
+function isURL(input) {
+  if (typeof input !== "string" || input.includes(" ")) return false;
+  try {
+    const url = new import_node_url.URL(input);
+    if (!SUPPORTED_PROTOCOL.some((p) => p === url.protocol)) return false;
+  } catch {
+    return false;
+  }
+  return true;
+}
+__name(isURL, "isURL");
+function checkIntents(options) {
+  const intents = options.intents;
+  const hasVoiceStates = typeof intents?.has === "function" ? intents.has(import_discord3.GatewayIntentBits.GuildVoiceStates) : new import_discord3.IntentsBitField(options.intents).has(import_discord3.GatewayIntentBits.GuildVoiceStates);
+  if (!hasVoiceStates) throw new DisTubeError("MISSING_INTENTS", "GuildVoiceStates");
+}
+__name(checkIntents, "checkIntents");
+function isVoiceChannelEmpty(voiceState) {
+  const guild = voiceState.guild;
+  const clientId = voiceState.client.user?.id;
+  if (!guild || !clientId) return false;
+  const voiceChannel = guild.members.me?.voice?.channel;
+  if (!voiceChannel) return false;
+  const members = voiceChannel.members.filter((m) => !m.user.bot);
+  return !members.size;
+}
+__name(isVoiceChannelEmpty, "isVoiceChannelEmpty");
+function isSnowflake(id) {
+  try {
+    return import_discord3.SnowflakeUtil.deconstruct(id).timestamp > import_discord3.SnowflakeUtil.epoch;
+  } catch {
+    return false;
+  }
+}
+__name(isSnowflake, "isSnowflake");
+function isMemberInstance(member) {
+  return Boolean(member) && isSnowflake(member.id) && isSnowflake(member.guild?.id) && isSnowflake(member.user?.id) && member.id === member.user.id;
+}
+__name(isMemberInstance, "isMemberInstance");
+function isTextChannelInstance(channel) {
+  return Boolean(channel) && isSnowflake(channel.id) && isSnowflake(channel.guildId || channel.guild?.id) && import_discord3.Constants.TextBasedChannelTypes.includes(channel.type) && typeof channel.send === "function" && (typeof channel.nsfw === "boolean" || typeof channel.parent?.nsfw === "boolean");
+}
+__name(isTextChannelInstance, "isTextChannelInstance");
+function isMessageInstance(message) {
+  return Boolean(message) && isSnowflake(message.id) && isSnowflake(message.guildId || message.guild?.id) && 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 Boolean(channel) && isSnowflake(channel.id) && isSnowflake(channel.guildId || channel.guild?.id) && import_discord3.Constants.VoiceBasedChannelTypes.includes(channel.type);
+}
+__name(isSupportedVoiceChannel, "isSupportedVoiceChannel");
+function isGuildInstance(guild) {
+  return Boolean(guild) && isSnowflake(guild.id) && isSnowflake(guild.ownerId) && typeof guild.name === "string";
+}
+__name(isGuildInstance, "isGuildInstance");
+function resolveGuildId(resolvable) {
+  let guildId;
+  if (typeof resolvable === "string") {
+    guildId = resolvable;
+  } else if (isObject(resolvable)) {
+    if ("guildId" in resolvable && resolvable.guildId) {
+      guildId = resolvable.guildId;
+    } else if (resolvable instanceof Queue || resolvable instanceof DisTubeVoice || isGuildInstance(resolvable)) {
+      guildId = resolvable.id;
+    } else if ("guild" in resolvable && isGuildInstance(resolvable.guild)) {
+      guildId = resolvable.guild.id;
+    }
+  }
+  if (!isSnowflake(guildId)) throw new DisTubeError("INVALID_TYPE", "GuildIdResolvable", resolvable);
+  return guildId;
+}
+__name(resolveGuildId, "resolveGuildId");
+function isClientInstance(client) {
+  return Boolean(client) && typeof client.login === "function";
+}
+__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 : objectKeys(source);
+  const invalidKey = objectKeys(target).find((key) => !sourceKeys.includes(key));
+  if (invalidKey) throw new DisTubeError("INVALID_KEY", sourceName, invalidKey);
+}
+__name(checkInvalidKey, "checkInvalidKey");
+function isObject(obj) {
+  return typeof obj === "object" && obj !== null && !Array.isArray(obj);
+}
+__name(isObject, "isObject");
+function objectKeys(obj) {
+  if (!isObject(obj)) return [];
+  return Object.keys(obj);
+}
+__name(objectKeys, "objectKeys");
+function isNsfwChannel(channel) {
+  if (!isTextChannelInstance(channel)) return false;
+  if (channel.isThread()) return channel.parent?.nsfw ?? false;
+  return channel.nsfw;
+}
+__name(isNsfwChannel, "isNsfwChannel");
+var isTruthy = /* @__PURE__ */ __name((x) => Boolean(x), "isTruthy");
+function handleUnhandledError(error, behavior = "log") {
+  if (behavior === "throw") throw error;
+  if (behavior === "ignore") return;
+  process.emitWarning(
+    "The 'error' event was emitted but there is no listener for it. Add a listener with `distube.on(Events.ERROR, (error, queue, song) => { ... })` to handle DisTube errors, or set `unhandledError` to 'throw' to restore the default behavior.",
+    {
+      code: "DIS_TUBE_UNHANDLED_ERROR",
+      detail: error?.stack ?? error?.message ?? String(error)
+    }
+  );
+}
+__name(handleUnhandledError, "handleUnhandledError");
+var checkEncryptionLibraries = /* @__PURE__ */ __name(async () => {
+  if (await import("crypto").then((m) => m.getCiphers().includes("aes-256-gcm"))) return true;
+  for (const lib of [
+    "@noble/ciphers",
+    "@stablelib/xchacha20poly1305",
+    "sodium-native",
+    "sodium",
+    "libsodium-wrappers",
+    "tweetnacl"
+  ]) {
+    try {
+      await import(lib);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}, "checkEncryptionLibraries");
+
+// src/struct/Playlist.ts
+var Playlist = class {
+  static {
+    __name(this, "Playlist");
+  }
+  /**
+   * Playlist source.
+   */
+  source;
+  /**
+   * Songs in the playlist.
+   */
+  songs;
+  /**
+   * Playlist ID.
+   */
+  id;
+  /**
+   * Playlist name.
+   */
+  name;
+  /**
+   * Playlist URL.
+   */
+  url;
+  /**
+   * Playlist thumbnail.
+   */
+  thumbnail;
+  #metadata;
+  #member;
+  /**
+   * Create a Playlist
+   * @param playlist  - Raw playlist info
+   * @param options   - Optional data
+   * @param options.member   - The user that requested the playlist
+   * @param options.metadata - The metadata of the playlist
+   * @throws {@link DisTubeError} When the playlist does not have any song
+   */
+  constructor(playlist, { member, metadata } = {}) {
+    if (!Array.isArray(playlist.songs) || !playlist.songs.length) throw new DisTubeError("EMPTY_PLAYLIST");
+    this.source = playlist.source.toLowerCase();
+    this.songs = playlist.songs;
+    this.name = playlist.name;
+    this.id = playlist.id;
+    this.url = playlist.url;
+    this.thumbnail = playlist.thumbnail;
+    this.member = member;
+    this.songs.forEach((s) => s.playlist = this);
+    this.metadata = metadata;
+  }
+  /**
+   * Playlist duration in second.
+   */
+  get duration() {
+    return this.songs.reduce((prev, next) => prev + next.duration, 0);
+  }
+  /**
+   * Formatted duration string `hh:mm:ss`.
+   */
+  get formattedDuration() {
+    return formatDuration(this.duration);
+  }
+  /**
+   * User requested.
+   */
+  get member() {
+    return this.#member;
+  }
+  /**
+   * Set the user that requested the playlist.
+   *
+   * The value is ignored when it is not a valid guild member.
+   * @param member - The member
+   */
+  set member(member) {
+    if (!isMemberInstance(member)) return;
+    this.#member = member;
+    this.songs.forEach((s) => s.member = this.member);
+  }
+  /**
+   * User requested.
+   */
+  get user() {
+    return this.member?.user;
+  }
+  /**
+   * Optional metadata that can be used to identify the playlist.
+   */
+  get metadata() {
+    return this.#metadata;
+  }
+  /**
+   * Set the metadata of the playlist.
+   *
+   * The metadata of the songs is not changed when the metadata is `undefined`.
+   * @param metadata - The metadata
+   */
+  set metadata(metadata) {
+    this.#metadata = metadata;
+    if (metadata === void 0) return;
+    this.songs.forEach((s) => s.metadata = metadata);
+  }
+  /**
+   * The name of the playlist and the number of its songs.
+   * @returns The string representation of the playlist
+   */
+  toString() {
+    return `${this.name} (${this.songs.length} songs)`;
+  }
+};
+
+// src/struct/Song.ts
+var Song = class {
+  static {
+    __name(this, "Song");
+  }
+  /**
+   * The source of this song info
+   */
+  source;
+  /**
+   * Song ID.
+   */
+  id;
+  /**
+   * Song name.
+   */
+  name;
+  /**
+   * Indicates if the song is an active live.
+   */
+  isLive;
+  /**
+   * Song duration.
+   */
+  duration;
+  /**
+   * Formatted duration string (`hh:mm:ss`, `mm:ss` or `Live`).
+   */
+  formattedDuration;
+  /**
+   * Song URL.
+   */
+  url;
+  /**
+   * Song thumbnail.
+   */
+  thumbnail;
+  /**
+   * Song view count
+   */
+  views;
+  /**
+   * Song like count
+   */
+  likes;
+  /**
+   * Song dislike count
+   */
+  dislikes;
+  /**
+   * Song repost (share) count
+   */
+  reposts;
+  /**
+   * Song uploader
+   */
+  uploader;
+  /**
+   * Whether or not an age-restricted content
+   */
+  ageRestricted;
+  /**
+   * Stream info
+   */
+  stream;
+  /**
+   * The plugin that created this song
+   */
+  plugin;
+  #metadata;
+  #member;
+  #playlist;
+  /**
+   * Create a Song
+   *
+   * @param info      - Raw song info
+   * @param options   - Optional data
+   * @param options.member   - The user that requested the song
+   * @param options.metadata - The metadata of the song
+   */
+  constructor(info, { member, metadata } = {}) {
+    this.source = info.source.toLowerCase();
+    this.metadata = metadata ?? info.metadata;
+    this.member = member;
+    this.id = info.id;
+    this.name = info.name;
+    this.isLive = info.isLive;
+    this.duration = this.isLive || !info.duration ? 0 : info.duration;
+    this.formattedDuration = this.isLive ? "Live" : formatDuration(this.duration);
+    this.url = info.url;
+    this.thumbnail = info.thumbnail;
+    this.views = info.views;
+    this.likes = info.likes;
+    this.dislikes = info.dislikes;
+    this.reposts = info.reposts;
+    this.uploader = {
+      name: info.uploader?.name,
+      url: info.uploader?.url
+    };
+    this.ageRestricted = info.ageRestricted;
+    this.stream = { playFromSource: info.playFromSource && info.plugin?.playable !== false };
+    this.plugin = info.plugin;
+  }
+  /**
+   * The playlist this song belongs to
+   */
+  get playlist() {
+    return this.#playlist;
+  }
+  /**
+   * Set the playlist this song belongs to.
+   * @param playlist - The playlist
+   * @throws {@link DisTubeError} When the value is not a {@link Playlist}
+   */
+  set playlist(playlist) {
+    if (!(playlist instanceof Playlist)) throw new DisTubeError("INVALID_TYPE", "Playlist", playlist, "Song#playlist");
+    this.#playlist = playlist;
+    this.member = playlist.member;
+  }
+  /**
+   * User requested to play this song.
+   */
+  get member() {
+    return this.#member;
+  }
+  /**
+   * Set the user that requested this song.
+   *
+   * The value is ignored when it is not a valid guild member.
+   * @param member - The member
+   */
+  set member(member) {
+    if (isMemberInstance(member)) this.#member = member;
+  }
+  /**
+   * User requested to play this song.
+   */
+  get user() {
+    return this.member?.user;
+  }
+  /**
+   * Optional metadata that can be used to identify the song. This is attached by the
+   * {@link DisTube#play} method.
+   */
+  get metadata() {
+    return this.#metadata;
+  }
+  /**
+   * Set the metadata of the song.
+   * @param metadata - The metadata
+   */
+  set metadata(metadata) {
+    this.#metadata = metadata;
+  }
+  /**
+   * The name of the song, or its url, or its id.
+   * @returns The string representation of the song
+   */
+  toString() {
+    return this.name || this.url || this.id || "Unknown";
+  }
+};
+
+// src/core/DisTubeHandler.ts
+var DisTubeHandler = class extends DisTubeBase {
+  static {
+    __name(this, "DisTubeHandler");
+  }
+  /**
+   * Resolve a url or a supported object to a {@link Song} or {@link Playlist}
+   * @throws {@link DisTubeError}
+   * @param input   - Resolvable input
+   * @param options - Optional options
+   * @returns Resolved
+   */
+  async resolve(input, options = {}) {
+    if (input instanceof Song || input instanceof Playlist) {
+      if ("metadata" in options) input.metadata = options.metadata;
+      if ("member" in options) input.member = options.member;
+      return input;
+    }
+    if (typeof input === "string") {
+      if (isURL(input)) {
+        const plugin = await this._getPluginFromURL(input) || await this._getPluginFromURL(input = await this.followRedirectLink(input));
+        if (!plugin) throw new DisTubeError("NOT_SUPPORTED_URL");
+        this.debug(`[${plugin.constructor.name}] Resolving from url: ${input}`);
+        return plugin.resolve(input, options);
+      }
+      try {
+        const song = await this.#searchSong(input, options);
+        if (song) return song;
+      } catch (e) {
+        const error = new DisTubeError("NO_RESULT", input);
+        error.cause = e;
+        throw error;
+      }
+    }
+    throw new DisTubeError("CANNOT_RESOLVE_SONG", input);
+  }
+  /**
+   * Find the plugin that supports the given url.
+   * @param url - The url to check
+   * @returns The plugin, or `null` when there is none
+   */
+  async _getPluginFromURL(url) {
+    for (const plugin of this.plugins) if (await plugin.validate(url)) return plugin;
+    return null;
+  }
+  async _getPluginFromSong(song, types, validate = true) {
+    if (!types || types.includes(song.plugin?.type)) return song.plugin;
+    if (!song.url) return null;
+    for (const plugin of this.plugins) {
+      if ((!types || types.includes(plugin?.type)) && (!validate || await plugin.validate(song.url))) {
+        return plugin;
+      }
+    }
+    return null;
+  }
+  async #searchSong(query, options = {}, getStreamURL = false) {
+    const source = options.source?.toLowerCase();
+    const plugins = this.plugins.filter(
+      (plugin) => plugin.type === "extractor" /* EXTRACTOR */ && (!source || plugin.identifiers.includes(source))
+    );
+    if (!plugins.length) throw new DisTubeError("NO_EXTRACTOR_PLUGIN");
+    for (const plugin of plugins) {
+      this.debug(`[${plugin.constructor.name}] Searching for song: ${query}`);
+      const result = await plugin.searchSong(query, options);
+      if (result) {
+        if (getStreamURL && result.stream.playFromSource) result.stream.url = await plugin.getStreamURL(result);
+        return result;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get {@link Song}'s stream info and attach it to the song.
+   * @param song - A Song
+   * @returns A promise that resolves when the stream info is attached
+   * @throws {@link DisTubeError} When no plugin supports the song, or when its
+   * stream URL cannot be found
+   */
+  async attachStreamInfo(song) {
+    if (song.stream.playFromSource) {
+      if (song.stream.url) return;
+      this.debug(`[DisTubeHandler] Getting stream info: ${song}`);
+      const plugin = await this._getPluginFromSong(song, ["extractor" /* EXTRACTOR */, "playable-extractor" /* PLAYABLE_EXTRACTOR */]);
+      if (!plugin) throw new DisTubeError("NOT_SUPPORTED_SONG", song.toString());
+      this.debug(`[${plugin.constructor.name}] Getting stream URL: ${song}`);
+      song.stream.url = await plugin.getStreamURL(song);
+      if (!song.stream.url) throw new DisTubeError("CANNOT_GET_STREAM_URL", song.toString());
+    } else {
+      if (song.stream.song?.stream?.playFromSource && song.stream.song.stream.url) return;
+      this.debug(`[DisTubeHandler] Getting stream info: ${song}`);
+      const source = song.plugin;
+      const query = source ? await source.createSearchQuery(song) : `${song.name ?? ""} ${song.uploader?.name ?? ""}`.trim();
+      if (!query) throw new DisTubeError("CANNOT_GET_SEARCH_QUERY", song.toString());
+      const altSong = await this.#findPlayableSong(query, song, source);
+      song.stream.song = altSong;
+    }
+  }
+  /**
+   * Look for a playable version of a song with the plugins that can search.
+   *
+   * Every searchable plugin is tried, in the order they were registered, until
+   * one of them has a result.
+   * @param query  - The search query
+   * @param song   - The song that cannot be played
+   * @param source - The plugin that resolved the song
+   * @returns The playable song
+   */
+  async #findPlayableSong(query, song, source) {
+    const options = { metadata: song.metadata, member: song.member };
+    for (const plugin of this.plugins) {
+      if (plugin === source) continue;
+      if (plugin.playable === false) continue;
+      const result = await plugin.searchSong(query, options);
+      if (!result) continue;
+      if (!result.stream.playFromSource) continue;
+      this.debug(`[${plugin.constructor.name}] Found a playable version of "${query}"`);
+      result.stream.url = await plugin.getStreamURL(result);
+      return result;
+    }
+    throw new DisTubeError("NO_RESULT", query);
+  }
+  /**
+   * Follow the redirections of an url.
+   * @param url        - The url to follow
+   * @param maxRedirect - The maximum number of redirections to follow
+   * @returns The final url
+   */
+  async followRedirectLink(url, maxRedirect = MAX_REDIRECT_DEPTH) {
+    if (maxRedirect === 0) return url;
+    const res = await (0, import_undici.request)(url, {
+      method: "HEAD",
+      headers: {
+        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.3"
+      }
+    });
+    if (HTTP_REDIRECT_CODES.has(res.statusCode ?? 200)) {
+      let location = res.headers.location;
+      if (typeof location !== "string") location = location?.[0] ?? url;
+      return this.followRedirectLink(location, --maxRedirect);
+    }
+    return url;
+  }
+};
+
+// src/core/DisTubeOptions.ts
+var UNHANDLED_ERROR_BEHAVIORS = ["log", "throw", "ignore"];
+var Options = class {
+  static {
+    __name(this, "Options");
+  }
+  /**
+   * The plugins of the DisTube instance.
+   */
+  plugins;
+  /**
+   * Whether or not the {@link Events.PLAY_SONG} event is emitted when looping a
+   * song or when the next song is the same as the previous one.
+   * @default false
+   */
+  emitNewSongOnly;
+  /**
+   * Whether or not the previous songs of a {@link Queue} are saved.
+   * @default true
+   */
+  savePreviousSongs;
+  /**
+   * The custom FFmpeg audio filters, that override the {@link defaultFilters}.
+   */
+  customFilters;
+  /**
+   * Whether or not age-restricted content can be played in a non-NSFW channel.
+   * @default false
+   */
+  nsfw;
+  /**
+   * Whether or not the {@link Events.ADD_SONG} event is emitted when a new
+   * {@link Queue} is created.
+   * @default true
+   */
+  emitAddSongWhenCreatingQueue;
+  /**
+   * Whether or not the {@link Events.ADD_LIST} event is emitted when a new
+   * {@link Queue} is created.
+   * @default true
+   */
+  emitAddListWhenCreatingQueue;
+  /**
+   * Whether or not the bot joins the new voice channel when
+   * {@link DisTube#play} is used.
+   * @default true
+   */
+  joinNewVoiceChannel;
+  /**
+   * The behavior of the {@link Events.ERROR} event when it has no listener.
+   * @default "log"
+   */
+  unhandledError;
+  /**
+   * The time (in milliseconds) a track may stay in the "buffering" state before
+   * it is considered stuck and gets skipped.
+   *
+   * Set to `0` to disable the stuck-track detection.
+   * @default 10000
+   */
+  stuckThreshold;
+  /**
+   * The FFmpeg options of the DisTube instance.
+   */
+  ffmpeg;
+  /**
+   * Create the options of a {@link DisTube} instance.
+   * @param options - The options given by the user
+   * @throws {@link DisTubeError} When an option has an invalid type, or when it
+   * is not a known option
+   */
+  constructor(options) {
+    if (typeof options !== "object" || Array.isArray(options)) {
+      throw new DisTubeError("INVALID_TYPE", "object", options, "DisTubeOptions");
+    }
+    const opts = { ...defaultOptions, ...options };
+    this.plugins = opts.plugins;
+    this.emitNewSongOnly = opts.emitNewSongOnly;
+    this.savePreviousSongs = opts.savePreviousSongs;
+    this.customFilters = opts.customFilters;
+    this.nsfw = opts.nsfw;
+    this.emitAddSongWhenCreatingQueue = opts.emitAddSongWhenCreatingQueue;
+    this.emitAddListWhenCreatingQueue = opts.emitAddListWhenCreatingQueue;
+    this.joinNewVoiceChannel = opts.joinNewVoiceChannel;
+    this.unhandledError = opts.unhandledError;
+    this.stuckThreshold = opts.stuckThreshold;
+    this.ffmpeg = this.#ffmpegOption(options);
+    checkInvalidKey(opts, this, "DisTubeOptions");
+    this.#validateOptions();
+  }
+  #validateOptions(options = this) {
+    const booleanOptions = /* @__PURE__ */ new Set([
+      "emitNewSongOnly",
+      "savePreviousSongs",
+      "joinNewVoiceChannel",
+      "nsfw",
+      "emitAddSongWhenCreatingQueue",
+      "emitAddListWhenCreatingQueue"
+    ]);
+    const numberOptions = /* @__PURE__ */ new Set(["stuckThreshold"]);
+    const stringOptions = /* @__PURE__ */ new Set(["unhandledError"]);
+    const objectOptions = /* @__PURE__ */ new Set(["customFilters", "ffmpeg"]);
+    const optionalOptions = /* @__PURE__ */ new Set(["customFilters"]);
+    for (const [key, value] of Object.entries(options)) {
+      if (value === void 0 && optionalOptions.has(key)) continue;
+      if (key === "plugins" && !Array.isArray(value)) {
+        throw new DisTubeError("INVALID_TYPE", "Array<Plugin>", value, `DisTubeOptions.${key}`);
+      } else if (booleanOptions.has(key)) {
+        if (typeof value !== "boolean") {
+          throw new DisTubeError("INVALID_TYPE", "boolean", value, `DisTubeOptions.${key}`);
+        }
+      } else if (numberOptions.has(key)) {
+        if (typeof value !== "number" || Number.isNaN(value)) {
+          throw new DisTubeError("INVALID_TYPE", "number", value, `DisTubeOptions.${key}`);
+        }
+      } else if (stringOptions.has(key)) {
+        if (typeof value !== "string") {
+          throw new DisTubeError("INVALID_TYPE", "string", value, `DisTubeOptions.${key}`);
+        }
+        if (!UNHANDLED_ERROR_BEHAVIORS.includes(value)) {
+          throw new DisTubeError("INVALID_TYPE", UNHANDLED_ERROR_BEHAVIORS, value, `DisTubeOptions.${key}`);
+        }
+      } else if (objectOptions.has(key)) {
+        if (typeof value !== "object" || Array.isArray(value)) {
+          throw new DisTubeError("INVALID_TYPE", "object", value, `DisTubeOptions.${key}`);
+        }
+      }
+    }
+  }
+  #ffmpegOption(opts) {
+    const args = { global: {}, input: {}, output: {} };
+    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;
+    }
+    const path = opts.ffmpeg?.path ?? "ffmpeg";
+    if (typeof path !== "string") {
+      throw new DisTubeError("INVALID_TYPE", "string", path, "DisTubeOptions.ffmpeg.path");
+    }
+    for (const [key, value] of Object.entries(args)) {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        throw new DisTubeError("INVALID_TYPE", "object", value, `DisTubeOptions.ffmpeg.${key}`);
+      }
+      for (const [k, v] of Object.entries(value)) {
+        if (typeof v !== "string" && typeof v !== "number" && typeof v !== "boolean" && !Array.isArray(v) && v !== null && v !== void 0) {
+          throw new DisTubeError(
+            "INVALID_TYPE",
+            ["string", "number", "boolean", "Array<string | null | undefined>", "null", "undefined"],
+            v,
+            `DisTubeOptions.ffmpeg.${key}.${k}`
+          );
+        }
+      }
+    }
+    return { path, args };
+  }
+};
+
+// src/core/DisTubeStream.ts
+var import_node_child_process = require("child_process");
+var import_node_stream = require("stream");
+var import_voice2 = require("@discordjs/voice");
+var import_tiny_typed_emitter2 = require("tiny-typed-emitter");
+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_node_child_process.spawnSync)(path, ["-h"], {
+      windowsHide: 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}`);
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.stack ?? e.message : String(e);
+    debug(`[test] failed to spawn ffmpeg at '${path}': ${errorMessage}`);
+    throw new DisTubeError("FFMPEG_NOT_INSTALLED", path);
+  }
+  checked = true;
+}, "checkFFmpeg");
+var DisTubeStream = class extends import_tiny_typed_emitter2.TypedEmitter {
+  static {
+    __name(this, "DisTubeStream");
+  }
+  #ffmpegPath;
+  #opts;
+  /**
+   * The FFmpeg process that decodes the audio.
+   *
+   * It is `undefined` until {@link DisTubeStream#spawn} is called.
+   */
+  process;
+  /**
+   * The stream of the decoded audio, with the volume applied to it.
+   */
+  stream;
+  /**
+   * The Discord.js audio resource that is played by the audio player.
+   */
+  audioResource;
+  /**
+   * The seek time in seconds that this stream started from
+   */
+  seekTime;
+  /**
+   * Create a DisTubeStream to play with {@link DisTubeVoice}
+   * @param url     - Stream URL
+   * @param options - Stream options
+   */
+  constructor(url, options) {
+    super();
+    const { ffmpeg, seek } = options;
+    this.seekTime = typeof seek === "number" && seek > 0 ? seek : 0;
+    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: AUDIO_SAMPLE_RATE,
+      ac: AUDIO_CHANNELS,
+      ...ffmpeg.args.output,
+      f: "s16le"
+    };
+    if (typeof seek === "number" && seek > 0) opts.ss = seek.toString();
+    const fileUrl = new URL(url);
+    if (fileUrl.protocol === "file:") {
+      opts.reconnect = null;
+      opts.reconnect_streamed = null;
+      opts.reconnect_delay_max = null;
+      opts.i = fileUrl.hostname + fileUrl.pathname;
+    }
+    this.#ffmpegPath = ffmpeg.path;
+    this.#opts = [
+      ...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"
+    ];
+    this.stream = new VolumeTransformer();
+    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.audioResource = (0, import_voice2.createAudioResource)(this.stream, {
+      inputType: import_voice2.StreamType.Raw,
+      inlineVolume: false
+    });
+  }
+  /**
+   * Spawn the FFmpeg process that decodes the audio.
+   * @returns Nothing
+   * @throws {Error} When the FFmpeg process cannot be created
+   */
+  spawn() {
+    this.debug(`[process] spawn: ${this.#ffmpegPath} ${this.#opts.join(" ")}`);
+    this.process = (0, import_node_child_process.spawn)(this.#ffmpegPath, this.#opts, {
+      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.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);
+  }
+  /**
+   * Set the volume of the stream.
+   * @param volume - The volume of the stream, between `0` and `1`
+   * @returns Nothing
+   */
+  setVolume(volume) {
+    this.stream.vol = volume;
+  }
+  /**
+   * Kill the FFmpeg process and destroy the stream.
+   * @returns Nothing
+   */
+  kill() {
+    if (!this.stream.destroyed) this.stream.destroy();
+    if (this.process && !this.process.killed) this.process.kill("SIGKILL");
+  }
+};
+var VolumeTransformer = class extends import_node_stream.Transform {
+  static {
+    __name(this, "VolumeTransformer");
+  }
+  buffer = Buffer.allocUnsafe(0);
+  extrema = [-(2 ** (16 - 1)), 2 ** (16 - 1) - 1];
+  vol = 1;
+  _transform(newChunk, _encoding, done) {
+    const { vol } = this;
+    if (vol === 1) {
+      this.push(newChunk);
+      done();
+      return;
+    }
+    const bytes = 2;
+    const chunk = Buffer.concat([this.buffer, newChunk]);
+    const readableLength = Math.floor(chunk.length / bytes) * bytes;
+    for (let i = 0; i < readableLength; i += bytes) {
+      const value = chunk.readInt16LE(i);
+      const clampedValue = Math.min(this.extrema[1], Math.max(this.extrema[0], value * vol));
+      chunk.writeInt16LE(clampedValue, i);
+    }
+    this.buffer = chunk.subarray(readableLength);
+    this.push(chunk.subarray(0, readableLength));
+    done();
+  }
+};
+
+// src/core/manager/DisTubeVoiceManager.ts
+var import_voice3 = require("@discordjs/voice");
+
+// src/core/manager/GuildIdManager.ts
+var GuildIdManager = class extends BaseManager {
+  static {
+    __name(this, "GuildIdManager");
+  }
+  /**
+   * Add an item to the collection.
+   *
+   * The item is not added when there is already one for the same guild.
+   * @param idOrInstance - The guild id, or anything that can be resolved to a guild id
+   * @param data         - The item to add
+   * @returns This manager, to allow chaining
+   * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+   */
+  add(idOrInstance, data) {
+    const id = resolveGuildId(idOrInstance);
+    const existing = this.get(id);
+    if (existing) return this;
+    this.collection.set(id, data);
+    return this;
+  }
+  /**
+   * Get the item of a guild.
+   * @param idOrInstance - The guild id, or anything that can be resolved to a guild id
+   * @returns The item of the guild, or `undefined` when there is none
+   * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+   */
+  get(idOrInstance) {
+    return this.collection.get(resolveGuildId(idOrInstance));
+  }
+  /**
+   * Remove the item of a guild.
+   * @param idOrInstance - The guild id, or anything that can be resolved to a guild id
+   * @returns `true` when an item was removed, `false` otherwise
+   * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+   */
+  remove(idOrInstance) {
+    return this.collection.delete(resolveGuildId(idOrInstance));
+  }
+  /**
+   * Check whether a guild has an item.
+   * @param idOrInstance - The guild id, or anything that can be resolved to a guild id
+   * @returns `true` when there is an item for the guild
+   * @throws {@link DisTubeError} When the value cannot be resolved to a guild id
+   */
+  has(idOrInstance) {
+    return this.collection.has(resolveGuildId(idOrInstance));
+  }
+};
+
+// src/core/manager/DisTubeVoiceManager.ts
+var DisTubeVoiceManager = class extends GuildIdManager {
+  static {
+    __name(this, "DisTubeVoiceManager");
+  }
+  /**
+   * Create a {@link DisTubeVoice} instance
+   * @param channel - A voice channel to join
+   * @returns The voice connection of the guild
+   * @throws {@link DisTubeError} When the guild already has a voice connection
+   * that is not managed by DisTube
+   */
+  create(channel) {
+    const existing = this.get(channel.guildId);
+    if (existing) {
+      existing.channel = channel;
+      return existing;
+    }
+    if ((0, import_voice3.getVoiceConnection)(resolveGuildId(channel), this.client.user?.id) || (0, import_voice3.getVoiceConnection)(resolveGuildId(channel))) {
+      throw new DisTubeError("VOICE_ALREADY_CREATED");
+    }
+    return new DisTubeVoice(this, channel);
+  }
+  /**
+   * Join a voice channel and wait until the connection is ready
+   * @param channel - A voice channel to join
+   * @returns The voice connection of the guild
+   * @throws {@link DisTubeError} When the connection cannot be established
+   */
+  join(channel) {
+    const existing = this.get(channel.guildId);
+    if (existing) return existing.join(channel);
+    return this.create(channel).join();
+  }
+  /**
+   * Leave the connected voice channel in a guild
+   * @param guild - Queue Resolvable
+   * @returns Nothing
+   */
+  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();
+      }
+    }
+  }
+};
+
+// src/core/manager/QueueManager.ts
+var QueueManager = class extends GuildIdManager {
+  static {
+    __name(this, "QueueManager");
+  }
+  /**
+   * Create a {@link Queue}
+   * @param channel     - A voice channel
+   * @param textChannel - Default text channel
+   * @returns The created queue
+   * @throws {@link DisTubeError} When the guild already has a queue, or when
+   * the voice channel cannot be joined
+   */
+  async create(channel, textChannel) {
+    if (this.has(channel.guildId)) throw new DisTubeError("QUEUE_EXIST");
+    this.debug(`[QueueManager] Creating queue for guild: ${channel.guildId}`);
+    const voice = this.voices.create(channel);
+    const queue = new Queue(this.distube, voice, textChannel);
+    await queue._taskQueue.queuing();
+    try {
+      checkFFmpeg(this.distube);
+      this.debug(`[QueueManager] Joining voice channel: ${channel.id}`);
+      await voice.join();
+      this.#voiceEventHandler(queue);
+      this.add(queue.id, queue);
+      this.emit("initQueue" /* INIT_QUEUE */, queue);
+      return queue;
+    } finally {
+      queue._taskQueue.resolve();
+    }
+  }
+  /**
+   * Listen to DisTubeVoice events and handle the Queue
+   * @param queue - Queue
+   */
+  #voiceEventHandler(queue) {
+    queue._listeners = {
+      disconnect: /* @__PURE__ */ __name((error) => {
+        queue.remove();
+        this.emit("disconnect" /* DISCONNECT */, queue);
+        if (error) this.emitError(error, queue, queue.songs?.[0]);
+      }, "disconnect"),
+      error: /* @__PURE__ */ __name((error) => void this.#handlePlayingError(queue, error), "error"),
+      finish: /* @__PURE__ */ __name(() => void this.handleSongFinish(queue), "finish")
+    };
+    for (const event of objectKeys(queue._listeners)) {
+      queue.voice.on(event, queue._listeners[event]);
+    }
+  }
+  /**
+   * Handle the queue when a Song finish
+   * @param queue - queue
+   * @returns A promise that resolves when the next song is playing
+   */
+  async handleSongFinish(queue) {
+    if (queue._manualUpdate) {
+      queue._manualUpdate = false;
+      await this.playSong(queue);
+      return;
+    }
+    this.debug(`[QueueManager] Handling song finish: ${queue.id}`);
+    const song = queue.songs[0];
+    this.emit("finishSong" /* FINISH_SONG */, queue, song);
+    await queue._taskQueue.queuing();
+    try {
+      if (queue.stopped) return;
+      if (queue.repeatMode === 2 /* QUEUE */) queue.songs.push(song);
+      if (queue.repeatMode !== 1 /* SONG */) {
+        const prev = queue.songs.shift();
+        if (this.options.savePreviousSongs) queue.previousSongs.push(prev);
+        else queue.previousSongs.push({ id: prev.id });
+      }
+      if (queue.songs.length === 0 && queue.autoplay) {
+        try {
+          this.debug(`[QueueManager] Adding related song: ${queue.id}`);
+          await queue._addRelatedSong(song);
+        } catch (e) {
+          const errorMessage = e instanceof Error ? e.message : String(e);
+          this.debug(`[${queue.id}] Add related song error: ${errorMessage}`);
+          if (e instanceof DisTubeError) {
+            this.emit("noRelated" /* NO_RELATED */, queue, e);
+          } else {
+            this.emit("noRelated" /* NO_RELATED */, queue, new DisTubeError("NO_RELATED"));
+          }
+        }
+      }
+      if (queue.songs.length === 0) {
+        this.debug(`[${queue.id}] Queue is empty, stopping...`);
+        this.emit("empty" /* EMPTY */, queue);
+        if (!queue.autoplay) this.emit("finish" /* FINISH */, queue);
+        queue.remove();
+        return;
+      }
+      if (song !== queue.songs[0]) {
+        const playedSong = song.stream.playFromSource ? song : song.stream.song;
+        if (playedSong?.stream.playFromSource) delete playedSong.stream.url;
+      }
+      await this.playSong(queue, true);
+    } finally {
+      queue._taskQueue.resolve();
+    }
+  }
+  /**
+   * Handle error while playing
+   * @param queue - queue
+   * @param error - error
+   */
+  async #handlePlayingError(queue, error) {
+    const song = queue.songs.shift();
+    try {
+      error.name = "PlayingError";
+    } catch {
+    }
+    this.debug(`[${queue.id}] Error while playing: ${error.stack || error.message}`);
+    this.emitError(error, queue, song);
+    if (queue.songs.length > 0) {
+      this.debug(`[${queue.id}] Playing next song: ${queue.songs[0]}`);
+      await this.playSong(queue);
+    } else {
+      this.debug(`[${queue.id}] Queue is empty, stopping...`);
+      await queue.stop();
+    }
+  }
+  /**
+   * Play a song on voice connection with queue properties
+   * @param queue         - The guild queue to play
+   * @param emitPlaySong  - Whether or not emit {@link Events.PLAY_SONG} event
+   * @param options       - Optional options
+   * @param options.keepSongOnError - Whether the current song has to stay in the
+   * queue when the stream cannot be started
+   * @returns A promise that resolves when the song is playing
+   * @throws {@link DisTubeError} When the song does not have any stream URL
+   */
+  async playSong(queue, emitPlaySong = true, options) {
+    if (!queue) return;
+    if (queue.stopped || !queue.songs.length) {
+      await queue.stop();
+      return;
+    }
+    try {
+      const song = queue.songs[0];
+      this.debug(`[${queue.id}] Getting stream from: ${song}`);
+      await this.handler.attachStreamInfo(song);
+      const willPlaySong = song.stream.playFromSource ? song : song.stream.song;
+      const stream = willPlaySong?.stream;
+      if (!willPlaySong || !stream?.playFromSource || !stream.url) throw new DisTubeError("NO_STREAM_URL", `${song}`);
+      this.debug(`[${queue.id}] Creating DisTubeStream for: ${willPlaySong}`);
+      const streamOptions = {
+        ffmpeg: {
+          path: this.options.ffmpeg.path,
+          args: {
+            global: { ...queue.ffmpegArgs.global },
+            input: { ...queue.ffmpegArgs.input },
+            output: { ...queue.ffmpegArgs.output, ...queue.filters.ffmpegArgs }
+          }
+        },
+        seek: willPlaySong.duration ? queue._beginTime : void 0
+      };
+      queue._beginTime = 0;
+      const dtStream = new DisTubeStream(stream.url, streamOptions);
+      dtStream.on("debug", (data) => this.emit("ffmpegDebug" /* FFMPEG_DEBUG */, `[${queue.id}] ${data}`));
+      this.debug(`[${queue.id}] Started playing: ${willPlaySong}`);
+      await queue.voice.play(dtStream);
+      if (emitPlaySong) this.emit("playSong" /* PLAY_SONG */, queue, song);
+    } catch (e) {
+      const error = e instanceof Error ? e : new Error(String(e));
+      if (options?.keepSongOnError) {
+        this.debug(`[${queue.id}] Error while restarting the stream: ${error.stack || error.message}`);
+        this.emitError(error, queue, queue.songs[0]);
+        return;
+      }
+      await this.#handlePlayingError(queue, error);
+    }
+  }
+};
+
+// src/core/StreamServer.ts
+var import_node_crypto = require("crypto");
+var import_node_http = require("http");
+var import_node_stream2 = require("stream");
+var parseRange = /* @__PURE__ */ __name((header) => {
+  if (!header) return 0;
+  const match = /^bytes=(\d+)-/u.exec(header);
+  return match ? Number(match[1]) : 0;
+}, "parseRange");
+var StreamServer = class {
+  static {
+    __name(this, "StreamServer");
+  }
+  #handlers = /* @__PURE__ */ new Map();
+  #port;
+  #prefix;
+  #server;
+  #ready;
+  #boundPort;
+  #closed = false;
+  /**
+   * Create a stream server.
+   * @param options - Optional options
+   */
+  constructor({ port = 0, prefix } = {}) {
+    this.#port = port;
+    this.#prefix = prefix ?? (0, import_node_crypto.randomBytes)(8).toString("hex");
+  }
+  /**
+   * The prefix of the URLs of the server.
+   */
+  get prefix() {
+    return this.#prefix;
+  }
+  /**
+   * The base URL of the server, e.g. `http://127.0.0.1:51234`.
+   *
+   * @throws When the server is not started yet.
+   */
+  get baseUrl() {
+    if (!this.#boundPort) throw new Error("The stream server is not started yet.");
+    return `http://127.0.0.1:${this.#boundPort}`;
+  }
+  /**
+   * Register a source.
+   *
+   * The handler is called for every request of that source. Return `null` to
+   * answer a `404`.
+   * @param source  - The identifier of the source
+   * @param handler - The handler of the source
+   * @returns A handle to unregister the source
+   * @example
+   * ```ts
+   * const disposable = distube.streams.register("my-source", async req => ({
+   *   body: Readable.from(Buffer.from("audio")),
+   *   contentType: "audio/mpeg",
+   * }));
+   * ```
+   */
+  register(source, handler) {
+    const key = source.toLowerCase();
+    this.#handlers.set(key, handler);
+    void this.#start();
+    return {
+      dispose: /* @__PURE__ */ __name(() => {
+        if (this.#handlers.get(key) === handler) this.#handlers.delete(key);
+      }, "dispose")
+    };
+  }
+  /**
+   * Build the URL of a stream.
+   *
+   * The server is started when it is not running yet.
+   * @param source - The identifier of the source
+   * @param path   - The path after the source
+   * @param query  - The query parameters
+   * @returns The URL of the stream
+   * @example
+   * ```ts
+   * const url = await distube.streams.url("my-source", "abc123", { token: "secret" });
+   * ```
+   */
+  async url(source, path, query) {
+    await this.#start();
+    const url = new URL(`${this.baseUrl}/${this.#prefix}/${source.toLowerCase()}`);
+    if (path) url.pathname = `${url.pathname}/${path.replace(/^\/+/u, "")}`;
+    for (const [key, value] of Object.entries(query ?? {})) url.searchParams.set(key, String(value));
+    return url.toString();
+  }
+  /**
+   * Close the server and release every handler.
+   * @returns A promise that resolves when the server is closed
+   */
+  async close() {
+    this.#closed = true;
+    this.#handlers.clear();
+    const server = this.#server;
+    this.#server = void 0;
+    this.#ready = void 0;
+    this.#boundPort = void 0;
+    if (!server) return;
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+  async #start() {
+    if (this.#closed) throw new Error("The stream server is closed.");
+    if (!this.#ready) {
+      this.#ready = new Promise((resolve, reject) => {
+        const server = (0, import_node_http.createServer)((req, res) => void this.#handle(req, res));
+        server.once("error", reject);
+        server.listen(this.#port, "127.0.0.1", () => {
+          const address = server.address();
+          this.#boundPort = typeof address === "object" && address ? address.port : this.#port;
+          this.#server = server;
+          server.unref?.();
+          resolve();
+        });
+      });
+    }
+    return this.#ready;
+  }
+  async #handle(req, res) {
+    const controller = new AbortController();
+    req.on("close", () => controller.abort());
+    try {
+      const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+      const segments = requestUrl.pathname.split("/").filter(Boolean);
+      if (segments[0] !== this.#prefix) {
+        res.writeHead(404, { "Content-Type": "text/plain" }).end("Not Found");
+        return;
+      }
+      const handler = this.#handlers.get((segments[1] ?? "").toLowerCase());
+      if (!handler) {
+        res.writeHead(404, { "Content-Type": "text/plain" }).end("Not Found");
+        return;
+      }
+      const result = await handler({
+        path: segments.slice(2).join("/"),
+        query: requestUrl.searchParams,
+        offset: parseRange(req.headers.range),
+        signal: controller.signal,
+        request: req
+      });
+      if (!result) {
+        res.writeHead(404, { "Content-Type": "text/plain" }).end("Not Found");
+        return;
+      }
+      const headers = {
+        "Content-Type": result.contentType ?? "application/octet-stream",
+        ...result.headers
+      };
+      if (result.size !== void 0) headers["Accept-Ranges"] = "bytes";
+      if (result.size !== void 0 && result.size > 0) {
+        const offset = Math.min(parseRange(req.headers.range), Math.max(result.size - 1, 0));
+        if (offset > 0) {
+          headers["Content-Range"] = `bytes ${offset}-${result.size - 1}/${result.size}`;
+          res.writeHead(206, headers);
+        } else {
+          res.writeHead(result.status ?? 200, headers);
+        }
+      } else {
+        res.writeHead(result.status ?? 200, headers);
+      }
+      const body = result.body instanceof import_node_stream2.Readable ? result.body : import_node_stream2.Readable.from(result.body);
+      body.on("error", () => res.end());
+      body.pipe(res);
+    } catch {
+      if (!res.headersSent) res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end();
+    }
+  }
+};
+
+// src/DisTube.ts
+var import_tiny_typed_emitter3 = require("tiny-typed-emitter");
+
+// src/struct/SearchResult.ts
+var SearchResult = class {
+  static {
+    __name(this, "SearchResult");
+  }
+  /**
+   * The query of the search.
+   */
+  query;
+  /**
+   * The kind of result that was looked for.
+   */
+  queryType;
+  /**
+   * The songs that were found.
+   */
+  songs;
+  /**
+   * The playlist that was found, when the search returned one.
+   */
+  playlist;
+  /**
+   * The identifiers of the plugins that contributed to the result.
+   */
+  sources;
+  /**
+   * Create a search result.
+   * @param query   - The query of the search
+   * @param options - Optional data
+   * @param options.songs     - The songs that were found
+   * @param options.playlist  - The playlist that was found
+   * @param options.queryType - The kind of result that was looked for
+   * @param options.sources   - The identifiers of the plugins that contributed
+   * to the result
+   * @example
+   * ```ts
+   * const result = new SearchResult("Never gonna give you up", { songs: [song] });
+   * ```
+   */
+  constructor(query, {
+    songs = [],
+    playlist,
+    queryType,
+    sources = []
+  } = {}) {
+    this.query = query;
+    this.songs = songs;
+    this.playlist = playlist;
+    this.queryType = queryType ?? "track" /* TRACK */;
+    this.sources = sources;
+  }
+  /**
+   * Whether the search returned nothing.
+   * @returns `true` when the result has neither songs nor a playlist
+   */
+  isEmpty() {
+    return this.songs.length === 0 && !this.playlist;
+  }
+  /**
+   * Whether the search returned songs.
+   * @returns `true` when the result has at least one song
+   */
+  hasSongs() {
+    return this.songs.length > 0;
+  }
+  /**
+   * Whether the search returned a playlist.
+   * @returns `true` when the result has a playlist
+   */
+  hasPlaylist() {
+    return Boolean(this.playlist);
+  }
+  /**
+   * A plain object representation of the result.
+   * @returns The plain object representation of the result
+   */
+  toJSON() {
+    return {
+      query: this.query,
+      queryType: this.queryType,
+      sources: [...this.sources],
+      songs: this.songs.map((song) => ({
+        id: song.id,
+        name: song.name,
+        url: song.url,
+        duration: song.duration,
+        formattedDuration: song.formattedDuration,
+        thumbnail: song.thumbnail,
+        source: song.source,
+        uploader: song.uploader
+      })),
+      playlist: this.playlist ? {
+        id: this.playlist.id,
+        name: this.playlist.name,
+        url: this.playlist.url,
+        thumbnail: this.playlist.thumbnail,
+        songs: this.playlist.songs.length
+      } : void 0
+    };
+  }
+};
+
+// src/DisTube.ts
+var DisTube = class _DisTube extends import_tiny_typed_emitter3.TypedEmitter {
+  static {
+    __name(this, "DisTube");
+  }
+  /**
+   * @event
+   * Emitted after DisTube add a new playlist to the playing {@link Queue}.
+   * @param queue    - The guild queue
+   * @param playlist - Playlist info
+   */
+  static ["addList" /* ADD_LIST */];
+  /**
+   * @event
+   * Emitted after DisTube add a new song to the playing {@link Queue}.
+   * @param queue - The guild queue
+   * @param song  - Added song
+   */
+  static ["addSong" /* ADD_SONG */];
+  /**
+   * @event
+   * Emitted when the {@link Queue} is deleted with any reasons.
+   * @param queue - The guild queue
+   */
+  static ["deleteQueue" /* DELETE_QUEUE */];
+  /**
+   * @event
+   * Emitted when the bot is disconnected to a voice channel.
+   * @param queue - The guild queue
+   */
+  static ["disconnect" /* DISCONNECT */];
+  /**
+   * @event
+   * Emitted when the {@link Queue} runs out of songs to play.
+   * @param queue - The guild queue
+   */
+  static ["empty" /* EMPTY */];
+  /**
+   * @event
+   * Emitted when DisTube encounters an error while playing songs.
+   * @param error   - error
+   * @param queue   - The queue encountered the error
+   * @param song    - The playing song when encountered the error
+   */
+  static ["error" /* ERROR */];
+  /**
+   * @event
+   * Emitted for logging FFmpeg debug information.
+   * @param debug - Debug message string.
+   */
+  static ["ffmpegDebug" /* FFMPEG_DEBUG */];
+  /**
+   * @event
+   * Emitted to provide debug information from DisTube's operation.
+   * Useful for troubleshooting or logging purposes.
+   *
+   * @param debug - Debug message string.
+   */
+  static ["debug" /* DEBUG */];
+  /**
+   * @event
+   * Emitted when there is no more song in the queue and {@link Queue#autoplay} is `false`.
+   * @param queue - The guild queue
+   */
+  static ["finish" /* FINISH */];
+  /**
+   * @event
+   * Emitted when DisTube finished a song.
+   * @param queue - The guild queue
+   * @param song  - Finished song
+   */
+  static ["finishSong" /* FINISH_SONG */];
+  /**
+   * @event
+   * Emitted when DisTube initialize a queue to change queue default properties.
+   * @param queue - The guild queue
+   */
+  static ["initQueue" /* INIT_QUEUE */];
+  /**
+   * @event
+   * Emitted when {@link Queue#autoplay} is `true`, {@link Queue#songs} is empty, and
+   * DisTube cannot find related songs to play.
+   * @param queue - The guild queue
+   * @param error - The error that occurred while looking for related songs
+   */
+  static ["noRelated" /* NO_RELATED */];
+  /**
+   * @event
+   * Emitted when DisTube play a song.
+   * If {@link DisTubeOptions}.emitNewSongOnly is `true`, this event is not emitted
+   * when looping a song or next song is the previous one.
+   * @param queue - The guild queue
+   * @param song  - Playing song
+   */
+  static ["playSong" /* PLAY_SONG */];
+  /**
+   * DisTube internal handler
+   */
+  handler;
+  /**
+   * DisTube options
+   */
+  options;
+  /**
+   * Discord.js v14 client
+   */
+  client;
+  /**
+   * Queues manager
+   */
+  queues;
+  /**
+   * DisTube voice connections manager
+   */
+  voices;
+  /**
+   * DisTube plugins
+   */
+  plugins;
+  /**
+   * The local HTTP server the plugins use to stream the audio.
+   *
+   * A plugin that cannot hand out a static URL to FFmpeg registers a handler on
+   * it, instead of running its own server.
+   */
+  streams;
+  /**
+   * DisTube ffmpeg audio filters
+   */
+  filters;
+  /**
+   * Create a new DisTube class.
+   * @throws {@link DisTubeError}
+   * @param client - Discord.JS client
+   * @param opts   - Custom DisTube options
+   * @example
+   * ```ts
+   * const distube = new DisTube(client, { nsfw: false });
+   * ```
+   */
+  constructor(client, opts = {}) {
+    super();
+    this.setMaxListeners(0);
+    if (!isClientInstance(client)) throw new DisTubeError("INVALID_TYPE", "Discord.Client", client, "client");
+    this.client = client;
+    checkIntents(client.options);
+    this.options = new Options(opts);
+    this.voices = new DisTubeVoiceManager(this);
+    this.handler = new DisTubeHandler(this);
+    this.queues = new QueueManager(this);
+    this.filters = { ...defaultFilters, ...this.options.customFilters };
+    this.plugins = [...this.options.plugins];
+    this.streams = new StreamServer();
+    for (const p of this.plugins) {
+      const result = p.init(this);
+      if (result && typeof result.catch === "function") {
+        result.catch((e) => {
+          const error = e instanceof Error ? e : new Error(String(e));
+          this.debug(`[DisTube] The plugin ${p.constructor.name} failed to initialize: ${error.message}`);
+          process.emitWarning(`The plugin ${p.constructor.name} failed to initialize: ${error.message}`, {
+            code: "DIS_TUBE_PLUGIN_INIT_FAILED",
+            detail: error.stack ?? error.message
+          });
+        });
+      }
+    }
+  }
+  /**
+   * Create a DisTube instance and wait for the plugins to be initialized.
+   *
+   * Use it when a plugin does asynchronous work in its `init` method: the
+   * constructor cannot await it.
+   * @param client - The Discord.js client
+   * @param opts   - Optional options
+   * @returns The DisTube instance
+   * @example
+   * ```ts
+   * const distube = await DisTube.create(client, { plugins: [new YoutubePlugin()] });
+   * ```
+   */
+  static async create(client, opts = {}) {
+    const distube = new _DisTube(client, opts);
+    await Promise.all(
+      distube.plugins.map(async (plugin) => {
+        try {
+          await plugin.init(distube);
+        } catch (e) {
+          const error = e instanceof Error ? e : new Error(String(e));
+          distube.debug(`[DisTube] The plugin ${plugin.constructor.name} failed to initialize: ${error.message}`);
+          process.emitWarning(`The plugin ${plugin.constructor.name} failed to initialize: ${error.message}`, {
+            code: "DIS_TUBE_PLUGIN_INIT_FAILED",
+            detail: error.stack ?? error.message
+          });
+        }
+      })
+    );
+    return distube;
+  }
+  /**
+   * Emit an event of the DisTube instance.
+   *
+   * The special {@link Events.ERROR} event is handled differently than the other
+   * events: Node.js throws an `ERR_UNHANDLED_ERROR` when the special `"error"`
+   * event is emitted without any listener, which crashes the whole process.
+   *
+   * Instead of crashing, DisTube follows {@link DisTubeOptions.unhandledError}
+   * (`"log"` by default).
+   * @param event - The event name
+   * @param args  - The event arguments
+   * @returns `true` when the event had listeners, `false` otherwise
+   */
+  emit(event, ...args) {
+    if (event === "error" /* ERROR */ && this.listenerCount("error" /* ERROR */) === 0) {
+      this.#handleUnhandledError(args[0]);
+      return false;
+    }
+    return super.emit(event, ...args);
+  }
+  /**
+   * Handle an {@link Events.ERROR} event that has no listener.
+   * @param error - The error
+   */
+  #handleUnhandledError(error) {
+    handleUnhandledError(error, this.options?.unhandledError ?? "log");
+  }
+  /**
+   * DisTube version
+   */
+  static get version() {
+    return version;
+  }
+  /**
+   * DisTube version
+   */
+  get version() {
+    return version;
+  }
+  /**
+   * Play / add a song or playlist from url.
+   * Search and play a song (with {@link ExtractorPlugin}) if it is not a valid url.
+   * @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 Playlist}
+   * @param options      - Optional options
+   * @returns A promise that resolves when the song is added to the queue
+   * @example
+   * ```ts
+   * await distube.play(channel, "Never gonna give you up", { message });
+   * ```
+   */
+  async play(voiceChannel, song, options = {}) {
+    if (!isSupportedVoiceChannel(voiceChannel)) {
+      throw new DisTubeError("INVALID_TYPE", "BaseGuildVoiceChannel", voiceChannel, "voiceChannel");
+    }
+    if (!isObject(options)) throw new DisTubeError("INVALID_TYPE", "object", options, "options");
+    const { textChannel, member, skip, message, metadata, source } = {
+      member: voiceChannel.guild.members.me ?? void 0,
+      textChannel: options?.message?.channel,
+      skip: false,
+      ...options
+    };
+    const position = Number(options.position) || (skip ? 1 : 0);
+    if (message && !isMessageInstance(message)) {
+      throw new DisTubeError("INVALID_TYPE", ["Discord.Message", "a falsy value"], message, "options.message");
+    }
+    if (textChannel && !isTextChannelInstance(textChannel)) {
+      throw new DisTubeError("INVALID_TYPE", "Discord.GuildTextBasedChannel", textChannel, "options.textChannel");
+    }
+    if (member && !isMemberInstance(member)) {
+      throw new DisTubeError("INVALID_TYPE", "Discord.GuildMember", member, "options.member");
+    }
+    const queue = this.getQueue(voiceChannel) || await this.queues.create(voiceChannel, textChannel);
+    await queue._taskQueue.queuing(true);
+    try {
+      this.debug(`[${queue.id}] Playing input: ${song}`);
+      const resolved = await this.handler.resolve(song, { member, metadata, source });
+      const isNsfw = isNsfwChannel(queue?.textChannel || textChannel);
+      const isFirstSong = queue.songs.length === 0;
+      if (resolved instanceof Playlist) {
+        if (!this.options.nsfw && !isNsfw) {
+          resolved.songs = resolved.songs.filter((s) => !s.ageRestricted);
+          if (!resolved.songs.length) throw new DisTubeError("EMPTY_FILTERED_PLAYLIST");
+        }
+        if (!resolved.songs.length) throw new DisTubeError("EMPTY_PLAYLIST");
+        this.debug(`[${queue.id}] Adding playlist to queue: ${resolved.songs.length} songs`);
+        queue.addToQueue(resolved.songs, position);
+        if (!isFirstSong || this.options.emitAddListWhenCreatingQueue) this.emit("addList" /* ADD_LIST */, queue, resolved);
+      } else {
+        if (!this.options.nsfw && resolved.ageRestricted && !isNsfwChannel(queue?.textChannel || textChannel)) {
+          throw new DisTubeError("NON_NSFW");
+        }
+        this.debug(`[${queue.id}] Adding song to queue: ${resolved.name || resolved.url || resolved.id || resolved}`);
+        queue.addToQueue(resolved, position);
+        if (!isFirstSong || this.options.emitAddSongWhenCreatingQueue) this.emit("addSong" /* ADD_SONG */, queue, resolved);
+      }
+      if (isFirstSong) await queue.play();
+      else if (skip) await queue.skip();
+    } catch (e) {
+      if (!(e instanceof DisTubeError)) {
+        const errorMessage = e instanceof Error ? e.stack ?? e.message : String(e);
+        this.debug(`[${queue.id}] Unexpected error while playing song: ${errorMessage}`);
+        if (e instanceof Error) {
+          try {
+            e.name = "PlayError";
+            e.message = `${typeof song === "string" ? song : song.url}
+${e.message}`;
+          } catch {
+          }
+        }
+      }
+      throw e;
+    } finally {
+      if (!queue.songs.length && !queue._taskQueue.hasPlayTask) queue.remove();
+      queue._taskQueue.resolve();
+    }
+  }
+  /**
+   * Create a custom playlist
+   * @param songs   - Array of url or Song
+   * @param options - Optional options
+   * @returns The created playlist
+   * @throws {@link DisTubeError} When the array is empty, or when it does not
+   * have any valid song
+   */
+  async createCustomPlaylist(songs, { member, parallel, metadata, name, source, url, thumbnail } = {}) {
+    if (!Array.isArray(songs)) 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));
+    if (!filteredSongs.length) throw new DisTubeError("NO_VALID_SONG");
+    if (member && !isMemberInstance(member)) {
+      throw new DisTubeError("INVALID_TYPE", "Discord.Member", member, "options.member");
+    }
+    let resolvedSongs;
+    if (parallel !== false) {
+      const promises = filteredSongs.map(
+        (song) => this.handler.resolve(song, { member, metadata }).catch(() => void 0)
+      );
+      resolvedSongs = (await Promise.all(promises)).filter((s) => s instanceof Song);
+    } else {
+      resolvedSongs = [];
+      for (const song of filteredSongs) {
+        const resolved = await this.handler.resolve(song, { member, metadata }).catch(() => void 0);
+        if (resolved instanceof Song) resolvedSongs.push(resolved);
+      }
+    }
+    return new Playlist(
+      {
+        source: source || "custom",
+        name,
+        url,
+        thumbnail: thumbnail || resolvedSongs.find((s) => s.thumbnail)?.thumbnail,
+        songs: resolvedSongs
+      },
+      { member, metadata }
+    );
+  }
+  /**
+   * Get the guild queue
+   * @param guild - The type can be resolved to give a {@link Queue}
+   * @returns The queue of the guild, or `undefined` when there is none
+   * @example
+   * ```ts
+   * const queue = distube.getQueue(guildId);
+   * ```
+   */
+  getQueue(guild) {
+    return this.queues.get(guild);
+  }
+  /**
+   * Get a plugin by the identifier of its source.
+   *
+   * It matches the {@link Plugin.source} of the plugin, or one of its
+   * {@link Plugin.aliases}. The identifier of the class is used when the
+   * plugin does not define a source (`YoutubePlugin` -> `youtube`).
+   * @param source - The identifier of the source
+   * @returns The plugin, or `undefined` when there is none
+   * @example
+   * ```ts
+   * const plugin = distube.getPlugin("youtube");
+   * ```
+   */
+  getPlugin(source) {
+    if (typeof source !== "string" || !source) return void 0;
+    const identifier = source.toLowerCase();
+    return this.plugins.find((plugin) => plugin.identifiers.includes(identifier));
+  }
+  /**
+   * Search for the songs of the plugins.
+   *
+   * The plugins are used in the order they were registered. When
+   * {@link ResolveOptions.source} is given, only the matching plugin is used.
+   * @param query   - The search query
+   * @param options - Optional options
+   * @returns The result of the search
+   * @example
+   * ```ts
+   * const result = await distube.search("Never gonna give you up", { limit: 5 });
+   * ```
+   */
+  async search(query, options = {}) {
+    const limit = options.limit ?? 10;
+    const plugins = options.source ? [this.getPlugin(options.source)].filter((plugin) => Boolean(plugin)) : this.plugins;
+    const songs = [];
+    const sources = [];
+    let playlist;
+    for (const plugin of plugins) {
+      if (songs.length >= limit) break;
+      const found = await plugin.search(query, { ...options, limit: limit - songs.length });
+      if (!found) continue;
+      if (found.songs.length) {
+        songs.push(...found.songs);
+        sources.push(plugin.identifiers[0] ?? plugin.constructor.name);
+      }
+      playlist ??= found.playlist;
+    }
+    return new SearchResult(query, {
+      songs: songs.slice(0, limit),
+      playlist,
+      queryType: options.type,
+      sources
+    });
+  }
+  /**
+  /**
+  /**
+  /**
+   * Emit error event
+   * @param error   - error
+   * @param queue   - The queue encountered the error
+   * @param song    - The playing song when encountered the error
+   * @returns Nothing
+   */
+  emitError(error, queue, song) {
+    this.emit("error" /* ERROR */, error, queue, song);
+  }
+  /**
+   * Emit debug event
+   * @param message - debug message
+   * @returns Nothing
+   */
+  debug(message) {
+    this.emit("debug" /* DEBUG */, message);
+  }
+  /**
+   * Destroy the DisTube instance.
+   *
+   * Stops every queue, leaves every voice channel, destroys every plugin and
+   * removes every listener.
+   * Call it before your Discord.js client is destroyed to release all resources.
+   * @returns A promise that resolves when every resource is released
+   * @example
+   * ```ts
+   * await distube.destroy();
+   * ```
+   */
+  async destroy() {
+    this.debug("[DisTube] Destroying the DisTube instance...");
+    const queues = [...this.queues.collection.values()];
+    for (const queue of queues) {
+      try {
+        await queue.stop();
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        this.debug(`[DisTube] Failed to stop the queue ${queue.id}: ${errorMessage}`);
+      }
+    }
+    const voices = [...this.voices.collection.values()];
+    for (const voice of voices) {
+      try {
+        voice.leave();
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        this.debug(`[DisTube] Failed to leave the voice connection ${voice.id}: ${errorMessage}`);
+      }
+    }
+    for (const plugin of this.plugins) {
+      try {
+        await plugin.destroy();
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        this.debug(`[DisTube] Failed to destroy the plugin ${plugin.constructor.name}: ${errorMessage}`);
+      }
+    }
+    await this.streams.close();
+    this.removeAllListeners();
+  }
+};
+
+// src/struct/Plugin.ts
+var Plugin = class {
+  static {
+    __name(this, "Plugin");
+  }
+  /**
+   * The identifier of the source of the plugin.
+   *
+   * It defaults to the name of the class, lowercased, without the `Plugin`
+   * suffix (`YoutubePlugin` -> `youtube`).
+   *
+   * It is used to route a search to a plugin, and to find a plugin with
+   * {@link DisTube#getPlugin}.
+   */
+  source;
+  /**
+   * Additional identifiers of the source of the plugin, e.g. `["yt"]`.
+   */
+  aliases;
+  /**
+   * Whether the songs of this plugin can be played directly.
+   *
+   * When it is `false`, the songs of the plugin are resolved to a playable
+   * version by another plugin. It defaults to `true`.
+   */
+  playable;
+  /**
+   * DisTube
+   */
+  distube;
+  /**
+   * Initialize the plugin.
+   *
+   * It can be asynchronous: use {@link DisTube.create} to wait for the
+   * initialization of the plugins.
+   * @param distube - The DisTube instance
+   * @returns Nothing, or a promise that resolves when the plugin is initialized
+   * @example
+   * ```ts
+   * override async init(distube: DisTube) {
+   *   this.client = await createSession();
+   * }
+   * ```
+   */
+  init(distube) {
+    this.distube = distube;
+  }
+  /**
+   * Every identifier of this plugin: its {@link Plugin.source} and its
+   * {@link Plugin.aliases}, lowercased.
+   *
+   * The static properties of the class are used when the instance ones are not
+   * defined, so a plugin can declare them either way.
+   */
+  get identifiers() {
+    const names = /* @__PURE__ */ new Set();
+    const ctor = this.constructor;
+    const source = this.source ?? ctor.source ?? this.constructor.name.replace(/Plugin$/iu, "");
+    if (source) names.add(source.toLowerCase());
+    for (const alias of this.aliases ?? ctor.aliases ?? []) {
+      if (typeof alias === "string" && alias) names.add(alias.toLowerCase());
+    }
+    return [...names];
+  }
+  /**
+   * The local HTTP server of the DisTube instance.
+   *
+   * Register a handler on it when the plugin cannot hand out a static URL to
+   * FFmpeg, instead of running its own server.
+   */
+  get streams() {
+    return this.distube.streams;
+  }
+  /**
+   * Search for a song of the source.
+   *
+   * Override it to enable the search of your source. It returns `null` by
+   * default, because a source that cannot be searched does not have any result.
+   * @param _query   - Search query
+   * @param _options - Optional options
+   * @returns The song that was found, or `null`
+   * @example
+   * ```ts
+   * override async searchSong(query: string): Promise<Song | null> {
+   *   return findSong(query);
+   * }
+   * ```
+   */
+  searchSong(_query, _options) {
+    return null;
+  }
+  /**
+   * Search for the songs of the source.
+   *
+   * The default implementation returns the single result of
+   * {@link Plugin#searchSong}. Override it to return more results, or to return
+   * a playlist.
+   * @param query   - Search query
+   * @param options - Optional options
+   * @returns The result of the search
+   * @example
+   * ```ts
+   * const result = await plugin.search("Never gonna give you up", { limit: 5 });
+   * ```
+   */
+  async search(query, options = {}) {
+    const song = await this.searchSong(query, options);
+    return new SearchResult(query, {
+      songs: song ? [song] : [],
+      queryType: options.type
+    });
+  }
+  /**
+   * Create the query used to find a playable version of a song.
+   *
+   * It is used when the plugin cannot play the songs it resolves.
+   * @param song - Input song
+   * @returns The search query
+   * @example
+   * ```ts
+   * override createSearchQuery(song: Song): string {
+   *   return `${song.name} ${song.uploader?.name}`;
+   * }
+   * ```
+   */
+  createSearchQuery(song) {
+    return `${song.name ?? ""} ${song.uploader?.name ?? ""}`.trim();
+  }
+  /**
+   * Get related songs from a supported url.
+   *
+   * Override it to enable the autoplay for your source. Return an empty array
+   * when your source does not have any related songs.
+   * @param _song - Input song
+   * @returns The related songs
+   */
+  getRelatedSongs(_song) {
+    return [];
+  }
+  /**
+   * Destroy the plugin.
+   *
+   * It is called when the {@link DisTube} instance is destroyed. Override it to
+   * release every resource held by the plugin (HTTP servers, timers, browser
+   * sessions, ...).
+   * @returns Nothing, or a promise that resolves when the plugin is destroyed
+   */
+  destroy() {
+  }
+};
+
+// src/struct/ExtractorPlugin.ts
+var ExtractorPlugin = class extends Plugin {
+  static {
+    __name(this, "ExtractorPlugin");
+  }
+  /**
+   * The type of the plugin.
+   */
+  type = "extractor" /* EXTRACTOR */;
+};
+
+// src/struct/PluginError.ts
+var PluginErrorCode = /* @__PURE__ */ ((PluginErrorCode2) => {
+  PluginErrorCode2["UNSUPPORTED_URL"] = "UNSUPPORTED_URL";
+  PluginErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  PluginErrorCode2["NO_STREAM"] = "NO_STREAM";
+  PluginErrorCode2["SOURCE_UNAVAILABLE"] = "SOURCE_UNAVAILABLE";
+  PluginErrorCode2["AGE_RESTRICTED"] = "AGE_RESTRICTED";
+  return PluginErrorCode2;
+})(PluginErrorCode || {});
+var DEFAULT_MESSAGES = {
+  ["UNSUPPORTED_URL" /* UNSUPPORTED_URL */]: "This URL is not supported by the plugin",
+  ["NOT_FOUND" /* NOT_FOUND */]: "The song was not found",
+  ["NO_STREAM" /* NO_STREAM */]: "No playable stream was found for the song",
+  ["SOURCE_UNAVAILABLE" /* SOURCE_UNAVAILABLE */]: "The source is temporarily unavailable",
+  ["AGE_RESTRICTED" /* AGE_RESTRICTED */]: "The content is age-restricted"
+};
+var PluginError = class extends DisTubeError {
+  static {
+    __name(this, "PluginError");
+  }
+  /**
+   * Create a plugin error.
+   * @param code    - The error code
+   * @param message - The message. It defaults to the one of the error code.
+   * @param options - Optional options
+   * @param options.cause - The original error that caused this one
+   * @example
+   * ```ts
+   * throw new PluginError(PluginErrorCode.NOT_FOUND);
+   * ```
+   */
+  constructor(code, message, options) {
+    super(code, message ?? DEFAULT_MESSAGES[code]);
+    if (options && "cause" in options) this.cause = options.cause;
+  }
+  /**
+   * The name of the error, with its code.
+   * @returns The name of the error, e.g. `PluginError [NOT_FOUND]`
+   */
+  get name() {
+    return `PluginError [${this.errorCode}]`;
+  }
+};
+
+// src/struct/InfoExtractorPlugin.ts
+var InfoExtractorPlugin = class extends ExtractorPlugin {
+  static {
+    __name(this, "InfoExtractorPlugin");
+  }
+  /**
+   * The type of the plugin.
+   */
+  type = "info-extractor" /* INFO_EXTRACTOR */;
+  /**
+   * The songs of this plugin are resolved to a playable version by another
+   * plugin.
+   */
+  playable = false;
+  /**
+   * This plugin cannot play the songs it resolves, so it never has a stream url.
+   * @param _song - Input song
+   * @returns Nothing: it always throws
+   * @throws {@link PluginError} Always, with the code `NO_STREAM`
+   */
+  async getStreamURL(_song) {
+    throw new PluginError("NO_STREAM" /* NO_STREAM */);
+  }
+};
+
+// src/struct/PlayableExtractorPlugin.ts
+var PlayableExtractorPlugin = class extends ExtractorPlugin {
+  static {
+    __name(this, "PlayableExtractorPlugin");
+  }
+  /**
+   * The type of the plugin.
+   */
+  type = "playable-extractor" /* PLAYABLE_EXTRACTOR */;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUDIO_CHANNELS,
+  AUDIO_SAMPLE_RATE,
+  BaseManager,
+  DEFAULT_VOLUME,
+  DisTube,
+  DisTubeBase,
+  DisTubeError,
+  DisTubeHandler,
+  DisTubeStream,
+  DisTubeVoice,
+  DisTubeVoiceManager,
+  Events,
+  ExtractorPlugin,
+  FilterManager,
+  GuildIdManager,
+  HTTP_REDIRECT_CODES,
+  InfoExtractorPlugin,
+  JOIN_TIMEOUT_MS,
+  MAX_REDIRECT_DEPTH,
+  Options,
+  PlayableExtractorPlugin,
+  Playlist,
+  Plugin,
+  PluginError,
+  PluginErrorCode,
+  PluginType,
+  Queue,
+  QueueManager,
+  RECONNECT_MAX_ATTEMPTS,
+  RECONNECT_TIMEOUT_MS,
+  RepeatMode,
+  STUCK_THRESHOLD_MS,
+  SearchResult,
+  SearchResultType,
+  Song,
+  StreamServer,
+  TaskQueue,
+  checkEncryptionLibraries,
+  checkFFmpeg,
+  checkIntents,
+  checkInvalidKey,
+  defaultFilters,
+  defaultOptions,
+  formatDuration,
+  handleUnhandledError,
+  isClientInstance,
+  isGuildInstance,
+  isMemberInstance,
+  isMessageInstance,
+  isNsfwChannel,
+  isObject,
+  isSnowflake,
+  isSupportedVoiceChannel,
+  isTextChannelInstance,
+  isTruthy,
+  isURL,
+  isVoiceChannelEmpty,
+  objectKeys,
+  resolveGuildId,
+  version
+});
+//# sourceMappingURL=index.js.map