"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __typeError = (msg) => {
  throw TypeError(msg);
};
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  AF_NIGHTCORE_RATE: () => import_equalizer3.AF_NIGHTCORE_RATE,
  AF_VAPORWAVE_RATE: () => import_equalizer3.AF_VAPORWAVE_RATE,
  AFilterGraph: () => AFilterGraph,
  AsyncQueue: () => AsyncQueue,
  AsyncQueueEntry: () => AsyncQueueEntry,
  AudioFilters: () => AudioFilters,
  AudioPlayer: () => import_discord_voip6.AudioPlayer,
  BASS_EQ_BANDS: () => import_equalizer3.BASS_EQ_BANDS,
  BaseExtractor: () => BaseExtractor,
  BiquadFilterType: () => import_equalizer3.FilterType,
  Context: () => Context,
  DependencyReportGenerator: () => DependencyReportGenerator,
  DiscordPlayerQueryResultCache: () => DiscordPlayerQueryResultCache,
  EqualizerConfigurationPreset: () => EqualizerConfigurationPreset,
  ExtractorExecutionContext: () => ExtractorExecutionContext,
  FFMPEG_ARGS_PIPED: () => FFMPEG_ARGS_PIPED,
  FFMPEG_ARGS_STRING: () => FFMPEG_ARGS_STRING,
  FFMPEG_SRATE_REGEX: () => FFMPEG_SRATE_REGEX,
  FFmpegFilterer: () => FFmpegFilterer,
  FiltersChain: () => import_equalizer3.FiltersChain,
  GuildNodeManager: () => GuildNodeManager,
  GuildQueue: () => GuildQueue5,
  GuildQueueAudioFilters: () => GuildQueueAudioFilters,
  GuildQueueEvent: () => GuildQueueEvent,
  GuildQueueHistory: () => GuildQueueHistory,
  GuildQueuePlayerNode: () => GuildQueuePlayerNode,
  GuildQueueStatistics: () => GuildQueueStatistics,
  InterceptedStream: () => InterceptedStream,
  LrcLib: () => LrcLib,
  PCMAudioFilters: () => import_equalizer3.AudioFilters,
  Player: () => Player,
  PlayerEvent: () => PlayerEvent,
  PlayerEventsEmitter: () => PlayerEventsEmitter,
  PlayerStreamInterceptor: () => PlayerStreamInterceptor,
  Playlist: () => Playlist,
  Q_BUTTERWORTH: () => import_equalizer3.Q_BUTTERWORTH,
  QueryCache: () => QueryCache,
  QueryResolver: () => QueryResolver,
  QueryType: () => QueryType,
  QueueRepeatMode: () => QueueRepeatMode,
  SearchResult: () => SearchResult,
  SequentialBucket: () => SequentialBucket,
  SerializedType: () => SerializedType,
  StreamDispatcher: () => StreamDispatcher,
  StreamType: () => import_discord_voip6.StreamType,
  Track: () => Track,
  TrackSkipReason: () => TrackSkipReason,
  TypeUtil: () => TypeUtil,
  Util: () => Util,
  VALIDATE_QUEUE_CAP: () => VALIDATE_QUEUE_CAP,
  VoiceUtils: () => VoiceUtils,
  VolumeTransformer: () => import_equalizer3.VolumeTransformer,
  createAudioPlayer: () => import_discord_voip6.createAudioPlayer,
  createAudioResource: () => import_discord_voip6.createAudioResource,
  createContext: () => createContext,
  createErisCompat: () => createErisCompat,
  createFFmpegStream: () => createFFmpegStream,
  createOceanicCompat: () => createOceanicCompat,
  decode: () => decode,
  deserialize: () => deserialize,
  encode: () => encode,
  getVoiceConnection: () => import_discord_voip6.getVoiceConnection,
  getVoiceConnections: () => import_discord_voip6.getVoiceConnections,
  isErisProxy: () => isErisProxy,
  isOceanicProxy: () => isOceanicProxy,
  joinVoiceChannel: () => import_discord_voip6.joinVoiceChannel,
  onAfterCreateStream: () => onAfterCreateStream,
  onBeforeCreateStream: () => onBeforeCreateStream,
  onStreamExtracted: () => onStreamExtracted,
  serialize: () => serialize,
  tryIntoThumbnailString: () => tryIntoThumbnailString,
  useContext: () => useContext,
  useHistory: () => useHistory,
  useMainPlayer: () => useMainPlayer,
  useMetadata: () => useMetadata,
  usePlayer: () => usePlayer,
  useQueue: () => useQueue,
  useTimeline: () => useTimeline,
  useVolume: () => useVolume,
  version: () => version
});
module.exports = __toCommonJS(src_exports);

// src/compat/createErisCompat.ts
var import_v10 = require("discord-api-types/v10");

// src/compat/common.ts
var DiscordPlayerClientSymbol = Symbol("DiscordPlayerClient");
function createCompatClient(client, provider) {
  Reflect.set(client, DiscordPlayerClientSymbol, provider);
  return {
    provider,
    client
  };
}
__name(createCompatClient, "createCompatClient");
function isClientProxy(client) {
  return Reflect.get(client, DiscordPlayerClientSymbol) != null;
}
__name(isClientProxy, "isClientProxy");
function getCompatName(client) {
  return Reflect.get(client, DiscordPlayerClientSymbol) ?? null;
}
__name(getCompatName, "getCompatName");
function isErisProxy(client) {
  return getCompatName(client) === "Eris";
}
__name(isErisProxy, "isErisProxy");
function isOceanicProxy(client) {
  return getCompatName(client) === "Oceanic";
}
__name(isOceanicProxy, "isOceanicProxy");

// src/utils/Util.ts
var import_promises = require("timers/promises");

// src/fabric/Track.ts
var import_discord = require("discord.js");

// src/errors/index.ts
var _DiscordPlayerError = class _DiscordPlayerError extends Error {
  constructor(code, message) {
    super(message);
    __publicField(this, "code");
    __publicField(this, "timestamp", Date.now());
    this.name = this.constructor.name;
    this.code = code;
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, this.constructor);
    }
  }
  toJSON() {
    return {
      name: this.constructor.name,
      code: this.code,
      message: this.message,
      timestamp: this.timestamp
    };
  }
};
__name(_DiscordPlayerError, "DiscordPlayerError");
var DiscordPlayerError = _DiscordPlayerError;
var _OutOfSpaceError = class _OutOfSpaceError extends DiscordPlayerError {
  constructor(target, capacity, total) {
    super(
      ErrorCodes.ERR_OUT_OF_SPACE,
      `Max capacity reached for ${target} (Capacity ${capacity}/Total ${total})`
    );
  }
};
__name(_OutOfSpaceError, "OutOfSpaceError");
var OutOfSpaceError = _OutOfSpaceError;
var _InvalidArgTypeError = class _InvalidArgTypeError extends DiscordPlayerError {
  constructor(target, expectation, found) {
    super(
      ErrorCodes.ERR_INVALID_ARG_TYPE,
      `Expected ${target} to be "${expectation}", received "${found}"`
    );
  }
};
__name(_InvalidArgTypeError, "InvalidArgTypeError");
var InvalidArgTypeError = _InvalidArgTypeError;
var _NoResultError = class _NoResultError extends DiscordPlayerError {
  constructor(message) {
    super(ErrorCodes.ERR_NO_RESULT, message);
  }
};
__name(_NoResultError, "NoResultError");
var NoResultError = _NoResultError;
var _NotImplementedError = class _NotImplementedError extends DiscordPlayerError {
  constructor(target) {
    super(ErrorCodes.ERR_NOT_IMPLEMENTED, `${target} is not yet implemented`);
  }
};
__name(_NotImplementedError, "NotImplementedError");
var NotImplementedError = _NotImplementedError;
var _NotExistingError = class _NotExistingError extends DiscordPlayerError {
  constructor(target) {
    super(ErrorCodes.ERR_NOT_EXISTING, `${target} does not exist`);
  }
};
__name(_NotExistingError, "NotExistingError");
var NotExistingError = _NotExistingError;
var _OutOfRangeError = class _OutOfRangeError extends DiscordPlayerError {
  constructor(target, value, minimum, maximum) {
    super(
      ErrorCodes.ERR_OUT_OF_RANGE,
      `${target} is out of range (Expected minimum ${minimum} and maximum ${maximum}, got ${value})`
    );
  }
};
__name(_OutOfRangeError, "OutOfRangeError");
var OutOfRangeError = _OutOfRangeError;
var _NoVoiceConnectionError = class _NoVoiceConnectionError extends DiscordPlayerError {
  constructor(message) {
    super(
      ErrorCodes.ERR_NO_VOICE_CONNECTION,
      message || "No voice connection available, maybe connect to a voice channel first?"
    );
  }
};
__name(_NoVoiceConnectionError, "NoVoiceConnectionError");
var NoVoiceConnectionError = _NoVoiceConnectionError;
var _VoiceConnectionDestroyedError = class _VoiceConnectionDestroyedError extends DiscordPlayerError {
  constructor() {
    super(
      ErrorCodes.ERR_VOICE_CONNECTION_DESTROYED,
      "Cannot use destroyed voice connection"
    );
  }
};
__name(_VoiceConnectionDestroyedError, "VoiceConnectionDestroyedError");
var VoiceConnectionDestroyedError = _VoiceConnectionDestroyedError;
var _NoVoiceChannelError = class _NoVoiceChannelError extends DiscordPlayerError {
  constructor() {
    super(ErrorCodes.ERR_NO_VOICE_CHANNEL, "Could not get the voice channel");
  }
};
__name(_NoVoiceChannelError, "NoVoiceChannelError");
var NoVoiceChannelError = _NoVoiceChannelError;
var _NoAudioResourceError = class _NoAudioResourceError extends DiscordPlayerError {
  constructor(message) {
    super(
      ErrorCodes.ERR_NO_AUDIO_RESOURCE,
      message || "Expected an audio resource"
    );
  }
};
__name(_NoAudioResourceError, "NoAudioResourceError");
var NoAudioResourceError = _NoAudioResourceError;
var _NoGuildQueueError = class _NoGuildQueueError extends DiscordPlayerError {
  constructor(message) {
    super(ErrorCodes.ERR_NO_GUILD_QUEUE, message || "Expected a guild queue");
  }
};
__name(_NoGuildQueueError, "NoGuildQueueError");
var NoGuildQueueError = _NoGuildQueueError;
var _NoGuildError = class _NoGuildError extends DiscordPlayerError {
  constructor(message) {
    super(ErrorCodes.ERR_NO_GUILD, message || "Expected a guild");
  }
};
__name(_NoGuildError, "NoGuildError");
var NoGuildError = _NoGuildError;
var _InfoRequiredError = class _InfoRequiredError extends DiscordPlayerError {
  constructor(target, actual) {
    super(
      ErrorCodes.ERR_INFO_REQUIRED,
      `Expected ${target}, found "${actual}"`
    );
  }
};
__name(_InfoRequiredError, "InfoRequiredError");
var InfoRequiredError = _InfoRequiredError;
var _SerializationError = class _SerializationError extends DiscordPlayerError {
  constructor() {
    super(
      ErrorCodes.ERR_SERIALIZATION_FAILED,
      "Don't know how to serialize this data"
    );
  }
};
__name(_SerializationError, "SerializationError");
var SerializationError = _SerializationError;
var _DeserializationError = class _DeserializationError extends DiscordPlayerError {
  constructor() {
    super(
      ErrorCodes.ERR_DESERIALIZATION_FAILED,
      "Don't know how to deserialize this data"
    );
  }
};
__name(_DeserializationError, "DeserializationError");
var DeserializationError = _DeserializationError;
var _IllegalHookInvocationError = class _IllegalHookInvocationError extends DiscordPlayerError {
  constructor(target, message) {
    super(
      ErrorCodes.ERR_ILLEGAL_HOOK_INVOCATION,
      `Illegal invocation of ${target} hook.${message ? ` ${message}` : ""}`
    );
  }
};
__name(_IllegalHookInvocationError, "IllegalHookInvocationError");
var IllegalHookInvocationError = _IllegalHookInvocationError;
var _BridgeFailedError = class _BridgeFailedError extends DiscordPlayerError {
  constructor(id, error) {
    super(
      ErrorCodes.ERR_BRIDGE_FAILED,
      `${id ? `(Extractor Execution Context ID is ${id})` : ""}Failed to bridge this query:
${error}`
    );
  }
};
__name(_BridgeFailedError, "BridgeFailedError");
var BridgeFailedError = _BridgeFailedError;
var ErrorCodes = {
  ERR_OUT_OF_SPACE: "ERR_OUT_OF_SPACE",
  ERR_INVALID_ARG_TYPE: "ERR_INVALID_ARG_TYPE",
  ERR_NO_RESULT: "ERR_NO_RESULT",
  ERR_NOT_IMPLEMENTED: "ERR_NOT_IMPLEMENTED",
  ERR_NOT_EXISTING: "ERR_NOT_EXISTING",
  ERR_OUT_OF_RANGE: "ERR_OUT_OF_RANGE",
  ERR_NO_VOICE_CONNECTION: "ERR_NO_VOICE_CONNECTION",
  ERR_VOICE_CONNECTION_DESTROYED: "ERR_VOICE_CONNECTION_DESTROYED",
  ERR_NO_VOICE_CHANNEL: "ERR_NO_VOICE_CHANNEL",
  ERR_INVALID_VOICE_CHANNEL: "ERR_INVALID_VOICE_CHANNEL",
  ERR_NO_RECEIVER: "ERR_NO_RECEIVER",
  ERR_FFMPEG_LOCATOR: "ERR_FFMPEG_LOCATOR",
  ERR_NO_AUDIO_RESOURCE: "ERR_NO_AUDIO_RESOURCE",
  ERR_NO_GUILD_QUEUE: "ERR_NO_GUILD_QUEUE",
  ERR_NO_GUILD: "ERR_NO_GUILD",
  ERR_INFO_REQUIRED: "ERR_INFO_REQUIRED",
  ERR_SERIALIZATION_FAILED: "ERR_SERIALIZATION_FAILED",
  ERR_DESERIALIZATION_FAILED: "ERR_DESERIALIZATION_FAILED",
  ERR_ILLEGAL_HOOK_INVOCATION: "ERR_ILLEGAL_HOOK_INVOCATION",
  ERR_NOT_EXISTING_MODULE: "ERR_NOT_EXISTING_MODULE",
  ERR_BRIDGE_FAILED: "ERR_BRIDGE_FAILED"
};
function isDiscordPlayerError(error) {
  return error != null && error instanceof DiscordPlayerError;
}
__name(isDiscordPlayerError, "isDiscordPlayerError");

// src/utils/TypeUtil.ts
var _TypeUtil = class _TypeUtil {
  constructor() {
    return _TypeUtil;
  }
  // eslint-disable-next-line @typescript-eslint/ban-types
  static isFunction(t) {
    return typeof t === "function";
  }
  static isNumber(t) {
    return typeof t === "number" && !isNaN(t);
  }
  static isString(t) {
    return typeof t === "string";
  }
  static isBoolean(t) {
    return typeof t === "boolean";
  }
  static isNullish(t) {
    return t == null;
  }
  static isArray(t) {
    return Array.isArray(t);
  }
  static isError(t) {
    return t instanceof Error;
  }
  static isDiscordPlayerError(t) {
    return isDiscordPlayerError(t);
  }
};
__name(_TypeUtil, "TypeUtil");
var TypeUtil = _TypeUtil;

// src/utils/serde.ts
var import_buffer = require("buffer");
var SerializedType = /* @__PURE__ */ ((SerializedType2) => {
  SerializedType2["Track"] = "track";
  SerializedType2["Playlist"] = "playlist";
  return SerializedType2;
})(SerializedType || {});
var isTrack = /* @__PURE__ */ __name((data) => data.$type === "track" /* Track */, "isTrack");
var isPlaylist = /* @__PURE__ */ __name((data) => data.$type === "playlist" /* Playlist */, "isPlaylist");
function serialize(data) {
  if (data instanceof Track) return data.serialize();
  if (data instanceof Playlist) return data.serialize();
  try {
    return data.toJSON();
  } catch {
    throw new SerializationError();
  }
}
__name(serialize, "serialize");
function deserialize(player, data) {
  if (isTrack(data)) return Track.fromSerialized(player, data);
  if (isPlaylist(data)) return Playlist.fromSerialized(player, data);
  throw new DeserializationError();
}
__name(deserialize, "deserialize");
function encode(data) {
  const str = JSON.stringify(data);
  return import_buffer.Buffer.from(str).toString("base64");
}
__name(encode, "encode");
function decode(data) {
  const str = import_buffer.Buffer.from(data, "base64").toString();
  return JSON.parse(str);
}
__name(decode, "decode");
function tryIntoThumbnailString(data) {
  if (!data) return null;
  try {
    if (TypeUtil.isString(data)) return data;
    return data?.url ?? data?.thumbnail?.url ?? null;
  } catch {
    return null;
  }
}
__name(tryIntoThumbnailString, "tryIntoThumbnailString");

// src/fabric/Track.ts
var _onSeek, _resource;
var _Track = class _Track {
  /**
   * Track constructor
   * @param player The player that instantiated this Track
   * @param data Track data
   */
  constructor(player, data) {
    this.player = player;
    __publicField(this, "title");
    __publicField(this, "description");
    __publicField(this, "author");
    __publicField(this, "url");
    __publicField(this, "thumbnail");
    __publicField(this, "duration");
    __publicField(this, "views");
    __publicField(this, "requestedBy", null);
    __publicField(this, "playlist");
    __publicField(this, "queryType", null);
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    __publicField(this, "raw");
    __publicField(this, "extractor", null);
    __publicField(this, "id", import_discord.SnowflakeUtil.generate().toString());
    __publicField(this, "__metadata", null);
    __publicField(this, "__reqMetadataFn");
    __publicField(this, "cleanTitle");
    __publicField(this, "live", false);
    __publicField(this, "bridgedExtractor", null);
    __publicField(this, "bridgedTrack", null);
    __privateAdd(this, _onSeek, null);
    __privateAdd(this, _resource, null);
    this.title = (0, import_discord.escapeMarkdown)(data.title ?? "");
    this.author = data.author ?? "";
    this.url = data.url ?? "";
    this.thumbnail = data.thumbnail ?? "";
    this.duration = data.duration ?? "";
    this.views = data.views ?? 0;
    this.queryType = data.queryType;
    this.requestedBy = data.requestedBy || null;
    this.playlist = data.playlist;
    this.description = `${this.title} by ${this.author}`;
    this.raw = Object.assign(
      {},
      { source: data.raw?.source ?? data.source },
      data.raw ?? data
    );
    this.__metadata = data.metadata ?? null;
    this.__reqMetadataFn = data.requestMetadata || (() => Promise.resolve(null));
    this.cleanTitle = data.cleanTitle ?? Util.cleanTitle(this.title, this.source);
    this.live = data.live ?? false;
  }
  /**
   * Whether this track can be seeked
   */
  get seekable() {
    return __privateGet(this, _onSeek) !== null;
  }
  /**
   * Set the onSeek event
   * @param fn The onSeek event
   */
  handleSeek(fn) {
    __privateSet(this, _onSeek, fn);
  }
  /**
   * Request seek
   * @param event The seek event
   */
  async seek(event) {
    if (__privateGet(this, _onSeek)) return __privateGet(this, _onSeek).call(this, event);
  }
  /**
   * Sets audio resource for this track. This is not useful outside of the library.
   * @param resource Audio resource
   */
  setResource(resource) {
    __privateSet(this, _resource, resource);
  }
  /**
   * Gets audio resource for this track
   */
  get resource() {
    return __privateGet(this, _resource);
  }
  /**
   * Whether this track has an audio resource
   */
  get hasResource() {
    return __privateGet(this, _resource) != null;
  }
  /**
   * Request metadata for this track
   */
  async requestMetadata() {
    const res = await this.__reqMetadataFn();
    this.setMetadata(res);
    return res;
  }
  /**
   * Set metadata for this track
   */
  setMetadata(m) {
    this.__metadata = m;
  }
  /**
   * Metadata of this track
   */
  get metadata() {
    return this.__metadata;
  }
  /**
   * If this track has metadata
   */
  get hasMetadata() {
    return this.metadata != null;
  }
  /**
   * The queue in which this track is located
   */
  get queue() {
    return this.player.nodes.cache.find(
      (q) => q.tracks.some((ab) => ab.id === this.id)
    );
  }
  /**
   * The track duration in millisecond
   */
  get durationMS() {
    const times = /* @__PURE__ */ __name((n, t) => {
      let tn = 1;
      for (let i = 0; i < t; i++) tn *= n;
      return t <= 0 ? 1e3 : tn * 1e3;
    }, "times");
    return this.duration.split(":").reverse().map((m, i) => parseInt(m) * times(60, i)).reduce((a, c) => a + c, 0);
  }
  /**
   * Discord hyperlink representation of this track
   */
  toHyperlink() {
    return `[${this.title}](${this.url})`;
  }
  /**
   * Returns source of this track
   */
  get source() {
    return this.raw?.source ?? "arbitrary";
  }
  /**
   * String representation of this track
   */
  toString() {
    return `${this.title} by ${this.author}`;
  }
  /**
   * Raw JSON representation of this track
   */
  toJSON(hidePlaylist) {
    return {
      id: this.id,
      title: this.title,
      description: this.description,
      author: this.author,
      url: this.url,
      thumbnail: this.thumbnail,
      duration: this.duration,
      durationMS: this.durationMS,
      views: this.views,
      requestedBy: this.requestedBy?.id || null,
      playlist: hidePlaylist ? null : this.playlist?.toJSON() ?? null
    };
  }
  /**
   * Serialized track data that can be reconstructed
   */
  serialize() {
    return {
      title: this.title,
      description: this.description,
      author: this.author,
      url: this.url,
      thumbnail: TypeUtil.isString(this.thumbnail) ? this.thumbnail : tryIntoThumbnailString(this.thumbnail),
      duration: this.duration,
      views: this.views ?? 0,
      requested_by: this.requestedBy?.toJSON() ?? null,
      source: this.source,
      live: false,
      query_type: this.queryType,
      extractor: this.extractor?.identifier ?? null,
      metadata: this.metadata,
      $type: "track" /* Track */,
      $encoder_version: this.player.version
    };
  }
  /**
   * Construct a track from serialized data
   * @param player Player instance
   * @param data Serialized data
   */
  static fromSerialized(player, data) {
    if (data.$type !== "track" /* Track */)
      throw new InvalidArgTypeError(
        "data",
        "SerializedTrack",
        "malformed data"
      );
    const track = new _Track(player, {
      ...data,
      requestedBy: data.requested_by ? (() => {
        const res = data.requested_by;
        try {
          const resolved = player.client.users.resolve(res.id);
          if (resolved) return resolved;
          if (player.client.users.cache.has(res.id))
            return player.client.users.cache.get(res.id);
          const user = new import_discord.User(player.client, res);
          return user;
        } catch {
          return null;
        }
      })() : null,
      queryType: data.query_type ?? void 0
    });
    track.setMetadata(data.metadata);
    return track;
  }
  /**
   * Get belonging queues of this track
   */
  getBelongingQueues() {
    const nodes = this.player.nodes.cache.filter(
      (node) => node.tracks.some((t) => t.id === this.id)
    );
    return nodes;
  }
  /**
   * Play this track to the given voice channel. If queue exists and another track is being played, this track will be added to the queue.
   * @param channel Voice channel on which this track shall be played
   * @param options Node initialization options
   */
  async play(channel, options) {
    const fn = this.player.play.bind(this.player);
    return await fn(channel, this, options);
  }
};
_onSeek = new WeakMap();
_resource = new WeakMap();
__name(_Track, "Track");
var Track = _Track;

// src/fabric/Playlist.ts
var _Playlist = class _Playlist {
  // eslint-disable-line @typescript-eslint/no-explicit-any
  /**
   * Playlist constructor
   * @param {Player} player The player
   * @param {PlaylistInitData} data The data
   */
  constructor(player, data) {
    __publicField(this, "player");
    __publicField(this, "tracks");
    __publicField(this, "title");
    __publicField(this, "description");
    __publicField(this, "thumbnail");
    __publicField(this, "type");
    __publicField(this, "source");
    __publicField(this, "author");
    __publicField(this, "id");
    __publicField(this, "url");
    __publicField(this, "rawPlaylist");
    this.player = player;
    this.tracks = data.tracks ?? [];
    this.author = data.author;
    this.description = data.description;
    this.thumbnail = data.thumbnail;
    this.type = data.type;
    this.source = data.source;
    this.id = data.id;
    this.url = data.url;
    this.title = data.title;
  }
  *[Symbol.iterator]() {
    yield* this.tracks;
  }
  /**
   * Estimated duration of this playlist
   */
  get estimatedDuration() {
    return this.tracks.reduce((p, c) => p + c.durationMS, 0);
  }
  /**
   * Formatted estimated duration of this playlist
   */
  get durationFormatted() {
    return Util.buildTimeCode(Util.parseMS(this.estimatedDuration));
  }
  /**
   * JSON representation of this playlist
   * @param {boolean} [withTracks=true] If it should build json with tracks
   * @returns {PlaylistJSON}
   */
  toJSON(withTracks = true) {
    const payload = {
      id: this.id,
      url: this.url,
      title: this.title,
      description: this.description,
      thumbnail: this.thumbnail,
      type: this.type,
      source: this.source,
      author: this.author,
      tracks: []
    };
    if (withTracks) payload.tracks = this.tracks.map((m) => m.toJSON(true));
    return payload;
  }
  /**
   * Serialize this playlist into reconstructable data
   */
  serialize() {
    return {
      tracks: this.tracks.map((m) => m.serialize()),
      title: this.title,
      description: this.description,
      thumbnail: TypeUtil.isString(this.thumbnail) ? this.thumbnail : tryIntoThumbnailString(this.thumbnail),
      type: this.type,
      source: this.source,
      author: this.author,
      id: this.id,
      url: this.url,
      $type: "playlist" /* Playlist */,
      $encoder_version: this.player.version
    };
  }
  /**
   * Deserialize this playlist from serialized data
   * @param player Player instance
   * @param data Serialized data
   */
  static fromSerialized(player, data) {
    if (data.$type !== "playlist" /* Playlist */)
      throw new InvalidArgTypeError(
        "data",
        "SerializedPlaylist",
        "malformed data"
      );
    return new _Playlist(player, {
      ...data,
      tracks: data.tracks.map((m) => Track.fromSerialized(player, m))
    });
  }
  /**
   * Play this playlist to the given voice channel. If queue exists and another track is being played, this playlist will be added to the queue.
   * @param channel Voice channel on which this playlist shall be played
   * @param options Node initialization options
   */
  async play(channel, options) {
    const fn = this.player.play.bind(this.player);
    return await fn(channel, this, options);
  }
};
__name(_Playlist, "Playlist");
var Playlist = _Playlist;

// src/utils/QueryResolver.ts
var import_undici = require("undici");
var spotifySongRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(intl-([a-z]|[A-Z])+\/)?(?:track\/|\?uri=spotify:track:)((\w|-){22})(\?si=.+)?$/;
var spotifyPlaylistRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(intl-([a-z]|[A-Z])+\/)?(?:playlist\/|\?uri=spotify:playlist:)((\w|-){22})(\?si=.+)?$/;
var spotifyAlbumRegex = /^https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(intl-([a-z]|[A-Z])+\/)?(?:album\/|\?uri=spotify:album:)((\w|-){22})(\?si=.+)?$/;
var vimeoRegex = /^(http|https)?:\/\/(www\.|player\.)?vimeo\.com\/(?:channels\/(?:\w+\/)?|groups\/([^/]*)\/videos\/|video\/|)(\d+)(?:|\/\?)$/;
var reverbnationRegex = /^https:\/\/(www.)?reverbnation.com\/(.+)\/song\/(.+)$/;
var attachmentRegex = /^https?:\/\/.+$/;
var appleMusicSongRegex = /^https?:\/\/music\.apple\.com\/.+?\/(song|album)\/.+?(\/.+?\?i=|\/)([0-9]+)$/;
var appleMusicPlaylistRegex = /^https?:\/\/music\.apple\.com\/.+?\/playlist\/.+\/pl\.(u-|pm-)?[a-zA-Z0-9]+$/;
var appleMusicAlbumRegex = /^https?:\/\/music\.apple\.com\/.+?\/album\/.+\/([0-9]+)$/;
var soundcloudTrackRegex = /^https?:\/\/(m.|www.)?soundcloud.com\/(\w|-)+\/(\w|-)+(.+)?$/;
var soundcloudPlaylistRegex = /^https?:\/\/(m.|www.)?soundcloud.com\/(\w|-)+\/sets\/(\w|-)+(.+)?$/;
var youtubePlaylistRegex = /^https?:\/\/(www.)?youtube.com\/playlist\?list=((PL|FL|UU|LL|RD|OL)[a-zA-Z0-9-_]{16,41})$/;
var youtubeVideoURLRegex = /^((?:https?:)?\/\/)?((?:www|m)\.)?((?:youtube\.com|youtu.be))(\/(?:[\w-]+\?v=|embed\/|v\/)?)([\w-]+)(\S+)?$/;
var youtubeVideoIdRegex = /^[a-zA-Z0-9-_]{11}$/;
var discordPlayerBlobRegex = /^discord-player:\/\/blob\/\d+$/;
var DomainsMap = {
  DiscordPlayer: ["discord-player"],
  YouTube: [
    "youtube.com",
    "youtu.be",
    "music.youtube.com",
    "gaming.youtube.com",
    "www.youtube.com",
    "m.youtube.com"
  ],
  Spotify: ["open.spotify.com", "embed.spotify.com"],
  Vimeo: ["vimeo.com", "player.vimeo.com"],
  ReverbNation: ["reverbnation.com"],
  SoundCloud: ["soundcloud.com"],
  AppleMusic: ["music.apple.com"]
};
var redirectDomains = /* @__PURE__ */ new Set(
  [
    /^https?:\/\/spotify.link\/[A-Za-z0-9]+$/,
    /^https:\/\/on\.soundcloud\.com\/[a-zA-Z1-9]{0,17}$/
  ]
);
var QueryType = {
  AUTO: "auto",
  YOUTUBE: "youtube",
  YOUTUBE_PLAYLIST: "youtubePlaylist",
  SOUNDCLOUD_TRACK: "soundcloudTrack",
  SOUNDCLOUD_PLAYLIST: "soundcloudPlaylist",
  SOUNDCLOUD: "soundcloud",
  SPOTIFY_SONG: "spotifySong",
  SPOTIFY_ALBUM: "spotifyAlbum",
  SPOTIFY_PLAYLIST: "spotifyPlaylist",
  SPOTIFY_SEARCH: "spotifySearch",
  FACEBOOK: "facebook",
  VIMEO: "vimeo",
  ARBITRARY: "arbitrary",
  REVERBNATION: "reverbnation",
  YOUTUBE_SEARCH: "youtubeSearch",
  YOUTUBE_VIDEO: "youtubeVideo",
  SOUNDCLOUD_SEARCH: "soundcloudSearch",
  APPLE_MUSIC_SONG: "appleMusicSong",
  APPLE_MUSIC_ALBUM: "appleMusicAlbum",
  APPLE_MUSIC_PLAYLIST: "appleMusicPlaylist",
  APPLE_MUSIC_SEARCH: "appleMusicSearch",
  FILE: "file",
  AUTO_SEARCH: "autoSearch",
  DISCORD_PLAYER_BLOB: "discordPlayerBlob"
};
var _QueryResolver = class _QueryResolver {
  /**
   * Query resolver
   */
  constructor() {
  }
  // eslint-disable-line @typescript-eslint/no-empty-function
  static get regex() {
    return {
      spotifyAlbumRegex,
      spotifyPlaylistRegex,
      spotifySongRegex,
      vimeoRegex,
      reverbnationRegex,
      attachmentRegex,
      appleMusicAlbumRegex,
      appleMusicPlaylistRegex,
      appleMusicSongRegex,
      soundcloudTrackRegex,
      soundcloudPlaylistRegex,
      youtubePlaylistRegex,
      discordPlayerBlobRegex
    };
  }
  /**
   * Pre-resolve redirect urls
   */
  static async preResolve(query, maxDepth = 5) {
    if (!TypeUtil.isString(query))
      throw new InvalidArgTypeError(query, "string", typeof query);
    for (const domain of redirectDomains) {
      if (domain.test(query)) {
        try {
          const res = await (0, import_undici.fetch)(query, {
            method: "GET",
            redirect: "follow"
          });
          if (!res.ok) break;
          if (/^https?:\/\/spotify.app.link\/(.+)$/.test(res.url)) {
            const body = await res.text();
            const target = body.split("https://open.spotify.com/track/")[1].split("?si=")[0];
            if (!target) break;
            return `https://open.spotify.com/track/${target}`;
          }
          return maxDepth < 1 ? res.url : this.preResolve(res.url, maxDepth - 1);
        } catch {
          break;
        }
      }
    }
    return query;
  }
  /**
   * Resolves the given search query
   * @param {string} query The query
   */
  static resolve(query, fallbackSearchEngine = QueryType.AUTO_SEARCH) {
    if (!TypeUtil.isString(query))
      throw new InvalidArgTypeError(query, "string", typeof query);
    if (!query.length) throw new InfoRequiredError("query", String(query));
    const resolver = /* @__PURE__ */ __name((type, query2) => ({
      type,
      query: query2
    }), "resolver");
    if (discordPlayerBlobRegex.test(query))
      return resolver(QueryType.DISCORD_PLAYER_BLOB, query);
    try {
      const url = new URL(query);
      if (DomainsMap.YouTube.includes(url.host)) {
        query = query.replace(/(m(usic)?|gaming)\./, "").trim();
        const playlistId = url.searchParams.get("list");
        if (playlistId)
          return resolver(
            QueryType.YOUTUBE_PLAYLIST,
            `https://www.youtube.com/${url.searchParams.size === 1 ? "playlist" : "watch"}${url.search}`
          );
        if (_QueryResolver.validateId(query) || _QueryResolver.validateURL(query))
          return resolver(QueryType.YOUTUBE_VIDEO, query);
        return resolver(fallbackSearchEngine, query);
      } else if (DomainsMap.Spotify.includes(url.host)) {
        query = query.replace(/intl-([a-zA-Z]+)\//, "");
        if (spotifyPlaylistRegex.test(query))
          return resolver(QueryType.SPOTIFY_PLAYLIST, query);
        if (spotifyAlbumRegex.test(query))
          return resolver(QueryType.SPOTIFY_ALBUM, query);
        if (spotifySongRegex.test(query))
          return resolver(QueryType.SPOTIFY_SONG, query);
        return resolver(fallbackSearchEngine, query);
      } else if (DomainsMap.Vimeo.includes(url.host)) {
        if (vimeoRegex.test(query)) return resolver(QueryType.VIMEO, query);
        return resolver(fallbackSearchEngine, query);
      } else if (DomainsMap.ReverbNation.includes(url.host)) {
        if (reverbnationRegex.test(query))
          return resolver(QueryType.REVERBNATION, query);
        return resolver(fallbackSearchEngine, query);
      } else if (DomainsMap.SoundCloud.includes(url.host)) {
        if (soundcloudPlaylistRegex.test(query))
          return resolver(QueryType.SOUNDCLOUD_PLAYLIST, query);
        if (soundcloudTrackRegex.test(query))
          return resolver(QueryType.SOUNDCLOUD_TRACK, query);
        return resolver(fallbackSearchEngine, query);
      } else if (DomainsMap.AppleMusic.includes(url.host)) {
        if (appleMusicAlbumRegex.test(query))
          return resolver(QueryType.APPLE_MUSIC_ALBUM, query);
        if (appleMusicPlaylistRegex.test(query))
          return resolver(QueryType.APPLE_MUSIC_PLAYLIST, query);
        if (appleMusicSongRegex.test(query))
          return resolver(QueryType.APPLE_MUSIC_SONG, query);
        return resolver(fallbackSearchEngine, query);
      } else {
        return resolver(QueryType.ARBITRARY, query);
      }
    } catch {
      return resolver(fallbackSearchEngine, query);
    }
  }
  /**
   * Parses vimeo id from url
   * @param {string} query The query
   * @returns {string}
   */
  static getVimeoID(query) {
    return _QueryResolver.resolve(query).type === QueryType.VIMEO ? query.split("/").filter(Boolean).pop() : null;
  }
  static validateId(q) {
    return youtubeVideoIdRegex.test(q);
  }
  static validateURL(q) {
    return youtubeVideoURLRegex.test(q);
  }
};
__name(_QueryResolver, "QueryResolver");
var QueryResolver = _QueryResolver;

// src/fabric/SearchResult.ts
var _SearchResult = class _SearchResult {
  constructor(player, _data) {
    this.player = player;
    this._data = _data;
    this._data.tracks?.forEach((track) => {
      track.extractor ?? (track.extractor = this._data.extractor || null);
      track.requestedBy ?? (track.requestedBy = _data.requestedBy || null);
    });
  }
  setQueryType(type) {
    this._data.queryType = type;
    return this;
  }
  setRequestedBy(user) {
    this._data.requestedBy = user;
    this._data.tracks?.forEach((track) => {
      track.requestedBy = user;
    });
    return this;
  }
  setExtractor(extractor) {
    this._data.extractor = extractor;
    this._data.tracks?.forEach((track) => {
      track.extractor = extractor;
    });
    return this;
  }
  setTracks(tracks) {
    this._data.tracks = tracks;
    return this;
  }
  setQuery(query) {
    this._data.query = query;
    return this;
  }
  setPlaylist(playlist) {
    this._data.playlist = playlist;
    return this;
  }
  /**
   * The search query
   */
  get query() {
    return this._data.query;
  }
  /**
   * The search query type
   */
  get queryType() {
    return this._data.queryType || QueryType.AUTO;
  }
  /**
   * The extractor
   */
  get extractor() {
    return this._data.extractor || null;
  }
  /**
   * Playlist result
   */
  get playlist() {
    return this._data.playlist;
  }
  /**
   * Tracks result
   */
  get tracks() {
    return this._data.tracks || [];
  }
  /**
   * Requested by
   */
  get requestedBy() {
    return this._data.requestedBy || null;
  }
  /**
   * Re-execute this search
   */
  async execute() {
    return this.player.search(this.query, {
      searchEngine: this.queryType,
      requestedBy: this.requestedBy
    });
  }
  /**
   * If this search result is empty
   */
  isEmpty() {
    return !this.tracks.length;
  }
  /**
   * If this search result has playlist
   */
  hasPlaylist() {
    return this.playlist != null;
  }
  /**
   * If this search result has tracks
   */
  hasTracks() {
    return this.tracks.length > 0;
  }
  /**
   * JSON representation of this search
   */
  toJSON() {
    return {
      query: this.query,
      queryType: this.queryType,
      playlist: this.playlist?.toJSON(false) || null,
      tracks: this.tracks.map((m) => m.toJSON(true)),
      extractor: this.extractor?.identifier || null,
      requestedBy: this.requestedBy?.toJSON() || null
    };
  }
};
__name(_SearchResult, "SearchResult");
var SearchResult = _SearchResult;

// src/utils/AudioFilters.ts
var bass = /* @__PURE__ */ __name((g) => `bass=g=${g}:f=110:w=0.3`, "bass");
var _AudioFilters = class _AudioFilters {
  constructor() {
    return _AudioFilters;
  }
  static get(name) {
    return this.filters[name] ?? name;
  }
  static has(name) {
    return name in this.filters;
  }
  static *[Symbol.iterator]() {
    for (const [k, v] of Object.entries(this.filters)) {
      yield { name: k, value: v };
    }
  }
  static get names() {
    return Object.keys(this.filters);
  }
  // @ts-ignore
  static get length() {
    return this.names.length;
  }
  static toString() {
    return this.names.map((m) => this[m]).join(",");
  }
  /**
   * Create ffmpeg args from the specified filters name
   * @param filter The filter name
   * @returns
   */
  static create(filters) {
    if (!filters || !Array.isArray(filters)) return this.toString();
    return filters.filter((predicate) => typeof predicate === "string").map((m) => this.get(m)).join(",");
  }
  /**
   * Defines audio filter
   * @param filterName The name of the filter
   * @param value The ffmpeg args
   */
  static define(filterName, value) {
    this.filters[filterName] = value;
  }
  /**
   * Defines multiple audio filters
   * @param filtersArray Array of filters containing the filter name and ffmpeg args
   */
  static defineBulk(filtersArray) {
    filtersArray.forEach((arr) => this.define(arr.name, arr.value));
  }
};
__name(_AudioFilters, "AudioFilters");
__publicField(_AudioFilters, "filters", {
  bassboost_low: bass(15),
  bassboost: bass(20),
  bassboost_high: bass(30),
  "8D": "apulsator=hz=0.09",
  vaporwave: "aresample=48000,asetrate=48000*0.8",
  nightcore: "aresample=48000,asetrate=48000*1.25",
  lofi: "aresample=48000,asetrate=48000*0.9,extrastereo=m=2.5:c=disabled",
  phaser: "aphaser=in_gain=0.4",
  tremolo: "tremolo",
  vibrato: "vibrato=f=6.5",
  reverse: "areverse",
  treble: "treble=g=5",
  normalizer2: "dynaudnorm=g=101",
  normalizer: "acompressor",
  surrounding: "surround",
  pulsator: "apulsator=hz=1",
  subboost: "asubboost",
  karaoke: "stereotools=mlev=0.03",
  flanger: "flanger",
  gate: "agate",
  haas: "haas",
  mcompand: "mcompand",
  mono: "pan=mono|c0=.5*c0+.5*c1",
  mstlr: "stereotools=mode=ms>lr",
  mstrr: "stereotools=mode=ms>rr",
  compressor: "compand=points=-80/-105|-62/-80|-15.4/-15.4|0/-12|20/-7.6",
  expander: "compand=attacks=0:points=-80/-169|-54/-80|-49.5/-64.6|-41.1/-41.1|-25.8/-15|-10.8/-4.5|0/0|20/8.3",
  softlimiter: "compand=attacks=0:points=-80/-80|-12.4/-12.4|-6/-8|0/-6.8|20/-2.8",
  chorus: "chorus=0.7:0.9:55:0.4:0.25:2",
  chorus2d: "chorus=0.6:0.9:50|60:0.4|0.32:0.25|0.4:2|1.3",
  chorus3d: "chorus=0.5:0.9:50|60|40:0.4|0.32|0.3:0.25|0.4|0.3:2|2.3|1.3",
  fadein: "afade=t=in:ss=0:d=10",
  dim: `afftfilt="'real=re * (1-clip((b/nb)*b,0,1))':imag='im * (1-clip((b/nb)*b,0,1))'"`,
  earrape: "channelsplit,sidechaingate=level_in=64",
  silenceremove: "silenceremove=1:0:-50dB"
});
var AudioFilters = _AudioFilters;

// src/utils/Util.ts
var import_node_crypto = require("crypto");
var import_metadata_filter = require("@web-scrobbler/metadata-filter");
var _Util = class _Util {
  /**
   * Utils
   */
  constructor() {
  }
  // eslint-disable-line @typescript-eslint/no-empty-function
  /**
   * Gets the runtime information
   */
  static getRuntime() {
    const version2 = typeof navigator !== "undefined" ? navigator.userAgent : null;
    if (typeof Deno !== "undefined" && Deno.version) {
      return { name: "deno", version: Deno.version.deno };
    }
    if (typeof Bun !== "undefined" && Bun.version) {
      return { name: "bun", version: Bun.version };
    }
    if (typeof process !== "undefined" && process.version)
      return { name: "node", version: process.version };
    return { name: "unknown", version: version2 ?? "unknown" };
  }
  /**
   * Creates duration string
   * @param {object} durObj The duration object
   * @returns {string}
   */
  static durationString(durObj) {
    return Object.values(durObj).map((m) => isNaN(m) ? 0 : m).join(":");
  }
  /**
   * Parses milliseconds to consumable time object
   * @param {number} milliseconds The time in ms
   * @returns {TimeData}
   */
  static parseMS(milliseconds) {
    if (isNaN(milliseconds)) milliseconds = 0;
    const round = milliseconds > 0 ? Math.floor : Math.ceil;
    return {
      days: round(milliseconds / 864e5),
      hours: round(milliseconds / 36e5) % 24,
      minutes: round(milliseconds / 6e4) % 60,
      seconds: round(milliseconds / 1e3) % 60
    };
  }
  /**
   * Builds time code
   * @param {TimeData} duration The duration object
   * @returns {string}
   */
  static buildTimeCode(duration) {
    const items = Object.keys(duration);
    const required = ["days", "hours", "minutes", "seconds"];
    const parsed = items.filter((x) => required.includes(x)).map((m) => duration[m]);
    const final = parsed.slice(parsed.findIndex((x) => x !== 0)).map((x) => x.toString().padStart(2, "0")).join(":");
    return final.length <= 3 ? `0:${final.padStart(2, "0") || 0}` : final;
  }
  /**
   * Formats duration
   * @param {number} duration The duration in ms
   */
  static formatDuration(duration) {
    return this.buildTimeCode(this.parseMS(duration));
  }
  /**
   * Picks last item of the given array
   * @param {any[]} arr The array
   * @returns {any}
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  static last(arr) {
    if (!Array.isArray(arr)) return arr;
    return arr[arr.length - 1];
  }
  /**
   * Checks if the voice channel is empty
   * @param {VoiceChannel|StageChannel} channel The voice channel
   * @returns {boolean}
   */
  static isVoiceEmpty(channel) {
    return channel && channel.members.filter((member) => !member.user.bot).size === 0;
  }
  /**
   * Cleans the track title
   * @param title The title
   * @param source The source
   * @returns Cleaned title
   */
  static cleanTitle(title, source) {
    try {
      const filterOpts = {
        // prettier-ignore
        track: [
          import_metadata_filter.removeRemastered,
          import_metadata_filter.removeLive,
          import_metadata_filter.fixTrackSuffix,
          import_metadata_filter.removeZeroWidth,
          import_metadata_filter.replaceNbsp,
          import_metadata_filter.replaceSmartQuotes,
          import_metadata_filter.removeCleanExplicit
        ]
      };
      const spotifyFilter = (0, import_metadata_filter.createFilter)(filterOpts);
      spotifyFilter.extend((0, import_metadata_filter.createSpotifyFilter)());
      const defaultFilter = (0, import_metadata_filter.createFilter)(filterOpts);
      switch (source) {
        case "youtube":
          return (0, import_metadata_filter.youtube)(title);
        case "spotify":
          return spotifyFilter.filterField("track", title);
        default:
          return defaultFilter.filterField("track", title);
      }
    } catch {
      return title;
    }
  }
  /**
   * Safer require
   * @param {string} id Node require id
   * @returns {any}
   */
  static require(id) {
    try {
      return { module: require(id), error: null };
    } catch (error) {
      return { module: null, error };
    }
  }
  static async import(id) {
    try {
      const mod = await import(id);
      return { module: mod, error: null };
    } catch (error) {
      return { module: null, error };
    }
  }
  /**
   * Asynchronous timeout
   * @param {number} time The time in ms to wait
   * @returns {Promise<unknown>}
   */
  static wait(time) {
    return (0, import_promises.setTimeout)(time, void 0, { ref: false });
  }
  static noop() {
  }
  // eslint-disable-line @typescript-eslint/no-empty-function
  static async getFetch() {
    if ("fetch" in globalThis) return globalThis.fetch;
    for (const lib of ["node-fetch", "undici"]) {
      try {
        return await import(lib).then(
          (res) => res.fetch || res.default?.fetch || res.default
        );
      } catch {
        try {
          const res = require(lib);
          if (res) return res.fetch || res.default?.fetch || res.default;
        } catch {
        }
      }
    }
  }
  static warn(message, code = "DeprecationWarning", detail) {
    process.emitWarning(message, {
      code,
      detail
    });
  }
  static randomChoice(src) {
    return src[(0, import_node_crypto.randomInt)(src.length)];
  }
  static arrayCloneShuffle(src) {
    const arr = src.slice();
    let m = arr.length;
    while (m) {
      const i = Math.floor(Math.random() * m--);
      [arr[m], arr[i]] = [arr[i], arr[m]];
    }
    return arr;
  }
};
__name(_Util, "Util");
var Util = _Util;
var VALIDATE_QUEUE_CAP = /* @__PURE__ */ __name((queue, items) => {
  if (queue.maxSize < 1 || queue.maxSize === Infinity) return;
  const tracks = typeof items === "number" ? items : (items instanceof Playlist ? items.tracks : Array.isArray(items) ? items : [items]).length;
  const maxCap = queue.getCapacity();
  if (maxCap < tracks) {
    throw new OutOfSpaceError("tracks queue", maxCap, tracks);
  }
}, "VALIDATE_QUEUE_CAP");

// src/compat/createErisCompat.ts
var DiscordPlayerClientSymbol2 = Symbol("DiscordPlayerClient");
function declareProperty(target, key, value) {
  Reflect.set(target, key, value);
}
__name(declareProperty, "declareProperty");
function getProperty(target, key) {
  return Reflect.get(target, key);
}
__name(getProperty, "getProperty");
function createErisCompat(client) {
  const { module: module2, error } = Util.require("eris");
  if (error) throw error;
  const eris = module2;
  erisVoiceEventsHandler(client);
  const erisProxy = new Proxy(client, {
    get(target, p) {
      switch (p) {
        case "users":
          return erisUsersProxy(target, eris);
        case "guilds":
          return erisGuildsProxy(target, eris);
        case "channels":
          return erisChannelsProxy(target, eris);
        case "__dp_voiceStateUpdate_proxy":
          return (handler) => erisVoiceStateUpdateProxy(target, erisProxy, handler);
        case "incrementMaxListeners":
          return () => {
            client.setMaxListeners(client.getMaxListeners() + 1);
          };
        case "decrementMaxListeners":
          return () => {
            const listeners = client.getMaxListeners() - 1;
            client.setMaxListeners(listeners < 0 ? 1 : listeners);
          };
        default:
          return target[p];
      }
    }
  });
  Reflect.set(erisProxy, DiscordPlayerClientSymbol2, "Eris");
  return createCompatClient(erisProxy, "Eris").client;
}
__name(createErisCompat, "createErisCompat");
function erisVoiceStateUpdateProxy(client, proxy, handler) {
  client.on("voiceStateUpdate", (member, oldState) => {
    try {
      const proxiedOldState = {
        channelId: oldState.channelID,
        serverMute: oldState.mute,
        suppress: oldState.suppress,
        guild: {
          id: oldState.guild.id
        },
        member: {
          id: oldState.user.id
        }
      };
      const me = member.guild.members.get(client.user.id);
      const resolvedChannel = member.guild.channels.get(
        member.voiceState.channelID
      );
      const proxiedNewState = {
        channelId: member.voiceState.channelID,
        serverMute: member.voiceState.mute,
        suppress: member.voiceState.suppress,
        channel: erisResolvedChannelProxy(resolvedChannel, client),
        member: {
          id: member.id
        },
        guild: {
          id: member.guild.id,
          members: {
            me: {
              id: me?.id,
              voice: {
                async setRequestToSpeak(value) {
                  return me?.voiceState;
                }
              }
            }
          }
        }
      };
      return handler(proxiedNewState, proxiedOldState);
    } catch {
    }
  });
}
__name(erisVoiceStateUpdateProxy, "erisVoiceStateUpdateProxy");
function erisVoiceEventsHandler(client) {
  let adapters = getProperty(client, "adapters");
  if (!adapters) {
    const collection = /* @__PURE__ */ new Map();
    adapters = collection;
    declareProperty(client, "adapters", collection);
  }
  client.on("shardDisconnect", (_, shardId) => {
    for (const [guildId, adapter] of adapters.entries()) {
      if (client.guilds.get(guildId)?.shard.id === shardId) {
        adapter.destroy();
      }
    }
  });
  client.on("rawWS", (packet) => {
    switch (packet.t) {
      case import_v10.GatewayDispatchEvents.VoiceServerUpdate: {
        const payload = packet.d;
        adapters.get(payload.guild_id)?.onVoiceServerUpdate(payload);
        return;
      }
      case import_v10.GatewayDispatchEvents.VoiceStateUpdate: {
        const payload = packet.d;
        if (payload.guild_id && payload.session_id && payload.user_id === client.user.id) {
          adapters.get(payload.guild_id)?.onVoiceStateUpdate(payload);
        }
        return;
      }
      default:
        break;
    }
  });
}
__name(erisVoiceEventsHandler, "erisVoiceEventsHandler");
function erisChannelsProxy(client, eris) {
  const handler = {
    client,
    get cache() {
      return {
        get(id) {
          return client.getChannel(id);
        },
        has(id) {
          return id in client.channelGuildMap;
        }
      };
    },
    resolve(resolvable) {
      if (typeof resolvable === "string") {
        return erisResolvedChannelProxy(
          this.client.getChannel(resolvable),
          client
        );
      }
      if (resolvable instanceof eris.GuildChannel) {
        return erisResolvedChannelProxy(resolvable, client);
      }
    },
    resolveId(resolvable) {
      const channel = this.resolve(resolvable);
      return channel?.id;
    }
  };
  return handler;
}
__name(erisChannelsProxy, "erisChannelsProxy");
function erisResolvedChannelProxy(channel, client) {
  if (!channel) return;
  return new Proxy(channel, {
    get(target, p) {
      switch (p) {
        case "guild":
          return erisVoiceAdapterProxy(target.guild, client);
        case "members":
          return target.voiceMembers;
        case "isVoiceBased":
          return () => target.type === import_v10.ChannelType.GuildVoice || target.type === import_v10.ChannelType.GuildStageVoice;
        case "isVoice":
          return () => target.type === import_v10.ChannelType.GuildVoice;
        case "isStage":
          return () => target.type === import_v10.ChannelType.GuildStageVoice;
        default:
          return target[p];
      }
    }
  });
}
__name(erisResolvedChannelProxy, "erisResolvedChannelProxy");
function erisVoiceAdapterProxy(guild, client) {
  if (!guild) return;
  return new Proxy(guild, {
    get(target, p) {
      if (p === "voiceAdapterCreator") {
        return erisVoiceAdapterCreator(target, client);
      }
      return target[p];
    }
  });
}
__name(erisVoiceAdapterProxy, "erisVoiceAdapterProxy");
function erisVoiceAdapterCreator(guild, client) {
  return (methods) => {
    let adapters = getProperty(client, "adapters");
    if (!adapters) {
      const collection = /* @__PURE__ */ new Map();
      adapters = collection;
      declareProperty(client, "adapters", collection);
    }
    adapters.set(guild.id, methods);
    return {
      sendPayload(payload) {
        if (guild.shard.status !== "ready") return false;
        guild.shard.sendWS(payload.op, payload.d);
        return true;
      },
      destroy() {
        adapters.delete(guild.id);
      }
    };
  };
}
__name(erisVoiceAdapterCreator, "erisVoiceAdapterCreator");
function erisGuildsProxy(client, eris) {
  return new Proxy(client.guilds, {
    get(target, p) {
      if (p === "cache") {
        return target;
      }
      if (p === "resolve" || p === "resolveId") {
        const resolver = /* @__PURE__ */ __name(function(resolvable) {
          if (typeof resolvable === "string") {
            return target.get(resolvable);
          }
          if (resolvable instanceof eris.Guild) {
            return resolvable;
          }
          if (resolvable instanceof eris.Member || resolvable instanceof eris.Guild || resolvable instanceof eris.GuildChannel || resolvable instanceof eris.Role) {
            return resolvable.guild;
          }
        }, "resolver");
        if (p === "resolve") {
          return resolver;
        }
        return (resolvable) => {
          const guild = resolver(resolvable);
          return guild?.id;
        };
      }
      return target[p];
    }
  });
}
__name(erisGuildsProxy, "erisGuildsProxy");
function erisUsersProxy(client, eris) {
  return new Proxy(client.users, {
    get(target, p) {
      if (p === "cache") {
        return target;
      }
      if (p === "resolve" || p === "resolveId") {
        const resolver = /* @__PURE__ */ __name(function(resolvable) {
          if (typeof resolvable === "string") {
            return target.get(resolvable);
          }
          if (resolvable instanceof eris.User) {
            return resolvable;
          }
          if (resolvable instanceof eris.Member) {
            return resolvable.user;
          }
        }, "resolver");
        if (p === "resolve") {
          return resolver;
        }
        return (resolvable) => {
          const user = resolver(resolvable);
          return user?.id;
        };
      }
      return target[p];
    }
  });
}
__name(erisUsersProxy, "erisUsersProxy");

// src/compat/createOceanicCompat.ts
var import_v102 = require("discord-api-types/v10");
var DiscordPlayerClientSymbol3 = Symbol("DiscordPlayerClient");
function declareProperty2(target, key, value) {
  Reflect.set(target, key, value);
}
__name(declareProperty2, "declareProperty");
function getProperty2(target, key) {
  return Reflect.get(target, key);
}
__name(getProperty2, "getProperty");
function createOceanicCompat(client) {
  const { module: module2, error } = Util.require("oceanic.js");
  if (error) throw error;
  const oceanic = module2;
  oceanicVoiceEventsHandler(client);
  const oceanicProxy = new Proxy(client, {
    get(target, p) {
      switch (p) {
        case "users":
          return oceanicUsersProxy(target, oceanic);
        case "guilds":
          return oceanicGuildsProxy(target, oceanic);
        case "channels":
          return oceanicChannelsProxy(target, oceanic);
        case "__dp_voiceStateUpdate_proxy":
          return (handler) => oceanicVoiceStateUpdateProxy(target, oceanicProxy, handler);
        case "incrementMaxListeners":
          return () => {
            client.setMaxListeners(client.getMaxListeners() + 1);
          };
        case "decrementMaxListeners":
          return () => {
            const listeners = client.getMaxListeners() - 1;
            client.setMaxListeners(listeners < 0 ? 1 : listeners);
          };
        default:
          return target[p];
      }
    }
  });
  Reflect.set(oceanicProxy, DiscordPlayerClientSymbol3, "Oceanic");
  return createCompatClient(oceanicProxy, "Oceanic").client;
}
__name(createOceanicCompat, "createOceanicCompat");
function oceanicVoiceStateUpdateProxy(client, proxy, handler) {
  client.on("voiceStateUpdate", (member, oldState) => {
    try {
      const proxiedOldState = {
        channelId: oldState.channelID,
        serverMute: oldState.mute,
        suppress: oldState.suppress,
        guild: {
          id: oldState.guild.id
        },
        member: {
          id: oldState.user.id
        }
      };
      const me = member.guild.members.get(client.user.id);
      const resolvedChannel = member.guild.channels.get(
        member.voiceState.channelID
      );
      const proxiedNewState = {
        channelId: member.voiceState.channelID,
        serverMute: member.voiceState.mute,
        suppress: member.voiceState.suppress,
        channel: oceanicResolvedChannelProxy(resolvedChannel, client),
        member: {
          id: member.id
        },
        guild: {
          id: member.guild.id,
          members: {
            me: {
              id: me?.id,
              voice: {
                async setRequestToSpeak(value) {
                  return me?.voiceState;
                }
              }
            }
          }
        }
      };
      return handler(proxiedNewState, proxiedOldState);
    } catch {
    }
  });
}
__name(oceanicVoiceStateUpdateProxy, "oceanicVoiceStateUpdateProxy");
function oceanicVoiceEventsHandler(client) {
  let adapters = getProperty2(client, "adapters");
  if (!adapters) {
    const collection = /* @__PURE__ */ new Map();
    adapters = collection;
    declareProperty2(client, "adapters", collection);
  }
  client.on("shardDisconnect", (_, shardId) => {
    for (const [guildId, adapter] of adapters.entries()) {
      if (client.guilds.get(guildId)?.shard.id === shardId) {
        adapter.destroy();
      }
    }
  });
  client.on("packet", (packet) => {
    switch (packet.t) {
      case import_v102.GatewayDispatchEvents.VoiceServerUpdate: {
        const payload = packet.d;
        adapters.get(payload.guild_id)?.onVoiceServerUpdate(payload);
        return;
      }
      case import_v102.GatewayDispatchEvents.VoiceStateUpdate: {
        const payload = packet.d;
        if (payload.guild_id && payload.session_id && payload.user_id === client.user.id) {
          adapters.get(payload.guild_id)?.onVoiceStateUpdate(payload);
        }
        return;
      }
      default:
        break;
    }
  });
}
__name(oceanicVoiceEventsHandler, "oceanicVoiceEventsHandler");
function oceanicChannelsProxy(client, oceanic) {
  const handler = {
    client,
    get cache() {
      return {
        get(id) {
          return client.getChannel(id);
        },
        has(id) {
          return id in client.channelGuildMap;
        }
      };
    },
    resolve(resolvable) {
      if (typeof resolvable === "string") {
        return oceanicResolvedChannelProxy(
          this.client.getChannel(resolvable),
          client
        );
      }
      if (resolvable instanceof oceanic.GuildChannel) {
        return oceanicResolvedChannelProxy(resolvable, client);
      }
    },
    resolveId(resolvable) {
      const channel = this.resolve(resolvable);
      return channel?.id;
    }
  };
  return handler;
}
__name(oceanicChannelsProxy, "oceanicChannelsProxy");
function oceanicResolvedChannelProxy(channel, client) {
  if (!channel) return;
  return new Proxy(channel, {
    get(target, p) {
      switch (p) {
        case "guild":
          return oceanicVoiceAdapterProxy(target.guild, client);
        case "members":
          return target.voiceMembers;
        case "isVoiceBased":
          return () => target.type === import_v102.ChannelType.GuildVoice || target.type === import_v102.ChannelType.GuildStageVoice;
        case "isVoice":
          return () => target.type === import_v102.ChannelType.GuildVoice;
        case "isStage":
          return () => target.type === import_v102.ChannelType.GuildStageVoice;
        default:
          return target[p];
      }
    }
  });
}
__name(oceanicResolvedChannelProxy, "oceanicResolvedChannelProxy");
function oceanicVoiceAdapterProxy(guild, client) {
  if (!guild) return;
  return new Proxy(guild, {
    get(target, p) {
      if (p === "voiceAdapterCreator") {
        return oceanicVoiceAdapterCreator(target, client);
      }
      return target[p];
    }
  });
}
__name(oceanicVoiceAdapterProxy, "oceanicVoiceAdapterProxy");
function oceanicVoiceAdapterCreator(guild, client) {
  return (methods) => {
    let adapters = getProperty2(client, "adapters");
    if (!adapters) {
      const collection = /* @__PURE__ */ new Map();
      adapters = collection;
      declareProperty2(client, "adapters", collection);
    }
    adapters.set(guild.id, methods);
    return {
      sendPayload(payload) {
        if (guild.shard.status !== "ready") return false;
        guild.shard.send(payload.op, payload.d);
        return true;
      },
      destroy() {
        adapters.delete(guild.id);
      }
    };
  };
}
__name(oceanicVoiceAdapterCreator, "oceanicVoiceAdapterCreator");
function oceanicGuildsProxy(client, oceanic) {
  return new Proxy(client.guilds, {
    get(target, p) {
      if (p === "cache") {
        return target;
      }
      if (p === "resolve" || p === "resolveId") {
        const resolver = /* @__PURE__ */ __name(function(resolvable) {
          if (typeof resolvable === "string") {
            return target.get(resolvable);
          }
          if (resolvable instanceof oceanic.Guild) {
            return resolvable;
          }
          if (resolvable instanceof oceanic.Member || resolvable instanceof oceanic.Guild || resolvable instanceof oceanic.GuildChannel || resolvable instanceof oceanic.Role) {
            return resolvable.guild;
          }
        }, "resolver");
        if (p === "resolve") {
          return resolver;
        }
        return (resolvable) => {
          const guild = resolver(resolvable);
          return guild?.id;
        };
      }
      return target[p];
    }
  });
}
__name(oceanicGuildsProxy, "oceanicGuildsProxy");
function oceanicUsersProxy(client, oceanic) {
  return new Proxy(client.users, {
    get(target, p) {
      if (p === "cache") {
        return target;
      }
      if (p === "resolve" || p === "resolveId") {
        const resolver = /* @__PURE__ */ __name(function(resolvable) {
          if (typeof resolvable === "string") {
            return target.get(resolvable);
          }
          if (resolvable instanceof oceanic.User) {
            return resolvable;
          }
          if (resolvable instanceof oceanic.Member) {
            return resolvable.user;
          }
        }, "resolver");
        if (p === "resolve") {
          return resolver;
        }
        return (resolvable) => {
          const user = resolver(resolvable);
          return user?.id;
        };
      }
      return target[p];
    }
  });
}
__name(oceanicUsersProxy, "oceanicUsersProxy");

// src/utils/PlayerEventsEmitter.ts
var import_utils = require("@discord-player/utils");
var _hasDebugger;
var _PlayerEventsEmitter = class _PlayerEventsEmitter extends import_utils.EventEmitter {
  constructor(requiredEvents = []) {
    super();
    this.requiredEvents = requiredEvents;
    __privateAdd(this, _hasDebugger, false);
  }
  on(name, listener) {
    if (name === "debug") {
      __privateSet(this, _hasDebugger, true);
    }
    return super.on(name, listener);
  }
  once(name, listener) {
    if (name === "debug") {
      __privateSet(this, _hasDebugger, true);
    }
    return super.once(name, listener);
  }
  addListener(name, listener) {
    if (name === "debug") {
      __privateSet(this, _hasDebugger, true);
    }
    return super.addListener(name, listener);
  }
  off(name, listener) {
    __privateSet(this, _hasDebugger, this.listenerCount("debug") > 0);
    return super.off(name, listener);
  }
  removeListener(name, listener) {
    __privateSet(this, _hasDebugger, this.listenerCount("debug") > 0);
    return super.removeListener(name, listener);
  }
  removeAllListeners(name) {
    __privateSet(this, _hasDebugger, this.listenerCount("debug") > 0);
    return super.removeAllListeners(name);
  }
  emit(name, ...args) {
    if (this.requiredEvents.includes(name) && !this.eventNames().includes(name)) {
      console.error(...args);
      Util.warn(
        `No event listener found for event "${String(
          name
        )}". Events ${this.requiredEvents.map((m) => `"${String(m)}"`).join(", ")} must have event listeners.`,
        "UnhandledEventsWarning"
      );
      return false;
    }
    return super.emit(name, ...args);
  }
  get hasDebugger() {
    return __privateGet(this, _hasDebugger);
  }
};
_hasDebugger = new WeakMap();
__name(_PlayerEventsEmitter, "PlayerEventsEmitter");
var PlayerEventsEmitter = _PlayerEventsEmitter;

// src/extractors/BaseExtractor.ts
var _BaseExtractor = class _BaseExtractor {
  /**
   * Extractor constructor
   * @param context Context that instantiated this extractor
   * @param options Initialization options for this extractor
   */
  constructor(context, options = {}) {
    this.context = context;
    this.options = options;
    /**
     * Priority of this extractor. Higher value means higher priority (will be executed first).
     */
    __publicField(this, "priority", 1);
    /**
     * A list of query protocols that this extractor supports.
     */
    __publicField(this, "protocols", []);
    /**
     * Handle bridge query creation
     * @param track The track to build query for
     */
    __publicField(this, "createBridgeQuery", /* @__PURE__ */ __name((track) => `${track.title} by ${track.author} official audio`, "createBridgeQuery"));
  }
  /**
   * Identifier of this extractor
   */
  get identifier() {
    return this.constructor.identifier;
  }
  /**
   * Reconfigures this extractor
   * @param options The new options to apply
   */
  async reconfigure(options) {
    this.options = options;
    await this.deactivate();
    await this.activate();
  }
  /**
   * This method will be executed when this extractor is activated
   */
  async activate() {
    return;
  }
  /**
   * This method will be executed when this extractor is deactivated
   */
  async deactivate() {
    return;
  }
  /**
   * Validate incoming query
   * @param query The query to validate
   */
  async validate(query, type) {
    return false;
  }
  /**
   * Stream the given track
   * @param info The track to stream
   */
  async stream(info) {
    throw new NotImplementedError(`${this.constructor.name}.stream()`);
  }
  /**
   * Handle the given query
   * @param query The query to handle
   */
  async handle(query, context) {
    throw new NotImplementedError(`${this.constructor.name}.handle()`);
  }
  /**
   * Get related tracks for the given track
   * @param track The track source
   */
  async getRelatedTracks(track, history) {
    throw new NotImplementedError(
      `${this.constructor.name}.getRelatedTracks()`
    );
  }
  /**
   * A stream middleware to handle streams before passing it to the player
   * @param stream The incoming stream
   * @param next The next function
   */
  handlePostStream(stream, next) {
    return next(null, stream);
  }
  /**
   * Dispatch an event to the player
   * @param event The event to dispatch
   * @param args The data to dispatch
   */
  emit(event, ...args) {
    return this.context.player.emit(event, ...args);
  }
  /**
   * Create extractor response
   * @param playlist The playlist
   * @param tracks The track array
   */
  createResponse(playlist, tracks = playlist?.tracks || []) {
    return { playlist: playlist || null, tracks };
  }
  /**
   * Write debug message
   * @param message The debug message
   */
  debug(message) {
    return this.context.player.debug(message);
  }
  /**
   * A flag to indicate `Demuxable` stream support for `opus`/`ogg/opus`/`webm/opus` formats.
   */
  get supportsDemux() {
    return !!this.context.player.options.skipFFmpeg;
  }
  /**
   * Handle stream extraction for another extractor
   * @param track The track to bridge
   * @param sourceExtractor The source extractor
   */
  async bridge(track, sourceExtractor) {
    return null;
  }
};
__name(_BaseExtractor, "BaseExtractor");
/**
 * Identifier for this extractor
 */
__publicField(_BaseExtractor, "identifier", "com.discord-player.extractor");
var BaseExtractor = _BaseExtractor;

// src/extractors/ExtractorExecutionContext.ts
var import_utils3 = require("@discord-player/utils");

// src/hooks/context/async-context.ts
var import_node_async_hooks = require("async_hooks");
var _Context = class _Context {
  constructor(defaultValue) {
    this.defaultValue = defaultValue;
    __publicField(this, "storage", new import_node_async_hooks.AsyncLocalStorage());
  }
  /**
   * Exit out of this context
   */
  exit(scope) {
    this.storage.exit(scope);
  }
  /**
   * Whether the context is lost
   */
  get isLost() {
    return this.storage.getStore() === void 0;
  }
  /**
   * Get the current value of the context. If the context is lost and no default value is provided, undefined will be returned.
   */
  consume() {
    const data = this.storage.getStore();
    if (data === void 0 && this.defaultValue !== void 0)
      return this.defaultValue;
    return data;
  }
  /**
   * Run a function within the context of this provider
   */
  provide(value, receiver) {
    if (value === void 0) {
      throw new Error("Context value may not be undefined");
    }
    if (typeof receiver !== "function") {
      throw new Error("Context receiver must be a function");
    }
    return this.storage.run(value, receiver);
  }
};
__name(_Context, "Context");
var Context = _Context;
function createContext(defaultValue) {
  return new Context(defaultValue);
}
__name(createContext, "createContext");
function useContext(context) {
  return context.consume();
}
__name(useContext, "useContext");

// src/utils/__internal__/_container.ts
var import_utils2 = require("@discord-player/utils");
var globalRegistry = new import_utils2.Collection();

// src/utils/__internal__/getGlobalRegistry.ts
function getGlobalRegistry() {
  return globalRegistry;
}
__name(getGlobalRegistry, "getGlobalRegistry");

// src/hooks/common.ts
var SUPER_CONTEXT = createContext();
var getFallbackContext = /* @__PURE__ */ __name(() => {
  return getGlobalRegistry().get("@[player]");
}, "getFallbackContext");
function useHooksContext(hookName, mainOnly = false) {
  let isFallback = false;
  let player;
  if (!(player = SUPER_CONTEXT.consume())) {
    player = getFallbackContext();
    isFallback = true;
  }
  if (!player)
    throw new IllegalHookInvocationError(
      "discord-player",
      `Player context is not available, ${isFallback ? "did you forget to initialize the player with `new Player(client)`?" : "is it being called inside <Player>.context.provide()?"}`
    );
  if (mainOnly) return { player, context: {}, isFallback };
  let context;
  if (!isFallback) {
    context = useContext(player.context);
    if (!context)
      throw new IllegalHookInvocationError(
        hookName,
        `${hookName} must be called inside a player context created by <Player>.context.provide()`
      );
  } else {
    context = {
      get guild() {
        throw new IllegalHookInvocationError(
          hookName,
          `${hookName} must be called with an explicit guild argument when not inside a player context`
        );
      }
    };
  }
  return { context, player, isFallback };
}
__name(useHooksContext, "useHooksContext");

// src/hooks/useHistory.ts
function useHistory(node) {
  const { context, player } = useHooksContext("useHistory");
  const queue = player.queues.get(node ?? context.guild.id);
  if (!queue) return null;
  return queue.history;
}
__name(useHistory, "useHistory");

// src/hooks/usePlayer.ts
function usePlayer(node) {
  const { context, player } = useHooksContext("usePlayer");
  const queue = player.queues.get(node ?? context.guild.id);
  if (!queue) return null;
  return queue.node;
}
__name(usePlayer, "usePlayer");

// src/hooks/useQueue.ts
function useQueue(node) {
  const { context, player } = useHooksContext("useQueue");
  const queue = player.queues.resolve(node ?? context.guild.id);
  if (!queue) return null;
  return queue;
}
__name(useQueue, "useQueue");

// src/hooks/useMainPlayer.ts
function useMainPlayer() {
  const { player } = useHooksContext("useMainPlayer", true);
  return player;
}
__name(useMainPlayer, "useMainPlayer");

// src/hooks/useMetadata.ts
function useMetadata(node) {
  const { context, player } = useHooksContext("useMetadata");
  const queue = player.queues.get(node ?? context.guild.id);
  const setter = /* @__PURE__ */ __name((metadata) => {
    if (queue) {
      if (TypeUtil.isFunction(metadata))
        return queue.setMetadata(metadata(queue.metadata));
      return queue.setMetadata(metadata);
    }
  }, "setter");
  const getter = /* @__PURE__ */ __name(() => {
    return queue?.metadata;
  }, "getter");
  return [getter, setter];
}
__name(useMetadata, "useMetadata");

// src/hooks/useTimeline.ts
function useTimeline(options) {
  const { context, player } = useHooksContext("useTimeline");
  const queue = player.queues.get(options?.node ?? context.guild.id);
  if (!queue) return null;
  const timeline = Object.preventExtensions({
    get timestamp() {
      return queue.node.getTimestamp(options?.ignoreFilters);
    },
    get volume() {
      return queue.node.volume;
    },
    get paused() {
      return queue.node.isPaused();
    },
    get track() {
      return queue.currentTrack;
    },
    pause() {
      return queue.node.pause();
    },
    resume() {
      return queue.node.resume();
    },
    setVolume(vol) {
      return queue.node.setVolume(vol);
    },
    async setPosition(time) {
      return queue.node.seek(time);
    }
  });
  return timeline;
}
__name(useTimeline, "useTimeline");

// src/hooks/stream/onAfterCreateStream.ts
function onAfterCreateStream(handler) {
  getGlobalRegistry().set("@[onAfterCreateStream]", handler);
}
__name(onAfterCreateStream, "onAfterCreateStream");

// src/hooks/stream/onBeforeCreateStream.ts
function onBeforeCreateStream(handler) {
  getGlobalRegistry().set("@[onBeforeCreateStream]", handler);
}
__name(onBeforeCreateStream, "onBeforeCreateStream");

// src/hooks/stream/onStreamExtracted.ts
function onStreamExtracted(handler) {
  getGlobalRegistry().set("@[onStreamExtracted]", handler);
}
__name(onStreamExtracted, "onStreamExtracted");

// src/hooks/useVolume.ts
function useVolume(node) {
  const { context, player } = useHooksContext("useVolume");
  const queue = player.queues.get(node ?? context.guild.id);
  const setter = /* @__PURE__ */ __name((volume) => {
    if (queue) {
      if (TypeUtil.isFunction(volume))
        return queue.node.setVolume(volume(queue.node.volume));
      return queue.node.setVolume(volume);
    }
  }, "setter");
  const getter = /* @__PURE__ */ __name(() => {
    return queue?.node.volume;
  }, "getter");
  return [getter, setter];
}
__name(useVolume, "useVolume");

// src/extractors/ExtractorExecutionContext.ts
var _ExtractorExecutionContext = class _ExtractorExecutionContext extends PlayerEventsEmitter {
  constructor(player) {
    super(["error"]);
    this.player = player;
    /**
     * The extractors store
     */
    __publicField(this, "store", new import_utils3.Collection());
    __publicField(this, "context", createContext());
  }
  /**
   * Get the current execution id
   */
  getExecutionId() {
    return this.context.consume()?.id ?? null;
  }
  /**
   * Get the current execution context
   */
  getContext() {
    return this.context.consume() ?? null;
  }
  async loadDefault() {
    const sample = `	import { DefaultExtractors } from '@discord-player/extractor';
	await player.extractors.loadMulti(DefaultExtractors);`;
    throw new Error(
      `extractors.loadDefault() is no longer supported. Use extractors.loadMulti instead. Example:
${sample}
`
    );
  }
  /**
   * Load a bundle of extractors.
   * @example import { DefaultExtractors } from '@discord-player/extractor';
   *
   * await player.extractors.loadMulti(DefaultExtractors);
   */
  async loadMulti(bundle, options = {}) {
    bundle.forEach((ext) => {
      this.register(ext, options?.[ext.identifier] || {});
    });
    return { success: true, error: null };
  }
  /**
   * Validate if the given extractor is registered
   * @param identifier The extractor identifier
   */
  isRegistered(identifier) {
    return this.store.has(identifier);
  }
  /**
   * The size of registered extractors
   */
  get size() {
    return this.store.size;
  }
  /**
   * Get single extractor
   * @param identifier The extractor to get
   */
  get(identifier) {
    return this.store.get(identifier);
  }
  /**
   * Register single extractor
   * @param _extractor The extractor to register
   * @param options Options supplied to the extractor
   */
  async register(_extractor, options) {
    if (typeof _extractor.identifier !== "string" || this.store.has(_extractor.identifier))
      return null;
    const extractor = new _extractor(this, options);
    try {
      this.store.set(_extractor.identifier, extractor);
      if (this.player.hasDebugger)
        this.player.debug(`${_extractor.identifier} extractor loaded!`);
      this.emit("registered", this, extractor);
      await extractor.activate();
      if (this.player.hasDebugger)
        this.player.debug(`${_extractor.identifier} extractor activated!`);
      this.emit("activate", this, extractor);
      return extractor;
    } catch (e) {
      this.store.delete(_extractor.identifier);
      if (this.player.hasDebugger)
        this.player.debug(
          `${_extractor.identifier} extractor failed to activate! Error: ${e}`
        );
      this.emit("error", this, extractor, e);
      return null;
    }
  }
  /**
   * Unregister single extractor
   * @param _extractor The extractor to unregister
   */
  async unregister(_extractor) {
    const extractor = typeof _extractor === "string" ? this.store.get(_extractor) : this.store.find((r) => r === _extractor);
    if (!extractor) return;
    try {
      const key = extractor.identifier || this.store.findKey((e) => e === extractor);
      this.store.delete(key);
      if (this.player.hasDebugger)
        this.player.debug(`${extractor.identifier} extractor disabled!`);
      this.emit("unregistered", this, extractor);
      await extractor.deactivate();
      if (this.player.hasDebugger)
        this.player.debug(`${extractor.identifier} extractor deactivated!`);
      this.emit("deactivate", this, extractor);
    } catch (e) {
      if (this.player.hasDebugger)
        this.player.debug(
          `${extractor.identifier} extractor failed to deactivate!`
        );
      this.emit("error", this, extractor, e);
    }
  }
  /**
   * Unregister all extractors
   */
  async unregisterAll() {
    try {
      await Promise.all(this.store.map((e) => this.unregister(e)));
    } catch {
    }
  }
  /**
   * Run all the extractors
   * @param fn The runner function
   * @param filterBlocked Filter blocked extractors
   */
  async run(fn, filterBlocked = true) {
    const blocked = this.player.options.blockExtractors ?? [];
    if (!this.store.size) {
      Util.warn(
        "Skipping extractors execution since zero extractors were registered",
        "NoExtractors"
      );
      return;
    }
    const extractors = this.store.sort((a, b) => b.priority - a.priority);
    let err = null, lastExt = null;
    for (const ext of extractors.values()) {
      if (filterBlocked && blocked.some((e) => e === ext.identifier)) continue;
      if (this.player.hasDebugger)
        this.player.debug(`Executing extractor ${ext.identifier}...`);
      const result = await fn(ext).then(
        (res) => {
          return res;
        },
        (e) => {
          if (this.player.hasDebugger)
            this.player.debug(
              `Extractor ${ext.identifier} failed with error: ${e}`
            );
          return TypeUtil.isError(e) ? e : new Error(`${e}`);
        }
      );
      lastExt = ext;
      if (result && !TypeUtil.isError(result)) {
        if (this.player.hasDebugger)
          this.player.debug(
            `Extractor ${ext.identifier} executed successfully!`
          );
        return {
          extractor: ext,
          error: null,
          result
        };
      } else if (TypeUtil.isError(result)) {
        err = result;
      }
    }
    if (err)
      return {
        extractor: lastExt,
        error: err,
        result: false
      };
  }
  /**
   * Request bridge for a track
   * @param track The track to request bridge for
   * @param sourceExtractor The source extractor of the track
   */
  async requestBridge(track, sourceExtractor = track.extractor) {
    const previouslyAttempted = this.getContext()?.bridgeAttemptedExtractors ?? /* @__PURE__ */ new Set();
    const result = await this.run(async (ext) => {
      if (sourceExtractor && ext.identifier === sourceExtractor.identifier)
        return false;
      if (previouslyAttempted.has(ext.identifier)) return false;
      previouslyAttempted.add(ext.identifier);
      const result2 = await ext.bridge(track, sourceExtractor);
      if (!result2) return false;
      return result2;
    });
    if (!result?.result)
      throw new BridgeFailedError(
        this.getExecutionId(),
        result?.error?.stack || result?.error?.message || "No extractors available to bridge"
      );
    track.bridgedExtractor = result.extractor;
    return result;
  }
  /**
   * Request bridge from the specified extractor
   * @param track The track to request bridge for
   * @param sourceExtractor The source extractor of the track
   * @param targetExtractor The target extractor to bridge to
   */
  async requestBridgeFrom(track, sourceExtractor, targetExtractor) {
    const target = this.resolve(targetExtractor);
    if (!target) return null;
    return target.bridge(track, sourceExtractor);
  }
  /**
   * Check if extractor is disabled
   */
  isDisabled(identifier) {
    return this.player.options.blockExtractors?.includes(identifier) ?? false;
  }
  /**
   * Check if extractor is enabled
   */
  isEnabled(identifier) {
    return !this.isDisabled(identifier);
  }
  /**
   * Resolve extractor identifier
   */
  resolveId(resolvable) {
    return typeof resolvable === "string" ? resolvable : resolvable.identifier;
  }
  /**
   * Resolve extractor
   */
  resolve(resolvable) {
    return typeof resolvable === "string" ? this.get(resolvable) : resolvable;
  }
};
__name(_ExtractorExecutionContext, "ExtractorExecutionContext");
var ExtractorExecutionContext = _ExtractorExecutionContext;

// src/queue/GuildNodeManager.ts
var import_utils7 = require("@discord-player/utils");

// src/queue/GuildQueue.ts
var import_discord3 = require("discord.js");
var import_utils6 = require("@discord-player/utils");

// src/stream/StreamDispatcher.ts
var import_discord_voip = require("discord-voip");
var import_utils4 = require("@discord-player/utils");
var import_equalizer = require("@discord-player/equalizer");

// src/stream/InterceptedStream.ts
var import_node_stream = require("stream");
var _intercepting;
var _InterceptedStream = class _InterceptedStream extends import_node_stream.Transform {
  constructor() {
    super(...arguments);
    __publicField(this, "interceptors", /* @__PURE__ */ new Set());
    __privateAdd(this, _intercepting, true);
  }
  /**
   * Start intercepting the stream. This is the default state of InterceptedStream.
   */
  startIntercepting() {
    __privateSet(this, _intercepting, true);
  }
  /**
   * Stop intercepting the stream. This will prevent the stream from being consumed by the interceptors.
   * This can be useful when you want to temporarily stop the interception. The stopped state can be resumed by calling startIntercepting again.
   */
  stopIntercepting() {
    __privateSet(this, _intercepting, false);
  }
  /**
   * Whether the stream is being intercepted
   */
  isIntercepting() {
    return __privateGet(this, _intercepting);
  }
  _transform(chunk, encoding, callback) {
    this.push(chunk, encoding);
    if (__privateGet(this, _intercepting) && this.interceptors.size > 0) {
      for (const consumer of this.interceptors) {
        consumer.write(chunk, encoding);
      }
    }
    callback();
  }
  _final(callback) {
    for (const consumer of this.interceptors) {
      consumer.end();
    }
    callback();
  }
  _destroy(error, callback) {
    const ignoreError = String(error).includes("ERR_STREAM_PREMATURE_CLOSE");
    const err = ignoreError ? void 0 : error;
    for (const consumer of this.interceptors) {
      consumer.destroy(err);
    }
    this.interceptors.clear();
    callback(err);
  }
};
_intercepting = new WeakMap();
__name(_InterceptedStream, "InterceptedStream");
var InterceptedStream = _InterceptedStream;

// src/stream/StreamDispatcher.ts
var _interceptor;
var _StreamDispatcher = class _StreamDispatcher extends import_utils4.EventEmitter {
  /**
   * Creates new connection object
   * @param {VoiceConnection} connection The connection
   * @param {VoiceChannel|StageChannel} channel The connected channel
   * @private
   */
  constructor(connection, channel, queue, connectionTimeout = 2e4, audioPlayer) {
    super();
    this.queue = queue;
    this.connectionTimeout = connectionTimeout;
    __publicField(this, "voiceConnection");
    __publicField(this, "audioPlayer");
    __publicField(this, "channel");
    __publicField(this, "audioResource");
    __publicField(this, "dsp", new import_equalizer.FiltersChain());
    __privateAdd(this, _interceptor, null);
    this.voiceConnection = connection;
    this.audioPlayer = audioPlayer || (0, import_discord_voip.createAudioPlayer)({
      debug: this.queue.hasDebugger
    });
    this.channel = channel;
    this.voiceConnection.on("debug", (m) => void this.emit("debug", m));
    this.voiceConnection.on(
      "error",
      (error) => void this.emit("error", error)
    );
    this.audioPlayer.on("debug", (m) => void this.emit("debug", m));
    this.audioPlayer.on("error", (error) => void this.emit("error", error));
    this.dsp.onUpdate = () => {
      if (!this.dsp) return;
      if (this.dsp.filters?.filters) {
        this.emit("dsp", this.dsp.filters?.filters);
      }
      if (this.dsp.biquad?.filters) {
        this.emit("biquad", this.dsp.biquad?.filters);
      }
      if (this.dsp.equalizer) {
        this.emit("eqBands", this.dsp.equalizer.getEQ());
      }
      if (this.dsp.volume) {
        this.emit("volume", this.dsp.volume.volume);
      }
      if (this.dsp.resampler) {
        this.emit("sampleRate", this.dsp.resampler.getParameters());
      }
      if (this.dsp.compressor) {
        this.emit("compressor", this.dsp.compressor.getParameters());
      }
      if (this.dsp.reverb) {
        this.emit("reverb", this.dsp.reverb.getParameters());
      }
      if (this.dsp.seeker) {
        this.emit("seeker", this.dsp.seeker.getParameters());
      }
    };
    this.dsp.onError = (e) => this.emit("error", e);
    this.voiceConnection.on(import_discord_voip.VoiceConnectionStatus.Disconnected, async (oldState, newState) => {
      if (newState.reason === import_discord_voip.VoiceConnectionDisconnectReason.Manual) {
        this.destroy();
        return;
      }
      if (newState.reason === import_discord_voip.VoiceConnectionDisconnectReason.WebSocketClose && newState.closeCode === 4014) {
        try {
          await (0, import_discord_voip.entersState)(
            this.voiceConnection,
            import_discord_voip.VoiceConnectionStatus.Connecting,
            this.connectionTimeout
          );
        } catch {
          try {
            if (this.voiceConnection.state.status !== import_discord_voip.VoiceConnectionStatus.Destroyed)
              this.destroy();
          } catch (err) {
            this.emit("error", err);
          }
        }
      } else if (this.voiceConnection.rejoinAttempts < 5) {
        await Util.wait((this.voiceConnection.rejoinAttempts + 1) * 5e3);
        this.voiceConnection.rejoin();
      } else {
        try {
          if (this.voiceConnection.state.status !== import_discord_voip.VoiceConnectionStatus.Destroyed)
            this.destroy();
        } catch (err) {
          this.emit("error", err);
        }
      }
    }).on(import_discord_voip.VoiceConnectionStatus.Destroyed, () => {
      this.end();
      this.queue.emit(GuildQueueEvent.ConnectionDestroyed, this.queue);
    });
    this.audioPlayer.on("stateChange", (oldState, newState) => {
      if (oldState.status !== import_discord_voip.AudioPlayerStatus.Paused && newState.status === import_discord_voip.AudioPlayerStatus.Paused) {
        this.queue.emit(GuildQueueEvent.PlayerPause, this.queue);
      }
      if (oldState.status === import_discord_voip.AudioPlayerStatus.Paused && newState.status !== import_discord_voip.AudioPlayerStatus.Paused) {
        this.queue.emit(GuildQueueEvent.PlayerResume, this.queue);
      }
      if (newState.status === import_discord_voip.AudioPlayerStatus.Playing) {
        if (oldState.status === import_discord_voip.AudioPlayerStatus.Idle || oldState.status === import_discord_voip.AudioPlayerStatus.Buffering) {
          return this.emit("start", this.audioResource);
        }
      } else if (newState.status === import_discord_voip.AudioPlayerStatus.Idle && oldState.status !== import_discord_voip.AudioPlayerStatus.Idle) {
        this.emit("finish", this.audioResource);
        this.dsp.destroy();
        this.audioResource = null;
      }
    });
    this.voiceConnection.subscribe(this.audioPlayer);
  }
  /**
   * Check if the player has been paused manually
   */
  get paused() {
    return this.audioPlayer.state.status === import_discord_voip.AudioPlayerStatus.Paused;
  }
  set paused(val) {
    val ? this.pause(true) : this.resume();
  }
  /**
   * Whether or not the player is currently paused automatically or manually.
   */
  isPaused() {
    return this.paused || this.audioPlayer.state.status === import_discord_voip.AudioPlayerStatus.AutoPaused;
  }
  /**
   * Whether or not the player is currently buffering
   */
  isBuffering() {
    return this.audioPlayer.state.status === import_discord_voip.AudioPlayerStatus.Buffering;
  }
  /**
   * Whether or not the player is currently playing
   */
  isPlaying() {
    return this.audioPlayer.state.status === import_discord_voip.AudioPlayerStatus.Playing;
  }
  /**
   * Whether or not the player is currently idle
   */
  isIdle() {
    return this.audioPlayer.state.status === import_discord_voip.AudioPlayerStatus.Idle;
  }
  /**
   * Whether or not the voice connection has been destroyed
   */
  isDestroyed() {
    return this.voiceConnection.state.status === import_discord_voip.VoiceConnectionStatus.Destroyed;
  }
  /**
   * Whether or not the voice connection has been destroyed
   */
  isDisconnected() {
    return this.voiceConnection.state.status === import_discord_voip.VoiceConnectionStatus.Disconnected;
  }
  /**
   * Whether or not the voice connection is ready to play
   */
  isReady() {
    return this.voiceConnection.state.status === import_discord_voip.VoiceConnectionStatus.Ready;
  }
  /**
   * Whether or not the voice connection is signalling
   */
  isSignalling() {
    return this.voiceConnection.state.status === import_discord_voip.VoiceConnectionStatus.Signalling;
  }
  /**
   * Whether or not the voice connection is connecting
   */
  isConnecting() {
    return this.voiceConnection.state.status === import_discord_voip.VoiceConnectionStatus.Connecting;
  }
  /**
   * Creates stream
   * @param {Readable} src The stream source
   * @param {object} [ops] Options
   * @returns {AudioResource}
   */
  async createStream(src, ops) {
    if (!ops?.disableFilters && this.queue.hasDebugger)
      this.queue.debug("Initiating DSP filters pipeline...");
    const stream = !ops?.disableFilters ? this.dsp.create(src, {
      dsp: {
        filters: ops?.defaultFilters,
        disabled: ops?.disableFilters
      },
      biquad: ops?.biquadFilter ? {
        filter: ops.biquadFilter,
        disabled: ops?.disableBiquad
      } : void 0,
      resampler: ops?.sampleRate ? {
        inputSampleRate: 48e3,
        targetSampleRate: ops?.sampleRate,
        disabled: ops?.disableResampler
      } : void 0,
      equalizer: {
        bandMultiplier: ops?.eq,
        disabled: ops?.disableEqualizer
      },
      volume: {
        volume: ops?.volume,
        disabled: ops?.disableVolume
      },
      compressor: ops?.compressor ? {
        threshold: ops?.compressor.threshold,
        ratio: ops?.compressor.ratio,
        attack: ops?.compressor.attack,
        release: ops?.compressor.release,
        makeupGain: ops?.compressor.makeupGain,
        disabled: ops?.disableCompressor,
        kneeWidth: ops?.compressor.kneeWidth
      } : void 0,
      reverb: ops?.reverb ? {
        roomSize: ops?.reverb.roomSize,
        damping: ops?.reverb.damping,
        wetLevel: ops?.reverb.wetLevel,
        dryLevel: ops?.reverb.dryLevel,
        disabled: ops?.disableReverb
      } : void 0,
      seeker: ops?.seeker ? {
        disabled: ops?.disableSeeker,
        seekTarget: ops?.seeker.seekTarget,
        sampleRate: 48e3,
        channels: 2,
        totalDuration: ops?.seeker.totalDuration
      } : void 0
    }) : src;
    if (this.dsp.seeker) {
      this.dsp.seeker.on("seek", (data) => {
        this.queue.node.requestSeek(data).catch(() => {
        });
      });
    }
    if (this.queue.hasDebugger) {
      this.queue.debug("Executing onAfterCreateStream hook...");
    }
    const postStream = await this.queue.onAfterCreateStream?.(stream, this.queue, ops?.data).catch(
      () => ({
        stream,
        type: ops?.type ?? import_discord_voip.StreamType.Arbitrary
      })
    );
    if (this.queue.hasDebugger) this.queue.debug("Preparing AudioResource...");
    const format = postStream?.type ?? ops?.type ?? import_discord_voip.StreamType.Arbitrary;
    let _stream;
    if (this.queue.canIntercept()) {
      __privateSet(this, _interceptor, new InterceptedStream());
      (postStream?.stream ?? stream).pipe(__privateGet(this, _interceptor));
      _stream = __privateGet(this, _interceptor);
      await this.queue.player.handleInterceptingStream(
        this.queue,
        ops?.data,
        format,
        __privateGet(this, _interceptor)
      );
    } else {
      _stream = postStream?.stream ?? stream;
    }
    this.audioResource = (0, import_discord_voip.createAudioResource)(_stream, {
      inputType: format,
      metadata: ops?.data,
      // volume controls happen from AudioFilter DSP utility
      inlineVolume: false
    });
    return this.audioResource;
  }
  get resampler() {
    return this.dsp?.resampler;
  }
  get filters() {
    return this.dsp?.filters;
  }
  get biquad() {
    return this.dsp?.biquad || null;
  }
  get equalizer() {
    return this.dsp?.equalizer || null;
  }
  get compressor() {
    return this.dsp?.compressor || null;
  }
  get reverb() {
    return this.dsp?.reverb || null;
  }
  get seeker() {
    return this.dsp?.seeker || null;
  }
  /**
   * The player status
   * @type {AudioPlayerStatus}
   */
  get status() {
    return this.audioPlayer.state.status;
  }
  /**
   * Disconnects from voice
   * @returns {void}
   */
  disconnect() {
    try {
      if (this.audioPlayer) this.audioPlayer.stop(true);
      if (this.voiceConnection.state.status !== import_discord_voip.VoiceConnectionStatus.Destroyed)
        this.voiceConnection.destroy();
    } catch {
    }
  }
  /**
   * Destroys this dispatcher
   */
  destroy() {
    this.disconnect();
    this.audioPlayer.removeAllListeners();
    this.voiceConnection.removeAllListeners();
    this.dsp.destroy();
    this.audioResource = null;
    this.emit("destroyed");
  }
  /**
   * Stops the player
   * @returns {void}
   */
  end() {
    try {
      this.audioPlayer.stop();
      this.dsp.destroy();
    } catch {
    }
  }
  /**
   * Pauses the stream playback
   * @param {boolean} [interpolateSilence=false] If true, the player will play 5 packets of silence after pausing to prevent audio glitches.
   * @returns {boolean}
   */
  pause(interpolateSilence) {
    const success = this.audioPlayer.pause(interpolateSilence);
    return success;
  }
  /**
   * Resumes the stream playback
   * @returns {boolean}
   */
  resume() {
    const success = this.audioPlayer.unpause();
    return success;
  }
  /**
   * Play stream
   * @param {AudioResource<Track>} [resource=this.audioResource] The audio resource to play
   * @param {boolean} [opus=false] Whether or not to use opus
   * @returns {Promise<StreamDispatcher>}
   */
  async playStream(resource = this.audioResource) {
    if (!resource) {
      throw new NoAudioResourceError();
    }
    if (resource.ended) {
      return void this.emit("finish", resource);
    }
    if (!this.audioResource) this.audioResource = resource;
    if (this.voiceConnection.state.status !== import_discord_voip.VoiceConnectionStatus.Ready) {
      try {
        await (0, import_discord_voip.entersState)(
          this.voiceConnection,
          import_discord_voip.VoiceConnectionStatus.Ready,
          this.connectionTimeout
        );
      } catch (err) {
        return void this.emit("error", err);
      }
    }
    try {
      this.audioPlayer.play(resource);
    } catch (e) {
      this.emit("error", e);
    }
    return this;
  }
  /**
   * Sets playback volume
   * @param {number} value The volume amount
   * @returns {boolean}
   */
  setVolume(value) {
    if (!this.dsp.volume) return false;
    return this.dsp.volume.setVolume(value);
  }
  /**
   * The current volume
   * @type {number}
   */
  get volume() {
    if (!this.dsp.volume) return 100;
    return this.dsp.volume.volume;
  }
  /**
   * The playback time
   * @type {number}
   */
  get streamTime() {
    if (!this.audioResource) return 0;
    return this.audioResource.playbackDuration;
  }
};
_interceptor = new WeakMap();
__name(_StreamDispatcher, "StreamDispatcher");
var StreamDispatcher = _StreamDispatcher;

// src/queue/GuildQueue.ts
var import_discord_voip3 = require("discord-voip");

// src/queue/GuildQueueHistory.ts
var import_utils5 = require("@discord-player/utils");
var _GuildQueueHistory = class _GuildQueueHistory {
  constructor(queue) {
    this.queue = queue;
    __publicField(this, "tracks", new import_utils5.Queue("LIFO"));
  }
  /**
   * Current track in the queue
   */
  get currentTrack() {
    return this.queue.dispatcher?.audioResource?.metadata || // eslint-disable-next-line @typescript-eslint/no-explicit-any
    this.queue.__current;
  }
  /**
   * Next track in the queue
   */
  get nextTrack() {
    return this.queue.tracks.at(0) || null;
  }
  /**
   * Previous track in the queue
   */
  get previousTrack() {
    return this.tracks.at(0) || null;
  }
  /**
   * If history is disabled
   */
  get disabled() {
    return this.queue.options.disableHistory;
  }
  /**
   * Gets the size of the queue
   */
  get size() {
    return this.tracks.size;
  }
  getSize() {
    return this.size;
  }
  /**
   * If history is empty
   */
  isEmpty() {
    return this.tracks.size < 1;
  }
  /**
   * Add track to track history
   * @param track The track to add
   */
  push(track) {
    if (this.disabled) return false;
    this.tracks.add(track);
    this.resize();
    return true;
  }
  /**
   * Clear history
   */
  clear() {
    this.tracks.clear();
  }
  /**
   * Play the next track in the queue
   */
  async next() {
    const track = this.nextTrack;
    if (!track) {
      throw new NoResultError("No next track in the queue");
    }
    this.queue.node.skip({
      reason: "HISTORY_NEXT_TRACK" /* HistoryNext */,
      description: "Skipped by GuildQueueHistory.next()"
    });
  }
  /**
   * Play the previous track in the queue
   */
  async previous(preserveCurrent = true) {
    const track = this.tracks.dispatch();
    if (!track) {
      throw new NoResultError("No previous track in the queue");
    }
    const current = this.currentTrack;
    await this.queue.node.play(track, { queue: false });
    if (current && preserveCurrent) this.queue.node.insert(current, 0);
  }
  /**
   * Alias to [GuildQueueHistory].previous()
   */
  back(preserveCurrent = true) {
    return this.previous(preserveCurrent);
  }
  /**
   * Resize history store
   */
  resize() {
    if (!Number.isFinite(this.queue.maxHistorySize)) return;
    if (this.tracks.store.length < this.queue.maxHistorySize) return;
    this.tracks.store.splice(this.queue.maxHistorySize);
  }
};
__name(_GuildQueueHistory, "GuildQueueHistory");
var GuildQueueHistory = _GuildQueueHistory;

// src/queue/GuildQueuePlayerNode.ts
var import_discord_voip2 = require("discord-voip");
var import_stream = require("stream");
var import_promises2 = require("timers/promises");

// src/utils/AsyncQueue.ts
var import_discord2 = require("discord.js");
var _AsyncQueue = class _AsyncQueue {
  constructor() {
    /**
     * The queued entries
     */
    __publicField(this, "entries", []);
    __publicField(this, "exceptionHandler");
  }
  /**
   * Clear entries queue
   * @param consume Whether or not to consume all entries before clearing
   */
  clear(consume = false) {
    if (consume) {
      this.entries.forEach((entry) => entry.consume());
    }
    this.entries = [];
  }
  /**
   * The total number of entries in this queue. Returns `0` if no entries are available.
   */
  get size() {
    return this.entries.length;
  }
  /**
   * Acquire an entry.
   *
   * @example // lock the queue
   * const entry = asyncQueue.acquire();
   * // wait until previous task is completed
   * await entry.getTask();
   * // do something expensive
   * await performSomethingExpensive();
   * // make sure to release the lock once done
   * asyncQueue.release();
   *
   */
  acquire(options) {
    const entry = new AsyncQueueEntry(this, options);
    if (this.exceptionHandler) entry.getTask().catch(this.exceptionHandler);
    if (this.entries.length === 0) {
      this.entries.push(entry);
      entry.consume();
      return entry;
    }
    this.entries.push(entry);
    return entry;
  }
  /**
   * Release the current acquisition and move to next entry.
   */
  release() {
    if (!this.entries.length) return;
    this.entries.shift();
    this.entries[0]?.consume();
  }
  /**
   * Cancel all entries
   */
  cancelAll() {
    this.entries.forEach((entry) => entry.cancel());
  }
  /**
   * Remove the given entry from the queue
   * @param entry The entry to remove
   */
  removeEntry(entry) {
    const entryIdx = this.entries.indexOf(entry);
    if (entryIdx !== -1) {
      this.entries.splice(entryIdx, 1);
      return true;
    }
    return false;
  }
};
__name(_AsyncQueue, "AsyncQueue");
var AsyncQueue = _AsyncQueue;
var _AsyncQueueEntry = class _AsyncQueueEntry {
  constructor(queue, options) {
    this.queue = queue;
    this.options = options;
    __publicField(this, "id", import_discord2.SnowflakeUtil.generate().toString());
    __publicField(this, "promise");
    __publicField(this, "signal", null);
    __publicField(this, "onAbort", null);
    __publicField(this, "resolve");
    __publicField(this, "reject");
    this.promise = new Promise((resolve2, reject) => {
      this.resolve = resolve2;
      this.reject = reject;
    });
    if (this.options?.signal) {
      this.setAbortSignal(this.options.signal);
    }
  }
  setAbortSignal(signal) {
    if (signal.aborted) return;
    this.signal = signal;
    this.onAbort = () => {
      this.queue.removeEntry(this);
      this.cancel();
    };
    this.signal.addEventListener("abort", this.onAbort);
  }
  consume() {
    this.cleanup();
    this.resolve();
  }
  release() {
    this.consume();
    this.queue.release();
  }
  cancel() {
    this.cleanup();
    this.reject(new Error("Cancelled"));
  }
  cleanup() {
    if (this.onAbort) this.signal?.removeEventListener("abort", this.onAbort);
    this.signal = null;
    this.onAbort = null;
  }
  getTask() {
    return this.promise;
  }
};
__name(_AsyncQueueEntry, "AsyncQueueEntry");
var AsyncQueueEntry = _AsyncQueueEntry;

// src/queue/GuildQueuePlayerNode.ts
var import_opus = require("@discord-player/opus");
var FFMPEG_SRATE_REGEX = /asetrate=\d+\*(\d(\.\d)?)/;
var _progress, _hasFFmpegOptimization, _GuildQueuePlayerNode_instances, throw_fn, performPlay_fn, createGenericStream_fn, createFallbackStream_fn, createFFmpegStream_fn;
var _GuildQueuePlayerNode = class _GuildQueuePlayerNode {
  constructor(queue) {
    this.queue = queue;
    __privateAdd(this, _GuildQueuePlayerNode_instances);
    __privateAdd(this, _progress, 0);
    __privateAdd(this, _hasFFmpegOptimization, false);
    __publicField(this, "tasksQueue", new AsyncQueue());
    __privateSet(this, _hasFFmpegOptimization, /libopus: (yes|true)/.test(
      this.queue.player.scanDeps()
    ));
  }
  /**
   * If the player is currently in idle mode
   */
  isIdle() {
    return !!this.queue.dispatcher?.isIdle();
  }
  /**
   * If the player is currently buffering the track
   */
  isBuffering() {
    return !!this.queue.dispatcher?.isBuffering();
  }
  /**
   * If the player is currently playing a track
   */
  isPlaying() {
    return !!this.queue.dispatcher?.isPlaying();
  }
  /**
   * If the player is currently paused
   */
  isPaused() {
    return !!this.queue.dispatcher?.isPaused();
  }
  /**
   * Reset progress history
   */
  resetProgress() {
    __privateSet(this, _progress, 0);
  }
  /**
   * Set player progress
   */
  setProgress(progress) {
    __privateSet(this, _progress, progress);
  }
  /**
   * The stream time for current session
   */
  get streamTime() {
    return this.queue.dispatcher?.streamTime ?? 0;
  }
  /**
   * Current playback duration with history included
   */
  get playbackTime() {
    if (this.queue.filters.seeker) {
      const pos = this.queue.filters.seeker.getPosition();
      if (pos > 0) return pos;
    }
    const dur = __privateGet(this, _progress) + this.streamTime;
    return dur;
  }
  /**
   * Get duration multiplier
   */
  getDurationMultiplier() {
    const srateFilters = this.queue.filters.ffmpeg.toArray().filter((ff) => FFMPEG_SRATE_REGEX.test(ff));
    const multipliers = srateFilters.map((m) => {
      return parseFloat(FFMPEG_SRATE_REGEX.exec(m)?.[1]);
    }).filter((f) => !isNaN(f));
    return !multipliers.length ? 1 : multipliers.reduce((accumulator, current) => current + accumulator);
  }
  /**
   * Estimated progress of the player
   */
  get estimatedPlaybackTime() {
    const dur = this.playbackTime;
    const val = this.getDurationMultiplier() * dur;
    return val;
  }
  /**
   * Estimated total duration of the player
   */
  get estimatedDuration() {
    const dur = this.totalDuration;
    const val = Math.round(dur / this.getDurationMultiplier());
    if (this.queue.filters.resampler) {
      const ratio = this.queue.filters.resampler.getRatio();
      if (ratio <= 0) return val;
      return Math.round(val / ratio);
    }
    return val;
  }
  /**
   * Total duration of the current audio track
   */
  get totalDuration() {
    const prefersBridgedMetadata = this.queue.options.preferBridgedMetadata;
    const track = this.queue.currentTrack;
    if (prefersBridgedMetadata) {
      const trackHasLegacyMetadata = track?.metadata != null && typeof track.metadata === "object" && "bridge" in track.metadata && track.metadata.bridge != null;
      const trackHasMetadata = track?.bridgedTrack != null;
      if (trackHasLegacyMetadata || trackHasMetadata) {
        const duration = track.bridgedTrack?.durationMS ?? track.metadata?.bridge.duration;
        if (TypeUtil.isNumber(duration)) return duration;
      }
    }
    return track?.durationMS ?? 0;
  }
  /**
   * Get stream progress
   * @param ignoreFilters Ignore filters
   */
  getTimestamp(ignoreFilters = false) {
    if (!this.queue.currentTrack) return null;
    const current = ignoreFilters ? this.playbackTime : this.estimatedPlaybackTime;
    const total = ignoreFilters ? this.totalDuration : this.estimatedDuration;
    return {
      current: {
        label: Util.buildTimeCode(Util.parseMS(current)),
        value: current
      },
      total: {
        label: Util.buildTimeCode(Util.parseMS(total)),
        value: total
      },
      progress: Math.round(current / total * 100)
    };
  }
  /**
   * Create progress bar for current progress
   * @param options Progress bar options
   */
  createProgressBar(options) {
    const timestamp = this.getTimestamp();
    if (!timestamp) return null;
    const {
      indicator = "\u{1F518}",
      leftChar = "\u25AC",
      rightChar = "\u25AC",
      length = 15,
      timecodes = true,
      separator = "\u2503"
    } = options || {};
    if (isNaN(length) || length < 0 || !Number.isFinite(length)) {
      throw new OutOfRangeError(
        "[PlayerProgressBarOptions.length]",
        String(length),
        "0",
        "Finite Number"
      );
    }
    const index = Math.round(
      timestamp.current.value / timestamp.total.value * length
    );
    if (index >= 1 && index <= length) {
      const bar = leftChar.repeat(index - 1).split("");
      bar.push(indicator);
      bar.push(rightChar.repeat(length - index));
      if (timecodes) {
        return `${timestamp.current.label} ${separator} ${bar.join(
          ""
        )} ${separator} ${timestamp.total.label}`;
      } else {
        return `${bar.join("")}`;
      }
    } else {
      if (timecodes) {
        return `${timestamp.current.label} ${separator} ${indicator}${rightChar.repeat(
          length - 1
        )} ${separator} ${timestamp.total.label}`;
      } else {
        return `${indicator}${rightChar.repeat(length - 1)}`;
      }
    }
  }
  /**
   * Seek the player
   * @param duration The duration to seek to
   */
  async seek(duration) {
    if (!this.queue.currentTrack) return false;
    if (duration === this.estimatedPlaybackTime) return true;
    if (duration > this.totalDuration) {
      return this.skip({
        reason: "SEEK_OVER_THRESHOLD" /* SEEK_OVER_THRESHOLD */,
        description: new OutOfRangeError(
          "[duration]",
          String(duration),
          "0",
          String(this.totalDuration)
        ).message
      });
    }
    if (duration < 0) duration = 0;
    const seeker = this.queue.filters.seeker;
    if (seeker) {
      seeker.seek(duration);
      return true;
    }
    return this.queue.filters.triggerReplay(duration).then((v) => {
      if (v) {
        this.queue.emit(GuildQueueEvent.PlayerSeek, this.queue, {
          currentPosition: this.estimatedPlaybackTime,
          seekTarget: duration,
          totalDuration: this.estimatedDuration
        });
      }
      return v;
    });
  }
  /**
   * Current volume
   */
  get volume() {
    return this.queue.dispatcher?.volume ?? 100;
  }
  /**
   * Set volume
   * @param vol Volume amount to set
   */
  setVolume(vol) {
    if (!this.queue.dispatcher) return false;
    const res = this.queue.dispatcher.setVolume(vol);
    if (res) this.queue.filters._lastFiltersCache.volume = vol;
    return res;
  }
  /**
   * Set bit rate
   * @param rate The bit rate to set
   */
  setBitrate(rate) {
    this.queue.dispatcher?.audioResource?.encoder?.setBitrate(
      rate === "auto" ? this.queue.channel?.bitrate ?? 64e3 : rate
    );
  }
  /**
   * Set paused state
   * @param state The state
   */
  setPaused(state) {
    if (state) return this.queue.dispatcher?.pause(true) || false;
    return this.queue.dispatcher?.resume() || false;
  }
  /**
   * Pause the playback
   */
  pause() {
    return this.setPaused(true);
  }
  /**
   * Resume the playback
   */
  resume() {
    return this.setPaused(false);
  }
  /**
   * Skip current track
   */
  skip(options) {
    if (!this.queue.dispatcher) return false;
    const track = this.queue.currentTrack;
    if (!track) return false;
    this.queue.setTransitioning(false);
    this.queue.dispatcher.end();
    const { reason, description } = options || {
      reason: "MANUAL" /* Manual */,
      description: "The track was skipped manually"
    };
    this.queue.emit(
      GuildQueueEvent.PlayerSkip,
      this.queue,
      track,
      reason,
      description
    );
    return true;
  }
  /**
   * Remove the given track from queue
   * @param track The track to remove
   * @param emitEvent Whether or not to emit the event @defaultValue true
   */
  remove(track, emitEvent = true) {
    const foundTrack = this.queue.tracks.find((t, idx) => {
      if (track instanceof Track || typeof track === "string") {
        return (typeof track === "string" ? track : track.id) === t.id;
      }
      if (typeof track === "string") return track === t.id;
      return idx === track;
    });
    if (!foundTrack) return null;
    this.queue.tracks.removeOne((t) => t.id === foundTrack.id);
    if (emitEvent)
      this.queue.emit(GuildQueueEvent.AudioTrackRemove, this.queue, foundTrack);
    return foundTrack;
  }
  /**
   * Jump to specific track on the queue
   * @param track The track to jump to without removing other tracks
   */
  jump(track) {
    const removed = this.remove(track, false);
    if (!removed) return false;
    this.queue.tracks.store.unshift(removed);
    return this.skip({
      reason: "JUMPED_TO_ANOTHER_TRACK" /* Jump */,
      description: "The track was jumped to manually"
    });
  }
  /**
   * Get track position
   * @param track The track
   */
  getTrackPosition(track) {
    return this.queue.tracks.toArray().findIndex((t, idx) => {
      if (track instanceof Track || typeof track === "string") {
        return (typeof track === "string" ? track : track.id) === t.id;
      }
      if (typeof track === "string") return track === t.id;
      return idx === track;
    });
  }
  /**
   * Skip to the given track, removing others on the way
   * @param track The track to skip to
   */
  skipTo(track) {
    const idx = this.getTrackPosition(track);
    if (idx < 0) return false;
    const removed = this.remove(idx);
    if (!removed) return false;
    const toRemove = this.queue.tracks.store.filter((_, i) => i <= idx);
    this.queue.tracks.store.splice(0, idx, removed);
    this.queue.emit(GuildQueueEvent.AudioTracksRemove, this.queue, toRemove);
    return this.skip({
      reason: "SKIP_TO_ANOTHER_TRACK" /* SkipTo */,
      description: "The player was skipped to another track manually"
    });
  }
  /**
   * Insert a track on the given position in queue
   * @param track The track to insert
   * @param index The position to insert to, defaults to 0.
   */
  insert(track, index = 0) {
    if (!(track instanceof Track))
      throw new InvalidArgTypeError(
        "track value",
        "instance of Track",
        String(track)
      );
    VALIDATE_QUEUE_CAP(this.queue, track);
    this.queue.tracks.store.splice(index, 0, track);
    if (!this.queue.options.noEmitInsert) {
      this.queue.emit(GuildQueueEvent.AudioTrackAdd, this.queue, track);
    }
  }
  /**
   * Moves a track in the queue
   * @param from The track to move
   * @param to The position to move to
   */
  move(from, to) {
    const removed = this.remove(from);
    if (!removed) {
      throw new NoResultError("invalid track to move");
    }
    this.insert(removed, to);
  }
  /**
   * Copy a track in the queue
   * @param from The track to clone
   * @param to The position to clone at
   */
  copy(from, to) {
    const src = this.queue.tracks.at(this.getTrackPosition(from));
    if (!src) {
      throw new NoResultError("invalid track to copy");
    }
    this.insert(src, to);
  }
  /**
   * Swap two tracks in the queue
   * @param first The first track to swap
   * @param second The second track to swap
   */
  swap(first, second) {
    const src = this.getTrackPosition(first);
    if (src < 0) throw new NoResultError("invalid src track to swap");
    const dest = this.getTrackPosition(second);
    if (dest < 0) throw new NoResultError("invalid dest track to swap");
    const srcT = this.queue.tracks.store[src];
    const destT = this.queue.tracks.store[dest];
    this.queue.tracks.store[src] = destT;
    this.queue.tracks.store[dest] = srcT;
  }
  /**
   * Stop the playback
   * @param force Whether or not to forcefully stop the playback
   */
  stop(force = false) {
    this.queue.tracks.clear();
    this.queue.history.clear();
    if (!this.queue.dispatcher) return false;
    this.queue.dispatcher.end();
    if (force) {
      this.queue.dispatcher.destroy();
      return true;
    }
    if (this.queue.options.leaveOnStop) {
      const tm = setTimeout(() => {
        if (this.isPlaying() || this.queue.tracks.size) return clearTimeout(tm);
        this.queue.dispatcher?.destroy();
      }, this.queue.options.leaveOnStopCooldown).unref();
    }
    return true;
  }
  /**
   * Request the source to seek
   * @param data The seek parameters
   */
  async requestSeek(data) {
    const track = this.queue.currentTrack;
    if (!track) return false;
    if (track.seekable) {
      return track.seek(data);
    }
    return this.queue.filters.triggerReplay(data.position);
  }
  /**
   * Play the given track
   * @param res The track to play
   * @param options Options for playing the track
   */
  async play(res, options) {
    if (!this.queue.dispatcher?.voiceConnection) {
      throw new NoVoiceConnectionError();
    }
    if (this.queue.hasDebugger)
      this.queue.debug(
        `Received play request from guild ${this.queue.guild.name} (ID: ${this.queue.guild.id})`
      );
    options = Object.assign(
      {},
      {
        queue: this.queue.currentTrack != null,
        transitionMode: false,
        seek: 0
      },
      options
    );
    if (res && options.queue) {
      if (this.queue.hasDebugger)
        this.queue.debug(
          "Requested option requires to queue the track, adding the given track to queue instead..."
        );
      return this.queue.addTrack(res);
    }
    const track = res || this.queue.tracks.dispatch();
    if (!track) {
      const error = new NoResultError(
        "Play request received but track was not provided"
      );
      this.queue.emit(GuildQueueEvent.Error, this.queue, error);
      return;
    }
    if (this.queue.hasDebugger)
      this.queue.debug(
        "Requested option requires to play the track, initializing..."
      );
    try {
      const assignedResource = track.resource;
      if (assignedResource) {
        if (this.queue.hasDebugger)
          this.queue.debug(
            "Track has an audio resource assigned, player will now play the resource directly..."
          );
        this.queue.setTransitioning(!!options.transitionMode);
        return __privateMethod(this, _GuildQueuePlayerNode_instances, performPlay_fn).call(this, assignedResource);
      }
      if (this.queue.hasDebugger)
        this.queue.debug(`Initiating stream extraction process...`);
      const src = track.raw?.source || track.source;
      const qt = track.queryType || (src === "spotify" ? "spotifySong" : src === "apple_music" ? "appleMusicSong" : src);
      if (this.queue.hasDebugger)
        this.queue.debug(
          `Executing onBeforeCreateStream hook (QueryType: ${qt})...`
        );
      const streamSrc = {
        error: null,
        stream: null
      };
      await this.queue.onBeforeCreateStream?.(track, qt || "arbitrary", this.queue).then(
        (s) => {
          if (s) {
            streamSrc.stream = s;
          }
        },
        (e) => streamSrc.error = e
      );
      if (!streamSrc.stream && streamSrc.error)
        return __privateMethod(this, _GuildQueuePlayerNode_instances, throw_fn).call(this, track, streamSrc.error);
      if (!streamSrc.stream) {
        if (this.queue.hasDebugger)
          this.queue.debug(
            "Failed to get stream from onBeforeCreateStream, attempting to extract stream using extractors..."
          );
        await this.queue.player.extractors.context.provide(
          {
            id: crypto.randomUUID(),
            attemptedExtractors: /* @__PURE__ */ new Set(),
            bridgeAttemptedExtractors: /* @__PURE__ */ new Set()
          },
          () => __privateMethod(this, _GuildQueuePlayerNode_instances, createGenericStream_fn).call(this, track).then(async (r) => {
            if (r?.result) {
              streamSrc.stream = await this.queue.onStreamExtracted?.(
                r.result,
                track,
                this.queue
              ) ?? r.result;
              return;
            }
            if (r?.error) {
              streamSrc.error = r.error;
              return;
            }
            streamSrc.stream = streamSrc.error = null;
          }).catch((e) => streamSrc.error = e)
        );
      }
      if (!streamSrc.stream) return __privateMethod(this, _GuildQueuePlayerNode_instances, throw_fn).call(this, track, streamSrc.error);
      if (typeof options.seek === "number" && options.seek >= 0) {
        __privateSet(this, _progress, options.seek);
      } else {
        __privateSet(this, _progress, 0);
      }
      const trackStreamConfig = {
        dispatcherConfig: {
          disableBiquad: this.queue.options.disableBiquad,
          disableEqualizer: this.queue.options.disableEqualizer,
          disableVolume: this.queue.options.disableVolume,
          disableFilters: this.queue.options.disableFilterer,
          disableResampler: this.queue.options.disableResampler,
          disableCompressor: this.queue.options.disableCompressor,
          disableReverb: this.queue.options.disableReverb,
          disableSeeker: this.queue.options.disableSeeker,
          compressor: this.queue.filters._lastFiltersCache.compressor ?? void 0,
          reverb: this.queue.filters._lastFiltersCache.reverb ?? void 0,
          seeker: {
            seekTarget: options.transitionMode && options.seek != null ? options.seek : null,
            totalDuration: track.durationMS ?? 0
          },
          sampleRate: this.queue.filters._lastFiltersCache.sampleRate ?? (typeof this.queue.options.resampler === "number" && this.queue.options.resampler > 0 ? this.queue.options.resampler : void 0),
          biquadFilter: this.queue.filters._lastFiltersCache.biquad || void 0,
          eq: this.queue.filters._lastFiltersCache.equalizer,
          defaultFilters: this.queue.filters._lastFiltersCache.filters,
          volume: this.queue.filters._lastFiltersCache.volume,
          data: track,
          type: import_discord_voip2.StreamType.Raw,
          skipFFmpeg: this.queue.player.options.skipFFmpeg
        },
        playerConfig: options
      };
      let resolver = Util.noop;
      const donePromise = new Promise((resolve2) => resolver = resolve2);
      const success = this.queue.emit(
        GuildQueueEvent.WillPlayTrack,
        this.queue,
        track,
        trackStreamConfig,
        resolver
      );
      if (!success) resolver();
      if (this.queue.hasDebugger)
        this.queue.debug("Waiting for willPlayTrack event to resolve...");
      await donePromise;
      const daspDisabled = [
        trackStreamConfig.dispatcherConfig.disableBiquad,
        trackStreamConfig.dispatcherConfig.disableEqualizer,
        trackStreamConfig.dispatcherConfig.disableFilters,
        trackStreamConfig.dispatcherConfig.disableResampler,
        trackStreamConfig.dispatcherConfig.disableVolume,
        trackStreamConfig.dispatcherConfig.disableCompressor,
        trackStreamConfig.dispatcherConfig.disableReverb,
        trackStreamConfig.dispatcherConfig.disableSeeker
      ].every((e) => !!e === true);
      const needsFilters = !!trackStreamConfig.playerConfig.seek || !!this.queue.filters.ffmpeg.args.length;
      const shouldSkipFFmpeg = !!trackStreamConfig.dispatcherConfig.skipFFmpeg && !needsFilters;
      let finalStream;
      const demuxable = /* @__PURE__ */ __name((fmt) => [
        import_discord_voip2.StreamType.Opus,
        import_discord_voip2.StreamType.WebmOpus,
        import_discord_voip2.StreamType.OggOpus,
        import_discord_voip2.StreamType.Raw,
        "pcm"
      ].includes(fmt), "demuxable");
      if (shouldSkipFFmpeg && !(streamSrc.stream instanceof import_stream.Readable) && typeof streamSrc.stream !== "string" && demuxable(streamSrc.stream.$fmt)) {
        const { $fmt, stream } = streamSrc.stream;
        const shouldPCM = !daspDisabled;
        if (this.queue.hasDebugger)
          this.queue.debug(
            `skipFFmpeg is set to true and stream is demuxable, creating stream with type ${shouldPCM ? "pcm" : "opus"}`
          );
        const isRaw = $fmt === "pcm" || $fmt === import_discord_voip2.StreamType.Raw;
        const opusStream = isRaw || $fmt === import_discord_voip2.StreamType.Opus ? stream : $fmt === import_discord_voip2.StreamType.OggOpus ? (
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          stream.pipe(new import_opus.OggDemuxer())
        ) : (
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          stream.pipe(new import_opus.WebmDemuxer())
        );
        if (shouldPCM) {
          if (isRaw) {
            finalStream = opusStream;
          } else {
            finalStream = opusStream.pipe(
              new import_opus.OpusDecoder({
                channels: 2,
                frameSize: 960,
                rate: 48e3
              })
            );
            trackStreamConfig.dispatcherConfig.type = import_discord_voip2.StreamType.Raw;
          }
        } else {
          finalStream = opusStream;
          trackStreamConfig.dispatcherConfig.type = import_discord_voip2.StreamType.Opus;
        }
      } else {
        finalStream = __privateMethod(this, _GuildQueuePlayerNode_instances, createFFmpegStream_fn).call(this, streamSrc.stream instanceof import_stream.Readable || typeof streamSrc.stream === "string" ? streamSrc.stream : streamSrc.stream.stream, track, options.seek ?? 0);
        trackStreamConfig.dispatcherConfig.type = import_discord_voip2.StreamType.Raw;
      }
      if (options.transitionMode) {
        if (this.queue.hasDebugger)
          this.queue.debug(
            `Transition mode detected, player will wait for buffering timeout to expire (Timeout: ${this.queue.options.bufferingTimeout}ms)`
          );
        await (0, import_promises2.setTimeout)(this.queue.options.bufferingTimeout);
        if (this.queue.hasDebugger)
          this.queue.debug("Buffering timeout has expired!");
      }
      if (this.queue.hasDebugger)
        this.queue.debug(
          `Preparing final stream config: ${JSON.stringify(
            trackStreamConfig,
            null,
            2
          )}`
        );
      const dispatcher = this.queue.dispatcher;
      if (!dispatcher) {
        if (this.queue.hasDebugger) {
          this.queue.debug(
            "Dispatcher is not available, this is most likely due to the queue being deleted in the middle of operation. Cancelling the stream..."
          );
        }
        finalStream.destroy();
      } else {
        const resource = await dispatcher.createStream(
          finalStream,
          trackStreamConfig.dispatcherConfig
        );
        this.queue.setTransitioning(!!options.transitionMode);
        await __privateMethod(this, _GuildQueuePlayerNode_instances, performPlay_fn).call(this, resource);
      }
    } catch (e) {
      if (this.queue.hasDebugger)
        this.queue.debug(`Failed to initialize audio player: ${e}`);
      throw e;
    }
  }
};
_progress = new WeakMap();
_hasFFmpegOptimization = new WeakMap();
_GuildQueuePlayerNode_instances = new WeakSet();
throw_fn = /* @__PURE__ */ __name(function(track, error) {
  const streamDefinitelyFailedMyDearT_TPleaseTrustMeItsNotMyFault = new NoResultError(`Could not extract stream for this track${error ? `

${error.stack || error}` : ""}`);
  this.queue.emit(
    GuildQueueEvent.PlayerSkip,
    this.queue,
    track,
    "ERR_NO_STREAM" /* NoStream */,
    streamDefinitelyFailedMyDearT_TPleaseTrustMeItsNotMyFault.message
  );
  this.queue.emit(
    GuildQueueEvent.PlayerError,
    this.queue,
    streamDefinitelyFailedMyDearT_TPleaseTrustMeItsNotMyFault,
    track
  );
  const nextTrack = this.queue.tracks.dispatch();
  if (nextTrack) return void this.play(nextTrack, { queue: false });
  this.queue.dispatcher?.emit("finish", null);
}, "#throw");
performPlay_fn = /* @__PURE__ */ __name(async function(resource) {
  if (!this.queue.dispatcher) {
    if (this.queue.hasDebugger) {
      this.queue.debug(
        "Dispatcher is not available, this is most likely due to the queue being deleted in the middle of operation. Cancelling the stream..."
      );
    }
  } else {
    if (this.queue.hasDebugger)
      this.queue.debug("Initializing audio player...");
    await this.queue.dispatcher.playStream(resource);
    if (this.queue.hasDebugger) this.queue.debug("Dispatching audio...");
  }
}, "#performPlay");
createGenericStream_fn = /* @__PURE__ */ __name(async function(track) {
  if (this.queue.hasDebugger)
    this.queue.debug(
      `Attempting to extract stream for Track { title: ${track.title}, url: ${track.url} } using registered extractors`
    );
  const attemptedExtractors = this.queue.player.extractors.getContext()?.attemptedExtractors || /* @__PURE__ */ new Set();
  const streamInfo = await this.queue.player.extractors.run(
    async (extractor) => {
      if (this.queue.player.options.blockStreamFrom?.some(
        (ext) => ext === extractor.identifier
      ))
        return false;
      if (attemptedExtractors.has(extractor.identifier)) return false;
      attemptedExtractors.add(extractor.identifier);
      const canStream = await extractor.validate(
        track.url,
        track.queryType || QueryResolver.resolve(track.url).type
      );
      if (!canStream) return false;
      return await extractor.stream(track);
    },
    false
  );
  if (!streamInfo || !streamInfo.result) {
    if (this.queue.hasDebugger) {
      this.queue.debug(
        `Failed to extract stream for Track { title: ${track.title}, url: ${track.url} } using registered extractors`
      );
    }
    if (!this.queue.options.disableFallbackStream) {
      if (this.queue.hasDebugger)
        this.queue.debug(
          `Generic stream extraction failed and fallback stream extraction is enabled`
        );
      return __privateMethod(this, _GuildQueuePlayerNode_instances, createFallbackStream_fn).call(this, track);
    }
    return streamInfo || null;
  }
  if (this.queue.hasDebugger)
    this.queue.debug(
      `Stream extraction was successful for Track { title: ${track.title}, url: ${track.url} } (Extractor: ${streamInfo.extractor?.identifier || "N/A"})`
    );
  return streamInfo;
}, "#createGenericStream");
createFallbackStream_fn = /* @__PURE__ */ __name(async function(track) {
  if (this.queue.hasDebugger)
    this.queue.debug(
      `Attempting to extract stream for Track { title: ${track.title}, url: ${track.url} } using fallback streaming method...`
    );
  const verifyFallbackStream = this.queue.options.verifyFallbackStream;
  const fallbackStream = await this.queue.player.extractors.run(
    async (extractor) => {
      if (extractor.identifier === track.extractor?.identifier) return false;
      if (this.queue.player.options.blockStreamFrom?.some(
        (ext) => ext === extractor.identifier
      )) {
        return false;
      }
      const query = `${track.title} ${track.author}`;
      if (verifyFallbackStream) {
        if (this.queue.hasDebugger) {
          this.queue.debug(
            `Fallback stream verification is enabled, validating query for Track { title: ${track.title}, url: ${track.url} } using ${extractor.identifier}...`
          );
        }
        const shouldProceed = await extractor.validate(
          query,
          track.queryType || track.source
        );
        if (!shouldProceed) {
          if (this.queue.hasDebugger)
            this.queue.debug(
              `Failed to validate query for Track { title: ${track.title}, url: ${track.url} } using ${extractor.identifier}`
            );
          return false;
        } else {
          if (this.queue.hasDebugger)
            this.queue.debug(
              `Query for Track { title: ${track.title}, url: ${track.url} } was validated using ${extractor.identifier}. Proceeding with extraction...`
            );
        }
      }
      const fallbackTracks = await extractor.handle(query, {
        requestedBy: track.requestedBy
      });
      const fallbackTrack = fallbackTracks.tracks[0];
      if (!fallbackTrack) return false;
      const stream = await extractor.stream(fallbackTrack);
      if (!stream) return false;
      track.bridgedTrack = fallbackTrack;
      return stream;
    },
    true
  );
  if (!fallbackStream || !fallbackStream.result) {
    if (this.queue.hasDebugger)
      this.queue.debug(
        `Failed to extract stream for Track { title: ${track.title}, url: ${track.url} } using fallback streaming method`
      );
    return fallbackStream || null;
  }
  track.bridgedExtractor = fallbackStream.extractor;
  return fallbackStream;
}, "#createFallbackStream");
createFFmpegStream_fn = /* @__PURE__ */ __name(function(stream, track, seek = 0, opus) {
  const ffmpegStream = this.queue.filters.ffmpeg.createStream(stream, {
    encoderArgs: this.queue.filters.ffmpeg.args,
    seek: seek / 1e3,
    fmt: opus ? "opus" : "s16le",
    requestOptions: track.raw?.requestOptions
  }).on("error", (err) => {
    const m = `${err}`.toLowerCase();
    if (this.queue.hasDebugger)
      this.queue.debug(
        `Stream closed due to an error from FFmpeg stream: ${err.stack || err.message || err}`
      );
    if (m.includes("premature close") || m.includes("epipe")) return;
    this.queue.emit(GuildQueueEvent.PlayerError, this.queue, err, track);
  });
  return ffmpegStream;
}, "#createFFmpegStream");
__name(_GuildQueuePlayerNode, "GuildQueuePlayerNode");
var GuildQueuePlayerNode = _GuildQueuePlayerNode;

// src/queue/GuildQueueAudioFilters.ts
var import_equalizer2 = require("@discord-player/equalizer");

// src/utils/FFmpegStream.ts
var import_ffmpeg = require("@discord-player/ffmpeg");
function FFMPEG_ARGS_STRING(stream, fmt, cookies, requestOptions) {
  const args = [];
  args.push("-reconnect", "1");
  args.push("-reconnect_streamed", "1");
  args.push("-reconnect_delay_max", "5");
  if (requestOptions?.headers) {
    const userAgent = requestOptions.headers["user-agent"] || requestOptions.headers["User-Agent"];
    if (userAgent) {
      args.push("-user_agent", String(userAgent));
    }
    const formattedHeaders = formatFFmpegHeaders(
      requestOptions.headers
    );
    if (formattedHeaders) {
      args.push("-headers", formattedHeaders);
    }
  }
  if (typeof cookies === "string") {
    const cookieValue = !cookies.includes(" ") ? cookies : `"${cookies}"`;
    args.push("-cookies", cookieValue);
  }
  args.push("-i", stream);
  args.push("-analyzeduration", "0");
  args.push("-loglevel", "0");
  args.push("-ar", "48000");
  args.push("-ac", "2");
  args.push("-f", typeof fmt === "string" ? fmt : "s16le");
  if (fmt === "opus") {
    args.push("-acodec", "libopus");
  }
  return args;
}
__name(FFMPEG_ARGS_STRING, "FFMPEG_ARGS_STRING");
function formatFFmpegHeaders(headers) {
  const headerPairs = [];
  for (const [name, value] of Object.entries(headers)) {
    if (value && name.toLowerCase() !== "user-agent") {
      const valueStr = Array.isArray(value) ? value.join(", ") : String(value);
      headerPairs.push(`${name}: ${valueStr}`);
    }
  }
  return headerPairs.length > 0 ? headerPairs.join("\r\n") : null;
}
__name(formatFFmpegHeaders, "formatFFmpegHeaders");
function FFMPEG_ARGS_PIPED(fmt) {
  const args = (0, import_ffmpeg.createFFmpegArgs)({
    analyzeduration: 0,
    loglevel: 0,
    ar: 48e3,
    ac: 2,
    f: `${typeof fmt === "string" ? fmt : "s16le"}`,
    acodec: fmt === "opus" ? "libopus" : null
  });
  return args;
}
__name(FFMPEG_ARGS_PIPED, "FFMPEG_ARGS_PIPED");
function createFFmpegStream(stream, options) {
  if (options?.skip && typeof stream !== "string") return stream;
  options ?? (options = {});
  const args = typeof stream === "string" ? FFMPEG_ARGS_STRING(
    stream,
    options.fmt,
    options.cookies,
    options.requestOptions
  ) : FFMPEG_ARGS_PIPED(options.fmt);
  if (!Number.isNaN(options.seek)) args.unshift("-ss", String(options.seek));
  if (Array.isArray(options.encoderArgs)) args.push(...options.encoderArgs);
  const transcoder = new import_ffmpeg.FFmpeg({ shell: false, args });
  transcoder.on("close", () => transcoder.destroy());
  if (typeof stream !== "string") {
    stream.on("error", () => transcoder.destroy());
    stream.pipe(transcoder);
  }
  return transcoder;
}
__name(createFFmpegStream, "createFFmpegStream");

// src/queue/GuildQueueAudioFilters.ts
var makeBands = /* @__PURE__ */ __name((arr) => {
  return Array.from(
    {
      length: import_equalizer2.Equalizer.BAND_COUNT
    },
    (_, i) => ({
      band: i,
      gain: arr[i] ? arr[i] / 30 : 0
    })
  );
}, "makeBands");
var EqualizerConfigurationPreset = Object.freeze({
  Flat: makeBands([]),
  Classical: makeBands(
    [
      -111022e-20,
      -111022e-20,
      -111022e-20,
      -111022e-20,
      -111022e-20,
      -111022e-20,
      -7.2,
      -7.2,
      -7.2,
      -9.6
    ]
  ),
  Club: makeBands(
    [
      -111022e-20,
      -111022e-20,
      8,
      5.6,
      5.6,
      5.6,
      3.2,
      -111022e-20,
      -111022e-20,
      -111022e-20
    ]
  ),
  Dance: makeBands(
    [
      9.6,
      7.2,
      2.4,
      -111022e-20,
      -111022e-20,
      -5.6,
      -7.2,
      -7.2,
      -111022e-20,
      -111022e-20
    ]
  ),
  FullBass: makeBands(
    [
      -8,
      9.6,
      9.6,
      5.6,
      1.6,
      -4,
      -8,
      -10.4,
      -11.2,
      -11.2
    ]
  ),
  FullBassTreble: makeBands(
    [
      7.2,
      5.6,
      -111022e-20,
      -7.2,
      -4.8,
      1.6,
      8,
      11.2,
      12,
      12
    ]
  ),
  FullTreble: makeBands(
    [
      -9.6,
      -9.6,
      -9.6,
      -4,
      2.4,
      11.2,
      16,
      16,
      16,
      16.8
    ]
  ),
  Headphones: makeBands(
    [
      4.8,
      11.2,
      5.6,
      -3.2,
      -2.4,
      1.6,
      4.8,
      9.6,
      12.8,
      14.4
    ]
  ),
  LargeHall: makeBands(
    [
      10.4,
      10.4,
      5.6,
      5.6,
      -111022e-20,
      -4.8,
      -4.8,
      -4.8,
      -111022e-20,
      -111022e-20
    ]
  ),
  Live: makeBands([-4.8, -111022e-20, 4, 5.6, 5.6, 5.6, 4, 2.4, 2.4, 2.4]),
  Party: makeBands(
    [
      7.2,
      7.2,
      -111022e-20,
      -111022e-20,
      -111022e-20,
      -111022e-20,
      -111022e-20,
      -111022e-20,
      7.2,
      7.2
    ]
  ),
  Pop: makeBands(
    [
      -1.6,
      4.8,
      7.2,
      8,
      5.6,
      -111022e-20,
      -2.4,
      -2.4,
      -1.6,
      -1.6
    ]
  ),
  Reggae: makeBands(
    [
      -111022e-20,
      -111022e-20,
      -111022e-20,
      -5.6,
      -111022e-20,
      6.4,
      6.4,
      -111022e-20,
      -111022e-20,
      -111022e-20
    ]
  ),
  Rock: makeBands([8, 4.8, -5.6, -8, -3.2, 4, 8.8, 11.2, 11.2, 11.2]),
  Ska: makeBands(
    [
      -2.4,
      -4.8,
      -4,
      -111022e-20,
      4,
      5.6,
      8.8,
      9.6,
      11.2,
      9.6
    ]
  ),
  Soft: makeBands(
    [
      4.8,
      1.6,
      -111022e-20,
      -2.4,
      -111022e-20,
      4,
      8,
      9.6,
      11.2,
      12
    ]
  ),
  SoftRock: makeBands(
    [
      4,
      4,
      2.4,
      -111022e-20,
      -4,
      -5.6,
      -3.2,
      -111022e-20,
      2.4,
      8.8
    ]
  ),
  Techno: makeBands(
    [
      8,
      5.6,
      -111022e-20,
      -5.6,
      -4.8,
      -111022e-20,
      8,
      9.6,
      9.6,
      8.8
    ]
  )
});
var _ffmpegFilters, _inputArgs, _FFmpegFilterer_instances, setFilters_fn;
var _FFmpegFilterer = class _FFmpegFilterer {
  constructor(af) {
    this.af = af;
    __privateAdd(this, _FFmpegFilterer_instances);
    __privateAdd(this, _ffmpegFilters, []);
    __privateAdd(this, _inputArgs, []);
  }
  /**
   * Indicates whether ffmpeg may be skipped
   */
  get skippable() {
    return !!this.af.queue.player.options.skipFFmpeg;
  }
  /**
   * Set input args for FFmpeg
   */
  setInputArgs(args) {
    if (!args.every((arg) => typeof arg === "string"))
      throw new InvalidArgTypeError("args", "Array<string>", "invalid item(s)");
    __privateSet(this, _inputArgs, args);
  }
  /**
   * Get input args
   */
  get inputArgs() {
    return __privateGet(this, _inputArgs);
  }
  /**
   * Get encoder args
   */
  get encoderArgs() {
    if (!this.filters.length) return [];
    return ["-af", this.toString()];
  }
  /**
   * Get final ffmpeg args
   */
  get args() {
    return this.inputArgs.concat(this.encoderArgs);
  }
  /**
   * Create ffmpeg stream
   * @param source The stream source
   * @param options The stream options
   */
  createStream(source, options) {
    if (__privateGet(this, _inputArgs).length)
      options.encoderArgs = [
        ...__privateGet(this, _inputArgs),
        ...options.encoderArgs || []
      ];
    const stream = createFFmpegStream(source, options);
    return stream;
  }
  /**
   * Set ffmpeg filters
   * @param filters The filters
   */
  setFilters(filters) {
    let _filters = [];
    if (typeof filters === "boolean") {
      _filters = !filters ? [] : Object.keys(AudioFilters.filters);
    } else if (Array.isArray(filters)) {
      _filters = filters;
    } else {
      _filters = Object.entries(filters).filter((res) => res[1] === true).map((m) => m[0]);
    }
    return __privateMethod(this, _FFmpegFilterer_instances, setFilters_fn).call(this, _filters);
  }
  /**
   * Currently active ffmpeg filters
   */
  get filters() {
    return __privateGet(this, _ffmpegFilters);
  }
  set filters(filters) {
    this.setFilters(filters);
  }
  /**
   * Toggle given ffmpeg filter(s)
   * @param filters The filter(s)
   */
  toggle(filters) {
    if (!Array.isArray(filters)) filters = [filters];
    const fresh = [];
    filters.forEach((f) => {
      if (this.filters.includes(f)) return;
      fresh.push(f);
    });
    return __privateMethod(this, _FFmpegFilterer_instances, setFilters_fn).call(this, __privateGet(this, _ffmpegFilters).filter((r) => !filters.includes(r)).concat(fresh));
  }
  /**
   * Set default filters
   * @param ff Filters list
   */
  setDefaults(ff) {
    __privateSet(this, _ffmpegFilters, ff);
  }
  /**
   * Get list of enabled filters
   */
  getFiltersEnabled() {
    return __privateGet(this, _ffmpegFilters);
  }
  /**
   * Get list of disabled filters
   */
  getFiltersDisabled() {
    return AudioFilters.names.filter((f) => !__privateGet(this, _ffmpegFilters).includes(f));
  }
  /**
   * Check if the given filter is enabled
   * @param filter The filter
   */
  isEnabled(filter) {
    return __privateGet(this, _ffmpegFilters).includes(filter);
  }
  /**
   * Check if the given filter is disabled
   * @param filter The filter
   */
  isDisabled(filter) {
    return !this.isEnabled(filter);
  }
  /**
   * Check if the given filter is a valid filter
   * @param filter The filter to test
   */
  isValidFilter(filter) {
    return AudioFilters.has(filter);
  }
  /**
   * Convert current filters to array
   */
  toArray() {
    return this.filters.map((filter) => AudioFilters.get(filter));
  }
  /**
   * Convert current filters to JSON object
   */
  toJSON() {
    const obj = {};
    this.filters.forEach((filter) => obj[filter] = AudioFilters.get(filter));
    return obj;
  }
  /**
   * String representation of current filters
   */
  toString() {
    return AudioFilters.create(this.filters);
  }
};
_ffmpegFilters = new WeakMap();
_inputArgs = new WeakMap();
_FFmpegFilterer_instances = new WeakSet();
setFilters_fn = /* @__PURE__ */ __name(function(filters) {
  const { queue } = this.af;
  if (filters.every((f) => __privateGet(this, _ffmpegFilters).includes(f)) && __privateGet(this, _ffmpegFilters).every((f) => filters.includes(f)))
    return Promise.resolve(false);
  const ignoreFilters = this.filters.some((ff) => ff === "nightcore" || ff === "vaporwave") && !filters.some((ff) => ff === "nightcore" || ff === "vaporwave");
  const seekTime = queue.node.getTimestamp(ignoreFilters)?.current.value || 0;
  const prev = __privateGet(this, _ffmpegFilters).slice();
  __privateSet(this, _ffmpegFilters, [...new Set(filters)]);
  return this.af.triggerReplay(seekTime).then((t) => {
    queue.emit(
      GuildQueueEvent.AudioFiltersUpdate,
      queue,
      prev,
      __privateGet(this, _ffmpegFilters).slice()
    );
    return t;
  });
}, "#setFilters");
__name(_FFmpegFilterer, "FFmpegFilterer");
var FFmpegFilterer = _FFmpegFilterer;
var _GuildQueueAudioFilters = class _GuildQueueAudioFilters {
  constructor(queue) {
    this.queue = queue;
    __publicField(this, "graph", new AFilterGraph(this));
    __publicField(this, "ffmpeg", new FFmpegFilterer(this));
    __publicField(this, "equalizerPresets", EqualizerConfigurationPreset);
    __publicField(this, "_lastFiltersCache", {
      biquad: null,
      equalizer: [],
      filters: [],
      volume: 100,
      sampleRate: -1,
      compressor: null,
      reverb: null,
      sampleRateFilter: null
    });
    if (typeof this.queue.options.volume === "number") {
      this._lastFiltersCache.volume = this.queue.options.volume;
    }
  }
  // TODO: enable this in the future
  // public get ffmpeg(): FFmpegFilterer<Meta> | null {
  //     if (this.queue.player.options.skipFFmpeg) {
  //         if (this.#ffmpeg) this.#ffmpeg = null;
  //         return null;
  //     }
  //     if (!this.#ffmpeg) {
  //         this.#ffmpeg = new FFmpegFilterer<Meta>(this);
  //     }
  //     return this.#ffmpeg;
  // }
  /**
   * Volume transformer
   */
  get volume() {
    return this.queue.dispatcher?.dsp?.volume || null;
  }
  /**
   * 15 Band Equalizer
   */
  get equalizer() {
    return this.queue.dispatcher?.equalizer || null;
  }
  /**
   * Digital biquad filters
   */
  get biquad() {
    return this.queue.dispatcher?.biquad || null;
  }
  /**
   * DSP filters
   */
  get filters() {
    return this.queue.dispatcher?.filters || null;
  }
  /**
   * Audio resampler
   */
  get resampler() {
    return this.queue.dispatcher?.resampler || null;
  }
  /**
   * Compressor transformer
   */
  get compressor() {
    return this.queue.dispatcher?.compressor || null;
  }
  /**
   * Reverb transformer
   */
  get reverb() {
    return this.queue.dispatcher?.reverb || null;
  }
  /**
   * PCM Seeker transformer
   */
  get seeker() {
    return this.queue.dispatcher?.seeker || null;
  }
  /**
   * Replay current track in transition mode
   * @param seek The duration to seek to
   */
  async triggerReplay(seek = 0) {
    if (!this.queue.currentTrack) return false;
    const entry = this.queue.node.tasksQueue.acquire();
    try {
      await entry.getTask();
      await this.queue.node.play(this.queue.currentTrack, {
        queue: false,
        seek,
        transitionMode: true
      });
      this.queue.node.tasksQueue.release();
      return true;
    } catch {
      this.queue.node.tasksQueue.release();
      return false;
    }
  }
};
__name(_GuildQueueAudioFilters, "GuildQueueAudioFilters");
var GuildQueueAudioFilters = _GuildQueueAudioFilters;
var _AFilterGraph = class _AFilterGraph {
  constructor(af) {
    this.af = af;
  }
  get ffmpeg() {
    return this.af.ffmpeg?.filters ?? [];
  }
  get equalizer() {
    return (this.af.equalizer?.bandMultipliers || []).map((m, i) => ({
      band: i,
      gain: m
    }));
  }
  get biquad() {
    return this.af.biquad?.getFilterName() || null;
  }
  get filters() {
    return this.af.filters?.filters || [];
  }
  get volume() {
    return this.af.volume;
  }
  get resampler() {
    return this.af.resampler;
  }
  dump() {
    return {
      ffmpeg: this.ffmpeg,
      equalizer: this.equalizer,
      biquad: this.biquad,
      filters: this.filters,
      sampleRate: this.resampler?.sampleRate || 48e3,
      volume: this.volume?.volume ?? 100
    };
  }
};
__name(_AFilterGraph, "AFilterGraph");
var AFilterGraph = _AFilterGraph;

// src/queue/GuildQueue.ts
var import_timers = require("timers");

// src/queue/GuildQueueStatistics.ts
var _GuildQueueStatistics = class _GuildQueueStatistics {
  constructor(queue) {
    this.queue = queue;
  }
  /**
   * Generate statistics of this queue
   */
  generate() {
    return {
      latency: {
        eventLoop: this.queue.player.eventLoopLag,
        voiceConnection: this.queue.ping
      },
      status: {
        buffering: this.queue.node.isBuffering(),
        playing: this.queue.node.isPlaying(),
        paused: this.queue.node.isPaused(),
        idle: this.queue.node.isIdle()
      },
      tracksCount: this.queue.tracks.size,
      historySize: this.queue.history.tracks.size,
      extractors: this.queue.player.extractors.size,
      listeners: this.queue.guild.members.me?.voice.channel?.members.filter(
        (m) => !m.user.bot
      ).size || 0,
      memoryUsage: process.memoryUsage(),
      versions: {
        node: process.version,
        player: this.queue.player.version
      }
    };
  }
};
__name(_GuildQueueStatistics, "GuildQueueStatistics");
var GuildQueueStatistics = _GuildQueueStatistics;

// src/queue/SyncedLyricsProvider.ts
var timestampPattern = /\[(\d{2}):(\d{2})\.(\d{2})\]/;
var _loop, _callback, _onUnsubscribe, _SyncedLyricsProvider_instances, createLoop_fn;
var _SyncedLyricsProvider = class _SyncedLyricsProvider {
  constructor(queue, raw) {
    this.queue = queue;
    this.raw = raw;
    __privateAdd(this, _SyncedLyricsProvider_instances);
    __privateAdd(this, _loop, null);
    __privateAdd(this, _callback, null);
    __privateAdd(this, _onUnsubscribe, null);
    __publicField(this, "interval", 100);
    __publicField(this, "lyrics", /* @__PURE__ */ new Map());
    if (raw?.syncedLyrics) this.load(raw?.syncedLyrics);
  }
  isSubscribed() {
    return __privateGet(this, _callback) !== null;
  }
  load(lyrics) {
    if (!lyrics) throw new NotExistingError("syncedLyrics");
    this.lyrics.clear();
    this.unsubscribe();
    const lines = lyrics.split("\n");
    for (const line of lines) {
      const match = line.match(timestampPattern);
      if (match) {
        const [, minutes, seconds, milliseconds] = match;
        const timestamp = parseInt(minutes) * 60 * 1e3 + parseInt(seconds) * 1e3 + parseInt(milliseconds);
        this.lyrics.set(timestamp, line.replace(timestampPattern, "").trim());
      }
    }
  }
  /**
   * Returns the lyrics at a specific time or at the closest time (±2 seconds)
   * @param time The time in milliseconds
   */
  at(time) {
    const lowestTime = this.lyrics.keys().next().value;
    if (lowestTime == null || time < lowestTime) return null;
    if (this.lyrics.has(time))
      return { line: this.lyrics.get(time), timestamp: time };
    const keys = Array.from(this.lyrics.keys());
    const closest = keys.reduce(
      (a, b) => Math.abs(b - time) < Math.abs(a - time) ? b : a
    );
    if (closest > time) return null;
    if (Math.abs(closest - time) > 2e3) return null;
    const line = this.lyrics.get(closest);
    if (!line) return null;
    return { timestamp: closest, line };
  }
  /**
   * Callback for the lyrics change.
   * @param callback The callback function
   */
  onChange(callback) {
    __privateSet(this, _callback, callback);
  }
  /**
   * Callback to detect when the provider is unsubscribed.
   * @param callback The callback function
   */
  onUnsubscribe(callback) {
    __privateSet(this, _onUnsubscribe, callback);
  }
  /**
   * Unsubscribes from the queue.
   */
  unsubscribe() {
    if (__privateGet(this, _loop)) clearInterval(__privateGet(this, _loop));
    if (__privateGet(this, _onUnsubscribe)) __privateGet(this, _onUnsubscribe).call(this);
    __privateSet(this, _callback, null);
    __privateSet(this, _onUnsubscribe, null);
    __privateSet(this, _loop, null);
  }
  /**
   * Subscribes to the queue to monitor the current time.
   * @returns The unsubscribe function
   */
  subscribe() {
    if (__privateGet(this, _loop)) return () => this.unsubscribe();
    __privateMethod(this, _SyncedLyricsProvider_instances, createLoop_fn).call(this);
    return () => this.unsubscribe();
  }
  /**
   * Pauses the lyrics provider.
   */
  pause() {
    const hasLoop = __privateGet(this, _loop) !== null;
    if (hasLoop) {
      clearInterval(__privateGet(this, _loop));
      __privateSet(this, _loop, null);
    }
    return hasLoop;
  }
  /**
   * Resumes the lyrics provider.
   */
  resume() {
    const hasLoop = __privateGet(this, _loop) !== null;
    if (!hasLoop) __privateMethod(this, _SyncedLyricsProvider_instances, createLoop_fn).call(this);
    return !hasLoop;
  }
};
_loop = new WeakMap();
_callback = new WeakMap();
_onUnsubscribe = new WeakMap();
_SyncedLyricsProvider_instances = new WeakSet();
createLoop_fn = /* @__PURE__ */ __name(function() {
  if (!__privateGet(this, _callback)) return;
  if (__privateGet(this, _loop)) clearInterval(__privateGet(this, _loop));
  let lastValue = null;
  __privateSet(this, _loop, setInterval(() => {
    if (this.queue.deleted) return this.unsubscribe();
    if (!__privateGet(this, _callback) || !this.queue.isPlaying()) return;
    const time = this.queue.node.getTimestamp();
    if (!time) return;
    const lyrics = this.at(time.current.value);
    if (!lyrics) return;
    if (lastValue !== null && lyrics.line === lastValue.line && lyrics.timestamp === lastValue.timestamp)
      return;
    lastValue = lyrics;
    __privateGet(this, _callback).call(this, lyrics.line, lyrics.timestamp);
  }, this.interval).unref());
}, "#createLoop");
__name(_SyncedLyricsProvider, "SyncedLyricsProvider");
var SyncedLyricsProvider = _SyncedLyricsProvider;

// src/queue/GuildQueue.ts
var GuildQueueEvent = {
  /**
   * Emitted when audio track is added to the queue
   */
  AudioTrackAdd: "audioTrackAdd",
  /**
   * Emitted when audio tracks were added to the queue
   */
  AudioTracksAdd: "audioTracksAdd",
  /**
   * Emitted when audio track is removed from the queue
   */
  AudioTrackRemove: "audioTrackRemove",
  /**
   * Emitted when audio tracks are removed from the queue
   */
  AudioTracksRemove: "audioTracksRemove",
  /**
   * Emitted when a connection is created
   */
  Connection: "connection",
  /**
   * Emitted when a voice connection is destroyed
   */
  ConnectionDestroyed: "connectionDestroyed",
  /**
   * Emitted when the bot is disconnected from the channel
   */
  Disconnect: "disconnect",
  /**
   * Emitted when the queue sends a debug info
   */
  Debug: "debug",
  /**
   * Emitted when the queue encounters error
   */
  Error: "error",
  /**
   * Emitted when the voice channel is empty
   */
  EmptyChannel: "emptyChannel",
  /**
   * Emitted when the queue is empty
   */
  EmptyQueue: "emptyQueue",
  /**
   * Emitted when the audio player starts streaming audio track
   */
  PlayerStart: "playerStart",
  /**
   * Emitted when the audio player errors while streaming audio track
   */
  PlayerError: "playerError",
  /**
   * Emitted when the audio player finishes streaming audio track
   */
  PlayerFinish: "playerFinish",
  /**
   * Emitted when the audio player skips current track
   */
  PlayerSkip: "playerSkip",
  /**
   * Emitted when the audio player is triggered
   */
  PlayerTrigger: "playerTrigger",
  /**
   * Emitted when the voice state is updated. Consuming this event may disable default voice state update handler if `Player.isVoiceStateHandlerLocked()` returns `false`.
   */
  VoiceStateUpdate: "voiceStateUpdate",
  /**
   * Emitted when volume is updated
   */
  VolumeChange: "volumeChange",
  /**
   * Emitted when player is paused
   */
  PlayerPause: "playerPause",
  /**
   * Emitted when player is resumed
   */
  PlayerResume: "playerResume",
  /**
   * Biquad Filters Update
   */
  BiquadFiltersUpdate: "biquadFiltersUpdate",
  /**
   * Equalizer Update
   */
  EqualizerUpdate: "equalizerUpdate",
  /**
   * DSP update
   */
  DSPUpdate: "dspUpdate",
  /**
   * Audio Filters Update
   */
  AudioFiltersUpdate: "audioFiltersUpdate",
  /**
   * Audio player will play next track
   */
  WillPlayTrack: "willPlayTrack",
  /**
   * Emitted when a voice channel is repopulated
   */
  ChannelPopulate: "channelPopulate",
  /**
   * Emitted when a queue is successfully created
   */
  QueueCreate: "queueCreate",
  /**
   * Emitted when a queue is deleted
   */
  QueueDelete: "queueDelete",
  /**
   * Emitted when a queue is trying to add similar track for autoplay
   */
  WillAutoPlay: "willAutoPlay",
  /**
   * Emitted when sample rate is updated
   */
  SampleRateUpdate: "sampleRateUpdate",
  /**
   * Emitted when a named sample rate filter is updated
   */
  SampleRateFilterUpdate: "sampleRateFilterUpdate",
  /**
   * Emitted when reverb filter is updated
   */
  ReverbUpdate: "reverbUpdate",
  /**
   * Emitted when compressor filter is updated
   */
  CompressorUpdate: "compressorUpdate",
  /**
   * Emitted when seek is performed
   */
  PlayerSeek: "playerSeek"
};
var TrackSkipReason = /* @__PURE__ */ ((TrackSkipReason2) => {
  TrackSkipReason2["NoStream"] = "ERR_NO_STREAM";
  TrackSkipReason2["Manual"] = "MANUAL";
  TrackSkipReason2["SEEK_OVER_THRESHOLD"] = "SEEK_OVER_THRESHOLD";
  TrackSkipReason2["Jump"] = "JUMPED_TO_ANOTHER_TRACK";
  TrackSkipReason2["SkipTo"] = "SKIP_TO_ANOTHER_TRACK";
  TrackSkipReason2["HistoryNext"] = "HISTORY_NEXT_TRACK";
  return TrackSkipReason2;
})(TrackSkipReason || {});
var QueueRepeatMode = {
  /**
   * Disable repeat mode.
   */
  OFF: 0,
  /**
   * Repeat the current track.
   */
  TRACK: 1,
  /**
   * Repeat the entire queue.
   */
  QUEUE: 2,
  /**
   * When last track ends, play similar tracks in the future if queue is empty.
   */
  AUTOPLAY: 3
};
var _transitioning, _deleted, _shuffle, _GuildQueue_instances, attachListeners_fn, removeListeners_fn, performStart_fn, getNextTrack_fn, performFinish_fn, emitEnd_fn, handleAutoplay_fn;
var _GuildQueue = class _GuildQueue {
  constructor(player, options) {
    this.player = player;
    this.options = options;
    __privateAdd(this, _GuildQueue_instances);
    __privateAdd(this, _transitioning, false);
    __privateAdd(this, _deleted, false);
    __privateAdd(this, _shuffle, false);
    __publicField(this, "__current", null);
    __publicField(this, "tracks");
    __publicField(this, "history", new GuildQueueHistory(this));
    __publicField(this, "dispatcher", null);
    __publicField(this, "node", new GuildQueuePlayerNode(this));
    __publicField(this, "filters", new GuildQueueAudioFilters(this));
    __publicField(this, "onBeforeCreateStream", /* @__PURE__ */ __name(async () => null, "onBeforeCreateStream"));
    __publicField(this, "onAfterCreateStream", /* @__PURE__ */ __name(async (stream) => ({
      stream,
      type: import_discord_voip3.StreamType.Raw
    }), "onAfterCreateStream"));
    __publicField(this, "onStreamExtracted", /* @__PURE__ */ __name(async (stream) => stream, "onStreamExtracted"));
    __publicField(this, "repeatMode", QueueRepeatMode.OFF);
    __publicField(this, "timeouts", new import_utils6.Collection());
    __publicField(this, "stats", new GuildQueueStatistics(this));
    __publicField(this, "tasksQueue", new AsyncQueue());
    __publicField(this, "syncedLyricsProvider", new SyncedLyricsProvider(this));
    this.tracks = new import_utils6.Queue(options.queueStrategy);
    if (TypeUtil.isFunction(options.onBeforeCreateStream))
      this.onBeforeCreateStream = options.onBeforeCreateStream;
    if (TypeUtil.isFunction(options.onAfterCreateStream))
      this.onAfterCreateStream = options.onAfterCreateStream;
    if (TypeUtil.isFunction(options.onStreamExtracted))
      this.onStreamExtracted = options.onStreamExtracted;
    if (!TypeUtil.isNullish(options.repeatMode))
      this.repeatMode = options.repeatMode;
    options.selfDeaf ?? (options.selfDeaf = true);
    options.maxSize ?? (options.maxSize = Infinity);
    options.maxHistorySize ?? (options.maxHistorySize = Infinity);
    options.pauseOnEmpty ?? (options.pauseOnEmpty = true);
    if (!TypeUtil.isNullish(this.options.biquad) && !TypeUtil.isBoolean(this.options.biquad)) {
      this.filters._lastFiltersCache.biquad = this.options.biquad;
    }
    if (Array.isArray(this.options.equalizer)) {
      this.filters._lastFiltersCache.equalizer = this.options.equalizer;
    }
    if (Array.isArray(this.options.filterer)) {
      this.filters._lastFiltersCache.filters = this.options.filterer;
    }
    if (TypeUtil.isNumber(this.options.resampler)) {
      this.filters._lastFiltersCache.sampleRate = this.options.resampler;
    }
    if (TypeUtil.isArray(this.options.ffmpegFilters)) {
      this.filters.ffmpeg.setDefaults(this.options.ffmpegFilters);
    }
    if (!TypeUtil.isNumber(options.maxSize)) {
      throw new InvalidArgTypeError(
        "[GuildNodeInit.maxSize]",
        "number",
        typeof options.maxSize
      );
    }
    if (!TypeUtil.isNumber(options.maxHistorySize)) {
      throw new InvalidArgTypeError(
        "[GuildNodeInit.maxHistorySize]",
        "number",
        typeof options.maxHistorySize
      );
    }
    if (options.maxSize < 1) options.maxSize = Infinity;
    if (options.maxHistorySize < 1) options.maxHistorySize = Infinity;
    if (this.hasDebugger)
      this.debug(
        `GuildQueue initialized for guild ${this.options.guild.name} (ID: ${this.options.guild.id})`
      );
    this.emit(GuildQueueEvent.QueueCreate, this);
  }
  /**
   * Whether this queue can intercept streams
   */
  canIntercept() {
    return this.options.enableStreamInterceptor;
  }
  /**
   * Estimated duration of this queue in ms
   */
  get estimatedDuration() {
    return this.tracks.store.reduce((a, c) => a + c.durationMS, 0);
  }
  /**
   * Formatted duration of this queue
   */
  get durationFormatted() {
    return Util.buildTimeCode(Util.parseMS(this.estimatedDuration));
  }
  /**
   * The sync lyrics provider for this queue.
   * @example const lyrics = await player.lyrics.search({ q: 'Alan Walker Faded' });
   * const syncedLyrics = queue.syncedLyrics(lyrics[0]);
   * console.log(syncedLyrics.at(10_000));
   * // subscribe to lyrics change
   * const unsubscribe = syncedLyrics.onChange((lyrics, timestamp) => {
   *    console.log(lyrics, timestamp);
   * });
   * // unsubscribe from lyrics change
   * unsubscribe(); // or
   * syncedLyrics.unsubscribe();
   */
  syncedLyrics(lyrics) {
    this.syncedLyricsProvider.load(lyrics?.syncedLyrics ?? "");
    return this.syncedLyricsProvider;
  }
  /**
   * Write a debug message to this queue
   * @param m The message to write
   */
  debug(m) {
    this.emit(GuildQueueEvent.Debug, this, m);
  }
  /**
   * The metadata of this queue
   */
  get metadata() {
    return this.options.metadata;
  }
  set metadata(m) {
    this.options.metadata = m;
  }
  /**
   * Set metadata for this queue
   * @param m Metadata to set
   */
  setMetadata(m) {
    this.options.metadata = m;
  }
  /**
   * Indicates current track of this queue
   */
  get currentTrack() {
    return this.dispatcher?.audioResource?.metadata || this.__current;
  }
  /**
   * Indicates if this queue was deleted previously
   */
  get deleted() {
    return __privateGet(this, _deleted);
  }
  /**
   * The voice channel of this queue
   */
  get channel() {
    return this.dispatcher?.channel || null;
  }
  set channel(c) {
    if (this.dispatcher) {
      if (c) {
        this.dispatcher.channel = c;
      } else {
        this.delete();
      }
    }
  }
  /**
   * The voice connection of this queue
   */
  get connection() {
    return this.dispatcher?.voiceConnection || null;
  }
  /**
   * The guild this queue belongs to
   */
  get guild() {
    return this.options.guild;
  }
  /**
   * The id of this queue
   */
  get id() {
    return this.guild.id;
  }
  /**
   * Set transition mode for this queue
   * @param state The state to set
   */
  setTransitioning(state) {
    __privateSet(this, _transitioning, state);
  }
  /**
   * if this queue is currently under transition mode
   */
  isTransitioning() {
    return __privateGet(this, _transitioning);
  }
  /**
   * Set repeat mode for this queue
   * @param mode The repeat mode to apply
   */
  setRepeatMode(mode) {
    this.repeatMode = mode;
  }
  /**
   * Max size of this queue
   */
  get maxSize() {
    return this.options.maxSize ?? Infinity;
  }
  /**
   * Max size of this queue
   */
  getMaxSize() {
    return this.maxSize;
  }
  /**
   * Gets the size of the queue
   */
  get size() {
    return this.tracks.size;
  }
  /**
   * The size of this queue
   */
  getSize() {
    return this.size;
  }
  /**
   * Max history size of this queue
   */
  get maxHistorySize() {
    return this.options.maxHistorySize ?? Infinity;
  }
  /**
   * Max history size of this queue
   */
  getMaxHistorySize() {
    return this.maxHistorySize;
  }
  /**
   * Set max history size for this queue
   * @param size The size to set
   */
  setMaxHistorySize(size) {
    if (!TypeUtil.isNumber(size)) {
      throw new InvalidArgTypeError("size", "number", typeof size);
    }
    if (size < 1) size = Infinity;
    this.options.maxHistorySize = size;
  }
  /**
   * Set max size for this queue
   * @param size The size to set
   */
  setMaxSize(size) {
    if (!TypeUtil.isNumber(size)) {
      throw new InvalidArgTypeError("size", "number", typeof size);
    }
    if (size < 1) size = Infinity;
    this.options.maxSize = size;
  }
  /**
   * Clear this queue
   */
  clear() {
    this.tracks.clear();
    this.history.clear();
  }
  /**
   * Check if this queue has no tracks left in it
   */
  isEmpty() {
    return this.tracks.size < 1;
  }
  /**
   * Check if this queue is full
   */
  isFull() {
    return this.tracks.size >= this.maxSize;
  }
  /**
   * Get queue capacity
   */
  getCapacity() {
    if (this.isFull()) return 0;
    const cap = this.maxSize - this.size;
    return cap;
  }
  /**
   * Check if this queue currently holds active audio resource
   */
  isPlaying() {
    return this.dispatcher?.audioResource != null && !this.dispatcher.audioResource.ended;
  }
  /**
   * Add track to the queue. This will emit `audioTracksAdd` when multiple tracks are added, otherwise `audioTrackAdd`.
   * @param track Track or playlist or array of tracks to add
   */
  addTrack(track) {
    const toAdd = track instanceof Playlist ? track.tracks : track;
    const isMulti = Array.isArray(toAdd);
    VALIDATE_QUEUE_CAP(this, toAdd);
    this.tracks.add(toAdd);
    if (isMulti) {
      this.emit(GuildQueueEvent.AudioTracksAdd, this, toAdd);
    } else {
      this.emit(GuildQueueEvent.AudioTrackAdd, this, toAdd);
    }
  }
  /**
   * Remove a track from queue
   * @param track The track to remove
   */
  removeTrack(track) {
    return this.node.remove(track);
  }
  /**
   * Prepends a track or track resolvable to the queue
   * @param track The track resolvable to insert
   * @param index The index to insert the track at (defaults to 0). If > 0, the inserted track will be placed before the track at the given index.
   */
  prepend(track, index = 0) {
    if (index < 0 || index > this.tracks.size) {
      throw new OutOfRangeError(
        "index",
        `${index}`,
        "0",
        `${this.tracks.size}`
      );
    }
    const count = Array.isArray(track) ? track.length : track instanceof import_utils6.Queue ? track.size : 1;
    VALIDATE_QUEUE_CAP(this, count);
    const insertionIndex = index === 0 ? 0 : index - 1;
    if (track instanceof Track) {
      this.node.insert(track, insertionIndex);
      this.emit(GuildQueueEvent.AudioTrackAdd, this, track);
      return;
    }
    const tracks = track instanceof import_utils6.Queue ? track.store : track;
    this.tracks.store.splice(insertionIndex, 0, ...tracks);
    if (!this.options.noEmitInsert) {
      this.emit(GuildQueueEvent.AudioTracksAdd, this, tracks);
    }
  }
  /**
   * Appends a track or track resolvable to the queue
   * @param track The track resolvable to insert
   * @param index The index to insert the track at (defaults to 0). If > 0, the inserted track will be placed after the track at the given index.
   */
  append(track, index = 0) {
    if (index < 0 || index > this.tracks.size) {
      throw new OutOfRangeError(
        "index",
        `${index}`,
        "0",
        `${this.tracks.size}`
      );
    }
    const count = Array.isArray(track) ? track.length : track instanceof import_utils6.Queue ? track.size : 1;
    VALIDATE_QUEUE_CAP(this, count);
    if (track instanceof Track) {
      this.node.insert(track, index);
      this.emit(GuildQueueEvent.AudioTrackAdd, this, track);
      return;
    }
    const tracks = track instanceof import_utils6.Queue ? track.store : track;
    this.tracks.store.splice(index, 0, ...tracks);
    if (!this.options.noEmitInsert) {
      this.emit(GuildQueueEvent.AudioTracksAdd, this, tracks);
    }
  }
  /**
   * Inserts the track to the given index
   * @param track The track to insert
   * @param index The index to insert the track at (defaults to 0)
   */
  insertTrack(track, index = 0) {
    return this.node.insert(track, index);
  }
  /**
   * Moves a track in the queue
   * @param from The track to move
   * @param to The position to move to
   */
  moveTrack(track, index = 0) {
    return this.node.move(track, index);
  }
  /**
   * Copy a track in the queue
   * @param from The track to clone
   * @param to The position to clone at
   */
  copyTrack(track, index = 0) {
    return this.node.copy(track, index);
  }
  /**
   * Swap two tracks in the queue
   * @param src The first track to swap
   * @param dest The second track to swap
   */
  swapTracks(src, dest) {
    return this.node.swap(src, dest);
  }
  /**
   * Create stream dispatcher from the given connection
   * @param connection The connection to use
   */
  createDispatcher(connection, options = {}) {
    if (connection.state.status === import_discord_voip3.VoiceConnectionStatus.Destroyed) {
      throw new VoiceConnectionDestroyedError();
    }
    const channel = this.player.client.channels.cache.get(
      connection.joinConfig.channelId
    );
    if (!channel) throw new NoVoiceChannelError();
    if (!channel.isVoiceBased())
      throw new InvalidArgTypeError(
        "channel",
        `VoiceBasedChannel (type ${import_discord3.ChannelType.GuildVoice}/${import_discord3.ChannelType.GuildStageVoice})`,
        String(channel?.type)
      );
    if (this.dispatcher) {
      __privateMethod(this, _GuildQueue_instances, removeListeners_fn).call(this, this.dispatcher);
      this.dispatcher.destroy();
      this.dispatcher = null;
    }
    this.dispatcher = new StreamDispatcher(
      connection,
      channel,
      this,
      options.timeout ?? this.options.connectionTimeout,
      options.audioPlayer
    );
  }
  /**
   * Connect to a voice channel
   * @param channelResolvable The voice channel to connect to
   * @param options Join config
   */
  async connect(channelResolvable, options = {}) {
    const channel = this.player.client.channels.resolve(channelResolvable);
    if (!channel || !channel.isVoiceBased()) {
      throw new InvalidArgTypeError(
        "channel",
        `VoiceBasedChannel (type ${import_discord3.ChannelType.GuildVoice}/${import_discord3.ChannelType.GuildStageVoice})`,
        String(channel?.type)
      );
    }
    if (this.hasDebugger)
      this.debug(
        `Connecting to ${channel.type === import_discord3.ChannelType.GuildStageVoice ? "stage" : "voice"} channel ${channel.name} (ID: ${channel.id})`
      );
    if (this.dispatcher && channel.id !== this.dispatcher.channel.id) {
      if (this.hasDebugger) this.debug("Destroying old connection");
      __privateMethod(this, _GuildQueue_instances, removeListeners_fn).call(this, this.dispatcher);
      this.dispatcher.destroy();
      this.dispatcher = null;
    }
    this.dispatcher = await this.player.voiceUtils.connect(channel, {
      deaf: options.deaf ?? this.options.selfDeaf ?? true,
      maxTime: options?.timeout ?? this.options.connectionTimeout ?? 12e4,
      queue: this,
      audioPlayer: options?.audioPlayer,
      group: options.group ?? this.player.client.user?.id,
      daveEncryption: options.daveEncryption,
      decryptionFailureTolerance: options.decryptionFailureTolerance
    });
    this.emit(GuildQueueEvent.Connection, this);
    if (this.channel.type === import_discord3.ChannelType.GuildStageVoice) {
      await this.channel.guild.members.me.voice.setSuppressed(false).catch(
        async () => {
          return await this.channel.guild.members.me.voice.setRequestToSpeak(
            true
          ).catch(Util.noop);
        }
      );
    }
    __privateMethod(this, _GuildQueue_instances, attachListeners_fn).call(this, this.dispatcher);
    return this;
  }
  /**
   * Enable shuffle mode for this queue
   * @param dynamic Whether to shuffle the queue dynamically. Defaults to `true`.
   * Dynamic shuffling will shuffle the queue when the current track ends, without mutating the queue.
   * If set to `false`, the queue will be shuffled immediately in-place, which cannot be undone.
   */
  enableShuffle(dynamic = true) {
    if (!dynamic) {
      this.tracks.shuffle();
      return true;
    }
    __privateSet(this, _shuffle, true);
    return true;
  }
  /**
   * Disable shuffle mode for this queue.
   */
  disableShuffle() {
    __privateSet(this, _shuffle, false);
    return true;
  }
  /**
   * Toggle shuffle mode for this queue.
   * @param dynamic Whether to shuffle the queue dynamically. Defaults to `true`.
   * @returns Whether shuffle is enabled or disabled.
   */
  toggleShuffle(dynamic = true) {
    if (dynamic) {
      __privateSet(this, _shuffle, !__privateGet(this, _shuffle));
      return __privateGet(this, _shuffle);
    } else {
      this.tracks.shuffle();
      return true;
    }
  }
  /**
   * Whether shuffle mode is enabled for this queue.
   */
  get isShuffling() {
    return __privateGet(this, _shuffle);
  }
  /**
   * The voice connection latency of this queue
   */
  get ping() {
    return this.connection?.ping.udp ?? -1;
  }
  /**
   * Delete this queue
   */
  delete() {
    if (this.player.nodes.delete(this.id)) {
      __privateSet(this, _deleted, true);
      this.player.events.emit(GuildQueueEvent.QueueDelete, this);
      this.node.tasksQueue.cancelAll();
      this.tasksQueue.cancelAll();
    }
  }
  /**
   * Revives this queue
   * @returns
   */
  revive() {
    if (!this.deleted || this.player.nodes.has(this.id)) return;
    __privateSet(this, _deleted, false);
    this.setTransitioning(false);
    this.player.nodes.cache.set(this.id, this);
    this.player.events.emit(GuildQueueEvent.QueueCreate, this);
  }
  /**
   * Set self deaf
   * @param mode On/Off state
   * @param reason Reason
   */
  setSelfDeaf(mode, reason) {
    return this.guild.members.me.voice.setDeaf(mode, reason);
  }
  /**
   * Set self mute
   * @param mode On/Off state
   * @param reason Reason
   */
  setSelfMute(mode, reason) {
    return this.guild.members.me.voice.setMute(mode, reason);
  }
  /**
   * Play a track in this queue
   * @param track The track to be played
   * @param options Player node initialization options
   */
  async play(track, options) {
    if (!this.channel) throw new NoVoiceConnectionError();
    return this.player.play(this.channel, track, options);
  }
  /**
   * Emit an event on this queue
   * @param event The event to emit
   * @param args The args for the event
   */
  emit(event, ...args) {
    if (this.deleted) return false;
    return this.player.events.emit(event, ...args);
  }
  get hasDebugger() {
    return this.player.events.hasDebugger;
  }
};
_transitioning = new WeakMap();
_deleted = new WeakMap();
_shuffle = new WeakMap();
_GuildQueue_instances = new WeakSet();
attachListeners_fn = /* @__PURE__ */ __name(function(dispatcher) {
  dispatcher.on("error", (e) => this.emit(GuildQueueEvent.Error, this, e));
  dispatcher.on(
    "debug",
    (m) => this.hasDebugger && this.emit(GuildQueueEvent.Debug, this, m)
  );
  dispatcher.on("finish", (r) => __privateMethod(this, _GuildQueue_instances, performFinish_fn).call(this, r));
  dispatcher.on("start", (r) => __privateMethod(this, _GuildQueue_instances, performStart_fn).call(this, r));
  dispatcher.on("destroyed", () => {
    __privateMethod(this, _GuildQueue_instances, removeListeners_fn).call(this, dispatcher);
    this.dispatcher = null;
  });
  dispatcher.on("dsp", (f) => {
    if (!Object.is(this.filters._lastFiltersCache.filters, f)) {
      this.emit(
        GuildQueueEvent.DSPUpdate,
        this,
        this.filters._lastFiltersCache.filters,
        f
      );
    }
    this.filters._lastFiltersCache.filters = f;
  });
  dispatcher.on("biquad", (f) => {
    if (this.filters._lastFiltersCache.biquad !== f) {
      this.emit(
        GuildQueueEvent.BiquadFiltersUpdate,
        this,
        this.filters._lastFiltersCache.biquad,
        f
      );
    }
    this.filters._lastFiltersCache.biquad = f;
  });
  dispatcher.on("eqBands", (f) => {
    if (!Object.is(f, this.filters._lastFiltersCache.equalizer)) {
      this.emit(
        GuildQueueEvent.EqualizerUpdate,
        this,
        this.filters._lastFiltersCache.equalizer,
        f
      );
    }
    this.filters._lastFiltersCache.equalizer = f;
  });
  dispatcher.on("volume", (f) => {
    if (this.filters._lastFiltersCache.volume !== f)
      this.emit(
        GuildQueueEvent.VolumeChange,
        this,
        this.filters._lastFiltersCache.volume,
        f
      );
    this.filters._lastFiltersCache.volume = f;
  });
  const areObjectsDifferent = /* @__PURE__ */ __name((a, b) => {
    if (!a && !b) return false;
    if (!a || !b) return true;
    if (Object.keys(a).length !== Object.keys(b).length) return true;
    return Object.keys(a).some((k) => a[k] !== b[k]);
  }, "areObjectsDifferent");
  dispatcher.on("sampleRate", (f) => {
    if (this.filters._lastFiltersCache.sampleRate !== f.sampleRate) {
      this.emit(
        GuildQueueEvent.SampleRateUpdate,
        this,
        this.filters._lastFiltersCache.sampleRate,
        f.sampleRate
      );
      this.filters._lastFiltersCache.sampleRate = f.sampleRate;
      this.filters.seeker?.setSampleRate(f.sampleRate);
      this.filters.seeker?.setTotalDuration(this.node.estimatedDuration);
    }
    if (f.currentFilter !== this.filters._lastFiltersCache.sampleRateFilter) {
      this.emit(
        GuildQueueEvent.SampleRateFilterUpdate,
        this,
        this.filters._lastFiltersCache.sampleRateFilter ?? null,
        f.currentFilter
      );
      this.filters._lastFiltersCache.sampleRateFilter = f.currentFilter;
    }
  });
  dispatcher.on("reverb", (f) => {
    if (areObjectsDifferent(f, this.filters._lastFiltersCache.reverb)) {
      this.emit(
        GuildQueueEvent.ReverbUpdate,
        this,
        this.filters._lastFiltersCache.reverb ?? null,
        f
      );
      this.filters._lastFiltersCache.reverb = f;
    }
  });
  dispatcher.on("seeker", (f) => {
    if (this.hasDebugger) {
      this.debug(
        `Seeker >> Seeked to ${f.seekTarget}ms for Track ${this.currentTrack?.title}`
      );
    }
    if (f.seekTarget != null) this.node.setProgress(f.seekTarget);
    this.emit(GuildQueueEvent.PlayerSeek, this, f);
  });
  dispatcher.on("compressor", (f) => {
    if (areObjectsDifferent(f, this.filters._lastFiltersCache.compressor)) {
      this.emit(
        GuildQueueEvent.CompressorUpdate,
        this,
        this.filters._lastFiltersCache.compressor ?? null,
        f
      );
      this.filters._lastFiltersCache.compressor = f;
    }
  });
}, "#attachListeners");
removeListeners_fn = /* @__PURE__ */ __name(function(target) {
  target.removeAllListeners();
}, "#removeListeners");
performStart_fn = /* @__PURE__ */ __name(function(resource) {
  const track = resource?.metadata || this.currentTrack;
  const reason = this.isTransitioning() ? "filters" : "normal";
  if (this.hasDebugger)
    this.debug(
      `Player triggered for Track ${JSON.stringify({
        title: track?.title,
        reason
      })}`
    );
  this.emit(GuildQueueEvent.PlayerTrigger, this, track, reason);
  if (track && !this.isTransitioning())
    this.emit(GuildQueueEvent.PlayerStart, this, track);
  this.setTransitioning(false);
}, "#performStart");
getNextTrack_fn = /* @__PURE__ */ __name(function() {
  if (!this.isShuffling) {
    return this.tracks.dispatch();
  }
  const store = this.tracks.store;
  if (!store.length) return;
  const track = Util.randomChoice(store);
  this.tracks.removeOne((t) => {
    return t.id === track.id;
  });
  return track;
}, "#getNextTrack");
performFinish_fn = /* @__PURE__ */ __name(function(resource) {
  const track = resource?.metadata || this.currentTrack;
  if (this.hasDebugger)
    this.debug(
      `Track ${JSON.stringify({
        title: track?.title,
        isTransitionMode: this.isTransitioning()
      })} was marked as finished`
    );
  if (!this.isTransitioning()) {
    this.syncedLyricsProvider.unsubscribe();
    this.syncedLyricsProvider.lyrics.clear();
    if (this.hasDebugger)
      this.debug(
        "Adding track to history and emitting finish event since transition mode is disabled..."
      );
    if (track) {
      this.history.push(track);
      this.node.resetProgress();
      this.emit(GuildQueueEvent.PlayerFinish, this, track);
    }
    if (__privateGet(this, _deleted)) return __privateMethod(this, _GuildQueue_instances, emitEnd_fn).call(this);
    if (this.tracks.size < 1 && this.repeatMode === QueueRepeatMode.OFF) {
      if (this.hasDebugger)
        this.debug(
          "No more tracks left in the queue to play and repeat mode is off, initiating #emitEnd()"
        );
      __privateMethod(this, _GuildQueue_instances, emitEnd_fn).call(this);
    } else {
      if (this.repeatMode === QueueRepeatMode.TRACK) {
        if (this.hasDebugger)
          this.debug(
            "Repeat mode is set to track, repeating last track from the history..."
          );
        this.__current = this.history.tracks.dispatch() || track;
        return this.node.play(this.__current, { queue: false });
      }
      if (this.repeatMode === QueueRepeatMode.QUEUE) {
        if (this.hasDebugger)
          this.debug(
            "Repeat mode is set to queue, moving last track from the history to current queue..."
          );
        const next = this.history.tracks.dispatch() || track;
        if (next) this.tracks.add(next);
      }
      if (!this.tracks.size && track) {
        if (this.repeatMode === QueueRepeatMode.AUTOPLAY) {
          if (this.hasDebugger)
            this.debug(
              "Repeat mode is set to autoplay, initiating autoplay handler..."
            );
          __privateMethod(this, _GuildQueue_instances, handleAutoplay_fn).call(this, track);
          return;
        }
      } else {
        if (this.hasDebugger)
          this.debug("Initializing next track of the queue...");
        this.__current = __privateMethod(this, _GuildQueue_instances, getNextTrack_fn).call(this);
        this.node.play(this.__current, {
          queue: false
        });
      }
    }
  }
}, "#performFinish");
emitEnd_fn = /* @__PURE__ */ __name(function() {
  this.__current = null;
  this.emit(GuildQueueEvent.EmptyQueue, this);
  if (this.options.leaveOnEnd) {
    const tm = (0, import_timers.setTimeout)(() => {
      if (this.isPlaying()) return clearTimeout(tm);
      this.dispatcher?.disconnect();
    }, this.options.leaveOnEndCooldown).unref();
  }
}, "#emitEnd");
handleAutoplay_fn = /* @__PURE__ */ __name(async function(track) {
  try {
    if (this.hasDebugger)
      this.debug(
        `Autoplay >> Finding related tracks for Track ${track.title} (${track.url}) [ext:${track.extractor?.identifier || "N/A"}]`
      );
    const tracks = (await track.extractor?.getRelatedTracks(track, this.history))?.tracks || (await this.player.extractors.run(async (ext) => {
      if (this.hasDebugger)
        this.debug(`Autoplay >> Querying extractor ${ext.identifier}`);
      const res = await ext.getRelatedTracks(track, this.history);
      if (!res.tracks.length) {
        if (this.hasDebugger)
          this.debug(
            `Autoplay >> Extractor ${ext.identifier} failed to provide results.`
          );
        return false;
      }
      if (this.hasDebugger)
        this.debug(
          `Autoplay >> Extractor ${ext.identifier} successfully returned results.`
        );
      return res.tracks;
    }))?.result || [];
    let resolver = Util.noop;
    const donePromise = new Promise(
      (resolve2) => resolver = resolve2
    );
    const success = this.emit(
      GuildQueueEvent.WillAutoPlay,
      this,
      tracks,
      resolver
    );
    if (!success) {
      resolver(
        tracks.length ? (() => {
          const unique = tracks.filter(
            (tr) => !this.history.tracks.find((t) => t.url === tr.url)
          );
          return unique?.[0] ?? Util.randomChoice(tracks.slice(0, 5));
        })() : null
      );
    }
    const nextTrack = await donePromise;
    if (!nextTrack) {
      if (this.hasDebugger)
        this.debug("Autoplay >> No track was found, initiating #emitEnd()");
      throw "No track was found";
    }
    await this.node.play(nextTrack, {
      queue: false,
      seek: 0,
      transitionMode: false
    });
  } catch {
    return __privateMethod(this, _GuildQueue_instances, emitEnd_fn).call(this);
  }
}, "#handleAutoplay");
__name(_GuildQueue, "GuildQueue");
var GuildQueue5 = _GuildQueue;

// src/queue/GuildNodeManager.ts
var _GuildNodeManager = class _GuildNodeManager {
  constructor(player) {
    this.player = player;
    __publicField(this, "cache", new import_utils7.Collection());
  }
  /**
   * Create guild queue if it does not exist
   * @param guild The guild which will be the owner of the queue
   * @param options Queue initializer options
   */
  create(guild, options = {}) {
    const server = this.player.client.guilds.resolve(guild);
    if (!server) {
      throw new NoGuildError("Invalid or unknown guild");
    }
    if (this.cache.has(server.id)) {
      return this.cache.get(server.id);
    }
    options.strategy ?? (options.strategy = "FIFO");
    options.volume ?? (options.volume = 100);
    options.equalizer ?? (options.equalizer = []);
    options.a_filter ?? (options.a_filter = []);
    options.disableHistory ?? (options.disableHistory = false);
    options.leaveOnEmpty ?? (options.leaveOnEmpty = true);
    options.leaveOnEmptyCooldown ?? (options.leaveOnEmptyCooldown = 0);
    options.leaveOnEnd ?? (options.leaveOnEnd = true);
    options.leaveOnEndCooldown ?? (options.leaveOnEndCooldown = 0);
    options.leaveOnStop ?? (options.leaveOnStop = true);
    options.leaveOnStopCooldown ?? (options.leaveOnStopCooldown = 0);
    options.resampler ?? (options.resampler = 48e3);
    options.selfDeaf ?? (options.selfDeaf = true);
    options.connectionTimeout ?? (options.connectionTimeout = this.player.options.connectionTimeout);
    options.bufferingTimeout ?? (options.bufferingTimeout = 1e3);
    options.maxSize ?? (options.maxSize = Infinity);
    options.maxHistorySize ?? (options.maxHistorySize = Infinity);
    options.preferBridgedMetadata ?? (options.preferBridgedMetadata = true);
    options.pauseOnEmpty ?? (options.pauseOnEmpty = true);
    options.disableBiquad ?? (options.disableBiquad = false);
    options.disableEqualizer ?? (options.disableEqualizer = false);
    options.disableFilterer ?? (options.disableFilterer = false);
    options.disableVolume ?? (options.disableVolume = false);
    options.disableResampler ?? (options.disableResampler = false);
    options.disableCompressor ?? (options.disableCompressor = true);
    options.disableSeeker ?? (options.disableSeeker = true);
    options.disableReverb ?? (options.disableReverb = true);
    options.disableFallbackStream ?? (options.disableFallbackStream = false);
    options.enableStreamInterceptor ?? (options.enableStreamInterceptor = false);
    options.verifyFallbackStream ?? (options.verifyFallbackStream = false);
    if (getGlobalRegistry().has("@[onStreamExtracted]") && !options.onStreamExtracted) {
      options.onStreamExtracted = getGlobalRegistry().get(
        "@[onStreamExtracted]"
      );
    }
    if (getGlobalRegistry().has("@[onBeforeCreateStream]") && !options.onBeforeCreateStream) {
      options.onBeforeCreateStream = getGlobalRegistry().get(
        "@[onBeforeCreateStream]"
      );
    }
    if (getGlobalRegistry().has("@[onAfterCreateStream]") && !options.onAfterCreateStream) {
      options.onAfterCreateStream = getGlobalRegistry().get(
        "@[onAfterCreateStream]"
      );
    }
    const queue = new GuildQueue5(this.player, {
      guild: server,
      queueStrategy: options.strategy,
      volume: options.volume,
      equalizer: options.equalizer,
      filterer: options.a_filter,
      biquad: options.biquad,
      resampler: options.resampler,
      disableHistory: options.disableHistory,
      onBeforeCreateStream: options.onBeforeCreateStream,
      onAfterCreateStream: options.onAfterCreateStream,
      onStreamExtracted: options.onStreamExtracted,
      repeatMode: options.repeatMode,
      leaveOnEmpty: options.leaveOnEmpty,
      leaveOnEmptyCooldown: options.leaveOnEmptyCooldown,
      leaveOnEnd: options.leaveOnEnd,
      leaveOnEndCooldown: options.leaveOnEndCooldown,
      leaveOnStop: options.leaveOnStop,
      leaveOnStopCooldown: options.leaveOnStopCooldown,
      metadata: options.metadata,
      connectionTimeout: options.connectionTimeout ?? 12e4,
      selfDeaf: options.selfDeaf,
      ffmpegFilters: options.defaultFFmpegFilters ?? [],
      bufferingTimeout: options.bufferingTimeout,
      noEmitInsert: options.noEmitInsert ?? false,
      preferBridgedMetadata: options.preferBridgedMetadata,
      maxHistorySize: options.maxHistorySize,
      maxSize: options.maxSize,
      pauseOnEmpty: options.pauseOnEmpty,
      disableBiquad: options.disableBiquad,
      disableEqualizer: options.disableEqualizer,
      disableFilterer: options.disableFilterer,
      disableResampler: options.disableResampler,
      disableVolume: options.disableVolume,
      disableFallbackStream: options.disableFallbackStream,
      enableStreamInterceptor: options.enableStreamInterceptor,
      verifyFallbackStream: options.verifyFallbackStream,
      disableCompressor: options.disableCompressor,
      disableSeeker: options.disableSeeker,
      disableReverb: options.disableReverb
    });
    this.cache.set(server.id, queue);
    return queue;
  }
  /**
   * Get existing queue
   * @param node Queue resolvable
   */
  get(node) {
    const queue = this.resolve(node);
    if (!queue) return null;
    return this.cache.get(queue.id) || null;
  }
  /**
   * Check if a queue exists
   * @param node Queue resolvable
   */
  has(node) {
    const id = node instanceof GuildQueue5 ? node.id : this.player.client.guilds.resolveId(node);
    return this.cache.has(id);
  }
  /**
   * Delete queue
   * @param node Queue resolvable
   */
  delete(node) {
    const queue = this.resolve(node);
    if (!queue) {
      throw new NoGuildQueueError("Cannot delete non-existing queue");
    }
    queue.setTransitioning(true);
    queue.node.stop(true);
    queue.connection?.removeAllListeners();
    queue.dispatcher?.removeAllListeners();
    queue.dispatcher?.disconnect();
    queue.timeouts.forEach((tm) => clearTimeout(tm));
    queue.history.clear();
    queue.tracks.clear();
    return this.cache.delete(queue.id);
  }
  /**
   * Resolve queue
   * @param node Queue resolvable
   */
  resolve(node) {
    if (node instanceof GuildQueue5) {
      return node;
    }
    return this.cache.get(
      this.player.client.guilds.resolveId(node)
    );
  }
  /**
   * Resolve queue id
   * @param node Queue resolvable
   */
  resolveId(node) {
    const q = this.resolve(node);
    return q?.id || null;
  }
};
__name(_GuildNodeManager, "GuildNodeManager");
var GuildNodeManager = _GuildNodeManager;

// src/utils/SequentialBucket.ts
var import_promises3 = require("timers/promises");
var _SequentialBucket = class _SequentialBucket {
  constructor() {
    __publicField(this, "limit", 1);
    __publicField(this, "remaining", 1);
    __publicField(this, "resetAfter", 0);
    __publicField(this, "queue", new AsyncQueue());
    __publicField(this, "MAX_RETRIES", 5);
  }
  /**
   * Checks if the bucket is rate limited.
   */
  isRateLimited() {
    return this.remaining <= 0 && Date.now() < this.resetAfter;
  }
  /**
   * Enqueues a request.
   * @param req The request function to enqueue
   */
  async enqueue(req) {
    const entry = this.queue.acquire();
    await entry.getTask();
    try {
      return this._request(req);
    } finally {
      entry.release();
    }
  }
  async _request(req, retries = 0) {
    while (this.isRateLimited()) {
      const reset = this.resetAfter - Date.now();
      await (0, import_promises3.setTimeout)(reset);
    }
    let pass = false;
    try {
      const res = await req();
      this._patchHeaders(res);
      if (res.status === 429) {
        const reset = this.resetAfter - Date.now();
        await (0, import_promises3.setTimeout)(reset);
        return this._request(req);
      }
      if (!res.ok) {
        let err;
        try {
          const body = await res.json();
          const error = new Error(body.message);
          error.name = body.name;
          error.code = body.code;
          err = error;
        } catch {
          err = new Error(`HTTP Error: ${res.status} ${res.statusText}`);
        }
        pass = true;
        throw err;
      }
      return res;
    } catch (e) {
      if (pass) throw e;
      const badReq = e instanceof Error && /Error: 4[0-9]{2}/.test(e.message);
      if (!badReq && retries < this.MAX_RETRIES) {
        return this._request(req, ++retries);
      }
      throw e;
    }
  }
  _patchHeaders(res) {
    const limit = Number(res.headers.get("X-RateLimit-Limit"));
    const remaining = Number(res.headers.get("X-RateLimit-Remaining"));
    const resetAfter = Number(res.headers.get("X-RateLimit-Reset")) * 1e3 + Date.now();
    if (!Number.isNaN(limit)) this.limit = limit;
    if (!Number.isNaN(remaining)) this.remaining = remaining;
    if (!Number.isNaN(resetAfter)) this.resetAfter = resetAfter;
  }
};
__name(_SequentialBucket, "SequentialBucket");
var SequentialBucket = _SequentialBucket;

// src/lrclib/LrcLib.ts
var toSnakeCase = /* @__PURE__ */ __name((obj) => {
  const snakeObj = {};
  for (const [key, value] of Object.entries(obj)) {
    if (value == null) continue;
    const newKey = key.replace(
      /[A-Z]/g,
      (letter) => `_${letter.toLowerCase()}`
    );
    snakeObj[newKey] = value;
  }
  return snakeObj;
}, "toSnakeCase");
var createQuery = /* @__PURE__ */ __name((params) => new URLSearchParams(toSnakeCase(params)).toString(), "createQuery");
var _LrcLib = class _LrcLib {
  /**
   * Creates a new LrcLib instance
   * @param {Player} player The player instance
   */
  constructor(player) {
    this.player = player;
    /**
     * The API URL
     */
    __publicField(this, "api", "https://lrclib.net/api");
    /**
     * The request timeout. Default is 15 seconds.
     */
    __publicField(this, "timeout", 15e3);
    /**
     * The request bucket
     */
    __publicField(this, "bucket", new SequentialBucket());
  }
  /**
   * Sets the request timeout
   * @param {number} timeout The timeout in milliseconds
   */
  setRequestTimeout(timeout) {
    this.timeout = timeout;
  }
  /**
   * Sets the retry limit. Default is 5.
   * @param {number} limit The retry limit
   */
  setRetryLimit(limit) {
    this.bucket.MAX_RETRIES = limit;
  }
  /**
   * Gets lyrics
   * @param params The get params
   */
  get(params) {
    const path = `get?${createQuery(params)}`;
    return this.request(path);
  }
  /**
   * Gets lyrics by ID
   * @param id The lyrics ID
   */
  getById(id) {
    return this.request(`get/${id}`);
  }
  /**
   * Gets cached lyrics
   * @param params The get params
   */
  getCached(params) {
    const path = `get-cached?${createQuery(params)}`;
    return this.request(path);
  }
  /**
   * Searches for lyrics
   * @param params The search params
   */
  search(params) {
    if (!params.q && !params.trackName) {
      throw new InvalidArgTypeError(
        "one of q or trackName",
        "string",
        [String(params.q), String(params.trackName)].join(", ")
      );
    }
    const path = `search?${createQuery(params)}`;
    return this.request(path);
  }
  /**
   * Requests the API
   * @param path The path
   * @param options The request options
   */
  async request(path, options) {
    const dispatcher = /* @__PURE__ */ __name(() => {
      const { name, version: version2 } = Util.getRuntime();
      const runtimeVersion = name === "unknown" ? version2 : `${name}/${version2}`;
      const init = {
        method: "GET",
        redirect: "follow",
        signal: AbortSignal.timeout(this.timeout),
        ...options,
        headers: {
          "User-Agent": `Discord-Player/${this.player.version} ${runtimeVersion ?? ""}`.trimEnd(),
          "Content-Type": "application/json",
          ...options?.headers
        }
      };
      this.player.debug(`[LrcLib] Requesting ${path}`);
      return fetch(
        `${this.api}${path.startsWith("/") ? path : "/" + path}`,
        init
      );
    }, "dispatcher");
    const res = await this.bucket.enqueue(dispatcher);
    return res.json();
  }
};
__name(_LrcLib, "LrcLib");
var LrcLib = _LrcLib;

// src/stream/VoiceUtils.ts
var import_discord_voip4 = require("discord-voip");
var import_utils8 = require("@discord-player/utils");
var _VoiceUtils = class _VoiceUtils {
  /**
   * The voice utils constructor
   */
  constructor(player) {
    this.player = player;
    /**
     * Voice connection cache to store voice connections of the Player components.
     * This property is deprecated and will be removed in the future.
     * It only exists for compatibility reasons.
     * @deprecated
     */
    __publicField(this, "cache", new import_utils8.Collection());
  }
  /**
   * Joins a voice channel, creating basic stream dispatch manager
   * @param {StageChannel|VoiceChannel} channel The voice channel
   * @param {object} [options] Join options
   * @returns {Promise<StreamDispatcher>}
   */
  async connect(channel, options) {
    if (!options?.queue) throw new NoGuildQueueError();
    const conn = await this.join(channel, options);
    const sub = new StreamDispatcher(
      conn,
      channel,
      options.queue,
      options.maxTime,
      options.audioPlayer
    );
    return sub;
  }
  /**
   * Joins a voice channel
   * @param {StageChannel|VoiceChannel} [channel] The voice/stage channel to join
   * @param {object} [options] Join options
   * @returns {VoiceConnection}
   */
  async join(channel, options) {
    const existingConnection = this.getConnection(
      channel.guild.id,
      options?.group
    );
    if (existingConnection?.joinConfig.channelId === channel?.id && existingConnection.state.status !== import_discord_voip4.VoiceConnectionStatus.Destroyed) {
      return existingConnection;
    }
    const conn = (0, import_discord_voip4.joinVoiceChannel)({
      guildId: channel.guild.id,
      channelId: channel.id,
      adapterCreator: channel.guild.voiceAdapterCreator,
      selfDeaf: Boolean(options?.deaf),
      debug: this.player.events.listenerCount("debug") > 0,
      group: options?.group,
      daveEncryption: options?.daveEncryption ?? true,
      decryptionFailureTolerance: options?.decryptionFailureTolerance ?? 24
    });
    return conn;
  }
  /**
   * Disconnects voice connection
   * @param {VoiceConnection} connection The voice connection
   * @returns {void}
   */
  disconnect(connection) {
    if (connection instanceof StreamDispatcher)
      connection = connection.voiceConnection;
    try {
      if (connection.state.status !== import_discord_voip4.VoiceConnectionStatus.Destroyed)
        return connection.destroy();
    } catch {
    }
  }
  /**
   * Returns Discord Player voice connection
   * @param {Snowflake} guild The guild id
   * @returns {StreamDispatcher}
   */
  getConnection(guild, group) {
    return (0, import_discord_voip4.getVoiceConnection)(guild, group);
  }
};
__name(_VoiceUtils, "VoiceUtils");
var VoiceUtils = _VoiceUtils;

// src/utils/QueryCache.ts
var DEFAULT_EXPIRY_TIMEOUT = 18e6;
var _defaultCache;
var _QueryCache = class _QueryCache {
  constructor(player, options = {
    checkInterval: DEFAULT_EXPIRY_TIMEOUT
  }) {
    this.player = player;
    this.options = options;
    __privateAdd(this, _defaultCache, /* @__PURE__ */ new Map());
    __publicField(this, "timer");
    this.timer = setInterval(
      this.cleanup.bind(this),
      this.checkInterval
    ).unref();
  }
  get checkInterval() {
    return this.options.checkInterval ?? DEFAULT_EXPIRY_TIMEOUT;
  }
  async cleanup() {
    for (const [id, value] of __privateGet(this, _defaultCache)) {
      if (value.hasExpired()) {
        __privateGet(this, _defaultCache).delete(id);
      }
    }
  }
  async clear() {
    __privateGet(this, _defaultCache).clear();
  }
  async getData() {
    return [...__privateGet(this, _defaultCache).values()];
  }
  async addData(data) {
    data.tracks.forEach((d) => {
      if (__privateGet(this, _defaultCache).has(d.url)) return;
      __privateGet(this, _defaultCache).set(d.url, new DiscordPlayerQueryResultCache(d));
    });
  }
  async resolve(context) {
    const result = __privateGet(this, _defaultCache).get(context.query);
    if (!result)
      return new SearchResult(this.player, {
        query: context.query,
        requestedBy: context.requestedBy,
        queryType: context.queryType
      });
    return new SearchResult(this.player, {
      query: context.query,
      tracks: [result.data],
      playlist: null,
      queryType: context.queryType,
      requestedBy: context.requestedBy
    });
  }
};
_defaultCache = new WeakMap();
__name(_QueryCache, "QueryCache");
var QueryCache = _QueryCache;
var _DiscordPlayerQueryResultCache = class _DiscordPlayerQueryResultCache {
  constructor(data, expireAfter = DEFAULT_EXPIRY_TIMEOUT) {
    this.data = data;
    __publicField(this, "expireAfter", DEFAULT_EXPIRY_TIMEOUT);
    if (typeof expireAfter === "number") {
      this.expireAfter = Date.now() + expireAfter;
    }
  }
  hasExpired() {
    if (typeof this.expireAfter !== "number" || isNaN(this.expireAfter) || this.expireAfter < 1)
      return false;
    return Date.now() <= this.expireAfter;
  }
};
__name(_DiscordPlayerQueryResultCache, "DiscordPlayerQueryResultCache");
var DiscordPlayerQueryResultCache = _DiscordPlayerQueryResultCache;

// src/index.ts
__reExport(src_exports, require("@discord-player/ffmpeg"), module.exports);

// src/Player.ts
var import_ffmpeg3 = require("@discord-player/ffmpeg");
var import_discord5 = require("discord.js");
var import_discord_voip5 = require("discord-voip");

// src/DefaultVoiceStateHandler.ts
var import_discord4 = require("discord.js");
function handleEmptyChannel(player, queue, guildId) {
  const timeout = setTimeout(() => {
    if (!Util.isVoiceEmpty(queue.channel) || !player.nodes.has(queue.guild.id))
      return;
    if (queue.options.leaveOnEmpty) queue.delete();
    player.events.emit(GuildQueueEvent.EmptyChannel, queue);
  }, queue.options.leaveOnEmptyCooldown || 0).unref();
  queue.timeouts.set(`empty_${guildId}`, timeout);
}
__name(handleEmptyChannel, "handleEmptyChannel");
function handleChannelPopulate(player, queue, guildId) {
  const emptyTimeout = queue.timeouts.get(`empty_${guildId}`);
  if (!Util.isVoiceEmpty(queue.channel) && emptyTimeout) {
    clearTimeout(emptyTimeout);
    queue.timeouts.delete(`empty_${guildId}`);
    player.events.emit(GuildQueueEvent.ChannelPopulate, queue);
  }
}
__name(handleChannelPopulate, "handleChannelPopulate");
function handlePauseOnEmpty(queue) {
  const isEmpty = Util.isVoiceEmpty(queue.channel);
  const wasPausedOnEmpty = Reflect.get(queue, "__pausedOnEmpty");
  if (isEmpty && !wasPausedOnEmpty) {
    queue.node.setPaused(true);
    Reflect.set(queue, "__pausedOnEmpty", true);
    if (queue.hasDebugger) {
      queue.debug(
        "Voice channel is empty and options#pauseOnEmpty is true, pausing..."
      );
    }
  } else if (!isEmpty && wasPausedOnEmpty) {
    queue.node.setPaused(false);
    Reflect.set(queue, "__pausedOnEmpty", false);
    if (queue.hasDebugger) {
      queue.debug(
        "Voice channel is not empty and options#pauseOnEmpty is true, resuming..."
      );
    }
  }
}
__name(handlePauseOnEmpty, "handlePauseOnEmpty");
function handleBotVoiceStateUpdate(queue, oldState, newState) {
  if (newState.serverMute != null && oldState.serverMute !== newState.serverMute) {
    queue.node.setPaused(newState.serverMute);
    return;
  }
  if (newState.channel?.type === import_discord4.ChannelType.GuildStageVoice && newState.suppress != null && oldState.suppress !== newState.suppress) {
    queue.node.setPaused(newState.suppress);
    if (newState.suppress) {
      newState.guild.members.me?.voice.setRequestToSpeak(true).catch(Util.noop);
    }
  }
}
__name(handleBotVoiceStateUpdate, "handleBotVoiceStateUpdate");
async function defaultVoiceStateHandler(player, queue, oldState, newState) {
  if (!queue?.connection || !queue.channel) return;
  const isBotState = newState.member?.id === newState.guild.members.me?.id;
  const guildId = oldState.guild.id;
  if (isBotState && oldState.channelId && !newState.channelId) {
    try {
      queue.delete();
    } catch {
    }
    return void player.events.emit(GuildQueueEvent.Disconnect, queue);
  }
  if (queue.options.pauseOnEmpty) {
    handlePauseOnEmpty(queue);
  }
  if (isBotState && newState.channelId && (!oldState.channelId || oldState.channelId !== newState.channelId)) {
    if (queue.connection) queue.channel = newState.channel;
    handleBotVoiceStateUpdate(queue, oldState, newState);
  }
  if (!newState.channelId && oldState.channelId === queue.channel.id) {
    if (!Util.isVoiceEmpty(queue.channel)) return;
    handleEmptyChannel(player, queue, guildId);
  } else if (newState.channelId === queue.channel.id) {
    handleChannelPopulate(player, queue, guildId);
  } else if (oldState.channelId !== newState.channelId) {
    if (newState.channelId !== queue.channel.id && !Util.isVoiceEmpty(queue.channel))
      return;
    if (!queue.timeouts.has(`empty_${guildId}`)) {
      handleEmptyChannel(player, queue, guildId);
    }
  }
}
__name(defaultVoiceStateHandler, "defaultVoiceStateHandler");

// src/utils/DependencyReportGenerator.ts
var import_node_path = require("path");
var import_ffmpeg2 = require("@discord-player/ffmpeg");

// src/version.ts
var version = (
  /* @__MACRO__ getVersion */
  "7.2.0"
);

// src/utils/DependencyReportGenerator.ts
var DependencyReportGenerator = {
  /**
   * Finds the package.json file of a package.
   * @param dir - The directory to start searching from
   * @param packageName - The name of the package to find
   * @param depth - The maximum depth to search
   * @returns The package.json file, or null if not found
   */
  findPackageJSON(dir, packageName, depth) {
    if (depth === 0) return null;
    const target = (0, import_node_path.resolve)(dir, "package.json");
    const next = /* @__PURE__ */ __name(() => DependencyReportGenerator.findPackageJSON(
      (0, import_node_path.resolve)(dir, ".."),
      packageName,
      depth - 1
    ), "next");
    try {
      const pkgJSON = require(target);
      if (pkgJSON.name !== packageName) {
        return next();
      }
      return pkgJSON;
    } catch {
      return next();
    }
  },
  /**
   * Tries to find the version of a dependency.
   * @param name - The package to find the version of
   * @param maxLookupDepth - The maximum depth to search for the package.json file
   * @returns The version of the package, or null if not found
   */
  version(name, maxLookupDepth = 3) {
    try {
      if (name === "discord-player") {
        return version;
      }
      const pkg = DependencyReportGenerator.findPackageJSON(
        (0, import_node_path.dirname)(require.resolve(name)),
        name,
        maxLookupDepth
      );
      return pkg?.version ?? null;
    } catch {
      return null;
    }
  },
  /**
   * Generates a report of the dependencies used by the discord-player module.
   * @returns The report object
   */
  generate() {
    const ffmpegReport = {};
    for (const lib of import_ffmpeg2.FFmpeg.sources) {
      ffmpegReport[lib.name] = null;
    }
    const ffmpeg = import_ffmpeg2.FFmpeg.resolveSafe();
    if (ffmpeg) {
      ffmpegReport[ffmpeg.name] = {
        hasLibopus: ffmpeg.command.includes("--enable-libopus"),
        version: ffmpeg.version
      };
    }
    return {
      core: {
        "discord-player": DependencyReportGenerator.version(
          "discord-player"
        ),
        "discord-voip": DependencyReportGenerator.version(
          "discord-voip"
        )
      },
      libopus: {
        mediaplex: DependencyReportGenerator.version("mediaplex"),
        "@discordjs/opus": DependencyReportGenerator.version("@discordjs/opus"),
        "@evan/opus": DependencyReportGenerator.version("@evan/opus"),
        opusscript: DependencyReportGenerator.version("opusscript"),
        "node-opus": DependencyReportGenerator.version("node-opus")
      },
      libsodium: {
        "sodium-native": DependencyReportGenerator.version("sodium-native"),
        sodium: DependencyReportGenerator.version("sodium"),
        "libsodium-wrappers": DependencyReportGenerator.version("libsodium-wrappers"),
        "@stablelib/xchacha20poly1305": DependencyReportGenerator.version(
          "@stablelib/xchacha20poly1305"
        ),
        "sodium-javascript": DependencyReportGenerator.version("sodium-javascript"),
        "@noble/ciphers": DependencyReportGenerator.version("@noble/ciphers")
      },
      DAVE: {
        "@snazzah/davey": DependencyReportGenerator.version("@snazzah/davey")
      },
      ffmpeg: ffmpegReport
    };
  },
  /**
   * Generates a string representation of the dependencies report.
   * @returns The string representation
   */
  generateString() {
    const report = DependencyReportGenerator.generate();
    const line = "-".repeat(50);
    const output = [];
    output.push("Dependencies Report");
    output.push(line);
    const keys = Object.keys(report);
    for (const _key of keys) {
      const key = _key;
      output.push(key);
      const subKeys = Object.keys(report[key]);
      for (const _subKey of subKeys) {
        const subKey = _subKey;
        const value = report[key][subKey] ?? "N/A";
        output.push(
          `- ${subKey}: ${typeof value === "object" ? JSON.stringify(value, null, 2) : value}`
        );
      }
      output.push("");
    }
    output.push(line);
    return output.join("\n");
  }
};

// src/PlayerStreamInterceptor.ts
var _onStream;
var _PlayerStreamInterceptor = class _PlayerStreamInterceptor {
  /**
   * Creates a new PlayerStreamInterceptor instance.
   * @param player The player instance
   * @param options The interceptor options
   */
  constructor(player, options) {
    this.player = player;
    this.options = options;
    __privateAdd(this, _onStream, /* @__PURE__ */ new Set());
  }
  /**
   * Handles the intercepted stream.
   * @param queue The guild queue
   * @param track The track
   * @param stream The intercepted stream
   * @returns Whether the stream was intercepted
   */
  async handle(queue, track, type, stream) {
    const filter = this.options.shouldIntercept;
    if (filter) {
      const result = await filter(queue, track, type, stream);
      if (!result) return false;
    }
    const hasListeners = __privateGet(this, _onStream).size;
    if (!hasListeners) return false;
    await Promise.all(
      [...__privateGet(this, _onStream)].map((handler) => handler(queue, track, type, stream))
    );
    return true;
  }
  /**
   * Adds a new intercepted stream listener.
   * @param handler The handler
   * @returns A function to remove the listener
   */
  onStream(handler) {
    __privateGet(this, _onStream).add(handler);
    return () => {
      __privateGet(this, _onStream).delete(handler);
    };
  }
};
_onStream = new WeakMap();
__name(_PlayerStreamInterceptor, "PlayerStreamInterceptor");
var PlayerStreamInterceptor = _PlayerStreamInterceptor;

// src/Player.ts
var PlayerEvent = {
  debug: "debug",
  Debug: "debug",
  error: "error",
  Error: "error",
  voiceStateUpdate: "voiceStateUpdate",
  VoiceStateUpdate: "voiceStateUpdate"
};
var _lastLatency, _voiceStateUpdateListener, _lagMonitorTimeout, _lagMonitorInterval, _onVoiceStateUpdate, _hooksCtx, _streamInterceptor;
var _Player = class _Player extends PlayerEventsEmitter {
  /**
   * Creates new Discord Player
   * @param {Client} client The Discord Client
   * @param {PlayerInitOptions} [options] The player init options
   */
  constructor(client, options = {}) {
    super([PlayerEvent.Error]);
    __privateAdd(this, _lastLatency, -1);
    __privateAdd(this, _voiceStateUpdateListener, this.handleVoiceState.bind(this));
    __privateAdd(this, _lagMonitorTimeout);
    __privateAdd(this, _lagMonitorInterval);
    __privateAdd(this, _onVoiceStateUpdate, defaultVoiceStateHandler);
    __privateAdd(this, _hooksCtx, null);
    /**
     * The unique identifier of this player instance
     */
    __publicField(this, "id", import_discord5.SnowflakeUtil.generate().toString());
    /**
     * The discord.js client
     */
    __publicField(this, "client");
    /**
     * The player options
     */
    __publicField(this, "options");
    /**
     * The player nodes (queue) manager
     */
    __publicField(this, "nodes", new GuildNodeManager(this));
    /**
     * The voice api utilities
     */
    __publicField(this, "voiceUtils", new VoiceUtils(this));
    /**
     * The extractors manager
     */
    __publicField(this, "extractors", new ExtractorExecutionContext(this));
    /**
     * The player events channel
     */
    __publicField(this, "events", new PlayerEventsEmitter(
      [
        GuildQueueEvent.Error,
        GuildQueueEvent.PlayerError
      ]
    ));
    /**
     * The player version
     */
    __publicField(this, "version", _Player.version);
    /**
     * The lyrics api
     */
    __publicField(this, "lyrics", new LrcLib(this));
    __privateAdd(this, _streamInterceptor, null);
    if (options.ffmpegPath) {
      if (typeof options.ffmpegPath !== "string")
        throw new TypeError(
          `Expected type "string" for options.ffmpegPath. Got ${typeof options.ffmpegPath} instead`
        );
      process.env.FFMPEG_PATH = options.ffmpegPath;
    }
    const isCompatMode = isClientProxy(client);
    this.client = client;
    if (!isCompatMode) {
      try {
        if (!(client instanceof import_discord5.Client)) {
          Util.warn(
            `Client is not an instance of discord.js@${import_discord5.version} client, some things may not work correctly. This can happen due to corrupt dependencies or having multiple installations of discord.js.`,
            "InvalidClientInstance"
          );
        }
        const ibf = this.client.options.intents instanceof import_discord5.IntentsBitField ? this.client.options.intents : new import_discord5.IntentsBitField(this.client.options.intents);
        if (!ibf.has(import_discord5.IntentsBitField.Flags.GuildVoiceStates)) {
          Util.warn(
            'client is missing "GuildVoiceStates" intent',
            "InvalidIntentsBitField"
          );
        }
      } catch {
      }
    }
    this.options = {
      lockVoiceStateHandler: false,
      blockExtractors: [],
      blockStreamFrom: [],
      connectionTimeout: 2e4,
      lagMonitor: 3e4,
      queryCache: options.queryCache === null ? null : options.queryCache || new QueryCache(this),
      skipFFmpeg: true,
      probeTimeout: 5e3,
      overrideFallbackContext: true,
      ...options
    };
    if (!isCompatMode) {
      this.client.incrementMaxListeners();
      this.client.on(import_discord5.Events.VoiceStateUpdate, __privateGet(this, _voiceStateUpdateListener));
    } else {
      try {
        this.client.__dp_voiceStateUpdate_proxy(__privateGet(this, _voiceStateUpdateListener));
      } catch (e) {
        Util.warn(
          "Failed to attach voice state update proxy, voice state handler will not work properly",
          "CompatModeError"
        );
      }
    }
    if (typeof this.options.lagMonitor === "number" && this.options.lagMonitor > 0) {
      __privateSet(this, _lagMonitorInterval, setInterval(() => {
        const start = performance.now();
        __privateSet(this, _lagMonitorTimeout, setTimeout(() => {
          __privateSet(this, _lastLatency, performance.now() - start);
          if (this.hasDebugger)
            this.debug(
              `[Lag Monitor] Event loop latency: ${__privateGet(this, _lastLatency)}ms`
            );
        }, 0).unref());
      }, this.options.lagMonitor).unref());
    }
    if (this.options.overrideFallbackContext) {
      getGlobalRegistry().set("@[player]", this);
    }
  }
  /**
   * The hooks context for this player instance.
   */
  get context() {
    if (!__privateGet(this, _hooksCtx)) {
      __privateSet(this, _hooksCtx, createContext());
      const originalProvider = __privateGet(this, _hooksCtx).provide.bind(__privateGet(this, _hooksCtx));
      __privateGet(this, _hooksCtx).provide = (value, receiver) => {
        return SUPER_CONTEXT.provide(this, () => {
          return originalProvider(value, () => {
            return receiver();
          });
        });
      };
    }
    return __privateGet(this, _hooksCtx);
  }
  /**
   * Override default voice state update handler
   * @param handler The handler callback
   */
  onVoiceStateUpdate(handler) {
    __privateSet(this, _onVoiceStateUpdate, handler);
  }
  debug(m) {
    return this.emit("debug", m);
  }
  /**
   * Creates new discord-player instance.
   * @param client The client that instantiated player
   * @param options Player initializer options
   */
  static create(client, options = {}) {
    return new _Player(client, options);
  }
  /**
   * The current query cache provider in use
   */
  get queryCache() {
    return this.options.queryCache ?? null;
  }
  /**
   * Alias to `Player.nodes`.
   */
  get queues() {
    return this.nodes;
  }
  /**
   * Event loop latency in ms. If your bot is laggy and this returns a number above 20ms for example,
   * some expensive task is being executed on the current thread which is slowing down the event loop.
   * @type {number}
   */
  get eventLoopLag() {
    return __privateGet(this, _lastLatency);
  }
  /**
   * Generates statistics that could be useful. Statistics generator is still experimental.
   * @example ```typescript
   * const stats = player.generateStatistics();
   *
   * console.log(stats);
   *
   * // outputs something like
   * // {
   * //   queuesCount: number,
   * //   queryCacheEnabled: boolean,
   * //   queues: [
   * //      GuildQueueStatisticsMetadata,
   * //      GuildQueueStatisticsMetadata,
   * //      GuildQueueStatisticsMetadata,
   * //      ...
   * //   ]
   * // }
   * ```
   */
  generateStatistics() {
    return {
      queuesCount: this.queues.cache.size,
      queryCacheEnabled: this.queryCache != null,
      queues: this.queues.cache.map((m) => m.stats.generate())
    };
  }
  /**
   * Whether the player is in compatibility mode. Compatibility mode is enabled when non-discord.js client is used.
   */
  isCompatMode() {
    return isClientProxy(this.client);
  }
  /**
   * Destroy every single queues managed by this master player instance
   * @example ```typescript
   * // use me when you want to immediately terminate every single queues in existence 🔪
   * await player.destroy();
   * ```
   */
  async destroy() {
    this.nodes.cache.forEach((node) => node.delete());
    if (!this.isCompatMode()) {
      this.client.off(import_discord5.Events.VoiceStateUpdate, __privateGet(this, _voiceStateUpdateListener));
      this.client.decrementMaxListeners();
    }
    this.removeAllListeners();
    this.events.removeAllListeners();
    await this.extractors.unregisterAll();
    if (__privateGet(this, _lagMonitorInterval)) clearInterval(__privateGet(this, _lagMonitorInterval));
    if (__privateGet(this, _lagMonitorTimeout)) clearInterval(__privateGet(this, _lagMonitorTimeout));
  }
  _handleVoiceState(oldState, newState) {
    const queue = this.nodes.get(oldState.guild.id);
    if (!queue || !queue.connection || !queue.channel) return;
    const wasHandled = this.events.emit(
      GuildQueueEvent.VoiceStateUpdate,
      queue,
      oldState,
      newState
    );
    if (wasHandled && !this.options.lockVoiceStateHandler) return;
    return __privateGet(this, _onVoiceStateUpdate).call(this, this, queue, oldState, newState);
  }
  /**
   * Handles voice state update
   * @param {VoiceState} oldState The old voice state
   * @param {VoiceState} newState The new voice state
   * @returns {void}
   * @example ```typescript
   * // passing voice state update data to this method will trigger voice state handler
   *
   * client.on('voiceStateUpdate', (oldState, newState) => {
   *   // this is definitely a rocket science, right here
   *   player.handleVoiceState(oldState, newState);
   * });
   * ```
   */
  handleVoiceState(oldState, newState) {
    this._handleVoiceState(oldState, newState);
  }
  /**
   * Lock voice state handler. When this method is called, discord-player will keep using the default voice state update handler, even if custom implementation exists.
   */
  lockVoiceStateHandler() {
    this.options.lockVoiceStateHandler = true;
  }
  /**
   * Unlock voice state handler. When this method is called, discord-player will stop using the default voice state update handler if custom implementation exists.
   */
  unlockVoiceStateHandler() {
    this.options.lockVoiceStateHandler = false;
  }
  /**
   * Checks if voice state handler is locked.
   */
  isVoiceStateHandlerLocked() {
    return !!this.options.lockVoiceStateHandler;
  }
  /**
   * Initiate audio player
   * @param channel The voice channel on which the music should be played
   * @param query The track or source to play
   * @param options Options for player
   * @example ```typescript
   * // no need to worry about queue management, just use this method 😄
   * const query = 'this is my super cool search query that I want to play';
   *
   * try {
   *    const { track } = await player.play(voiceChannel, query);
   *   console.log(`🎉 I am playing ${track.title} 🎉`);
   * } catch(e) {
   *   console.log(`😭 Failed to play error oh no:\n\n${e}`);
   * }
   * ```
   */
  async play(channel, query, options = {}) {
    const vc = this.client.channels.resolve(channel);
    if (!vc?.isVoiceBased())
      throw new InvalidArgTypeError(
        "channel",
        "VoiceBasedChannel",
        !vc ? "undefined" : `channel type ${vc.type}`
      );
    const originalResult = query instanceof SearchResult ? query : await this.search(query, options);
    const result = await options.afterSearch?.(originalResult) || originalResult;
    if (result.isEmpty()) {
      throw new NoResultError(
        `No results found for "${query}" (Extractor: ${result.extractor?.identifier || "N/A"})`
      );
    }
    const queue = this.nodes.create(vc.guild, options.nodeOptions);
    if (this.hasDebugger) this.debug(`[AsyncQueue] Acquiring an entry...`);
    const entry = queue.tasksQueue.acquire({ signal: options.signal });
    if (this.hasDebugger)
      this.debug(`[AsyncQueue] Entry ${entry.id} was acquired successfully!`);
    if (this.hasDebugger)
      this.debug(`[AsyncQueue] Waiting for the queue to resolve...`);
    await entry.getTask();
    if (this.hasDebugger)
      this.debug(`[AsyncQueue] Entry ${entry.id} was resolved!`);
    try {
      if (!queue.channel) await queue.connect(vc, options.connectionOptions);
      if (!result.playlist) {
        queue.addTrack(result.tracks[0]);
      } else {
        queue.addTrack(result.playlist);
      }
      if (!queue.isPlaying())
        await queue.node.play(null, options.audioPlayerOptions);
    } finally {
      if (this.hasDebugger)
        this.debug(`[AsyncQueue] Releasing an entry from the queue...`);
      queue.tasksQueue.release();
    }
    return {
      track: result.tracks[0],
      extractor: result.extractor,
      searchResult: result,
      queue
    };
  }
  /**
   * Search tracks
   * @param {string | Track | Track[] | Playlist | SearchResult} query The search query
   * @param {SearchOptions} options The search options
   * @returns {Promise<SearchResult>}
   * @example ```typescript
   * const searchQuery = 'pass url or text or discord-player track constructable objects, we got you covered 😎';
   * const result = await player.search(searchQuery);
   *
   * console.log(result); // Logs `SearchResult` object
   * ```
   */
  async search(searchQuery, options = {}) {
    if (searchQuery instanceof SearchResult) return searchQuery;
    if (searchQuery instanceof import_discord_voip5.AudioResource) {
      searchQuery = this.createTrackFromAudioResource(searchQuery);
    }
    if (options.requestedBy != null)
      options.requestedBy = this.client.users.resolve(options.requestedBy);
    options.blockExtractors ?? (options.blockExtractors = this.options.blockExtractors);
    options.fallbackSearchEngine ?? (options.fallbackSearchEngine = QueryType.AUTO_SEARCH);
    if (searchQuery instanceof Track) {
      return new SearchResult(this, {
        playlist: searchQuery.playlist || null,
        tracks: [searchQuery],
        query: searchQuery.title,
        extractor: searchQuery.extractor,
        queryType: searchQuery.queryType,
        requestedBy: options.requestedBy
      });
    }
    if (searchQuery instanceof Playlist) {
      return new SearchResult(this, {
        playlist: searchQuery,
        tracks: searchQuery.tracks,
        query: searchQuery.title,
        extractor: searchQuery.tracks[0]?.extractor,
        queryType: QueryType.AUTO,
        requestedBy: options.requestedBy
      });
    }
    if (Array.isArray(searchQuery)) {
      const tracks = searchQuery.filter((t) => t instanceof Track);
      return new SearchResult(this, {
        playlist: null,
        tracks,
        query: "@@#%{{UserLoadedContent}}%#@@",
        extractor: null,
        queryType: QueryType.AUTO,
        requestedBy: options.requestedBy
      });
    }
    if (this.hasDebugger) this.debug(`Searching ${searchQuery}`);
    let extractor = null, protocol = null;
    options.searchEngine ?? (options.searchEngine = QueryType.AUTO);
    options.fallbackSearchEngine ?? (options.fallbackSearchEngine = QueryType.AUTO_SEARCH);
    if (this.hasDebugger)
      this.debug(
        `Search engine set to ${options.searchEngine}, fallback search engine set to ${options.fallbackSearchEngine}`
      );
    if (/^\w+:/.test(searchQuery)) {
      const [protocolName, ...query2] = searchQuery.split(":");
      if (this.hasDebugger)
        this.debug(`Protocol ${protocolName} detected in query`);
      const matchingExtractor = this.extractors.store.find(
        (e) => !this.extractors.isDisabled(e.identifier) && e.protocols.includes(protocolName)
      );
      if (matchingExtractor) {
        if (this.hasDebugger)
          this.debug(
            `Protocol ${protocolName} is supported by ${matchingExtractor.identifier} extractor!`
          );
        extractor = matchingExtractor;
        searchQuery = query2.join(":");
        protocol = protocolName;
      } else {
        if (this.hasDebugger)
          this.debug(
            `Could not find an extractor that supports ${protocolName} protocol. Falling back to default behavior...`
          );
      }
    }
    const redirected = await QueryResolver.preResolve(searchQuery);
    const { type: queryType, query } = options.searchEngine === QueryType.AUTO ? QueryResolver.resolve(redirected, options.fallbackSearchEngine) : { type: options.searchEngine, query: redirected };
    if (this.hasDebugger)
      this.debug(
        `Query type identified as ${queryType}${extractor && protocol ? " but might not be used due to the presence of protocol" : ""}`
      );
    if (options.searchEngine.startsWith("ext:")) {
      if (this.hasDebugger)
        this.debug(`Forcing ${options.searchEngine.substring(4)} extractor...`);
      extractor = this.extractors.get(options.searchEngine.substring(4));
      if (!extractor)
        return new SearchResult(this, {
          query,
          queryType,
          extractor,
          requestedBy: options.requestedBy
        });
    }
    if (!extractor) {
      if (!options.ignoreCache) {
        if (this.hasDebugger) this.debug(`Checking cache...`);
        const res2 = await this.queryCache?.resolve({
          query,
          queryType,
          requestedBy: options.requestedBy
        });
        if (res2?.hasTracks()) {
          if (this.hasDebugger) this.debug(`Cache hit for query ${query}`);
          return res2;
        }
        if (this.hasDebugger) this.debug(`Cache miss for query ${query}`);
      }
      if (this.hasDebugger) this.debug(`Executing extractors...`);
      extractor = (await this.extractors.run(async (ext) => {
        if (options.blockExtractors?.includes(ext.identifier)) return false;
        return ext.validate(query, queryType);
      }))?.extractor || null;
    }
    if (!extractor) {
      if (this.hasDebugger) this.debug("Failed to find appropriate extractor");
      return new SearchResult(this, {
        query,
        queryType,
        requestedBy: options.requestedBy
      });
    }
    if (this.hasDebugger)
      this.debug(
        `Executing metadata query using ${extractor.identifier} extractor...`
      );
    const res = await extractor.handle(query, {
      type: queryType,
      requestedBy: options.requestedBy,
      requestOptions: options.requestOptions,
      protocol
    }).catch(() => null);
    if (res) {
      if (this.hasDebugger) this.debug("Metadata query was successful!");
      if (options.requestOptions && res.tracks) {
        res.tracks.forEach((track) => {
          if (track.raw) {
            track.raw.requestOptions = options.requestOptions;
          } else {
            track.raw = { requestOptions: options.requestOptions };
          }
        });
      }
      const result2 = new SearchResult(this, {
        query,
        queryType,
        playlist: res.playlist,
        tracks: res.tracks,
        extractor,
        requestedBy: options.requestedBy
      });
      if (!options.ignoreCache) {
        if (this.hasDebugger) this.debug(`Adding data to cache...`);
        await this.queryCache?.addData(result2);
      }
      return result2;
    }
    if (this.hasDebugger)
      this.debug(
        "Failed to find result using appropriate extractor. Querying all extractors..."
      );
    const result = await this.extractors.run(
      async (ext) => !options.blockExtractors?.includes(ext.identifier) && await ext.validate(query) && ext.handle(query, {
        type: queryType,
        requestedBy: options.requestedBy,
        requestOptions: options.requestOptions,
        protocol
      })
    );
    if (!result?.result) {
      if (this.hasDebugger)
        this.debug(
          `Failed to query metadata query using ${result?.extractor.identifier || "N/A"} extractor.`
        );
      return new SearchResult(this, {
        query,
        queryType,
        requestedBy: options.requestedBy,
        extractor: result?.extractor
      });
    }
    if (this.hasDebugger)
      this.debug(
        `Metadata query was successful using ${result.extractor.identifier}!`
      );
    if (options.requestOptions && result.result.tracks) {
      result.result.tracks.forEach((track) => {
        if (track.raw) {
          track.raw.requestOptions = options.requestOptions;
        } else {
          track.raw = { requestOptions: options.requestOptions };
        }
      });
    }
    const data = new SearchResult(this, {
      query,
      queryType,
      playlist: result.result.playlist,
      tracks: result.result.tracks,
      extractor: result.extractor,
      requestedBy: options.requestedBy
    });
    if (!options.ignoreCache) {
      if (this.hasDebugger) this.debug(`Adding data to cache...`);
      await this.queryCache?.addData(data);
    }
    return data;
  }
  /**
   * Generates a report of the dependencies used by the `discord-voip` module. Useful for debugging.
   * @example ```typescript
   * console.log(player.scanDeps());
   * // -> logs dependencies report
   * ```
   * @returns {string}
   */
  scanDeps() {
    const line = "-".repeat(50);
    const runtime = "Bun" in globalThis ? "Bun" : "Deno" in globalThis ? "Deno" : "Node";
    const depsReport = [
      "Discord Player",
      line,
      `- discord-player: ${_Player.version}${this.isCompatMode() ? ` (${getCompatName(this.client)} compatibility mode)` : ""}`,
      `- discord-voip: ${import_discord_voip5.version}`,
      `- discord.js: ${import_discord5.version}`,
      `- Node version: ${process.version} (Detected Runtime: ${runtime}, Platform: ${process.platform} [${process.arch}])`,
      (() => {
        const info = import_ffmpeg3.FFmpeg.resolveSafe();
        if (!info) return "FFmpeg/Avconv not found";
        return [
          `- ffmpeg: ${info.version}`,
          `- command: ${info.command}`,
          `- static: ${info.module}`,
          `- libopus: ${info.result.includes("--enable-libopus")}`
        ].join("\n");
      })(),
      "\n",
      "Loaded Extractors:",
      line,
      this.extractors.store.map((m) => {
        return m.identifier;
      }).join("\n") || "N/A",
      "\n\ndiscord-voip",
      DependencyReportGenerator.generateString()
    ];
    return depsReport.join("\n");
  }
  *[Symbol.iterator]() {
    yield* this.nodes.cache.values();
  }
  /**
   * Creates `Playlist` instance
   * @param data The data to initialize a playlist
   */
  createPlaylist(data) {
    return new Playlist(this, data);
  }
  /**
   * Creates a track from an audio resource.
   * @param resource The audio resource
   */
  createTrackFromAudioResource(resource) {
    const metadata = resource.metadata || {};
    const ref = import_discord5.SnowflakeUtil.generate().toString();
    const maybeTitle = "title" in metadata ? `${metadata.title}` : `Track ${ref}`;
    const maybeAuthor = "author" in metadata ? `${metadata.author}` : "Unknown author";
    const maybeDuration = "duration" in metadata ? `${metadata.duration}` : "00:00";
    const maybeThumbnail = "thumbnail" in metadata ? `${metadata.thumbnail}` : void 0;
    const maybeURL = "url" in metadata ? `${metadata.url}` : `discord-player://blob/${ref}`;
    const maybeDescription = "description" in metadata ? `${metadata.description}` : "No description available.";
    const maybeViews = "views" in metadata ? Number(metadata.views) || 0 : 0;
    const track = new Track(this, {
      title: maybeTitle,
      author: maybeAuthor,
      duration: maybeDuration,
      thumbnail: maybeThumbnail,
      url: maybeURL,
      description: maybeDescription,
      queryType: QueryType.DISCORD_PLAYER_BLOB,
      source: "arbitrary",
      metadata,
      live: false,
      views: maybeViews
    });
    resource.metadata = track;
    track.setResource(resource);
    return track;
  }
  /**
   * Handles intercepting streams
   * @param stream The stream to intercept
   */
  async handleInterceptingStream(queue, track, format, stream) {
    if (!__privateGet(this, _streamInterceptor)) return;
    return __privateGet(this, _streamInterceptor).handle(queue, track, format, stream);
  }
  /**
   * Creates a global stream interceptor
   * @param options The stream interceptor options
   */
  createStreamInterceptor(options) {
    if (__privateGet(this, _streamInterceptor)) {
      return __privateGet(this, _streamInterceptor);
    }
    __privateSet(this, _streamInterceptor, new PlayerStreamInterceptor(this, options));
    return __privateGet(this, _streamInterceptor);
  }
};
_lastLatency = new WeakMap();
_voiceStateUpdateListener = new WeakMap();
_lagMonitorTimeout = new WeakMap();
_lagMonitorInterval = new WeakMap();
_onVoiceStateUpdate = new WeakMap();
_hooksCtx = new WeakMap();
_streamInterceptor = new WeakMap();
__name(_Player, "Player");
/**
 * The version of discord-player
 */
__publicField(_Player, "version", version);
var Player = _Player;

// src/index.ts
var import_equalizer3 = require("@discord-player/equalizer");
var import_discord_voip6 = require("discord-voip");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  AF_NIGHTCORE_RATE,
  AF_VAPORWAVE_RATE,
  AFilterGraph,
  AsyncQueue,
  AsyncQueueEntry,
  AudioFilters,
  AudioPlayer,
  BASS_EQ_BANDS,
  BaseExtractor,
  BiquadFilterType,
  Context,
  DependencyReportGenerator,
  DiscordPlayerQueryResultCache,
  EqualizerConfigurationPreset,
  ExtractorExecutionContext,
  FFMPEG_ARGS_PIPED,
  FFMPEG_ARGS_STRING,
  FFMPEG_SRATE_REGEX,
  FFmpegFilterer,
  FiltersChain,
  GuildNodeManager,
  GuildQueue,
  GuildQueueAudioFilters,
  GuildQueueEvent,
  GuildQueueHistory,
  GuildQueuePlayerNode,
  GuildQueueStatistics,
  InterceptedStream,
  LrcLib,
  PCMAudioFilters,
  Player,
  PlayerEvent,
  PlayerEventsEmitter,
  PlayerStreamInterceptor,
  Playlist,
  Q_BUTTERWORTH,
  QueryCache,
  QueryResolver,
  QueryType,
  QueueRepeatMode,
  SearchResult,
  SequentialBucket,
  SerializedType,
  StreamDispatcher,
  StreamType,
  Track,
  TrackSkipReason,
  TypeUtil,
  Util,
  VALIDATE_QUEUE_CAP,
  VoiceUtils,
  VolumeTransformer,
  createAudioPlayer,
  createAudioResource,
  createContext,
  createErisCompat,
  createFFmpegStream,
  createOceanicCompat,
  decode,
  deserialize,
  encode,
  getVoiceConnection,
  getVoiceConnections,
  isErisProxy,
  isOceanicProxy,
  joinVoiceChannel,
  onAfterCreateStream,
  onBeforeCreateStream,
  onStreamExtracted,
  serialize,
  tryIntoThumbnailString,
  useContext,
  useHistory,
  useMainPlayer,
  useMetadata,
  usePlayer,
  useQueue,
  useTimeline,
  useVolume,
  version,
  ...require("@discord-player/ffmpeg")
});
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/compat/createErisCompat.ts", "../src/compat/common.ts", "../src/utils/Util.ts", "../src/fabric/Track.ts", "../src/errors/index.ts", "../src/utils/TypeUtil.ts", "../src/utils/serde.ts", "../src/fabric/Playlist.ts", "../src/utils/QueryResolver.ts", "../src/fabric/SearchResult.ts", "../src/utils/AudioFilters.ts", "../src/compat/createOceanicCompat.ts", "../src/utils/PlayerEventsEmitter.ts", "../src/extractors/BaseExtractor.ts", "../src/extractors/ExtractorExecutionContext.ts", "../src/hooks/context/async-context.ts", "../src/utils/__internal__/_container.ts", "../src/utils/__internal__/getGlobalRegistry.ts", "../src/hooks/common.ts", "../src/hooks/useHistory.ts", "../src/hooks/usePlayer.ts", "../src/hooks/useQueue.ts", "../src/hooks/useMainPlayer.ts", "../src/hooks/useMetadata.ts", "../src/hooks/useTimeline.ts", "../src/hooks/stream/onAfterCreateStream.ts", "../src/hooks/stream/onBeforeCreateStream.ts", "../src/hooks/stream/onStreamExtracted.ts", "../src/hooks/useVolume.ts", "../src/queue/GuildNodeManager.ts", "../src/queue/GuildQueue.ts", "../src/stream/StreamDispatcher.ts", "../src/stream/InterceptedStream.ts", "../src/queue/GuildQueueHistory.ts", "../src/queue/GuildQueuePlayerNode.ts", "../src/utils/AsyncQueue.ts", "../src/queue/GuildQueueAudioFilters.ts", "../src/utils/FFmpegStream.ts", "../src/queue/GuildQueueStatistics.ts", "../src/queue/SyncedLyricsProvider.ts", "../src/utils/SequentialBucket.ts", "../src/lrclib/LrcLib.ts", "../src/stream/VoiceUtils.ts", "../src/utils/QueryCache.ts", "../src/Player.ts", "../src/DefaultVoiceStateHandler.ts", "../src/utils/DependencyReportGenerator.ts", "../src/version.ts", "../src/PlayerStreamInterceptor.ts"],
  "sourcesContent": ["export { createErisCompat } from './compat/createErisCompat';\nexport { createOceanicCompat } from './compat/createOceanicCompat';\nexport { isErisProxy, isOceanicProxy } from './compat/common';\nexport * from './utils/PlayerEventsEmitter';\nexport * from './utils/AudioFilters';\nexport * from './extractors/BaseExtractor';\nexport * from './extractors/ExtractorExecutionContext';\nexport * from './fabric';\nexport * from './queue';\nexport * from './lrclib/LrcLib';\nexport * from './utils/SequentialBucket';\nexport * from './stream/VoiceUtils';\nexport * from './stream/StreamDispatcher';\nexport * from './utils/Util';\nexport * from './utils/TypeUtil';\nexport * from './utils/AsyncQueue';\nexport * from './utils/FFmpegStream';\nexport * from './utils/QueryCache';\nexport * from './utils/QueryResolver';\nexport * from '@discord-player/ffmpeg';\nexport * from './Player';\nexport * from './hooks';\nexport * from './utils/serde';\nexport * from './utils/DependencyReportGenerator';\nexport * from './stream/InterceptedStream';\nexport * from './PlayerStreamInterceptor';\nexport {\n  AudioFilters as PCMAudioFilters,\n  type BiquadFilters,\n  FilterType as BiquadFilterType,\n  type PCMFilters,\n  Q_BUTTERWORTH,\n  VolumeTransformer,\n  BASS_EQ_BANDS,\n  AF_NIGHTCORE_RATE,\n  AF_VAPORWAVE_RATE,\n  FiltersChain } from\n'@discord-player/equalizer';\nexport {\n  createAudioPlayer,\n  AudioPlayer,\n  getVoiceConnection,\n  getVoiceConnections,\n  joinVoiceChannel,\n  StreamType,\n  createAudioResource,\n  type JoinConfig,\n  type JoinVoiceChannelOptions,\n  type CreateAudioPlayerOptions } from\n'discord-voip';\n\nexport { version } from './version';", "/* eslint-disable @typescript-eslint/no-explicit-any */\n// @ts-nocheck\n\nimport { ChannelType, GatewayDispatchEvents } from 'discord-api-types/v10';\nimport { createCompatClient } from './common';\nimport { Util } from '../utils/Util';\n\nimport type { DiscordGatewayAdapterCreator } from 'discord-voip';\nimport {\n  Client,\n  GatewayVoiceServerUpdateDispatchData,\n  GatewayVoiceStateUpdateDispatchData,\n  VoiceState } from\n'discord.js';\nimport type Eris from 'eris';\n\ntype ErisUserResolvable = Eris.User | string | Eris.Member;\ntype ErisGuildResolvable =\nEris.Guild |\nstring |\nEris.Member |\nEris.GuildChannel |\nEris.Role;\ntype ErisChannelResolvable = Eris.GuildChannel | string;\n\nconst DiscordPlayerClientSymbol = Symbol('DiscordPlayerClient');\n\nexport function isErisClient(client: any): client is Eris.Client {\n  const { module, error } = Util.require('eris');\n\n  if (error) return false;\n\n  const eris = module as typeof import('eris');\n\n  return client instanceof eris.Client;\n}\n\nfunction declareProperty(target: any, key: string, value: any) {\n  Reflect.set(target, key, value);\n}\n\nfunction getProperty<T>(target: any, key: string): T {\n  return Reflect.get(target, key);\n}\n\n/**\n * Allows Eris clients to be used with discord-player. When this method is called, discord-player creates a proxy object that intercepts certain methods and properties to make it compatible with discord-player.\n * @param client The Eris client to be used.\n * @returns The Eris client with discord-player compatibility.\n */\nexport function createErisCompat(client: Eris.Client): Client {\n  const { module, error } = Util.require('eris');\n\n  if (error) throw error;\n\n  const eris = module as typeof import('eris');\n\n  erisVoiceEventsHandler(client);\n\n  const erisProxy = new Proxy(client, {\n    get(target, p) {\n      switch (p) {\n        case 'users':\n          return erisUsersProxy(target, eris);\n        case 'guilds':\n          return erisGuildsProxy(target, eris);\n        case 'channels':\n          return erisChannelsProxy(target, eris);\n        case '__dp_voiceStateUpdate_proxy':\n          return (handler: (a, b) => void) =>\n          erisVoiceStateUpdateProxy(target, erisProxy, handler);\n        case 'incrementMaxListeners':\n          return () => {\n            // @ts-expect-error patching\n            client.setMaxListeners(client.getMaxListeners() + 1);\n          };\n        case 'decrementMaxListeners':\n          return () => {\n            // @ts-expect-error patching\n            const listeners = client.getMaxListeners() - 1;\n\n            // @ts-expect-error patching\n            client.setMaxListeners(listeners < 0 ? 1 : listeners);\n          };\n        default:\n          // @ts-expect-error patching\n          return target[p];\n      }\n    }\n  });\n\n  Reflect.set(erisProxy, DiscordPlayerClientSymbol, 'Eris');\n\n  return createCompatClient(erisProxy, 'Eris').client as unknown as Client;\n}\n\nfunction erisVoiceStateUpdateProxy(\nclient: Eris.Client,\nproxy: Eris.Client,\nhandler: (a, b) => void)\n{\n  client.on('voiceStateUpdate', (member, oldState) => {\n    try {\n      const proxiedOldState = {\n        channelId: oldState.channelID,\n        serverMute: oldState.mute,\n        suppress: oldState.suppress,\n        guild: {\n          id: oldState.guild.id\n        },\n        member: {\n          id: oldState.user.id\n        }\n      } as VoiceState;\n\n      const me = member.guild.members.get(client.user.id);\n      const resolvedChannel = member.guild.channels.get(\n        member.voiceState.channelID\n      );\n\n      const proxiedNewState = {\n        channelId: member.voiceState.channelID,\n        serverMute: member.voiceState.mute,\n        suppress: member.voiceState.suppress,\n        channel: erisResolvedChannelProxy(resolvedChannel, client),\n        member: {\n          id: member.id\n        },\n        guild: {\n          id: member.guild.id,\n          members: {\n            me: {\n              id: me?.id,\n              voice: {\n                async setRequestToSpeak(value: boolean) {\n                  void value;\n                  return me?.voiceState;\n                  // if (me) {\n                  //   return me.voice.setRequestToSpeak(value);\n                  // }\n                }\n              }\n            }\n          }\n        }\n      } as VoiceState;\n\n      return handler(proxiedNewState, proxiedOldState);\n    } catch {\n\n      /* noop */}\n  });\n}\n\nfunction erisVoiceEventsHandler(client: Eris.Client) {\n  let adapters = getProperty<Map<string, any>>(client, 'adapters');\n\n  if (!adapters) {\n    const collection = new Map<string, any>();\n    adapters = collection;\n    declareProperty(client, 'adapters', collection);\n  }\n\n  client.on('shardDisconnect', (_, shardId) => {\n    for (const [guildId, adapter] of adapters.entries()) {\n      if (client.guilds.get(guildId)?.shard.id === shardId) {\n        adapter.destroy();\n      }\n    }\n  });\n\n  client.on('rawWS', (packet) => {\n    switch (packet.t) {\n      case GatewayDispatchEvents.VoiceServerUpdate:{\n          const payload = packet.d as GatewayVoiceServerUpdateDispatchData;\n          adapters.get(payload.guild_id)?.onVoiceServerUpdate(payload);\n          return;\n        }\n      case GatewayDispatchEvents.VoiceStateUpdate:{\n          const payload = packet.d as GatewayVoiceStateUpdateDispatchData;\n\n          if (\n          payload.guild_id &&\n          payload.session_id &&\n          payload.user_id === client.user.id)\n          {\n            adapters.get(payload.guild_id)?.onVoiceStateUpdate(payload);\n          }\n\n          return;\n        }\n      default:\n        break;\n    }\n  });\n}\n\nfunction erisChannelsProxy(client: Eris.Client, eris: typeof import('eris')) {\n  const handler = {\n    client,\n    get cache() {\n      return {\n        get(id: string) {\n          return client.getChannel(id);\n        },\n        has(id: string) {\n          return id in client.channelGuildMap;\n        }\n      };\n    },\n    resolve(resolvable: string | ErisChannelResolvable) {\n      if (typeof resolvable === 'string') {\n        return erisResolvedChannelProxy(\n          this.client.getChannel(resolvable) as Eris.GuildChannel,\n          client\n        );\n      }\n\n      if (resolvable instanceof eris.GuildChannel) {\n        return erisResolvedChannelProxy(resolvable, client);\n      }\n    },\n    resolveId(resolvable: ErisChannelResolvable) {\n      const channel = this.resolve(resolvable);\n      return channel?.id;\n    }\n  };\n\n  return handler;\n}\n\nfunction erisResolvedChannelProxy(\nchannel: Eris.GuildChannel | undefined,\nclient: Eris.Client)\n: Eris.GuildChannel | undefined {\n  if (!channel) return;\n\n  return new Proxy(channel, {\n    get(target, p) {\n      switch (p) {\n        case 'guild':\n          return erisVoiceAdapterProxy(target.guild, client);\n        case 'members':\n          return (target as Eris.VoiceChannel).voiceMembers;\n        case 'isVoiceBased':\n          return () =>\n          target.type === ChannelType.GuildVoice ||\n          target.type === ChannelType.GuildStageVoice;\n        case 'isVoice':\n          return () => target.type === ChannelType.GuildVoice;\n        case 'isStage':\n          return () => target.type === ChannelType.GuildStageVoice;\n        default:\n          // @ts-expect-error patching\n          return target[p];\n      }\n    }\n  });\n}\n\nfunction erisVoiceAdapterProxy(\nguild: Eris.Guild | undefined,\nclient: Eris.Client)\n: Eris.Guild | undefined {\n  if (!guild) return;\n\n  return new Proxy(guild, {\n    get(target, p) {\n      if (p === 'voiceAdapterCreator') {\n        return erisVoiceAdapterCreator(target, client);\n      }\n\n      // @ts-expect-error patching\n      return target[p];\n    }\n  });\n}\n\nfunction erisVoiceAdapterCreator(\nguild: Eris.Guild,\nclient: Eris.Client)\n: DiscordGatewayAdapterCreator {\n  return (methods) => {\n    let adapters = getProperty<Map<string, typeof methods>>(client, 'adapters');\n\n    if (!adapters) {\n      const collection = new Map<string, typeof methods>();\n      adapters = collection;\n      declareProperty(client, 'adapters', collection);\n    }\n\n    adapters.set(guild.id, methods);\n\n    return {\n      sendPayload(payload) {\n        if (guild.shard.status !== 'ready') return false;\n        guild.shard.sendWS(payload.op, payload.d);\n        return true;\n      },\n      destroy() {\n        adapters.delete(guild.id);\n      }\n    };\n  };\n}\n\nfunction erisGuildsProxy(client: Eris.Client, eris: typeof import('eris')) {\n  return new Proxy(client.guilds, {\n    get(target, p) {\n      if (p === 'cache') {\n        return target;\n      }\n\n      if (p === 'resolve' || p === 'resolveId') {\n        const resolver = function (resolvable: ErisGuildResolvable) {\n          if (typeof resolvable === 'string') {\n            return target.get(resolvable);\n          }\n\n          if (resolvable instanceof eris.Guild) {\n            return resolvable;\n          }\n\n          if (\n          resolvable instanceof eris.Member ||\n          resolvable instanceof eris.Guild ||\n          resolvable instanceof eris.GuildChannel ||\n          resolvable instanceof eris.Role)\n          {\n            return resolvable.guild;\n          }\n        };\n\n        if (p === 'resolve') {\n          return resolver;\n        }\n\n        return (resolvable: ErisGuildResolvable) => {\n          const guild = resolver(resolvable);\n          return guild?.id;\n        };\n      }\n\n      // @ts-expect-error patching\n      return target[p];\n    }\n  });\n}\n\nfunction erisUsersProxy(client: Eris.Client, eris: typeof import('eris')) {\n  return new Proxy(client.users, {\n    get(target, p) {\n      if (p === 'cache') {\n        return target;\n      }\n\n      if (p === 'resolve' || p === 'resolveId') {\n        const resolver = function (resolvable: ErisUserResolvable) {\n          if (typeof resolvable === 'string') {\n            return target.get(resolvable);\n          }\n\n          if (resolvable instanceof eris.User) {\n            return resolvable;\n          }\n\n          if (resolvable instanceof eris.Member) {\n            return resolvable.user;\n          }\n        };\n\n        if (p === 'resolve') {\n          return resolver;\n        }\n\n        return (resolvable: ErisUserResolvable) => {\n          const user = resolver(resolvable);\n          return user?.id;\n        };\n      }\n\n      // @ts-expect-error patching\n      return target[p];\n    }\n  });\n}", "/* eslint-disable @typescript-eslint/no-explicit-any */\n\nexport const DiscordPlayerClientSymbol = Symbol('DiscordPlayerClient');\n\nexport type CompatProvider = 'Eris' | 'Oceanic';\n\nexport interface CompatClient {\n  provider: CompatProvider;\n  client: any;\n}\n\nexport function createCompatClient(\nclient: any,\nprovider: CompatProvider)\n: CompatClient {\n  Reflect.set(client, DiscordPlayerClientSymbol, provider);\n  return {\n    provider,\n    client\n  };\n}\n\nexport function isClientProxy(client: any): boolean {\n  return Reflect.get(client, DiscordPlayerClientSymbol) != null;\n}\n\nexport function getCompatName(client: any): CompatProvider | null {\n  return Reflect.get(client, DiscordPlayerClientSymbol) ?? null;\n}\n\nexport function isErisProxy(client: any): boolean {\n  return getCompatName(client) === 'Eris';\n}\n\nexport function isOceanicProxy(client: any): boolean {\n  return getCompatName(client) === 'Oceanic';\n}", "import { StageChannel, VoiceChannel } from 'discord.js';\nimport { setTimeout } from 'node:timers/promises';\nimport { GuildQueue } from '../queue';\nimport { Playlist, Track, TrackSource } from '../fabric';\nimport { OutOfSpaceError } from '../errors';\nimport { randomInt } from 'node:crypto';\nimport {\n  createFilter,\n  createSpotifyFilter,\n  fixTrackSuffix,\n  removeLive,\n  removeRemastered,\n  youtube,\n  removeZeroWidth,\n  replaceNbsp,\n  replaceSmartQuotes,\n  removeCleanExplicit } from\n'@web-scrobbler/metadata-filter';\n\nexport type RuntimeType = 'node' | 'deno' | 'bun' | 'unknown';\n\nexport interface TimeData {\n  /**\n   * Time in days\n   */\n  days: number;\n  /**\n   * Time in hours\n   */\n  hours: number;\n  /**\n   * Time in minutes\n   */\n  minutes: number;\n  /**\n   * Time in seconds\n   */\n  seconds: number;\n}\n\nexport interface Runtime {\n  name: RuntimeType;\n  version: string;\n}\n\nclass Util {\n  /**\n   * Utils\n   */\n  private constructor() {} // eslint-disable-line @typescript-eslint/no-empty-function\n\n  /**\n   * Gets the runtime information\n   */\n  static getRuntime(): Runtime {\n    const version =\n    typeof navigator !== 'undefined' ? navigator.userAgent : null;\n\n    // @ts-ignore\n    if (typeof Deno !== 'undefined' && Deno.version) {\n      // @ts-ignore\n      return { name: 'deno', version: Deno.version.deno };\n    }\n\n    // @ts-ignore\n    if (typeof Bun !== 'undefined' && Bun.version) {\n      // @ts-ignore\n      return { name: 'bun', version: Bun.version };\n    }\n\n    if (typeof process !== 'undefined' && process.version)\n    return { name: 'node', version: process.version };\n\n    return { name: 'unknown', version: version ?? 'unknown' };\n  }\n\n  /**\n   * Creates duration string\n   * @param {object} durObj The duration object\n   * @returns {string}\n   */\n  static durationString(durObj: Record<string, number>) {\n    return Object.values(durObj).\n    map((m) => isNaN(m) ? 0 : m).\n    join(':');\n  }\n\n  /**\n   * Parses milliseconds to consumable time object\n   * @param {number} milliseconds The time in ms\n   * @returns {TimeData}\n   */\n  static parseMS(milliseconds: number) {\n    if (isNaN(milliseconds)) milliseconds = 0;\n    const round = milliseconds > 0 ? Math.floor : Math.ceil;\n\n    return {\n      days: round(milliseconds / 86400000),\n      hours: round(milliseconds / 3600000) % 24,\n      minutes: round(milliseconds / 60000) % 60,\n      seconds: round(milliseconds / 1000) % 60\n    } as TimeData;\n  }\n\n  /**\n   * Builds time code\n   * @param {TimeData} duration The duration object\n   * @returns {string}\n   */\n  static buildTimeCode(duration: TimeData) {\n    const items = Object.keys(duration);\n    const required = ['days', 'hours', 'minutes', 'seconds'];\n\n    const parsed = items.\n    filter((x) => required.includes(x)).\n    map((m) => duration[m as keyof TimeData]);\n    const final = parsed.\n    slice(parsed.findIndex((x) => x !== 0)).\n    map((x) => x.toString().padStart(2, '0')).\n    join(':');\n\n    return final.length <= 3 ? `0:${final.padStart(2, '0') || 0}` : final;\n  }\n\n  /**\n   * Formats duration\n   * @param {number} duration The duration in ms\n   */\n  static formatDuration(duration: number) {\n    return this.buildTimeCode(this.parseMS(duration));\n  }\n\n  /**\n   * Picks last item of the given array\n   * @param {any[]} arr The array\n   * @returns {any}\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static last<T = any>(arr: T[]): T {\n    if (!Array.isArray(arr)) return arr;\n    return arr[arr.length - 1];\n  }\n\n  /**\n   * Checks if the voice channel is empty\n   * @param {VoiceChannel|StageChannel} channel The voice channel\n   * @returns {boolean}\n   */\n  static isVoiceEmpty(channel: VoiceChannel | StageChannel) {\n    return (\n      channel && channel.members.filter((member) => !member.user.bot).size === 0);\n\n  }\n\n  /**\n   * Cleans the track title\n   * @param title The title\n   * @param source The source\n   * @returns Cleaned title\n   */\n  static cleanTitle(title: string, source: TrackSource) {\n    try {\n      const filterOpts = {\n        // prettier-ignore\n        track: [\n        removeRemastered,\n        removeLive,\n        fixTrackSuffix,\n        removeZeroWidth,\n        replaceNbsp,\n        replaceSmartQuotes,\n        removeCleanExplicit]\n\n      };\n      const spotifyFilter = createFilter(filterOpts);\n      spotifyFilter.extend(createSpotifyFilter());\n      const defaultFilter = createFilter(filterOpts);\n\n      switch (source) {\n        case 'youtube':\n          return youtube(title);\n        case 'spotify':\n          return spotifyFilter.filterField('track', title);\n        default:\n          return defaultFilter.filterField('track', title);\n      }\n    } catch {\n      return title;\n    }\n  }\n\n  /**\n   * Safer require\n   * @param {string} id Node require id\n   * @returns {any}\n   */\n  static require(id: string) {\n    try {\n      return { module: require(id), error: null };\n    } catch (error) {\n      return { module: null, error };\n    }\n  }\n\n  static async import(id: string) {\n    try {\n      const mod = await import(id);\n      return { module: mod, error: null };\n    } catch (error) {\n      return { module: null, error };\n    }\n  }\n\n  /**\n   * Asynchronous timeout\n   * @param {number} time The time in ms to wait\n   * @returns {Promise<unknown>}\n   */\n  static wait(time: number) {\n    return setTimeout(time, undefined, { ref: false });\n  }\n\n  static noop() {} // eslint-disable-line @typescript-eslint/no-empty-function\n\n  static async getFetch() {\n    if ('fetch' in globalThis) return globalThis.fetch;\n    for (const lib of ['node-fetch', 'undici']) {\n      try {\n        return await import(lib).then(\n          (res) => res.fetch || res.default?.fetch || res.default\n        );\n      } catch {\n        try {\n          // eslint-disable-next-line\n          const res = require(lib);\n          if (res) return res.fetch || res.default?.fetch || res.default;\n        } catch {\n\n          // no?\n        }}\n    }\n  }\n\n  static warn(message: string, code = 'DeprecationWarning', detail?: string) {\n    process.emitWarning(message, {\n      code,\n      detail\n    });\n  }\n\n  static randomChoice<T>(src: T[]): T {\n    return src[randomInt(src.length)];\n  }\n\n  static arrayCloneShuffle<T>(src: T[]): T[] {\n    const arr = src.slice();\n\n    let m = arr.length;\n\n    while (m) {\n      const i = Math.floor(Math.random() * m--);\n      [arr[m], arr[i]] = [arr[i], arr[m]];\n    }\n\n    return arr;\n  }\n}\n\nexport const VALIDATE_QUEUE_CAP = (\nqueue: GuildQueue,\nitems: Playlist | Track | Track[] | number) =>\n{\n  if (queue.maxSize < 1 || queue.maxSize === Infinity) return;\n\n  const tracks =\n  typeof items === 'number' ?\n  items :\n  (items instanceof Playlist ?\n  items.tracks :\n  Array.isArray(items) ?\n  items :\n  [items]).\n  length;\n\n  const maxCap = queue.getCapacity();\n\n  if (maxCap < tracks) {\n    throw new OutOfSpaceError('tracks queue', maxCap, tracks);\n  }\n};\n\nexport { Util };", "import {\n  User,\n  escapeMarkdown,\n  SnowflakeUtil,\n  GuildVoiceChannelResolvable,\n  APIUser } from\n'discord.js';\nimport {\n  Player,\n  PlayerNodeInitializationResult,\n  PlayerNodeInitializerOptions } from\n'../Player';\nimport { Playlist, PlaylistJSON } from './Playlist';\nimport { GuildQueue } from '../queue/GuildQueue';\nimport { BaseExtractor } from '../extractors/BaseExtractor';\nimport { Collection } from '@discord-player/utils';\nimport { TypeUtil } from '../utils/TypeUtil';\nimport { SerializedType, tryIntoThumbnailString } from '../utils/serde';\nimport { InvalidArgTypeError } from '../errors';\nimport { Util } from '../utils/Util';\nimport { SearchQueryType } from '../utils/QueryResolver';\nimport { AudioResource } from 'discord-voip';\nimport { SeekEvent } from '@discord-player/equalizer';\n\nexport type TrackResolvable = Track | string | number;\n\nexport type WithMetadata<T extends object, M> = T & {\n  metadata: M;\n  requestMetadata(): Promise<M>;\n};\n\nexport type SerializedTrack = ReturnType<Track['serialize']>;\n\n/**\n * The track source:\n * - soundcloud\n * - youtube\n * - spotify\n * - apple_music\n * - arbitrary\n */\nexport type TrackSource =\n'soundcloud' |\n'youtube' |\n'spotify' |\n'apple_music' |\n'arbitrary';\n\nexport interface RawTrackData {\n  /**\n   * The title\n   */\n  title: string;\n  /**\n   * The description\n   */\n  description: string;\n  /**\n   * The author\n   */\n  author: string;\n  /**\n   * The url\n   */\n  url: string;\n  /**\n   * The thumbnail\n   */\n  thumbnail: string;\n  /**\n   * The duration\n   */\n  duration: string;\n  /**\n   * The duration in ms\n   */\n  views: number;\n  /**\n   * The user who requested this track\n   */\n  requestedBy?: User | null;\n  /**\n   * The playlist\n   */\n  playlist?: Playlist;\n  /**\n   * The source\n   */\n  source?: TrackSource;\n  /**\n   * The engine\n   */\n  engine?: any; // eslint-disable-line @typescript-eslint/no-explicit-any\n  /**\n   * If this track is live\n   */\n  live?: boolean;\n  /**\n   * The raw data\n   */\n  raw?: any; // eslint-disable-line @typescript-eslint/no-explicit-any\n  /**\n   * The query type\n   */\n  queryType?: SearchQueryType;\n  /**\n   * The serialized title\n   */\n  cleanTitle?: string;\n}\n\nexport interface TrackJSON {\n  /**\n   * The track id\n   */\n  id: string;\n  /**\n   * The track title\n   */\n  title: string;\n  /**\n   * The track description\n   */\n  description: string;\n  /**\n   * The track author\n   */\n  author: string;\n  /**\n   * The track url\n   */\n  url: string;\n  /**\n   * The track thumbnail\n   */\n  thumbnail: string;\n  /**\n   * The track duration\n   */\n  duration: string;\n  /**\n   * The track duration in ms\n   */\n  durationMS: number;\n  /**\n   * The track views\n   */\n  views: number;\n  /**\n   * The user id who requested this track\n   */\n  requestedBy: string;\n  /**\n   * The playlist info (if any)\n   */\n  playlist?: PlaylistJSON;\n}\n\nexport class Track<T = unknown> {\n  public title: string;\n  public description: string;\n  public author: string;\n  public url: string;\n  public thumbnail: string;\n  public duration: string;\n  public views: number;\n  public requestedBy: User | null = null;\n  public playlist?: Playlist;\n  public queryType: SearchQueryType | null | undefined = null;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public raw: any;\n  public extractor: BaseExtractor | null = null;\n  public readonly id = SnowflakeUtil.generate().toString();\n  private __metadata: T | null = null;\n  private __reqMetadataFn: () => Promise<T | null>;\n  public cleanTitle: string;\n  public live: boolean = false;\n  public bridgedExtractor: BaseExtractor | null = null;\n  public bridgedTrack: Track | null = null;\n\n  #onSeek: ((event: SeekEvent) => Awaited<void>) | null = null;\n  #resource: AudioResource<Track> | null = null;\n\n  /**\n   * Track constructor\n   * @param player The player that instantiated this Track\n   * @param data Track data\n   */\n  public constructor(\n  public readonly player: Player,\n  data: Partial<WithMetadata<RawTrackData, T>>)\n  {\n    this.title = escapeMarkdown(data.title ?? '');\n    this.author = data.author ?? '';\n    this.url = data.url ?? '';\n    this.thumbnail = data.thumbnail ?? '';\n    this.duration = data.duration ?? '';\n    this.views = data.views ?? 0;\n    this.queryType = data.queryType;\n    this.requestedBy = data.requestedBy || null;\n    this.playlist = data.playlist;\n    this.description = `${this.title} by ${this.author}`;\n    this.raw = Object.assign(\n      {},\n      { source: data.raw?.source ?? data.source },\n      data.raw ?? data\n    );\n    this.__metadata = data.metadata ?? null;\n    this.__reqMetadataFn =\n    data.requestMetadata || (() => Promise.resolve<T | null>(null));\n    this.cleanTitle =\n    data.cleanTitle ?? Util.cleanTitle(this.title, this.source);\n    this.live = data.live ?? false;\n  }\n\n  /**\n   * Whether this track can be seeked\n   */\n  public get seekable() {\n    return this.#onSeek !== null;\n  }\n\n  /**\n   * Set the onSeek event\n   * @param fn The onSeek event\n   */\n  public handleSeek(fn: (event: SeekEvent) => Awaited<void>) {\n    this.#onSeek = fn;\n  }\n\n  /**\n   * Request seek\n   * @param event The seek event\n   */\n  public async seek(event: SeekEvent) {\n    if (this.#onSeek) return this.#onSeek(event);\n  }\n\n  /**\n   * Sets audio resource for this track. This is not useful outside of the library.\n   * @param resource Audio resource\n   */\n  public setResource(resource: AudioResource<Track> | null) {\n    this.#resource = resource;\n  }\n\n  /**\n   * Gets audio resource for this track\n   */\n  public get resource() {\n    return this.#resource;\n  }\n\n  /**\n   * Whether this track has an audio resource\n   */\n  public get hasResource() {\n    return this.#resource != null;\n  }\n\n  /**\n   * Request metadata for this track\n   */\n  public async requestMetadata() {\n    const res = await this.__reqMetadataFn();\n\n    this.setMetadata(res);\n\n    return res;\n  }\n\n  /**\n   * Set metadata for this track\n   */\n  public setMetadata(m: T | null) {\n    this.__metadata = m;\n  }\n\n  /**\n   * Metadata of this track\n   */\n  public get metadata() {\n    return this.__metadata;\n  }\n\n  /**\n   * If this track has metadata\n   */\n  public get hasMetadata() {\n    return this.metadata != null;\n  }\n\n  /**\n   * The queue in which this track is located\n   */\n  public get queue(): GuildQueue {\n    return this.player.nodes.cache.find((q) =>\n    q.tracks.some((ab) => ab.id === this.id)\n    )!;\n  }\n\n  /**\n   * The track duration in millisecond\n   */\n  public get durationMS(): number {\n    const times = (n: number, t: number) => {\n      let tn = 1;\n      for (let i = 0; i < t; i++) tn *= n;\n      return t <= 0 ? 1000 : tn * 1000;\n    };\n\n    return this.duration.\n    split(':').\n    reverse().\n    map((m, i) => parseInt(m) * times(60, i)).\n    reduce((a, c) => a + c, 0);\n  }\n\n  /**\n   * Discord hyperlink representation of this track\n   */\n  public toHyperlink(): string /* not using `[${string}](${string})` yet */ {\n    return `[${this.title}](${this.url})`;\n  }\n\n  /**\n   * Returns source of this track\n   */\n  public get source() {\n    return this.raw?.source ?? 'arbitrary';\n  }\n\n  /**\n   * String representation of this track\n   */\n  public toString(): string {\n    return `${this.title} by ${this.author}`;\n  }\n\n  /**\n   * Raw JSON representation of this track\n   */\n  public toJSON(hidePlaylist?: boolean) {\n    return {\n      id: this.id,\n      title: this.title,\n      description: this.description,\n      author: this.author,\n      url: this.url,\n      thumbnail: this.thumbnail,\n      duration: this.duration,\n      durationMS: this.durationMS,\n      views: this.views,\n      requestedBy: this.requestedBy?.id || null,\n      playlist: hidePlaylist ? null : this.playlist?.toJSON() ?? null\n    } as TrackJSON;\n  }\n\n  /**\n   * Serialized track data that can be reconstructed\n   */\n  public serialize() {\n    return {\n      title: this.title,\n      description: this.description,\n      author: this.author,\n      url: this.url,\n      thumbnail: TypeUtil.isString(this.thumbnail) ?\n      this.thumbnail :\n      tryIntoThumbnailString(this.thumbnail),\n      duration: this.duration,\n      views: this.views ?? 0,\n      requested_by: this.requestedBy?.toJSON() ?? null,\n      source: this.source,\n      live: false,\n      query_type: this.queryType,\n      extractor: this.extractor?.identifier ?? null,\n      metadata: this.metadata,\n      $type: SerializedType.Track,\n      $encoder_version: this.player.version\n    };\n  }\n\n  /**\n   * Construct a track from serialized data\n   * @param player Player instance\n   * @param data Serialized data\n   */\n  public static fromSerialized(\n  player: Player,\n  data: ReturnType<Track['serialize']>)\n  {\n    if (data.$type !== SerializedType.Track)\n    throw new InvalidArgTypeError(\n      'data',\n      'SerializedTrack',\n      'malformed data'\n    );\n    const track = new Track(player, {\n      ...data,\n      requestedBy: data.requested_by ?\n      (() => {\n        const res = data.requested_by as APIUser;\n        try {\n          const resolved = player.client.users.resolve(res.id);\n          if (resolved) return resolved;\n          if (player.client.users.cache.has(res.id))\n          return player.client.users.cache.get(res.id)!;\n          // @ts-expect-error\n          const user = new User(player.client, res);\n          return user;\n        } catch {\n          return null;\n        }\n      })() :\n      null,\n      queryType: data.query_type ?? undefined\n    });\n\n    track.setMetadata(data.metadata);\n\n    return track;\n  }\n\n  /**\n   * Get belonging queues of this track\n   */\n  public getBelongingQueues() {\n    const nodes = this.player.nodes.cache.filter((node) =>\n    node.tracks.some((t) => t.id === this.id)\n    );\n\n    return nodes as Collection<string, GuildQueue<unknown>>;\n  }\n\n  /**\n   * Play this track to the given voice channel. If queue exists and another track is being played, this track will be added to the queue.\n   * @param channel Voice channel on which this track shall be played\n   * @param options Node initialization options\n   */\n  public async play<T = unknown>(\n  channel: GuildVoiceChannelResolvable,\n  options?: PlayerNodeInitializerOptions<T>)\n  : Promise<PlayerNodeInitializationResult<T>> {\n    const fn = this.player.play.bind(this.player);\n\n    return await fn(channel, this, options);\n  }\n}", "export class DiscordPlayerError extends Error {\n  public readonly code: ErrorCodes;\n  public readonly timestamp: number = Date.now();\n\n  public constructor(code: ErrorCodes, message: string) {\n    super(message);\n    this.name = this.constructor.name;\n    this.code = code;\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n  }\n\n  public toJSON() {\n    return {\n      name: this.constructor.name,\n      code: this.code,\n      message: this.message,\n      timestamp: this.timestamp\n    };\n  }\n}\n\nexport class OutOfSpaceError extends DiscordPlayerError {\n  constructor(target: string, capacity: number, total: number) {\n    super(\n      ErrorCodes.ERR_OUT_OF_SPACE,\n      `Max capacity reached for ${target} (Capacity ${capacity}/Total ${total})`\n    );\n  }\n}\n\nexport class InvalidArgTypeError extends DiscordPlayerError {\n  constructor(target: string, expectation: string, found: string) {\n    super(\n      ErrorCodes.ERR_INVALID_ARG_TYPE,\n      `Expected ${target} to be \"${expectation}\", received \"${found}\"`\n    );\n  }\n}\n\nexport class NoResultError extends DiscordPlayerError {\n  constructor(message: string) {\n    super(ErrorCodes.ERR_NO_RESULT, message);\n  }\n}\n\nexport class NotImplementedError extends DiscordPlayerError {\n  constructor(target: string) {\n    super(ErrorCodes.ERR_NOT_IMPLEMENTED, `${target} is not yet implemented`);\n  }\n}\n\nexport class NotExistingError extends DiscordPlayerError {\n  constructor(target: string) {\n    super(ErrorCodes.ERR_NOT_EXISTING, `${target} does not exist`);\n  }\n}\n\nexport class OutOfRangeError extends DiscordPlayerError {\n  constructor(target: string, value: string, minimum: string, maximum: string) {\n    super(\n      ErrorCodes.ERR_OUT_OF_RANGE,\n      `${target} is out of range (Expected minimum ${minimum} and maximum ${maximum}, got ${value})`\n    );\n  }\n}\n\nexport class NoVoiceConnectionError extends DiscordPlayerError {\n  constructor(message?: string) {\n    super(\n      ErrorCodes.ERR_NO_VOICE_CONNECTION,\n      message ||\n      'No voice connection available, maybe connect to a voice channel first?'\n    );\n  }\n}\n\nexport class VoiceConnectionDestroyedError extends DiscordPlayerError {\n  constructor() {\n    super(\n      ErrorCodes.ERR_VOICE_CONNECTION_DESTROYED,\n      'Cannot use destroyed voice connection'\n    );\n  }\n}\n\nexport class NoVoiceChannelError extends DiscordPlayerError {\n  constructor() {\n    super(ErrorCodes.ERR_NO_VOICE_CHANNEL, 'Could not get the voice channel');\n  }\n}\n\nexport class InvalidVoiceChannelError extends DiscordPlayerError {\n  constructor() {\n    super(ErrorCodes.ERR_INVALID_VOICE_CHANNEL, 'Expected a voice channel');\n  }\n}\n\nexport class NoReceiverError extends DiscordPlayerError {\n  constructor(message?: string) {\n    super(\n      ErrorCodes.ERR_NO_RECEIVER,\n      message ||\n      'No voice receiver is available, maybe connect to a voice channel first?'\n    );\n  }\n}\n\nexport class FFmpegError extends DiscordPlayerError {\n  constructor(message: string) {\n    super(ErrorCodes.ERR_FFMPEG_LOCATOR, message);\n  }\n}\n\nexport class NoAudioResourceError extends DiscordPlayerError {\n  constructor(message?: string) {\n    super(\n      ErrorCodes.ERR_NO_AUDIO_RESOURCE,\n      message || 'Expected an audio resource'\n    );\n  }\n}\n\nexport class NoGuildQueueError extends DiscordPlayerError {\n  constructor(message?: string) {\n    super(ErrorCodes.ERR_NO_GUILD_QUEUE, message || 'Expected a guild queue');\n  }\n}\n\nexport class NoGuildError extends DiscordPlayerError {\n  constructor(message?: string) {\n    super(ErrorCodes.ERR_NO_GUILD, message || 'Expected a guild');\n  }\n}\n\nexport class InfoRequiredError extends DiscordPlayerError {\n  constructor(target: string, actual: string) {\n    super(\n      ErrorCodes.ERR_INFO_REQUIRED,\n      `Expected ${target}, found \"${actual}\"`\n    );\n  }\n}\n\nexport class SerializationError extends DiscordPlayerError {\n  constructor() {\n    super(\n      ErrorCodes.ERR_SERIALIZATION_FAILED,\n      \"Don't know how to serialize this data\"\n    );\n  }\n}\n\nexport class DeserializationError extends DiscordPlayerError {\n  constructor() {\n    super(\n      ErrorCodes.ERR_DESERIALIZATION_FAILED,\n      \"Don't know how to deserialize this data\"\n    );\n  }\n}\n\nexport class IllegalHookInvocationError extends DiscordPlayerError {\n  constructor(target: string, message?: string) {\n    super(\n      ErrorCodes.ERR_ILLEGAL_HOOK_INVOCATION,\n      `Illegal invocation of ${target} hook.${message ? ` ${message}` : ''}`\n    );\n  }\n}\n\nexport class ModuleNotFoundError extends DiscordPlayerError {\n  constructor(target: string, description = '') {\n    super(\n      ErrorCodes.ERR_NOT_EXISTING_MODULE,\n      `${target} module does not exist. Install it with \\`npm install ${target}\\`.${\n      description ? ' ' + description : ''}`\n\n    );\n  }\n}\n\nexport class BridgeFailedError extends DiscordPlayerError {\n  constructor(id: string | null, error: string) {\n    super(\n      ErrorCodes.ERR_BRIDGE_FAILED,\n      `${\n      id ? `(Extractor Execution Context ID is ${id})` : ''}Failed to bridge this query:\\n${\n      error}`\n    );\n  }\n}\n\n// For backwards compatibility\nexport const ErrorCodes = {\n  ERR_OUT_OF_SPACE: 'ERR_OUT_OF_SPACE',\n  ERR_INVALID_ARG_TYPE: 'ERR_INVALID_ARG_TYPE',\n  ERR_NO_RESULT: 'ERR_NO_RESULT',\n  ERR_NOT_IMPLEMENTED: 'ERR_NOT_IMPLEMENTED',\n  ERR_NOT_EXISTING: 'ERR_NOT_EXISTING',\n  ERR_OUT_OF_RANGE: 'ERR_OUT_OF_RANGE',\n  ERR_NO_VOICE_CONNECTION: 'ERR_NO_VOICE_CONNECTION',\n  ERR_VOICE_CONNECTION_DESTROYED: 'ERR_VOICE_CONNECTION_DESTROYED',\n  ERR_NO_VOICE_CHANNEL: 'ERR_NO_VOICE_CHANNEL',\n  ERR_INVALID_VOICE_CHANNEL: 'ERR_INVALID_VOICE_CHANNEL',\n  ERR_NO_RECEIVER: 'ERR_NO_RECEIVER',\n  ERR_FFMPEG_LOCATOR: 'ERR_FFMPEG_LOCATOR',\n  ERR_NO_AUDIO_RESOURCE: 'ERR_NO_AUDIO_RESOURCE',\n  ERR_NO_GUILD_QUEUE: 'ERR_NO_GUILD_QUEUE',\n  ERR_NO_GUILD: 'ERR_NO_GUILD',\n  ERR_INFO_REQUIRED: 'ERR_INFO_REQUIRED',\n  ERR_SERIALIZATION_FAILED: 'ERR_SERIALIZATION_FAILED',\n  ERR_DESERIALIZATION_FAILED: 'ERR_DESERIALIZATION_FAILED',\n  ERR_ILLEGAL_HOOK_INVOCATION: 'ERR_ILLEGAL_HOOK_INVOCATION',\n  ERR_NOT_EXISTING_MODULE: 'ERR_NOT_EXISTING_MODULE',\n  ERR_BRIDGE_FAILED: 'ERR_BRIDGE_FAILED'\n} as const;\n\nexport type ErrorCodes = (typeof ErrorCodes)[keyof typeof ErrorCodes];\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nexport function isDiscordPlayerError(error: any): error is DiscordPlayerError {\n  return error != null && error instanceof DiscordPlayerError;\n}\n\n/**\n * Handle a `DiscordPlayerError` error.\n * @param error The error to handle\n * @param handler The handler function. This function will only be called if the error is a `DiscordPlayerError`.\n * @param args The arguments to pass to the handler\n * @returns The result of the handler\n * @example ```typescript\n * try {\n *   // ...\n * } catch (error) {\n *  handleDiscordPlayerError(error, (error) => {\n *    console.error(`An error occurred from discord-player: ${error.message}`);\n *  });\n * }\n * ```\n */\nexport function handleDiscordPlayerError<\n  T extends any[],\n  F extends (error: DiscordPlayerError, ...args: T) => any,\n  R extends ReturnType<F>>(\nerror: any, handler: F, args: T): R {\n  if (isDiscordPlayerError(error)) {\n    return handler(error, ...args) as R;\n  }\n\n  return undefined as R;\n}\n\n/* eslint-enable @typescript-eslint/no-explicit-any */", "import { DiscordPlayerError, isDiscordPlayerError } from '../errors';\n\nexport class TypeUtil {\n  private constructor() {\n    return TypeUtil;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  public static isFunction(t: unknown): t is Function {\n    return typeof t === 'function';\n  }\n\n  public static isNumber(t: unknown): t is number {\n    return typeof t === 'number' && !isNaN(t);\n  }\n\n  public static isString(t: unknown): t is string {\n    return typeof t === 'string';\n  }\n\n  public static isBoolean(t: unknown): t is boolean {\n    return typeof t === 'boolean';\n  }\n\n  public static isNullish(t: unknown): t is null | undefined {\n    return t == null;\n  }\n\n  public static isArray(t: unknown): t is unknown[] {\n    return Array.isArray(t);\n  }\n\n  public static isError(t: unknown): t is Error {\n    return t instanceof Error;\n  }\n\n  public static isDiscordPlayerError(t: unknown): t is DiscordPlayerError {\n    return isDiscordPlayerError(t);\n  }\n}", "/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport { DeserializationError, SerializationError } from '../errors';\nimport {\n  Playlist,\n  type SerializedTrack,\n  Track,\n  SerializedPlaylist } from\n'../fabric';\nimport { TypeUtil } from './TypeUtil';\nimport { Buffer } from 'buffer';\nimport { Player } from '../Player';\n\nexport enum SerializedType {\n  Track = 'track',\n  Playlist = 'playlist',\n}\n\nexport type Encodable = SerializedTrack | SerializedPlaylist;\n\nconst isTrack = (data: any): data is SerializedTrack =>\ndata.$type === SerializedType.Track;\nconst isPlaylist = (data: any): data is SerializedPlaylist =>\ndata.$type === SerializedType.Playlist;\n\nexport function serialize(data: Track | Playlist | any) {\n  if (data instanceof Track) return data.serialize();\n  if (data instanceof Playlist) return data.serialize();\n\n  try {\n    return data.toJSON();\n  } catch {\n    throw new SerializationError();\n  }\n}\n\nexport function deserialize(player: Player, data: Encodable) {\n  if (isTrack(data)) return Track.fromSerialized(player, data);\n  if (isPlaylist(data)) return Playlist.fromSerialized(player, data);\n\n  throw new DeserializationError();\n}\n\nexport function encode(data: Encodable) {\n  const str = JSON.stringify(data);\n\n  return Buffer.from(str).toString('base64');\n}\n\nexport function decode(data: string) {\n  const str = Buffer.from(data, 'base64').toString();\n\n  return JSON.parse(str);\n}\n\nexport function tryIntoThumbnailString(data: any) {\n  if (!data) return null;\n  try {\n    if (TypeUtil.isString(data)) return data;\n    return data?.url ?? data?.thumbnail?.url ?? null;\n  } catch {\n    return null;\n  }\n}", "import {\n  Player,\n  PlayerNodeInitializationResult,\n  PlayerNodeInitializerOptions } from\n'../Player';\nimport { Track, TrackJSON, TrackSource } from './Track';\nimport { Util } from '../utils/Util';\nimport { GuildVoiceChannelResolvable } from 'discord.js';\nimport { SerializedType, tryIntoThumbnailString } from '../utils/serde';\nimport { TypeUtil } from '../utils/TypeUtil';\nimport { InvalidArgTypeError } from '../errors';\n\nexport type SerializedPlaylist = ReturnType<Playlist['serialize']>;\n\nexport interface PlaylistInitData {\n  /**\n   * The tracks of this playlist\n   */\n  tracks: Track[];\n  /**\n   * The playlist title\n   */\n  title: string;\n  /**\n   * The description\n   */\n  description: string;\n  /**\n   * The thumbnail\n   */\n  thumbnail: string;\n  /**\n   * The playlist type: `album` | `playlist`\n   */\n  type: 'album' | 'playlist';\n  /**\n   * The playlist source\n   */\n  source: TrackSource;\n  /**\n   * The playlist author\n   */\n  author: {\n    /**\n     * The author name\n     */\n    name: string;\n    /**\n     * The author url\n     */\n    url: string;\n  };\n  /**\n   * The playlist id\n   */\n  id: string;\n  /**\n   * The playlist url\n   */\n  url: string;\n  /**\n   * The raw playlist data\n   */\n  rawPlaylist?: any; // eslint-disable-line @typescript-eslint/no-explicit-any\n}\n\nexport interface PlaylistJSON {\n  /**\n   * The playlist id\n   */\n  id: string;\n  /**\n   * The playlist url\n   */\n  url: string;\n  /**\n   * The playlist title\n   */\n  title: string;\n  /**\n   * The playlist description\n   */\n  description: string;\n  /**\n   * The thumbnail\n   */\n  thumbnail: string;\n  /**\n   * The playlist type: `album` | `playlist`\n   */\n  type: 'album' | 'playlist';\n  /**\n   * The track source\n   */\n  source: TrackSource;\n  /**\n   * The playlist author\n   */\n  author: {\n    /**\n     * The author name\n     */\n    name: string;\n    /**\n     * The author url\n     */\n    url: string;\n  };\n  /**\n   * The tracks data (if any)\n   */\n  tracks: TrackJSON[];\n}\n\nexport class Playlist {\n  public readonly player: Player;\n  public tracks: Track[];\n  public title: string;\n  public description: string;\n  public thumbnail: string;\n  public type: 'album' | 'playlist';\n  public source: TrackSource;\n  public author: {\n    name: string;\n    url: string;\n  };\n  public id: string;\n  public url: string;\n  public readonly rawPlaylist?: any; // eslint-disable-line @typescript-eslint/no-explicit-any\n\n  /**\n   * Playlist constructor\n   * @param {Player} player The player\n   * @param {PlaylistInitData} data The data\n   */\n  constructor(player: Player, data: PlaylistInitData) {\n    /**\n     * The player\n     * @name Playlist#player\n     * @type {Player}\n     * @readonly\n     */\n    this.player = player;\n\n    /**\n     * The tracks in this playlist\n     * @name Playlist#tracks\n     * @type {Track[]}\n     */\n    this.tracks = data.tracks ?? [];\n\n    /**\n     * The author of this playlist\n     * @name Playlist#author\n     * @type {object}\n     */\n    this.author = data.author;\n\n    /**\n     * The description\n     * @name Playlist#description\n     * @type {string}\n     */\n    this.description = data.description;\n\n    /**\n     * The thumbnail of this playlist\n     * @name Playlist#thumbnail\n     * @type {string}\n     */\n    this.thumbnail = data.thumbnail;\n\n    /**\n     * The playlist type:\n     * - `album`\n     * - `playlist`\n     * @name Playlist#type\n     * @type {string}\n     */\n    this.type = data.type;\n\n    /**\n     * The source of this playlist:\n     * - `youtube`\n     * - `soundcloud`\n     * - `spotify`\n     * - `arbitrary`\n     * @name Playlist#source\n     * @type {string}\n     */\n    this.source = data.source;\n\n    /**\n     * The playlist id\n     * @name Playlist#id\n     * @type {string}\n     */\n    this.id = data.id;\n\n    /**\n     * The playlist url\n     * @name Playlist#url\n     * @type {string}\n     */\n    this.url = data.url;\n\n    /**\n     * The playlist title\n     * @type {string}\n     */\n    this.title = data.title;\n\n    /**\n     * @name Playlist#rawPlaylist\n     * @type {any}\n     * @readonly\n     */\n  }\n\n  *[Symbol.iterator]() {\n    yield* this.tracks;\n  }\n\n  /**\n   * Estimated duration of this playlist\n   */\n  public get estimatedDuration() {\n    return this.tracks.reduce((p, c) => p + c.durationMS, 0);\n  }\n\n  /**\n   * Formatted estimated duration of this playlist\n   */\n  public get durationFormatted() {\n    return Util.buildTimeCode(Util.parseMS(this.estimatedDuration));\n  }\n\n  /**\n   * JSON representation of this playlist\n   * @param {boolean} [withTracks=true] If it should build json with tracks\n   * @returns {PlaylistJSON}\n   */\n  toJSON(withTracks = true) {\n    const payload = {\n      id: this.id,\n      url: this.url,\n      title: this.title,\n      description: this.description,\n      thumbnail: this.thumbnail,\n      type: this.type,\n      source: this.source,\n      author: this.author,\n      tracks: [] as TrackJSON[]\n    };\n\n    if (withTracks) payload.tracks = this.tracks.map((m) => m.toJSON(true));\n\n    return payload as PlaylistJSON;\n  }\n\n  /**\n   * Serialize this playlist into reconstructable data\n   */\n  public serialize() {\n    return {\n      tracks: this.tracks.map((m) => m.serialize()),\n      title: this.title,\n      description: this.description,\n      thumbnail: TypeUtil.isString(this.thumbnail) ?\n      this.thumbnail :\n      tryIntoThumbnailString(this.thumbnail),\n      type: this.type,\n      source: this.source,\n      author: this.author,\n      id: this.id,\n      url: this.url,\n      $type: SerializedType.Playlist,\n      $encoder_version: this.player.version\n    };\n  }\n\n  /**\n   * Deserialize this playlist from serialized data\n   * @param player Player instance\n   * @param data Serialized data\n   */\n  public static fromSerialized(player: Player, data: SerializedPlaylist) {\n    if (data.$type !== SerializedType.Playlist)\n    throw new InvalidArgTypeError(\n      'data',\n      'SerializedPlaylist',\n      'malformed data'\n    );\n    return new Playlist(player, {\n      ...data,\n      tracks: data.tracks.map((m) => Track.fromSerialized(player, m))\n    });\n  }\n\n  /**\n   * Play this playlist to the given voice channel. If queue exists and another track is being played, this playlist will be added to the queue.\n   * @param channel Voice channel on which this playlist shall be played\n   * @param options Node initialization options\n   */\n  public async play<T = unknown>(\n  channel: GuildVoiceChannelResolvable,\n  options?: PlayerNodeInitializerOptions<T>)\n  : Promise<PlayerNodeInitializationResult<T>> {\n    const fn = this.player.play.bind(this.player);\n\n    return await fn(channel, this, options);\n  }\n}", "import { TypeUtil } from './TypeUtil';\nimport { InfoRequiredError, InvalidArgTypeError } from '../errors';\nimport { fetch } from 'undici';\n\n// #region scary things below *sigh*\nconst spotifySongRegex =\n/^https?:\\/\\/(?:embed\\.|open\\.)(?:spotify\\.com\\/)(intl-([a-z]|[A-Z])+\\/)?(?:track\\/|\\?uri=spotify:track:)((\\w|-){22})(\\?si=.+)?$/;\nconst spotifyPlaylistRegex =\n/^https?:\\/\\/(?:embed\\.|open\\.)(?:spotify\\.com\\/)(intl-([a-z]|[A-Z])+\\/)?(?:playlist\\/|\\?uri=spotify:playlist:)((\\w|-){22})(\\?si=.+)?$/;\nconst spotifyAlbumRegex =\n/^https?:\\/\\/(?:embed\\.|open\\.)(?:spotify\\.com\\/)(intl-([a-z]|[A-Z])+\\/)?(?:album\\/|\\?uri=spotify:album:)((\\w|-){22})(\\?si=.+)?$/;\nconst vimeoRegex =\n/^(http|https)?:\\/\\/(www\\.|player\\.)?vimeo\\.com\\/(?:channels\\/(?:\\w+\\/)?|groups\\/([^/]*)\\/videos\\/|video\\/|)(\\d+)(?:|\\/\\?)$/;\nconst reverbnationRegex =\n/^https:\\/\\/(www.)?reverbnation.com\\/(.+)\\/song\\/(.+)$/;\nconst attachmentRegex = /^https?:\\/\\/.+$/;\nconst appleMusicSongRegex =\n/^https?:\\/\\/music\\.apple\\.com\\/.+?\\/(song|album)\\/.+?(\\/.+?\\?i=|\\/)([0-9]+)$/;\nconst appleMusicPlaylistRegex =\n/^https?:\\/\\/music\\.apple\\.com\\/.+?\\/playlist\\/.+\\/pl\\.(u-|pm-)?[a-zA-Z0-9]+$/;\nconst appleMusicAlbumRegex =\n/^https?:\\/\\/music\\.apple\\.com\\/.+?\\/album\\/.+\\/([0-9]+)$/;\nconst soundcloudTrackRegex =\n/^https?:\\/\\/(m.|www.)?soundcloud.com\\/(\\w|-)+\\/(\\w|-)+(.+)?$/;\nconst soundcloudPlaylistRegex =\n/^https?:\\/\\/(m.|www.)?soundcloud.com\\/(\\w|-)+\\/sets\\/(\\w|-)+(.+)?$/;\nconst youtubePlaylistRegex =\n/^https?:\\/\\/(www.)?youtube.com\\/playlist\\?list=((PL|FL|UU|LL|RD|OL)[a-zA-Z0-9-_]{16,41})$/;\nconst youtubeVideoURLRegex =\n/^((?:https?:)?\\/\\/)?((?:www|m)\\.)?((?:youtube\\.com|youtu.be))(\\/(?:[\\w-]+\\?v=|embed\\/|v\\/)?)([\\w-]+)(\\S+)?$/;\nconst youtubeVideoIdRegex = /^[a-zA-Z0-9-_]{11}$/;\n// discord-player://blob/uuid-v4\nconst discordPlayerBlobRegex = /^discord-player:\\/\\/blob\\/\\d+$/;\n// #endregion scary things above *sigh*\n\nconst DomainsMap = {\n  DiscordPlayer: ['discord-player'],\n  YouTube: [\n  'youtube.com',\n  'youtu.be',\n  'music.youtube.com',\n  'gaming.youtube.com',\n  'www.youtube.com',\n  'm.youtube.com'],\n\n  Spotify: ['open.spotify.com', 'embed.spotify.com'],\n  Vimeo: ['vimeo.com', 'player.vimeo.com'],\n  ReverbNation: ['reverbnation.com'],\n  SoundCloud: ['soundcloud.com'],\n  AppleMusic: ['music.apple.com']\n};\n\n// prettier-ignore\nconst redirectDomains = new Set([\n/^https?:\\/\\/spotify.link\\/[A-Za-z0-9]+$/,\n/^https:\\/\\/on\\.soundcloud\\.com\\/[a-zA-Z1-9]{0,17}$/]\n);\n\n/**\n * The search query type\n * This can be one of:\n * - AUTO\n * - YOUTUBE\n * - YOUTUBE_PLAYLIST\n * - SOUNDCLOUD_TRACK\n * - SOUNDCLOUD_PLAYLIST\n * - SOUNDCLOUD\n * - SPOTIFY_SONG\n * - SPOTIFY_ALBUM\n * - SPOTIFY_PLAYLIST\n * - SPOTIFY_SEARCH\n * - FACEBOOK\n * - VIMEO\n * - ARBITRARY\n * - REVERBNATION\n * - YOUTUBE_SEARCH\n * - YOUTUBE_VIDEO\n * - SOUNDCLOUD_SEARCH\n * - APPLE_MUSIC_SONG\n * - APPLE_MUSIC_ALBUM\n * - APPLE_MUSIC_PLAYLIST\n * - APPLE_MUSIC_SEARCH\n * - FILE\n * - AUTO_SEARCH\n * - DISCORD_PLAYER_BLOB\n * @typedef {string} QueryType\n */\nexport const QueryType = {\n  AUTO: 'auto',\n  YOUTUBE: 'youtube',\n  YOUTUBE_PLAYLIST: 'youtubePlaylist',\n  SOUNDCLOUD_TRACK: 'soundcloudTrack',\n  SOUNDCLOUD_PLAYLIST: 'soundcloudPlaylist',\n  SOUNDCLOUD: 'soundcloud',\n  SPOTIFY_SONG: 'spotifySong',\n  SPOTIFY_ALBUM: 'spotifyAlbum',\n  SPOTIFY_PLAYLIST: 'spotifyPlaylist',\n  SPOTIFY_SEARCH: 'spotifySearch',\n  FACEBOOK: 'facebook',\n  VIMEO: 'vimeo',\n  ARBITRARY: 'arbitrary',\n  REVERBNATION: 'reverbnation',\n  YOUTUBE_SEARCH: 'youtubeSearch',\n  YOUTUBE_VIDEO: 'youtubeVideo',\n  SOUNDCLOUD_SEARCH: 'soundcloudSearch',\n  APPLE_MUSIC_SONG: 'appleMusicSong',\n  APPLE_MUSIC_ALBUM: 'appleMusicAlbum',\n  APPLE_MUSIC_PLAYLIST: 'appleMusicPlaylist',\n  APPLE_MUSIC_SEARCH: 'appleMusicSearch',\n  FILE: 'file',\n  AUTO_SEARCH: 'autoSearch',\n  DISCORD_PLAYER_BLOB: 'discordPlayerBlob'\n} as const;\n\nexport type QueryType = (typeof QueryType)[keyof typeof QueryType];\n\nexport type SearchQueryType = keyof typeof QueryType | QueryType;\n\nexport interface ResolvedQuery {\n  type: (typeof QueryType)[keyof typeof QueryType];\n  query: string;\n}\n\nclass QueryResolver {\n  /**\n   * Query resolver\n   */\n  private constructor() {} // eslint-disable-line @typescript-eslint/no-empty-function\n\n  static get regex() {\n    return {\n      spotifyAlbumRegex,\n      spotifyPlaylistRegex,\n      spotifySongRegex,\n      vimeoRegex,\n      reverbnationRegex,\n      attachmentRegex,\n      appleMusicAlbumRegex,\n      appleMusicPlaylistRegex,\n      appleMusicSongRegex,\n      soundcloudTrackRegex,\n      soundcloudPlaylistRegex,\n      youtubePlaylistRegex,\n      discordPlayerBlobRegex\n    };\n  }\n\n  /**\n   * Pre-resolve redirect urls\n   */\n  static async preResolve(query: string, maxDepth = 5): Promise<string> {\n    if (!TypeUtil.isString(query))\n    throw new InvalidArgTypeError(query, 'string', typeof query);\n\n    for (const domain of redirectDomains) {\n      if (domain.test(query)) {\n        try {\n          const res = await fetch(query, {\n            method: 'GET',\n            redirect: 'follow'\n          });\n\n          if (!res.ok) break;\n\n          // spotify does not \"redirect\", it returns a page with js that redirects\n          if (/^https?:\\/\\/spotify.app.link\\/(.+)$/.test(res.url)) {\n            const body = await res.text();\n            const target = body.\n            split('https://open.spotify.com/track/')[1].\n            split('?si=')[0];\n\n            if (!target) break;\n\n            return `https://open.spotify.com/track/${target}`;\n          }\n          return maxDepth < 1 ?\n          res.url :\n          this.preResolve(res.url, maxDepth - 1);\n        } catch {\n          break;\n        }\n      }\n    }\n\n    return query;\n  }\n\n  /**\n   * Resolves the given search query\n   * @param {string} query The query\n   */\n  static resolve(\n  query: string,\n  fallbackSearchEngine: (typeof QueryType)[keyof typeof QueryType] = QueryType.AUTO_SEARCH)\n  : ResolvedQuery {\n    if (!TypeUtil.isString(query))\n    throw new InvalidArgTypeError(query, 'string', typeof query);\n    if (!query.length) throw new InfoRequiredError('query', String(query));\n\n    const resolver = (type: typeof fallbackSearchEngine, query: string) => ({\n      type,\n      query\n    });\n\n    if (discordPlayerBlobRegex.test(query))\n    return resolver(QueryType.DISCORD_PLAYER_BLOB, query);\n\n    try {\n      const url = new URL(query);\n\n      if (DomainsMap.YouTube.includes(url.host)) {\n        query = query.replace(/(m(usic)?|gaming)\\./, '').trim();\n        const playlistId = url.searchParams.get('list');\n        if (playlistId)\n        return resolver(\n          QueryType.YOUTUBE_PLAYLIST,\n          `https://www.youtube.com/${\n          url.searchParams.size === 1 ? 'playlist' : 'watch'}${\n          url.search}`\n        );\n        if (QueryResolver.validateId(query) || QueryResolver.validateURL(query))\n        return resolver(QueryType.YOUTUBE_VIDEO, query);\n        return resolver(fallbackSearchEngine, query);\n      } else if (DomainsMap.Spotify.includes(url.host)) {\n        query = query.replace(/intl-([a-zA-Z]+)\\//, '');\n        if (spotifyPlaylistRegex.test(query))\n        return resolver(QueryType.SPOTIFY_PLAYLIST, query);\n        if (spotifyAlbumRegex.test(query))\n        return resolver(QueryType.SPOTIFY_ALBUM, query);\n        if (spotifySongRegex.test(query))\n        return resolver(QueryType.SPOTIFY_SONG, query);\n        return resolver(fallbackSearchEngine, query);\n      } else if (DomainsMap.Vimeo.includes(url.host)) {\n        if (vimeoRegex.test(query)) return resolver(QueryType.VIMEO, query);\n        return resolver(fallbackSearchEngine, query);\n      } else if (DomainsMap.ReverbNation.includes(url.host)) {\n        if (reverbnationRegex.test(query))\n        return resolver(QueryType.REVERBNATION, query);\n        return resolver(fallbackSearchEngine, query);\n      } else if (DomainsMap.SoundCloud.includes(url.host)) {\n        if (soundcloudPlaylistRegex.test(query))\n        return resolver(QueryType.SOUNDCLOUD_PLAYLIST, query);\n        if (soundcloudTrackRegex.test(query))\n        return resolver(QueryType.SOUNDCLOUD_TRACK, query);\n        return resolver(fallbackSearchEngine, query);\n      } else if (DomainsMap.AppleMusic.includes(url.host)) {\n        if (appleMusicAlbumRegex.test(query))\n        return resolver(QueryType.APPLE_MUSIC_ALBUM, query);\n        if (appleMusicPlaylistRegex.test(query))\n        return resolver(QueryType.APPLE_MUSIC_PLAYLIST, query);\n        if (appleMusicSongRegex.test(query))\n        return resolver(QueryType.APPLE_MUSIC_SONG, query);\n        return resolver(fallbackSearchEngine, query);\n      } else {\n        return resolver(QueryType.ARBITRARY, query);\n      }\n    } catch {\n      return resolver(fallbackSearchEngine, query);\n    }\n  }\n\n  /**\n   * Parses vimeo id from url\n   * @param {string} query The query\n   * @returns {string}\n   */\n  static getVimeoID(query: string): string | null | undefined {\n    return QueryResolver.resolve(query).type === QueryType.VIMEO ?\n    query.split('/').filter(Boolean).pop() :\n    null;\n  }\n\n  static validateId(q: string) {\n    return youtubeVideoIdRegex.test(q);\n  }\n\n  static validateURL(q: string) {\n    return youtubeVideoURLRegex.test(q);\n  }\n}\n\nexport { QueryResolver };", "import { User, UserResolvable } from 'discord.js';\nimport { BaseExtractor } from '../extractors/BaseExtractor';\nimport { Player } from '../Player';\nimport { Playlist } from './Playlist';\nimport { Track } from './Track';\nimport { QueryType, SearchQueryType } from '../utils/QueryResolver';\nimport type { RequestOptions } from 'http';\n\nexport interface SearchResultData {\n  query: string;\n  queryType?: SearchQueryType | QueryExtractorSearch | null;\n  extractor?: BaseExtractor | null;\n  playlist?: Playlist | null;\n  tracks?: Track[];\n  requestedBy?: User | null;\n}\n\nexport interface PlayOptions {\n  /**\n   * If this play was triggered for filters update\n   */\n  filtersUpdate?: boolean;\n  /**\n   * FFmpeg args passed to encoder\n   */\n  encoderArgs?: string[];\n  /**\n   * Time to seek to before playing\n   */\n  seek?: number;\n  /**\n   * If it should start playing the provided track immediately\n   */\n  immediate?: boolean;\n}\n\nexport type QueryExtractorSearch = `ext:${string}`;\n\nexport interface SearchOptions {\n  /**\n   * The user who requested this search\n   */\n  requestedBy?: UserResolvable;\n  /**\n   * The query search engine, can be extractor name to target specific one (custom)\n   */\n  searchEngine?: SearchQueryType | QueryExtractorSearch;\n  /**\n   * List of the extractors to block\n   */\n  blockExtractors?: string[];\n  /**\n   * If it should ignore query cache lookup\n   */\n  ignoreCache?: boolean;\n  /**\n   * Request options to be passed with the http request\n   */\n  requestOptions?: RequestOptions;\n  /**\n   * Fallback search engine to use\n   */\n  fallbackSearchEngine?: (typeof QueryType)[keyof typeof QueryType];\n}\n\nexport interface PlayerSearchResult {\n  playlist: Playlist | null;\n  tracks: Track[];\n}\n\nexport class SearchResult {\n  public constructor(public player: Player, private _data: SearchResultData) {\n    this._data.tracks?.forEach((track) => {\n      track.extractor ??= this._data.extractor || null;\n      track.requestedBy ??= _data.requestedBy || null;\n    });\n  }\n\n  public setQueryType(type: SearchQueryType | QueryExtractorSearch) {\n    this._data.queryType = type;\n    return this;\n  }\n\n  public setRequestedBy(user: User) {\n    this._data.requestedBy = user;\n    this._data.tracks?.forEach((track) => {\n      track.requestedBy = user;\n    });\n    return this;\n  }\n\n  public setExtractor(extractor: BaseExtractor) {\n    this._data.extractor = extractor;\n    this._data.tracks?.forEach((track) => {\n      track.extractor = extractor;\n    });\n    return this;\n  }\n\n  public setTracks(tracks: Track[]) {\n    this._data.tracks = tracks;\n    return this;\n  }\n\n  public setQuery(query: string) {\n    this._data.query = query;\n    return this;\n  }\n\n  public setPlaylist(playlist: Playlist) {\n    this._data.playlist = playlist;\n    return this;\n  }\n\n  /**\n   * The search query\n   */\n  public get query() {\n    return this._data.query;\n  }\n\n  /**\n   * The search query type\n   */\n  public get queryType() {\n    return this._data.queryType || QueryType.AUTO;\n  }\n\n  /**\n   * The extractor\n   */\n  public get extractor() {\n    return this._data.extractor || null;\n  }\n\n  /**\n   * Playlist result\n   */\n  public get playlist() {\n    return this._data.playlist;\n  }\n\n  /**\n   * Tracks result\n   */\n  public get tracks() {\n    return this._data.tracks || [];\n  }\n\n  /**\n   * Requested by\n   */\n  public get requestedBy() {\n    return this._data.requestedBy || null;\n  }\n\n  /**\n   * Re-execute this search\n   */\n  public async execute() {\n    return this.player.search(this.query, {\n      searchEngine: this.queryType,\n      requestedBy: this.requestedBy!\n    });\n  }\n\n  /**\n   * If this search result is empty\n   */\n  public isEmpty() {\n    return !this.tracks.length;\n  }\n\n  /**\n   * If this search result has playlist\n   */\n  public hasPlaylist() {\n    return this.playlist != null;\n  }\n\n  /**\n   * If this search result has tracks\n   */\n  public hasTracks() {\n    return this.tracks.length > 0;\n  }\n\n  /**\n   * JSON representation of this search\n   */\n  public toJSON() {\n    return {\n      query: this.query,\n      queryType: this.queryType,\n      playlist: this.playlist?.toJSON(false) || null,\n      tracks: this.tracks.map((m) => m.toJSON(true)),\n      extractor: this.extractor?.identifier || null,\n      requestedBy: this.requestedBy?.toJSON() || null\n    };\n  }\n}", "export type FiltersName = keyof QueueFilters;\n\n/**\n * Represents FFmpeg filters\n */\nexport interface QueueFilters {\n  bassboost_low?: boolean;\n  bassboost?: boolean;\n  bassboost_high?: boolean;\n  '8D'?: boolean;\n  vaporwave?: boolean;\n  nightcore?: boolean;\n  phaser?: boolean;\n  tremolo?: boolean;\n  vibrato?: boolean;\n  reverse?: boolean;\n  treble?: boolean;\n  normalizer?: boolean;\n  normalizer2?: boolean;\n  surrounding?: boolean;\n  pulsator?: boolean;\n  subboost?: boolean;\n  karaoke?: boolean;\n  flanger?: boolean;\n  gate?: boolean;\n  haas?: boolean;\n  mcompand?: boolean;\n  mono?: boolean;\n  mstlr?: boolean;\n  mstrr?: boolean;\n  compressor?: boolean;\n  expander?: boolean;\n  softlimiter?: boolean;\n  chorus?: boolean;\n  chorus2d?: boolean;\n  chorus3d?: boolean;\n  fadein?: boolean;\n  dim?: boolean;\n  earrape?: boolean;\n  lofi?: boolean;\n  silenceremove?: boolean;\n}\n\nconst bass = (g: number) => `bass=g=${g}:f=110:w=0.3`;\n\nexport class AudioFilters {\n  public constructor() {\n    return AudioFilters;\n  }\n\n  public static filters: Record<FiltersName, string> = {\n    bassboost_low: bass(15),\n    bassboost: bass(20),\n    bassboost_high: bass(30),\n    '8D': 'apulsator=hz=0.09',\n    vaporwave: 'aresample=48000,asetrate=48000*0.8',\n    nightcore: 'aresample=48000,asetrate=48000*1.25',\n    lofi: 'aresample=48000,asetrate=48000*0.9,extrastereo=m=2.5:c=disabled',\n    phaser: 'aphaser=in_gain=0.4',\n    tremolo: 'tremolo',\n    vibrato: 'vibrato=f=6.5',\n    reverse: 'areverse',\n    treble: 'treble=g=5',\n    normalizer2: 'dynaudnorm=g=101',\n    normalizer: 'acompressor',\n    surrounding: 'surround',\n    pulsator: 'apulsator=hz=1',\n    subboost: 'asubboost',\n    karaoke: 'stereotools=mlev=0.03',\n    flanger: 'flanger',\n    gate: 'agate',\n    haas: 'haas',\n    mcompand: 'mcompand',\n    mono: 'pan=mono|c0=.5*c0+.5*c1',\n    mstlr: 'stereotools=mode=ms>lr',\n    mstrr: 'stereotools=mode=ms>rr',\n    compressor: 'compand=points=-80/-105|-62/-80|-15.4/-15.4|0/-12|20/-7.6',\n    expander:\n    'compand=attacks=0:points=-80/-169|-54/-80|-49.5/-64.6|-41.1/-41.1|-25.8/-15|-10.8/-4.5|0/0|20/8.3',\n    softlimiter:\n    'compand=attacks=0:points=-80/-80|-12.4/-12.4|-6/-8|0/-6.8|20/-2.8',\n    chorus: 'chorus=0.7:0.9:55:0.4:0.25:2',\n    chorus2d: 'chorus=0.6:0.9:50|60:0.4|0.32:0.25|0.4:2|1.3',\n    chorus3d: 'chorus=0.5:0.9:50|60|40:0.4|0.32|0.3:0.25|0.4|0.3:2|2.3|1.3',\n    fadein: 'afade=t=in:ss=0:d=10',\n    dim: `afftfilt=\"'real=re * (1-clip((b/nb)*b,0,1))':imag='im * (1-clip((b/nb)*b,0,1))'\"`,\n    earrape: 'channelsplit,sidechaingate=level_in=64',\n    silenceremove: 'silenceremove=1:0:-50dB'\n  };\n\n  public static get<K extends FiltersName>(name: K) {\n    return this.filters[name] ?? name;\n  }\n\n  public static has<K extends FiltersName>(name: K) {\n    return name in this.filters;\n  }\n\n  public static *[Symbol.iterator](): IterableIterator<{\n    name: FiltersName;\n    value: string;\n  }> {\n    for (const [k, v] of Object.entries(this.filters)) {\n      yield { name: k as FiltersName, value: v as string };\n    }\n  }\n\n  public static get names() {\n    return Object.keys(this.filters) as FiltersName[];\n  }\n\n  // @ts-ignore\n  public static get length() {\n    return this.names.length;\n  }\n\n  public static toString() {\n    return this.names.map((m) => (this as any)[m]).join(','); // eslint-disable-line @typescript-eslint/no-explicit-any\n  }\n\n  /**\n   * Create ffmpeg args from the specified filters name\n   * @param filter The filter name\n   * @returns\n   */\n  public static create<K extends FiltersName>(filters?: (K | string)[]) {\n    if (!filters || !Array.isArray(filters)) return this.toString();\n    return filters.\n    filter((predicate) => typeof predicate === 'string').\n    map((m) => this.get(m as K)).\n    join(',');\n  }\n\n  /**\n   * Defines audio filter\n   * @param filterName The name of the filter\n   * @param value The ffmpeg args\n   */\n  public static define(filterName: string, value: string) {\n    this.filters[filterName as FiltersName] = value;\n  }\n\n  /**\n   * Defines multiple audio filters\n   * @param filtersArray Array of filters containing the filter name and ffmpeg args\n   */\n  public static defineBulk(filtersArray: {name: string;value: string;}[]) {\n    filtersArray.forEach((arr) => this.define(arr.name, arr.value));\n  }\n}", "/* eslint-disable @typescript-eslint/no-explicit-any */\n// @ts-nocheck\n\nimport { ChannelType, GatewayDispatchEvents } from 'discord-api-types/v10';\nimport { createCompatClient } from './common';\nimport { Util } from '../utils/Util';\n\nimport type { DiscordGatewayAdapterCreator } from 'discord-voip';\nimport {\n  Client,\n  GatewayVoiceServerUpdateDispatchData,\n  GatewayVoiceStateUpdateDispatchData,\n  VoiceState } from\n'discord.js';\nimport type Oceanic from 'oceanic.js';\n\ntype OceanicUserResolvable = Oceanic.User | string | Oceanic.Member;\ntype OceanicGuildResolvable =\nOceanic.Guild |\nstring |\nOceanic.Member |\nOceanic.GuildChannel |\nOceanic.Role;\ntype OceanicChannelResolvable = Oceanic.GuildChannel | string;\n\nconst DiscordPlayerClientSymbol = Symbol('DiscordPlayerClient');\n\nexport function isOceanicClient(client: any): client is Oceanic.Client {\n  const { module, error } = Util.require('oceanic.js');\n\n  if (error) return false;\n\n  const oceanic = module as typeof import('oceanic.js');\n\n  return client instanceof oceanic.Client;\n}\n\nfunction declareProperty(target: any, key: string, value: any): T {\n  Reflect.set(target, key, value);\n}\n\nfunction getProperty<T>(target: any, key: string): T {\n  return Reflect.get(target, key);\n}\n\n/**\n * Allows Oceanic.js clients to be used with discord-player. When this method is called, discord-player creates a proxy object that intercepts certain methods and properties to make it compatible with discord-player.\n * @param client The Oceanic.js client to be used.\n * @returns The Oceanic.js client with discord-player compatibility.\n */\nexport function createOceanicCompat(client: Oceanic.Client): Client {\n  const { module, error } = Util.require('oceanic.js');\n\n  if (error) throw error;\n\n  const oceanic = module as typeof import('oceanic.js');\n\n  oceanicVoiceEventsHandler(client);\n\n  const oceanicProxy = new Proxy(client, {\n    get(target, p) {\n      switch (p) {\n        case 'users':\n          return oceanicUsersProxy(target, oceanic);\n        case 'guilds':\n          return oceanicGuildsProxy(target, oceanic);\n        case 'channels':\n          return oceanicChannelsProxy(target, oceanic);\n        case '__dp_voiceStateUpdate_proxy':\n          return (handler: (a, b) => void) =>\n          oceanicVoiceStateUpdateProxy(target, oceanicProxy, handler);\n        case 'incrementMaxListeners':\n          return () => {\n            // @ts-expect-error patching\n            client.setMaxListeners(client.getMaxListeners() + 1);\n          };\n        case 'decrementMaxListeners':\n          return () => {\n            // @ts-expect-error patching\n            const listeners = client.getMaxListeners() - 1;\n\n            // @ts-expect-error patching\n            client.setMaxListeners(listeners < 0 ? 1 : listeners);\n          };\n        default:\n          // @ts-expect-error patching\n          return target[p];\n      }\n    }\n  });\n\n  Reflect.set(oceanicProxy, DiscordPlayerClientSymbol, 'Oceanic');\n\n  return createCompatClient(oceanicProxy, 'Oceanic').\n  client as unknown as Client;\n}\n\nfunction oceanicVoiceStateUpdateProxy(\nclient: Oceanic.Client,\nproxy: Oceanic.Client,\nhandler: (a, b) => void)\n{\n  client.on('voiceStateUpdate', (member, oldState) => {\n    try {\n      const proxiedOldState = {\n        channelId: oldState.channelID,\n        serverMute: oldState.mute,\n        suppress: oldState.suppress,\n        guild: {\n          id: oldState.guild.id\n        },\n        member: {\n          id: oldState.user.id\n        }\n      } as VoiceState;\n\n      const me = member.guild.members.get(client.user.id);\n      const resolvedChannel = member.guild.channels.get(\n        member.voiceState.channelID\n      );\n\n      const proxiedNewState = {\n        channelId: member.voiceState.channelID,\n        serverMute: member.voiceState.mute,\n        suppress: member.voiceState.suppress,\n        channel: oceanicResolvedChannelProxy(resolvedChannel, client),\n        member: {\n          id: member.id\n        },\n        guild: {\n          id: member.guild.id,\n          members: {\n            me: {\n              id: me?.id,\n              voice: {\n                async setRequestToSpeak(value: boolean) {\n                  void value;\n                  return me?.voiceState;\n                  // if (me) {\n                  //   return me.voice.setRequestToSpeak(value);\n                  // }\n                }\n              }\n            }\n          }\n        }\n      } as VoiceState;\n\n      return handler(proxiedNewState, proxiedOldState);\n    } catch {\n\n      /* noop */}\n  });\n}\n\nfunction oceanicVoiceEventsHandler(client: Oceanic.Client) {\n  let adapters = getProperty<Map<string, any>>(client, 'adapters');\n\n  if (!adapters) {\n    const collection = new Map<string, any>();\n    adapters = collection;\n    declareProperty(client, 'adapters', collection);\n  }\n\n  client.on('shardDisconnect', (_, shardId) => {\n    for (const [guildId, adapter] of adapters.entries()) {\n      if (client.guilds.get(guildId)?.shard.id === shardId) {\n        adapter.destroy();\n      }\n    }\n  });\n\n  client.on('packet', (packet) => {\n    switch (packet.t) {\n      case GatewayDispatchEvents.VoiceServerUpdate:{\n          const payload = packet.d as GatewayVoiceServerUpdateDispatchData;\n          adapters.get(payload.guild_id)?.onVoiceServerUpdate(payload);\n          return;\n        }\n      case GatewayDispatchEvents.VoiceStateUpdate:{\n          const payload = packet.d as GatewayVoiceStateUpdateDispatchData;\n\n          if (\n          payload.guild_id &&\n          payload.session_id &&\n          payload.user_id === client.user.id)\n          {\n            adapters.get(payload.guild_id)?.onVoiceStateUpdate(payload);\n          }\n\n          return;\n        }\n      default:\n        break;\n    }\n  });\n}\n\nfunction oceanicChannelsProxy(\nclient: Oceanic.Client,\noceanic: typeof import('oceanic.js'))\n{\n  const handler = {\n    client,\n    get cache() {\n      return {\n        get(id: string) {\n          return client.getChannel(id);\n        },\n        has(id: string) {\n          return id in client.channelGuildMap;\n        }\n      };\n    },\n    resolve(resolvable: string | OceanicChannelResolvable) {\n      if (typeof resolvable === 'string') {\n        return oceanicResolvedChannelProxy(\n          this.client.getChannel(resolvable) as Oceanic.GuildChannel,\n          client\n        );\n      }\n\n      if (resolvable instanceof oceanic.GuildChannel) {\n        return oceanicResolvedChannelProxy(resolvable, client);\n      }\n    },\n    resolveId(resolvable: OceanicChannelResolvable) {\n      const channel = this.resolve(resolvable);\n      return channel?.id;\n    }\n  };\n\n  return handler;\n}\n\nfunction oceanicResolvedChannelProxy(\nchannel: Oceanic.GuildChannel | undefined,\nclient: Oceanic.Client)\n: Oceanic.GuildChannel | undefined {\n  if (!channel) return;\n\n  return new Proxy(channel, {\n    get(target, p) {\n      switch (p) {\n        case 'guild':\n          return oceanicVoiceAdapterProxy(target.guild, client);\n        case 'members':\n          return (target as Oceanic.VoiceChannel).voiceMembers;\n        case 'isVoiceBased':\n          return () =>\n          target.type === ChannelType.GuildVoice ||\n          target.type === ChannelType.GuildStageVoice;\n        case 'isVoice':\n          return () => target.type === ChannelType.GuildVoice;\n        case 'isStage':\n          return () => target.type === ChannelType.GuildStageVoice;\n        default:\n          // @ts-expect-error patching\n          return target[p];\n      }\n    }\n  });\n}\n\nfunction oceanicVoiceAdapterProxy(\nguild: Oceanic.Guild | undefined,\nclient: Oceanic.Client)\n: Oceanic.Guild | undefined {\n  if (!guild) return;\n\n  return new Proxy(guild, {\n    get(target, p) {\n      if (p === 'voiceAdapterCreator') {\n        return oceanicVoiceAdapterCreator(target, client);\n      }\n\n      // @ts-expect-error patching\n      return target[p];\n    }\n  });\n}\n\nfunction oceanicVoiceAdapterCreator(\nguild: Oceanic.Guild,\nclient: Oceanic.Client)\n: DiscordGatewayAdapterCreator {\n  return (methods) => {\n    let adapters = getProperty<Map<string, typeof methods>>(client, 'adapters');\n\n    if (!adapters) {\n      const collection = new Map<string, typeof methods>();\n      adapters = collection;\n      declareProperty(client, 'adapters', collection);\n    }\n\n    adapters.set(guild.id, methods);\n\n    return {\n      sendPayload(payload) {\n        if (guild.shard.status !== 'ready') return false;\n        guild.shard.send(payload.op, payload.d);\n        return true;\n      },\n      destroy() {\n        adapters.delete(guild.id);\n      }\n    };\n  };\n}\n\nfunction oceanicGuildsProxy(\nclient: Oceanic.Client,\noceanic: typeof import('oceanic.js'))\n{\n  return new Proxy(client.guilds, {\n    get(target, p) {\n      if (p === 'cache') {\n        return target;\n      }\n\n      if (p === 'resolve' || p === 'resolveId') {\n        const resolver = function (resolvable: OceanicGuildResolvable) {\n          if (typeof resolvable === 'string') {\n            return target.get(resolvable);\n          }\n\n          if (resolvable instanceof oceanic.Guild) {\n            return resolvable;\n          }\n\n          if (\n          resolvable instanceof oceanic.Member ||\n          resolvable instanceof oceanic.Guild ||\n          resolvable instanceof oceanic.GuildChannel ||\n          resolvable instanceof oceanic.Role)\n          {\n            return resolvable.guild;\n          }\n        };\n\n        if (p === 'resolve') {\n          return resolver;\n        }\n\n        return (resolvable: OceanicGuildResolvable) => {\n          const guild = resolver(resolvable);\n          return guild?.id;\n        };\n      }\n\n      // @ts-expect-error patching\n      return target[p];\n    }\n  });\n}\n\nfunction oceanicUsersProxy(\nclient: Oceanic.Client,\noceanic: typeof import('oceanic.js'))\n{\n  return new Proxy(client.users, {\n    get(target, p) {\n      if (p === 'cache') {\n        return target;\n      }\n\n      if (p === 'resolve' || p === 'resolveId') {\n        const resolver = function (resolvable: OceanicUserResolvable) {\n          if (typeof resolvable === 'string') {\n            return target.get(resolvable);\n          }\n\n          if (resolvable instanceof oceanic.User) {\n            return resolvable;\n          }\n\n          if (resolvable instanceof oceanic.Member) {\n            return resolvable.user;\n          }\n        };\n\n        if (p === 'resolve') {\n          return resolver;\n        }\n\n        return (resolvable: OceanicUserResolvable) => {\n          const user = resolver(resolvable);\n          return user?.id;\n        };\n      }\n\n      // @ts-expect-error patching\n      return target[p];\n    }\n  });\n}", "import { DefaultListener } from '@discord-player/utils';\nimport { ListenerSignature } from '@discord-player/utils';\nimport { EventEmitter } from '@discord-player/utils';\nimport { Util } from './Util';\n\nexport class PlayerEventsEmitter<\n  L extends ListenerSignature<L> = DefaultListener> extends\nEventEmitter<L> {\n  #hasDebugger = false;\n  public constructor(public requiredEvents: Array<keyof L> = []) {\n    super();\n  }\n\n  public on<K extends keyof L>(name: K, listener: L[K]) {\n    if (name === 'debug') {\n      this.#hasDebugger = true;\n    }\n\n    return super.on(name, listener);\n  }\n\n  public once<K extends keyof L>(name: K, listener: L[K]) {\n    if (name === 'debug') {\n      this.#hasDebugger = true;\n    }\n\n    return super.once(name, listener);\n  }\n\n  public addListener<K extends keyof L>(name: K, listener: L[K]) {\n    if (name === 'debug') {\n      this.#hasDebugger = true;\n    }\n\n    return super.addListener(name, listener);\n  }\n\n  public off<K extends keyof L>(name: K, listener: L[K]) {\n    this.#hasDebugger = this.listenerCount('debug' as K) > 0;\n\n    return super.off(name, listener);\n  }\n\n  public removeListener<K extends keyof L>(name: K, listener: L[K]) {\n    this.#hasDebugger = this.listenerCount('debug' as K) > 0;\n\n    return super.removeListener(name, listener);\n  }\n\n  public removeAllListeners<K extends keyof L>(name?: K) {\n    this.#hasDebugger = this.listenerCount('debug' as K) > 0;\n\n    return super.removeAllListeners(name);\n  }\n\n  public emit<K extends keyof L>(name: K, ...args: Parameters<L[K]>) {\n    if (\n    this.requiredEvents.includes(name) &&\n    !this.eventNames().includes(name))\n    {\n      // eslint-disable-next-line no-console\n      console.error(...args);\n      Util.warn(\n        `No event listener found for event \"${String(\n          name\n        )}\". Events ${this.requiredEvents.\n        map((m) => `\"${String(m)}\"`).\n        join(', ')} must have event listeners.`,\n        'UnhandledEventsWarning'\n      );\n      return false;\n    }\n\n    return super.emit(name, ...args);\n  }\n\n  public get hasDebugger() {\n    return this.#hasDebugger;\n  }\n}", "import { User } from 'discord.js';\nimport { Readable } from 'stream';\nimport { Playlist } from '../fabric/Playlist';\nimport { Track } from '../fabric/Track';\nimport { ExtractorExecutionContext } from './ExtractorExecutionContext';\nimport type { RequestOptions } from 'http';\nimport { NotImplementedError } from '../errors';\nimport type { GuildQueueHistory } from '../queue';\nimport { SearchQueryType } from '../utils/QueryResolver';\nimport { PlayerEvents } from '../Player';\n\nexport type ExtractorStreamable =\nReadable |\nstring |\n{\n  $fmt: string;\n  stream: Readable;\n};\n\nexport class BaseExtractor<T extends object = object> {\n  /**\n   * Identifier for this extractor\n   */\n  public static identifier = 'com.discord-player.extractor';\n\n  /**\n   * Priority of this extractor. Higher value means higher priority (will be executed first).\n   */\n  public priority = 1;\n\n  /**\n   * A list of query protocols that this extractor supports.\n   */\n  public protocols: string[] = [];\n\n  /**\n   * Handle bridge query creation\n   * @param track The track to build query for\n   */\n  public createBridgeQuery = (track: Track) =>\n  `${track.title} by ${track.author} official audio`;\n\n  /**\n   * Extractor constructor\n   * @param context Context that instantiated this extractor\n   * @param options Initialization options for this extractor\n   */\n  public constructor(\n  public context: ExtractorExecutionContext,\n  public options: T = <T> {})\n  {}\n\n  /**\n   * Identifier of this extractor\n   */\n  public get identifier() {\n    return (this.constructor as typeof BaseExtractor).identifier;\n  }\n\n  /**\n   * Reconfigures this extractor\n   * @param options The new options to apply\n   */\n  public async reconfigure(options: T) {\n    this.options = options;\n    await this.deactivate();\n    await this.activate();\n  }\n\n  /**\n   * This method will be executed when this extractor is activated\n   */\n  public async activate() {\n    // executed when this extractor is activated\n    return;\n  }\n\n  /**\n   * This method will be executed when this extractor is deactivated\n   */\n  public async deactivate() {\n    // executed when this extractor is deactivated\n    return;\n  }\n\n  /**\n   * Validate incoming query\n   * @param query The query to validate\n   */\n  public async validate(\n  query: string,\n  type?: SearchQueryType | null)\n  : Promise<boolean> {\n    void type;\n    return false;\n  }\n\n  /**\n   * Stream the given track\n   * @param info The track to stream\n   */\n  public async stream(info: Track): Promise<ExtractorStreamable> {\n    void info;\n    throw new NotImplementedError(`${this.constructor.name}.stream()`);\n  }\n\n  /**\n   * Handle the given query\n   * @param query The query to handle\n   */\n  public async handle(\n  query: string,\n  context: ExtractorSearchContext)\n  : Promise<ExtractorInfo> {\n    void context;\n    throw new NotImplementedError(`${this.constructor.name}.handle()`);\n  }\n\n  /**\n   * Get related tracks for the given track\n   * @param track The track source\n   */\n  public async getRelatedTracks(\n  track: Track,\n  history: GuildQueueHistory)\n  : Promise<ExtractorInfo> {\n    void track;\n    void history;\n    throw new NotImplementedError(\n      `${this.constructor.name}.getRelatedTracks()`\n    );\n  }\n\n  /**\n   * A stream middleware to handle streams before passing it to the player\n   * @param stream The incoming stream\n   * @param next The next function\n   */\n  public handlePostStream(stream: Readable, next: NextFunction) {\n    return next(null, stream);\n  }\n\n  /**\n   * Dispatch an event to the player\n   * @param event The event to dispatch\n   * @param args The data to dispatch\n   */\n  public emit<K extends keyof PlayerEvents>(\n  event: K,\n  ...args: Parameters<PlayerEvents[K]>)\n  {\n    return this.context.player.emit(event, ...args);\n  }\n\n  /**\n   * Create extractor response\n   * @param playlist The playlist\n   * @param tracks The track array\n   */\n  public createResponse(\n  playlist?: Playlist | null,\n  tracks: Track[] = playlist?.tracks || [])\n  : ExtractorInfo {\n    return { playlist: playlist || null, tracks };\n  }\n\n  /**\n   * Write debug message\n   * @param message The debug message\n   */\n  public debug(message: string) {\n    return this.context.player.debug(message);\n  }\n\n  /**\n   * A flag to indicate `Demuxable` stream support for `opus`/`ogg/opus`/`webm/opus` formats.\n   */\n  public get supportsDemux() {\n    return !!this.context.player.options.skipFFmpeg;\n  }\n\n  /**\n   * Handle stream extraction for another extractor\n   * @param track The track to bridge\n   * @param sourceExtractor The source extractor\n   */\n  public async bridge(\n  track: Track,\n  sourceExtractor: BaseExtractor | null)\n  : Promise<ExtractorStreamable | null> {\n    void sourceExtractor;\n    return null;\n  }\n}\n\nexport type NextFunction = (error?: Error | null, stream?: Readable) => void;\n\nexport interface ExtractorInfo {\n  playlist: Playlist | null;\n  tracks: Track[];\n}\n\nexport interface ExtractorSearchContext {\n  type?: SearchQueryType | null;\n  requestedBy?: User | null;\n  requestOptions?: RequestOptions;\n  protocol?: string | null;\n}", "import { Player } from '../Player';\nimport { Collection } from '@discord-player/utils';\nimport { BaseExtractor, ExtractorStreamable } from './BaseExtractor';\nimport { Util } from '../utils/Util';\nimport { PlayerEventsEmitter } from '../utils/PlayerEventsEmitter';\nimport { TypeUtil } from '../utils/TypeUtil';\nimport { Track } from '../fabric';\nimport { createContext } from '../hooks';\nimport { BridgeFailedError } from '../errors';\n\nexport interface ExtractorSession {\n  id: string;\n  attemptedExtractors: Set<string>;\n  bridgeAttemptedExtractors: Set<string>;\n}\n\nexport interface ExtractorExecutionEvents {\n  /**\n   * Emitted when a extractor is registered\n   * @param context The context where extractor was registered\n   * @param extractor The extractor that was registered\n   */\n  registered: (\n  context: ExtractorExecutionContext,\n  extractor: BaseExtractor)\n  => unknown;\n  /**\n   * Emitted when a extractor is unregistered\n   * @param context The context where extractor was unregistered\n   * @param extractor The extractor that was unregistered\n   */\n  unregistered: (\n  context: ExtractorExecutionContext,\n  extractor: BaseExtractor)\n  => unknown;\n  /**\n   * Emitted when a extractor is activated\n   * @param context The context where this event occurred\n   * @param extractor The extractor which was activated\n   */\n  activate: (\n  context: ExtractorExecutionContext,\n  extractor: BaseExtractor)\n  => unknown;\n  /**\n   * Emitted when a extractor is deactivated\n   * @param context The context where this event occurred\n   * @param extractor The extractor which was deactivated\n   */\n  deactivate: (\n  context: ExtractorExecutionContext,\n  extractor: BaseExtractor)\n  => unknown;\n  /**\n   * Emitted when a extractor fails to activate/deactivate\n   * @param context The context where this event occurred\n   * @param extractor The extractor which was deactivated\n   */\n  error: (\n  context: ExtractorExecutionContext,\n  extractor: BaseExtractor,\n  error: Error)\n  => unknown;\n}\n\nexport class ExtractorExecutionContext extends PlayerEventsEmitter<ExtractorExecutionEvents> {\n  /**\n   * The extractors store\n   */\n  public store = new Collection<string, BaseExtractor>();\n\n  public readonly context = createContext<ExtractorSession>();\n\n  public constructor(public player: Player) {\n    super(['error']);\n  }\n\n  /**\n   * Get the current execution id\n   */\n  public getExecutionId(): string | null {\n    return this.context.consume()?.id ?? null;\n  }\n\n  /**\n   * Get the current execution context\n   */\n  public getContext() {\n    return this.context.consume() ?? null;\n  }\n\n  public async loadDefault() {\n    const sample = `\\timport { DefaultExtractors } from '@discord-player/extractor';\\n\\tawait player.extractors.loadMulti(DefaultExtractors);`;\n\n    throw new Error(\n      `extractors.loadDefault() is no longer supported. Use extractors.loadMulti instead. Example:\\n${sample}\\n`\n    );\n  }\n\n  /**\n   * Load a bundle of extractors.\n   * @example import { DefaultExtractors } from '@discord-player/extractor';\n   *\n   * await player.extractors.loadMulti(DefaultExtractors);\n   */\n  public async loadMulti<\n    O extends object,\n    T extends (typeof BaseExtractor<O>)[],\n    R extends Record<\n      T[number]['identifier'],\n      ConstructorParameters<T[number]>[1]>>(\n\n  bundle: T, options: R = {} as R) {\n    bundle.forEach((ext) => {\n      // @ts-ignore\n      this.register(ext, options?.[ext.identifier] || {});\n    });\n\n    return { success: true, error: null };\n  }\n\n  /**\n   * Validate if the given extractor is registered\n   * @param identifier The extractor identifier\n   */\n  public isRegistered(identifier: string) {\n    return this.store.has(identifier);\n  }\n\n  /**\n   * The size of registered extractors\n   */\n  public get size() {\n    return this.store.size;\n  }\n\n  /**\n   * Get single extractor\n   * @param identifier The extractor to get\n   */\n  public get(identifier: string) {\n    return this.store.get(identifier);\n  }\n\n  /**\n   * Register single extractor\n   * @param _extractor The extractor to register\n   * @param options Options supplied to the extractor\n   */\n  public async register<O extends object, T extends typeof BaseExtractor<O>>(\n  _extractor: T,\n  options: ConstructorParameters<T>['1'])\n  : Promise<InstanceType<T> | null> {\n    if (\n    typeof _extractor.identifier !== 'string' ||\n    this.store.has(_extractor.identifier))\n\n    return null;\n    const extractor = new _extractor(this, options);\n\n    try {\n      this.store.set(_extractor.identifier, extractor);\n      if (this.player.hasDebugger)\n      this.player.debug(`${_extractor.identifier} extractor loaded!`);\n      this.emit('registered', this, extractor);\n      await extractor.activate();\n      if (this.player.hasDebugger)\n      this.player.debug(`${_extractor.identifier} extractor activated!`);\n      this.emit('activate', this, extractor);\n      return extractor as unknown as InstanceType<T>;\n    } catch (e) {\n      this.store.delete(_extractor.identifier);\n      if (this.player.hasDebugger)\n      this.player.debug(\n        `${_extractor.identifier} extractor failed to activate! Error: ${e}`\n      );\n      this.emit('error', this, extractor, e as Error);\n      return null;\n    }\n  }\n\n  /**\n   * Unregister single extractor\n   * @param _extractor The extractor to unregister\n   */\n  public async unregister<K extends string | BaseExtractor>(_extractor: K) {\n    const extractor =\n    typeof _extractor === 'string' ?\n    this.store.get(_extractor) :\n    this.store.find((r) => r === _extractor);\n    if (!extractor) return;\n\n    try {\n      const key =\n      extractor.identifier || this.store.findKey((e) => e === extractor)!;\n      this.store.delete(key);\n      if (this.player.hasDebugger)\n      this.player.debug(`${extractor.identifier} extractor disabled!`);\n      this.emit('unregistered', this, extractor);\n      await extractor.deactivate();\n      if (this.player.hasDebugger)\n      this.player.debug(`${extractor.identifier} extractor deactivated!`);\n      this.emit('deactivate', this, extractor);\n    } catch (e) {\n      if (this.player.hasDebugger)\n      this.player.debug(\n        `${extractor.identifier} extractor failed to deactivate!`\n      );\n      this.emit('error', this, extractor, e as Error);\n    }\n  }\n\n  /**\n   * Unregister all extractors\n   */\n  public async unregisterAll() {\n    try {\n      await Promise.all(this.store.map((e) => this.unregister(e)));\n    } catch {\n\n      // do nothing\n    }}\n\n  /**\n   * Run all the extractors\n   * @param fn The runner function\n   * @param filterBlocked Filter blocked extractors\n   */\n  public async run<T = unknown>(\n  fn: ExtractorExecutionFN<T>,\n  filterBlocked = true)\n  {\n    const blocked = this.player.options.blockExtractors ?? [];\n\n    if (!this.store.size) {\n      Util.warn(\n        'Skipping extractors execution since zero extractors were registered',\n        'NoExtractors'\n      );\n      return;\n    }\n\n    // sort by priority so that extractors with higher priority are executed first\n    const extractors = this.store.sort((a, b) => b.priority - a.priority);\n\n    let err: Error | null = null,\n      lastExt: BaseExtractor | null = null;\n\n    for (const ext of extractors.values()) {\n      if (filterBlocked && blocked.some((e) => e === ext.identifier)) continue;\n      if (this.player.hasDebugger)\n      this.player.debug(`Executing extractor ${ext.identifier}...`);\n      const result = await fn(ext).then(\n        (res) => {\n          return res;\n        },\n        (e) => {\n          if (this.player.hasDebugger)\n          this.player.debug(\n            `Extractor ${ext.identifier} failed with error: ${e}`\n          );\n\n          return TypeUtil.isError(e) ? e : new Error(`${e}`);\n        }\n      );\n\n      lastExt = ext;\n\n      if (result && !TypeUtil.isError(result)) {\n        if (this.player.hasDebugger)\n        this.player.debug(\n          `Extractor ${ext.identifier} executed successfully!`\n        );\n\n        return {\n          extractor: ext,\n          error: null,\n          result\n        } as ExtractorExecutionResult<T>;\n      } else if (TypeUtil.isError(result)) {\n        err = result;\n      }\n    }\n\n    if (err)\n    return {\n      extractor: lastExt!,\n      error: err,\n      result: false\n    } as ExtractorExecutionResult<false>;\n  }\n\n  /**\n   * Request bridge for a track\n   * @param track The track to request bridge for\n   * @param sourceExtractor The source extractor of the track\n   */\n  public async requestBridge(\n  track: Track,\n  sourceExtractor: BaseExtractor | null = track.extractor)\n  {\n    const previouslyAttempted =\n    this.getContext()?.bridgeAttemptedExtractors ?? new Set<string>();\n\n    const result = await this.run<ExtractorStreamable>(async (ext) => {\n      if (sourceExtractor && ext.identifier === sourceExtractor.identifier)\n      return false;\n      if (previouslyAttempted.has(ext.identifier)) return false;\n\n      previouslyAttempted.add(ext.identifier);\n\n      const result = await ext.bridge(track, sourceExtractor);\n\n      if (!result) return false;\n\n      return result;\n    });\n\n    if (!result?.result)\n    throw new BridgeFailedError(\n      this.getExecutionId(),\n      result?.error?.stack ||\n      result?.error?.message ||\n      'No extractors available to bridge'\n    );\n\n    track.bridgedExtractor = result.extractor;\n\n    return result;\n  }\n\n  /**\n   * Request bridge from the specified extractor\n   * @param track The track to request bridge for\n   * @param sourceExtractor The source extractor of the track\n   * @param targetExtractor The target extractor to bridge to\n   */\n  public async requestBridgeFrom(\n  track: Track,\n  sourceExtractor: BaseExtractor | null,\n  targetExtractor: ExtractorResolvable)\n  {\n    const target = this.resolve(targetExtractor);\n    if (!target) return null;\n    return target.bridge(track, sourceExtractor);\n  }\n\n  /**\n   * Check if extractor is disabled\n   */\n  public isDisabled(identifier: string) {\n    return this.player.options.blockExtractors?.includes(identifier) ?? false;\n  }\n\n  /**\n   * Check if extractor is enabled\n   */\n  public isEnabled(identifier: string) {\n    return !this.isDisabled(identifier);\n  }\n\n  /**\n   * Resolve extractor identifier\n   */\n  public resolveId(resolvable: ExtractorResolvable) {\n    return typeof resolvable === 'string' ? resolvable : resolvable.identifier;\n  }\n\n  /**\n   * Resolve extractor\n   */\n  public resolve(resolvable: ExtractorResolvable) {\n    return typeof resolvable === 'string' ? this.get(resolvable) : resolvable;\n  }\n}\n\nexport interface ExtractorExecutionResult<T = unknown> {\n  extractor: BaseExtractor;\n  error: Error | null;\n  result: T;\n}\n\nexport type ExtractorExecutionFN<T = unknown> = (\nextractor: BaseExtractor)\n=> Promise<T | boolean>;\n\nexport type ExtractorResolvable = string | BaseExtractor;", "import { AsyncLocalStorage } from 'node:async_hooks';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype unsafe = any;\n\n/**\n * The receiver function that will be called when the context is provided\n */\nexport type ContextReceiver<R> = () => R;\n\nexport class Context<T> {\n  private storage = new AsyncLocalStorage<T>();\n\n  public constructor(private defaultValue?: T) {}\n\n  /**\n   * Exit out of this context\n   */\n  public exit(scope: ContextReceiver<void>) {\n    this.storage.exit(scope);\n  }\n\n  /**\n   * Whether the context is lost\n   */\n  public get isLost() {\n    return this.storage.getStore() === undefined;\n  }\n\n  /**\n   * Get the current value of the context. If the context is lost and no default value is provided, undefined will be returned.\n   */\n  public consume(): T | undefined {\n    const data = this.storage.getStore();\n\n    if (data === undefined && this.defaultValue !== undefined)\n    return this.defaultValue;\n\n    return data;\n  }\n\n  /**\n   * Run a function within the context of this provider\n   */\n  public provide<R = unsafe>(value: T, receiver: ContextReceiver<R>): R {\n    if (value === undefined) {\n      throw new Error('Context value may not be undefined');\n    }\n\n    if (typeof receiver !== 'function') {\n      throw new Error('Context receiver must be a function');\n    }\n\n    return this.storage.run(value, receiver);\n  }\n}\n\n/**\n * Create a new context. The default value is optional.\n * @param defaultValue The default value of the context\n * @example const userContext = createContext();\n *\n *  // the value to provide\n *  const user = {\n *   id: 1,\n *   name: 'John Doe'\n *  };\n *\n *  // provide the context value to the receiver\n *  context.provide(user, handler);\n *\n *  function handler() {\n *    // get the context value\n *    const { id, name } = useContext(context);\n *\n *    console.log(id, name); // 1, John Doe\n *  }\n */\nexport function createContext<T = unsafe>(defaultValue?: T): Context<T> {\n  return new Context(defaultValue);\n}\n\n/**\n * Get the current value of the context. If the context is lost and no default value is provided, undefined will be returned.\n * @param context The context to get the value from\n * @example const value = useContext(context);\n */\nexport function useContext<T = unsafe>(context: Context<T>): T | undefined {\n  return context.consume();\n}", "import { Collection } from '@discord-player/utils';\n\nexport const globalRegistry = new Collection<string, unknown>();", "import { globalRegistry } from './_container';\n\nexport function getGlobalRegistry() {\n  return globalRegistry;\n}", "import { Guild } from 'discord.js';\nimport { Player } from '../Player';\nimport { IllegalHookInvocationError } from '../errors';\nimport { createContext, useContext } from './context/async-context';\nimport { getGlobalRegistry } from '../utils/__internal__';\n\nexport interface HooksCtx {\n  guild: Guild;\n}\n\nexport const SUPER_CONTEXT = createContext<Player>();\n\nconst getFallbackContext = () => {\n  return getGlobalRegistry().get('@[player]') as Player | undefined;\n};\n\n/**\n * @private\n */\nexport function useHooksContext(hookName: string, mainOnly = false) {\n  let isFallback = false;\n\n  let player: Player | undefined;\n\n  if (!(player = SUPER_CONTEXT.consume())) {\n    player = getFallbackContext();\n    isFallback = true;\n  }\n\n  if (!player)\n  throw new IllegalHookInvocationError(\n    'discord-player',\n    `Player context is not available, ${\n    isFallback ?\n    'did you forget to initialize the player with `new Player(client)`?' :\n    'is it being called inside <Player>.context.provide()?'}`\n\n  );\n\n  if (mainOnly) return { player, context: {} as HooksCtx, isFallback };\n\n  let context: HooksCtx | undefined;\n\n  if (!isFallback) {\n    context = useContext(player.context);\n    if (!context)\n    throw new IllegalHookInvocationError(\n      hookName,\n      `${hookName} must be called inside a player context created by <Player>.context.provide()`\n    );\n  } else {\n    context = {\n      get guild() {\n        throw new IllegalHookInvocationError(\n          hookName,\n          `${hookName} must be called with an explicit guild argument when not inside a player context`\n        );\n      }\n    } as unknown as HooksCtx;\n  }\n\n  return { context, player, isFallback };\n}", "import { GuildQueueHistory, NodeResolvable } from '../queue';\nimport { useHooksContext } from './common';\n\n/**\n * Fetch guild queue history\n * @param node guild queue node resolvable\n */\nexport function useHistory<Meta = unknown>(): GuildQueueHistory<Meta> | null;\nexport function useHistory<Meta = unknown>(\nnode: NodeResolvable)\n: GuildQueueHistory<Meta> | null;\nexport function useHistory<Meta = unknown>(\nnode?: NodeResolvable)\n: GuildQueueHistory<Meta> | null {\n  const { context, player } = useHooksContext('useHistory');\n\n  const queue = player.queues.get<Meta>(node ?? context.guild.id);\n  if (!queue) return null;\n\n  return queue.history;\n}", "import { GuildQueuePlayerNode, NodeResolvable } from '../queue';\nimport { useHooksContext } from './common';\n\n/**\n * Fetch guild queue player node\n * @param node Guild queue node resolvable\n */\nexport function usePlayer<Meta = unknown>(): GuildQueuePlayerNode<Meta> | null;\nexport function usePlayer<Meta = unknown>(\nnode: NodeResolvable)\n: GuildQueuePlayerNode<Meta> | null;\nexport function usePlayer<Meta = unknown>(\nnode?: NodeResolvable)\n: GuildQueuePlayerNode<Meta> | null {\n  const { context, player } = useHooksContext('usePlayer');\n  const queue = player.queues.get<Meta>(node ?? context.guild.id);\n  if (!queue) return null;\n\n  return queue.node;\n}", "import { GuildQueue, NodeResolvable } from '../queue';\nimport { useHooksContext } from './common';\n\n/**\n * Fetch guild queue.\n * @param node Guild queue node resolvable. Defaults to inferred guild from context.\n */\nexport function useQueue<Meta = unknown>(): GuildQueue<Meta> | null;\nexport function useQueue<Meta = unknown>(\nnode: NodeResolvable)\n: GuildQueue<Meta> | null;\nexport function useQueue<Meta = unknown>(\nnode?: NodeResolvable)\n: GuildQueue<Meta> | null {\n  const { context, player } = useHooksContext('useQueue');\n  const queue = player.queues.resolve<Meta>(node ?? context.guild.id);\n  if (!queue) return null;\n\n  return queue;\n}", "import { useHooksContext } from './common';\n\n/**\n * Fetch main player instance\n */\nexport function useMainPlayer() {\n  const { player } = useHooksContext('useMainPlayer', true);\n\n  return player;\n}", "import { NodeResolvable } from '../queue';\nimport { TypeUtil } from '../utils/TypeUtil';\nimport { useHooksContext } from './common';\n\nexport type SetterFN<T, P> = (previous: P) => T;\nexport type MetadataDispatch<T> = readonly [\n  () => T,\n  (metadata: T | SetterFN<T, T>) => void];\n\n\n/**\n * Fetch or manipulate guild queue metadata\n * @param node Guild queue node resolvable\n */\nexport function useMetadata<T = unknown>(): MetadataDispatch<T>;\nexport function useMetadata<T = unknown>(\nnode: NodeResolvable)\n: MetadataDispatch<T>;\nexport function useMetadata<T = unknown>(\nnode?: NodeResolvable)\n: MetadataDispatch<T> {\n  const { context, player } = useHooksContext('useMetadata');\n  const queue = player.queues.get<T>(node ?? context.guild.id);\n  const setter = (metadata: T | SetterFN<T, T>) => {\n    if (queue) {\n      if (TypeUtil.isFunction(metadata))\n      return queue.setMetadata(metadata(queue.metadata));\n      return queue.setMetadata(metadata);\n    }\n  };\n\n  const getter = () => {\n    return queue?.metadata as T;\n  };\n\n  return [getter, setter] as const;\n}", "import { Track } from '../fabric';\nimport { NodeResolvable, PlayerTimestamp } from '../queue';\nimport { useHooksContext } from './common';\n\nexport interface TimelineDispatcherOptions {\n  ignoreFilters: boolean;\n  node: NodeResolvable;\n}\n\nexport interface GuildQueueTimeline {\n  readonly timestamp: PlayerTimestamp;\n  readonly volume: number;\n  readonly paused: boolean;\n  readonly track: Track<unknown> | null;\n  pause(): boolean;\n  resume(): boolean;\n  setVolume(vol: number): boolean;\n  setPosition(time: number): Promise<boolean>;\n}\n\n/**\n * Fetch or manipulate current track\n * @param options Options for timeline dispatcher\n */\nexport function useTimeline(): GuildQueueTimeline | null;\nexport function useTimeline(\noptions: Partial<TimelineDispatcherOptions>)\n: GuildQueueTimeline | null;\nexport function useTimeline(\noptions?: Partial<TimelineDispatcherOptions>)\n: GuildQueueTimeline | null {\n  const { context, player } = useHooksContext('useTimeline');\n  const queue = player.queues.get(options?.node ?? context.guild.id);\n  if (!queue) return null;\n\n  const timeline = Object.preventExtensions({\n    get timestamp() {\n      return queue.node.getTimestamp(options?.ignoreFilters)!;\n    },\n    get volume() {\n      return queue.node.volume;\n    },\n    get paused() {\n      return queue.node.isPaused();\n    },\n    get track() {\n      return queue.currentTrack;\n    },\n    pause() {\n      return queue.node.pause();\n    },\n    resume() {\n      return queue.node.resume();\n    },\n    setVolume(vol: number) {\n      return queue.node.setVolume(vol);\n    },\n    async setPosition(time: number) {\n      return queue.node.seek(time);\n    }\n  } satisfies GuildQueueTimeline);\n\n  return timeline;\n}", "import { OnAfterCreateStreamHandler } from '../../queue';\nimport { getGlobalRegistry } from '../../utils/__internal__';\n\n/**\n * Global onAfterCreateStream handler\n * @param handler The handler callback\n */\nexport function onAfterCreateStream(handler: OnAfterCreateStreamHandler) {\n  getGlobalRegistry().set('@[onAfterCreateStream]', handler);\n}", "import { OnBeforeCreateStreamHandler } from '../../queue';\nimport { getGlobalRegistry } from '../../utils/__internal__';\n\n/**\n * Global onBeforeCreateStream handler\n * @param handler The handler callback\n */\nexport function onBeforeCreateStream(handler: OnBeforeCreateStreamHandler) {\n  getGlobalRegistry().set('@[onBeforeCreateStream]', handler);\n}", "import { OnStreamExtractedHandler } from '../../queue';\nimport { getGlobalRegistry } from '../../utils/__internal__';\n\n/**\n * Global onStreamExtracted handler\n * @param handler The handler callback\n */\nexport function onStreamExtracted(handler: OnStreamExtractedHandler) {\n  getGlobalRegistry().set('@[onStreamExtracted]', handler);\n}", "import { NodeResolvable } from '../queue';\nimport { TypeUtil } from '../utils/TypeUtil';\nimport { useHooksContext } from './common';\n\ntype SetterFN = (previous: number) => number;\ntype VolumeDispatch = readonly [\n  () => number,\n  (volume: number | SetterFN) => boolean | undefined];\n\n\n/**\n * Fetch or manipulate player volume\n * @param node Guild queue node resolvable\n */\nexport function useVolume(): VolumeDispatch;\nexport function useVolume(node: NodeResolvable): VolumeDispatch;\nexport function useVolume(node?: NodeResolvable): VolumeDispatch {\n  const { context, player } = useHooksContext('useVolume');\n  const queue = player.queues.get(node ?? context.guild.id);\n  const setter = (volume: number | SetterFN) => {\n    if (queue) {\n      if (TypeUtil.isFunction(volume))\n      return queue.node.setVolume(volume(queue.node.volume));\n      return queue.node.setVolume(volume);\n    }\n  };\n\n  const getter = () => {\n    return queue?.node.volume as number;\n  };\n\n  return [getter, setter] as const;\n}", "import {\n  EqualizerBand,\n  PCMFilters,\n  BiquadFilters } from\n'@discord-player/equalizer';\nimport { Collection, QueueStrategy } from '@discord-player/utils';\nimport { GuildResolvable } from 'discord.js';\nimport { Player } from '../Player';\nimport {\n  GuildQueue,\n  OnAfterCreateStreamHandler,\n  OnBeforeCreateStreamHandler,\n  OnStreamExtractedHandler,\n  QueueRepeatMode } from\n'./GuildQueue';\nimport { getGlobalRegistry } from '../utils/__internal__';\nimport { NoGuildError, NoGuildQueueError } from '../errors';\nimport { FiltersName } from '../fabric';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface GuildNodeCreateOptions<T = any> {\n  strategy?: QueueStrategy;\n  volume?: number;\n  equalizer?: EqualizerBand[];\n  a_filter?: PCMFilters[];\n  biquad?: BiquadFilters;\n  resampler?: number;\n  disableHistory?: boolean;\n  onBeforeCreateStream?: OnBeforeCreateStreamHandler;\n  onAfterCreateStream?: OnAfterCreateStreamHandler;\n  onStreamExtracted?: OnStreamExtractedHandler;\n  repeatMode?: QueueRepeatMode;\n  pauseOnEmpty?: boolean;\n  leaveOnEmpty?: boolean;\n  leaveOnEmptyCooldown?: number;\n  leaveOnEnd?: boolean;\n  leaveOnEndCooldown?: number;\n  leaveOnStop?: boolean;\n  leaveOnStopCooldown?: number;\n  metadata?: T | null;\n  selfDeaf?: boolean;\n  connectionTimeout?: number;\n  defaultFFmpegFilters?: FiltersName[];\n  bufferingTimeout?: number;\n  noEmitInsert?: boolean;\n  maxSize?: number;\n  maxHistorySize?: number;\n  preferBridgedMetadata?: boolean;\n  disableVolume?: boolean;\n  disableEqualizer?: boolean;\n  disableFilterer?: boolean;\n  disableBiquad?: boolean;\n  disableResampler?: boolean;\n  disableCompressor?: boolean;\n  disableSeeker?: boolean;\n  disableReverb?: boolean;\n  disableFallbackStream?: boolean;\n  enableStreamInterceptor?: boolean;\n  verifyFallbackStream?: boolean;\n}\n\nexport type NodeResolvable = GuildQueue | GuildResolvable;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class GuildNodeManager<Meta = any> {\n  public cache = new Collection<string, GuildQueue>();\n  public constructor(public player: Player) {}\n\n  /**\n   * Create guild queue if it does not exist\n   * @param guild The guild which will be the owner of the queue\n   * @param options Queue initializer options\n   */\n  public create<T = Meta>(\n  guild: GuildResolvable,\n  options: GuildNodeCreateOptions<T> = {})\n  : GuildQueue<T> {\n    const server = this.player.client.guilds.resolve(guild);\n    if (!server) {\n      throw new NoGuildError('Invalid or unknown guild');\n    }\n\n    if (this.cache.has(server.id)) {\n      return this.cache.get(server.id) as GuildQueue<T>;\n    }\n\n    options.strategy ??= 'FIFO';\n    options.volume ??= 100;\n    options.equalizer ??= [];\n    options.a_filter ??= [];\n    options.disableHistory ??= false;\n    options.leaveOnEmpty ??= true;\n    options.leaveOnEmptyCooldown ??= 0;\n    options.leaveOnEnd ??= true;\n    options.leaveOnEndCooldown ??= 0;\n    options.leaveOnStop ??= true;\n    options.leaveOnStopCooldown ??= 0;\n    options.resampler ??= 48000;\n    options.selfDeaf ??= true;\n    options.connectionTimeout ??= this.player.options.connectionTimeout;\n    options.bufferingTimeout ??= 1000;\n    options.maxSize ??= Infinity;\n    options.maxHistorySize ??= Infinity;\n    options.preferBridgedMetadata ??= true;\n    options.pauseOnEmpty ??= true;\n\n    // todo(twlite): maybe disable these by default?\n    options.disableBiquad ??= false;\n    options.disableEqualizer ??= false;\n    options.disableFilterer ??= false;\n    options.disableVolume ??= false;\n    options.disableResampler ??= false;\n    options.disableCompressor ??= true;\n    options.disableSeeker ??= true;\n    options.disableReverb ??= true;\n\n    options.disableFallbackStream ??= false;\n    options.enableStreamInterceptor ??= false;\n    options.verifyFallbackStream ??= false;\n\n    if (\n    getGlobalRegistry().has('@[onStreamExtracted]') &&\n    !options.onStreamExtracted)\n    {\n      options.onStreamExtracted = getGlobalRegistry().get(\n        '@[onStreamExtracted]'\n      ) as OnStreamExtractedHandler;\n    }\n\n    if (\n    getGlobalRegistry().has('@[onBeforeCreateStream]') &&\n    !options.onBeforeCreateStream)\n    {\n      options.onBeforeCreateStream = getGlobalRegistry().get(\n        '@[onBeforeCreateStream]'\n      ) as OnBeforeCreateStreamHandler;\n    }\n\n    if (\n    getGlobalRegistry().has('@[onAfterCreateStream]') &&\n    !options.onAfterCreateStream)\n    {\n      options.onAfterCreateStream = getGlobalRegistry().get(\n        '@[onAfterCreateStream]'\n      ) as OnAfterCreateStreamHandler;\n    }\n\n    const queue = new GuildQueue<T>(this.player, {\n      guild: server,\n      queueStrategy: options.strategy,\n      volume: options.volume,\n      equalizer: options.equalizer,\n      filterer: options.a_filter,\n      biquad: options.biquad,\n      resampler: options.resampler,\n      disableHistory: options.disableHistory,\n      onBeforeCreateStream: options.onBeforeCreateStream,\n      onAfterCreateStream: options.onAfterCreateStream,\n      onStreamExtracted: options.onStreamExtracted,\n      repeatMode: options.repeatMode,\n      leaveOnEmpty: options.leaveOnEmpty,\n      leaveOnEmptyCooldown: options.leaveOnEmptyCooldown,\n      leaveOnEnd: options.leaveOnEnd,\n      leaveOnEndCooldown: options.leaveOnEndCooldown,\n      leaveOnStop: options.leaveOnStop,\n      leaveOnStopCooldown: options.leaveOnStopCooldown,\n      metadata: options.metadata,\n      connectionTimeout: options.connectionTimeout ?? 120_000,\n      selfDeaf: options.selfDeaf,\n      ffmpegFilters: options.defaultFFmpegFilters ?? [],\n      bufferingTimeout: options.bufferingTimeout,\n      noEmitInsert: options.noEmitInsert ?? false,\n      preferBridgedMetadata: options.preferBridgedMetadata,\n      maxHistorySize: options.maxHistorySize,\n      maxSize: options.maxSize,\n      pauseOnEmpty: options.pauseOnEmpty,\n      disableBiquad: options.disableBiquad,\n      disableEqualizer: options.disableEqualizer,\n      disableFilterer: options.disableFilterer,\n      disableResampler: options.disableResampler,\n      disableVolume: options.disableVolume,\n      disableFallbackStream: options.disableFallbackStream,\n      enableStreamInterceptor: options.enableStreamInterceptor,\n      verifyFallbackStream: options.verifyFallbackStream,\n      disableCompressor: options.disableCompressor,\n      disableSeeker: options.disableSeeker,\n      disableReverb: options.disableReverb\n    });\n\n    this.cache.set(server.id, queue);\n\n    return queue;\n  }\n\n  /**\n   * Get existing queue\n   * @param node Queue resolvable\n   */\n  public get<T = Meta>(node: NodeResolvable) {\n    const queue = this.resolve(node);\n    if (!queue) return null;\n\n    return this.cache.get(queue.id) as GuildQueue<T> || null;\n  }\n\n  /**\n   * Check if a queue exists\n   * @param node Queue resolvable\n   */\n  public has(node: NodeResolvable) {\n    const id =\n    node instanceof GuildQueue ?\n    node.id :\n    this.player.client.guilds.resolveId(node)!;\n    return this.cache.has(id);\n  }\n\n  /**\n   * Delete queue\n   * @param node Queue resolvable\n   */\n  public delete(node: NodeResolvable) {\n    const queue = this.resolve(node);\n    if (!queue) {\n      throw new NoGuildQueueError('Cannot delete non-existing queue');\n    }\n\n    queue.setTransitioning(true);\n    queue.node.stop(true);\n    // @ts-ignore\n    queue.connection?.removeAllListeners();\n    queue.dispatcher?.removeAllListeners();\n    queue.dispatcher?.disconnect();\n    queue.timeouts.forEach((tm) => clearTimeout(tm));\n    queue.history.clear();\n    queue.tracks.clear();\n\n    return this.cache.delete(queue.id);\n  }\n\n  /**\n   * Resolve queue\n   * @param node Queue resolvable\n   */\n  public resolve<T = Meta>(node: NodeResolvable): GuildQueue<T> | undefined {\n    if (node instanceof GuildQueue) {\n      return node as GuildQueue<T>;\n    }\n\n    return this.cache.get(\n      this.player.client.guilds.resolveId(node)!\n    ) as GuildQueue<T>;\n  }\n\n  /**\n   * Resolve queue id\n   * @param node Queue resolvable\n   */\n  public resolveId(node: NodeResolvable) {\n    const q = this.resolve(node);\n    return q?.id || null;\n  }\n}", "import { Player, PlayerNodeInitializerOptions, TrackLike } from '../Player';\nimport {\n  ChannelType,\n  Guild,\n  GuildVoiceChannelResolvable,\n  VoiceBasedChannel,\n  VoiceState } from\n'discord.js';\nimport { Collection, Queue, QueueStrategy } from '@discord-player/utils';\nimport {\n  BiquadFilters,\n  CommonResamplerFilterPreset,\n  CompressorParameters,\n  EqualizerBand,\n  PCMFilters,\n  ReverbParameters,\n  SeekerParameters } from\n'@discord-player/equalizer';\nimport { Track, TrackResolvable } from '../fabric/Track';\nimport { StreamDispatcher } from '../stream/StreamDispatcher';\nimport {\n  type AudioPlayer,\n  AudioResource,\n  StreamType,\n  VoiceConnection,\n  VoiceConnectionStatus } from\n'discord-voip';\nimport { Util, VALIDATE_QUEUE_CAP } from '../utils/Util';\nimport { Playlist } from '../fabric/Playlist';\nimport { GuildQueueHistory } from './GuildQueueHistory';\nimport { GuildQueuePlayerNode, StreamConfig } from './GuildQueuePlayerNode';\nimport { GuildQueueAudioFilters } from './GuildQueueAudioFilters';\nimport { Readable } from 'stream';\nimport { setTimeout } from 'timers';\nimport { GuildQueueStatistics } from './GuildQueueStatistics';\nimport { TypeUtil } from '../utils/TypeUtil';\nimport { AsyncQueue } from '../utils/AsyncQueue';\nimport {\n  InvalidArgTypeError,\n  NoVoiceChannelError,\n  NoVoiceConnectionError,\n  OutOfRangeError,\n  VoiceConnectionDestroyedError } from\n'../errors';\nimport { SyncedLyricsProvider } from './SyncedLyricsProvider';\nimport { LrcGetResult, LrcSearchResult } from '../lrclib/LrcLib';\nimport { FiltersName } from '../fabric';\nimport { SearchQueryType } from '../utils/QueryResolver';\nimport type { ExtractorStreamable } from '../extractors/BaseExtractor';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface GuildNodeInit<Meta = any> {\n  guild: Guild;\n  queueStrategy: QueueStrategy;\n  equalizer: EqualizerBand[] | boolean;\n  volume: number | boolean;\n  biquad: BiquadFilters | boolean | undefined;\n  resampler: number | boolean;\n  filterer: PCMFilters[] | boolean;\n  ffmpegFilters: FiltersName[];\n  disableHistory: boolean;\n  onBeforeCreateStream?: OnBeforeCreateStreamHandler;\n  onAfterCreateStream?: OnAfterCreateStreamHandler;\n  onStreamExtracted?: OnStreamExtractedHandler;\n  repeatMode?: QueueRepeatMode;\n  leaveOnEmpty: boolean;\n  leaveOnEmptyCooldown: number;\n  leaveOnEnd: boolean;\n  leaveOnEndCooldown: number;\n  leaveOnStop: boolean;\n  leaveOnStopCooldown: number;\n  connectionTimeout: number;\n  selfDeaf?: boolean;\n  metadata?: Meta | null;\n  bufferingTimeout: number;\n  noEmitInsert: boolean;\n  maxSize?: number;\n  maxHistorySize?: number;\n  preferBridgedMetadata: boolean;\n  pauseOnEmpty?: boolean;\n  disableVolume: boolean;\n  disableEqualizer: boolean;\n  disableFilterer: boolean;\n  disableBiquad: boolean;\n  disableResampler: boolean;\n  disableCompressor: boolean;\n  disableReverb: boolean;\n  disableSeeker: boolean;\n  disableFallbackStream: boolean;\n  enableStreamInterceptor: boolean;\n  verifyFallbackStream: boolean;\n}\n\nexport interface VoiceConnectConfig {\n  deaf?: boolean;\n  timeout?: number;\n  group?: string;\n  audioPlayer?: AudioPlayer;\n  daveEncryption?: boolean;\n  decryptionFailureTolerance?: number;\n}\n\nexport interface PostProcessedResult {\n  stream: Readable;\n  type: StreamType;\n}\n\nexport type OnBeforeCreateStreamHandler = (\ntrack: Track,\nqueryType: SearchQueryType,\nqueue: GuildQueue)\n=> Promise<Readable | null>;\n\nexport type OnStreamExtractedHandler = (\nstream: Readable | ExtractorStreamable | string,\ntrack: Track,\nqueue: GuildQueue)\n=> Promise<Readable | ExtractorStreamable | string>;\n\nexport type OnAfterCreateStreamHandler<T = unknown> = (\nstream: Readable,\nqueue: GuildQueue,\ntrack: Track<T>)\n=> Promise<PostProcessedResult | null>;\n\nexport type PlayerTriggeredReason = 'filters' | 'normal';\n\nexport const GuildQueueEvent = {\n  /**\n   * Emitted when audio track is added to the queue\n   */\n  AudioTrackAdd: 'audioTrackAdd',\n  /**\n   * Emitted when audio tracks were added to the queue\n   */\n  AudioTracksAdd: 'audioTracksAdd',\n  /**\n   * Emitted when audio track is removed from the queue\n   */\n  AudioTrackRemove: 'audioTrackRemove',\n  /**\n   * Emitted when audio tracks are removed from the queue\n   */\n  AudioTracksRemove: 'audioTracksRemove',\n  /**\n   * Emitted when a connection is created\n   */\n  Connection: 'connection',\n  /**\n   * Emitted when a voice connection is destroyed\n   */\n  ConnectionDestroyed: 'connectionDestroyed',\n  /**\n   * Emitted when the bot is disconnected from the channel\n   */\n  Disconnect: 'disconnect',\n  /**\n   * Emitted when the queue sends a debug info\n   */\n  Debug: 'debug',\n  /**\n   * Emitted when the queue encounters error\n   */\n  Error: 'error',\n  /**\n   * Emitted when the voice channel is empty\n   */\n  EmptyChannel: 'emptyChannel',\n  /**\n   * Emitted when the queue is empty\n   */\n  EmptyQueue: 'emptyQueue',\n  /**\n   * Emitted when the audio player starts streaming audio track\n   */\n  PlayerStart: 'playerStart',\n  /**\n   * Emitted when the audio player errors while streaming audio track\n   */\n  PlayerError: 'playerError',\n  /**\n   * Emitted when the audio player finishes streaming audio track\n   */\n  PlayerFinish: 'playerFinish',\n  /**\n   * Emitted when the audio player skips current track\n   */\n  PlayerSkip: 'playerSkip',\n  /**\n   * Emitted when the audio player is triggered\n   */\n  PlayerTrigger: 'playerTrigger',\n  /**\n   * Emitted when the voice state is updated. Consuming this event may disable default voice state update handler if `Player.isVoiceStateHandlerLocked()` returns `false`.\n   */\n  VoiceStateUpdate: 'voiceStateUpdate',\n  /**\n   * Emitted when volume is updated\n   */\n  VolumeChange: 'volumeChange',\n  /**\n   * Emitted when player is paused\n   */\n  PlayerPause: 'playerPause',\n  /**\n   * Emitted when player is resumed\n   */\n  PlayerResume: 'playerResume',\n  /**\n   * Biquad Filters Update\n   */\n  BiquadFiltersUpdate: 'biquadFiltersUpdate',\n  /**\n   * Equalizer Update\n   */\n  EqualizerUpdate: 'equalizerUpdate',\n  /**\n   * DSP update\n   */\n  DSPUpdate: 'dspUpdate',\n  /**\n   * Audio Filters Update\n   */\n  AudioFiltersUpdate: 'audioFiltersUpdate',\n  /**\n   * Audio player will play next track\n   */\n  WillPlayTrack: 'willPlayTrack',\n  /**\n   * Emitted when a voice channel is repopulated\n   */\n  ChannelPopulate: 'channelPopulate',\n  /**\n   * Emitted when a queue is successfully created\n   */\n  QueueCreate: 'queueCreate',\n  /**\n   * Emitted when a queue is deleted\n   */\n  QueueDelete: 'queueDelete',\n  /**\n   * Emitted when a queue is trying to add similar track for autoplay\n   */\n  WillAutoPlay: 'willAutoPlay',\n  /**\n   * Emitted when sample rate is updated\n   */\n  SampleRateUpdate: 'sampleRateUpdate',\n  /**\n   * Emitted when a named sample rate filter is updated\n   */\n  SampleRateFilterUpdate: 'sampleRateFilterUpdate',\n  /**\n   * Emitted when reverb filter is updated\n   */\n  ReverbUpdate: 'reverbUpdate',\n  /**\n   * Emitted when compressor filter is updated\n   */\n  CompressorUpdate: 'compressorUpdate',\n  /**\n   * Emitted when seek is performed\n   */\n  PlayerSeek: 'playerSeek'\n} as const;\n\nexport type GuildQueueEvent =\n(typeof GuildQueueEvent)[keyof typeof GuildQueueEvent];\n\nexport enum TrackSkipReason {\n  NoStream = 'ERR_NO_STREAM',\n  Manual = 'MANUAL',\n  SEEK_OVER_THRESHOLD = 'SEEK_OVER_THRESHOLD',\n  Jump = 'JUMPED_TO_ANOTHER_TRACK',\n  SkipTo = 'SKIP_TO_ANOTHER_TRACK',\n  HistoryNext = 'HISTORY_NEXT_TRACK',\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface GuildQueueEvents<Meta = any> {\n  /**\n   * Emitted when audio track is added to the queue\n   * @param queue The queue where this event occurred\n   * @param track The track\n   */\n  [GuildQueueEvent.AudioTrackAdd]: (\n  queue: GuildQueue<Meta>,\n  track: Track)\n  => unknown;\n  /**\n   * Emitted when audio tracks were added to the queue\n   * @param queue The queue where this event occurred\n   * @param tracks The tracks array\n   */\n  [GuildQueueEvent.AudioTracksAdd]: (\n  queue: GuildQueue<Meta>,\n  track: Track[])\n  => unknown;\n  /**\n   * Emitted when audio track is removed from the queue\n   * @param queue The queue where this event occurred\n   * @param track The track\n   */\n  [GuildQueueEvent.AudioTrackRemove]: (\n  queue: GuildQueue<Meta>,\n  track: Track)\n  => unknown;\n  /**\n   * Emitted when audio tracks are removed from the queue\n   * @param queue The queue where this event occurred\n   * @param track The track\n   */\n  [GuildQueueEvent.AudioTracksRemove]: (\n  queue: GuildQueue<Meta>,\n  track: Track[])\n  => unknown;\n  /**\n   * Emitted when a connection is created\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.Connection]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when a connection is destroyed\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.ConnectionDestroyed]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when the bot is disconnected from the channel\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.Disconnect]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when the queue sends a debug info\n   * @param queue The queue where this event occurred\n   * @param message The debug message\n   */\n  [GuildQueueEvent.Debug]: (\n  queue: GuildQueue<Meta>,\n  message: string)\n  => unknown;\n  /**\n   * Emitted when the queue encounters error\n   * @param queue The queue where this event occurred\n   * @param error The error\n   */\n  [GuildQueueEvent.Error]: (queue: GuildQueue<Meta>, error: Error) => unknown;\n  /**\n   * Emitted when the voice channel is empty\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.EmptyChannel]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when the queue is empty\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.EmptyQueue]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when the audio player starts streaming audio track\n   * @param queue The queue where this event occurred\n   * @param track The track that is being streamed\n   */\n  [GuildQueueEvent.PlayerStart]: (\n  queue: GuildQueue<Meta>,\n  track: Track)\n  => unknown;\n  /**\n   * Emitted when the audio player errors while streaming audio track\n   * @param queue The queue where this event occurred\n   * @param error The error\n   * @param track The track that is being streamed\n   */\n  [GuildQueueEvent.PlayerError]: (\n  queue: GuildQueue<Meta>,\n  error: Error,\n  track: Track)\n  => unknown;\n  /**\n   * Emitted when the audio player finishes streaming audio track\n   * @param queue The queue where this event occurred\n   * @param track The track that was being streamed\n   */\n  [GuildQueueEvent.PlayerFinish]: (\n  queue: GuildQueue<Meta>,\n  track: Track)\n  => unknown;\n  /**\n   * Emitted when the audio player skips current track\n   * @param queue The queue where this event occurred\n   * @param track The track that was skipped\n   * @param reason The reason for skipping\n   * @param description The description for skipping\n   */\n  [GuildQueueEvent.PlayerSkip]: (\n  queue: GuildQueue<Meta>,\n  track: Track,\n  reason: TrackSkipReason,\n  description: string)\n  => unknown;\n  /**\n   * Emitted when the audio player is triggered\n   * @param queue The queue where this event occurred\n   * @param track The track which was played in this event\n   */\n  [GuildQueueEvent.PlayerTrigger]: (\n  queue: GuildQueue<Meta>,\n  track: Track,\n  reason: PlayerTriggeredReason)\n  => unknown;\n  /**\n   * Emitted when the voice state is updated. Consuming this event may disable default voice state update handler if `Player.isVoiceStateHandlerLocked()` returns `false`.\n   * @param queue The queue where this event occurred\n   * @param oldState The old voice state\n   * @param newState The new voice state\n   */\n  [GuildQueueEvent.VoiceStateUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldState: VoiceState,\n  newState: VoiceState)\n  => unknown;\n  /**\n   * Emitted when audio player is paused\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.PlayerPause]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when audio player is resumed\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.PlayerResume]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when audio player's volume is changed\n   * @param queue The queue where this event occurred\n   * @param oldVolume The old volume\n   * @param newVolume The updated volume\n   */\n  [GuildQueueEvent.VolumeChange]: (\n  queue: GuildQueue<Meta>,\n  oldVolume: number,\n  newVolume: number)\n  => unknown;\n  /**\n   * Emitted when equalizer config is updated\n   * @param queue The queue where this event occurred\n   * @param oldFilters Old filters\n   * @param newFilters New filters\n   */\n  [GuildQueueEvent.EqualizerUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldFilters: EqualizerBand[],\n  newFilters: EqualizerBand[])\n  => unknown;\n  /**\n   * Emitted when biquad filters is updated\n   * @param queue The queue where this event occurred\n   * @param oldFilters Old filters\n   * @param newFilters New filters\n   */\n  [GuildQueueEvent.BiquadFiltersUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldFilters: BiquadFilters | null,\n  newFilters: BiquadFilters | null)\n  => unknown;\n  /**\n   * Emitted when dsp filters is updated\n   * @param queue The queue where this event occurred\n   * @param oldFilters Old filters\n   * @param newFilters New filters\n   */\n  [GuildQueueEvent.DSPUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldFilters: PCMFilters[],\n  newFilters: PCMFilters[])\n  => unknown;\n  /**\n   * Emitted when ffmpeg audio filters is updated\n   * @param queue The queue where this event occurred\n   * @param oldFilters Old filters\n   * @param newFilters New filters\n   */\n  [GuildQueueEvent.AudioFiltersUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldFilters: FiltersName[],\n  newFilters: FiltersName[])\n  => unknown;\n\n  /**\n   * Emitted before streaming an audio track. This event can be used to modify stream config before playing a track.\n   * Listening to this event will pause the execution of audio player until `done()` is invoked.\n   * @param queue The queue where this event occurred\n   * @param track The track that will be streamed\n   * @param config Configurations for streaming\n   * @param done Done callback\n   */\n  [GuildQueueEvent.WillPlayTrack]: (\n  queue: GuildQueue<Meta>,\n  track: Track<unknown>,\n  config: StreamConfig,\n  done: () => void)\n  => unknown;\n  /**\n   * Emitted when a voice channel is populated\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.ChannelPopulate]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when a queue is successfully created\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.QueueCreate]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when a queue is successfully deleted\n   * @param queue The queue where this event occurred\n   */\n  [GuildQueueEvent.QueueDelete]: (queue: GuildQueue<Meta>) => unknown;\n  /**\n   * Emitted when a queue is trying to add similar track for autoplay\n   * @param queue The queue where this event occurred\n   * @param tracks The similar tracks that were found\n   * @param done Done callback\n   */\n  [GuildQueueEvent.WillAutoPlay]: (\n  queue: GuildQueue<Meta>,\n  tracks: Track[],\n  done: (track: Track | null) => void)\n  => unknown;\n  /**\n   * Emitted when sample rate is updated\n   * @param queue The queue where this event occurred\n   * @param oldRate The old sample rate\n   * @param newRate The new sample rate\n   */\n  [GuildQueueEvent.SampleRateUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldRate: number,\n  newRate: number)\n  => unknown;\n  /**\n   * Emitted when a named sample rate filter is updated\n   * @param queue The queue where this event occurred\n   * @param oldRate The old sample rate filter\n   * @param newRate The new sample rate filter\n   */\n  [GuildQueueEvent.SampleRateFilterUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldFilter: CommonResamplerFilterPreset | null,\n  newFilter: CommonResamplerFilterPreset | null)\n  => unknown;\n  /**\n   * Emitted when reverb filter is updated\n   * @param queue The queue where this event occurred\n   * @param oldFilter The old reverb filter\n   * @param newFilter The new reverb filter\n   */\n  [GuildQueueEvent.ReverbUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldFilter: ReverbParameters | null,\n  newFilter: ReverbParameters | null)\n  => unknown;\n  /**\n   * Emitted when compressor filter is updated\n   * @param queue The queue where this event occurred\n   * @param oldFilter The old compressor filter\n   * @param newFilter The new compressor filter\n   */\n  [GuildQueueEvent.CompressorUpdate]: (\n  queue: GuildQueue<Meta>,\n  oldFilter: CompressorParameters | null,\n  newFilter: CompressorParameters | null)\n  => unknown;\n  /**\n   * Emitted when seek is performed\n   * @param queue The queue where this event occurred\n   * @param position The seek position\n   */\n  [GuildQueueEvent.PlayerSeek]: (\n  queue: GuildQueue<Meta>,\n  parameters: SeekerParameters)\n  => unknown;\n}\n\n/**\n * The queue repeat mode. This can be one of:\n * - OFF\n * - TRACK\n * - QUEUE\n * - AUTOPLAY\n */\nexport const QueueRepeatMode = {\n  /**\n   * Disable repeat mode.\n   */\n  OFF: 0,\n  /**\n   * Repeat the current track.\n   */\n  TRACK: 1,\n  /**\n   * Repeat the entire queue.\n   */\n  QUEUE: 2,\n  /**\n   * When last track ends, play similar tracks in the future if queue is empty.\n   */\n  AUTOPLAY: 3\n} as const;\n\nexport type QueueRepeatMode =\n(typeof QueueRepeatMode)[keyof typeof QueueRepeatMode];\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class GuildQueue<Meta = any> {\n  #transitioning = false;\n  #deleted = false;\n  #shuffle = false;\n  private __current: Track | null = null;\n  public tracks: Queue<Track>;\n  public history = new GuildQueueHistory<Meta>(this);\n  public dispatcher: StreamDispatcher | null = null;\n  public node = new GuildQueuePlayerNode<Meta>(this);\n  public filters = new GuildQueueAudioFilters<Meta>(this);\n  public onBeforeCreateStream: OnBeforeCreateStreamHandler = async () => null;\n  public onAfterCreateStream: OnAfterCreateStreamHandler = async (stream) => ({\n    stream,\n    type: StreamType.Raw\n  });\n  public onStreamExtracted: OnStreamExtractedHandler = async (stream) => stream;\n  public repeatMode: QueueRepeatMode = QueueRepeatMode.OFF;\n  public timeouts = new Collection<string, NodeJS.Timeout>();\n  public stats = new GuildQueueStatistics<Meta>(this);\n  public tasksQueue = new AsyncQueue();\n  public syncedLyricsProvider = new SyncedLyricsProvider(this);\n\n  public constructor(\n  public player: Player,\n  public options: GuildNodeInit<Meta>)\n  {\n    this.tracks = new Queue<Track>(options.queueStrategy);\n    if (TypeUtil.isFunction(options.onBeforeCreateStream))\n    this.onBeforeCreateStream = options.onBeforeCreateStream;\n    if (TypeUtil.isFunction(options.onAfterCreateStream))\n    this.onAfterCreateStream = options.onAfterCreateStream;\n    if (TypeUtil.isFunction(options.onStreamExtracted))\n    this.onStreamExtracted = options.onStreamExtracted;\n    if (!TypeUtil.isNullish(options.repeatMode))\n    this.repeatMode = options.repeatMode;\n\n    options.selfDeaf ??= true;\n    options.maxSize ??= Infinity;\n    options.maxHistorySize ??= Infinity;\n    options.pauseOnEmpty ??= true;\n\n    if (\n    !TypeUtil.isNullish(this.options.biquad) &&\n    !TypeUtil.isBoolean(this.options.biquad))\n    {\n      this.filters._lastFiltersCache.biquad = this.options.biquad;\n    }\n\n    if (Array.isArray(this.options.equalizer)) {\n      this.filters._lastFiltersCache.equalizer = this.options.equalizer;\n    }\n\n    if (Array.isArray(this.options.filterer)) {\n      this.filters._lastFiltersCache.filters = this.options.filterer;\n    }\n\n    if (TypeUtil.isNumber(this.options.resampler)) {\n      this.filters._lastFiltersCache.sampleRate = this.options.resampler;\n    }\n\n    if (TypeUtil.isArray(this.options.ffmpegFilters)) {\n      this.filters.ffmpeg.setDefaults(this.options.ffmpegFilters);\n    }\n\n    if (!TypeUtil.isNumber(options.maxSize)) {\n      throw new InvalidArgTypeError(\n        '[GuildNodeInit.maxSize]',\n        'number',\n        typeof options.maxSize\n      );\n    }\n\n    if (!TypeUtil.isNumber(options.maxHistorySize)) {\n      throw new InvalidArgTypeError(\n        '[GuildNodeInit.maxHistorySize]',\n        'number',\n        typeof options.maxHistorySize\n      );\n    }\n\n    if (options.maxSize < 1) options.maxSize = Infinity;\n    if (options.maxHistorySize < 1) options.maxHistorySize = Infinity;\n\n    if (this.hasDebugger)\n    this.debug(\n      `GuildQueue initialized for guild ${this.options.guild.name} (ID: ${this.options.guild.id})`\n    );\n    this.emit(GuildQueueEvent.QueueCreate, this);\n  }\n\n  /**\n   * Whether this queue can intercept streams\n   */\n  public canIntercept() {\n    return this.options.enableStreamInterceptor;\n  }\n\n  /**\n   * Estimated duration of this queue in ms\n   */\n  public get estimatedDuration() {\n    return this.tracks.store.reduce((a, c) => a + c.durationMS, 0);\n  }\n\n  /**\n   * Formatted duration of this queue\n   */\n  public get durationFormatted() {\n    return Util.buildTimeCode(Util.parseMS(this.estimatedDuration));\n  }\n\n  /**\n   * The sync lyrics provider for this queue.\n   * @example const lyrics = await player.lyrics.search({ q: 'Alan Walker Faded' });\n   * const syncedLyrics = queue.syncedLyrics(lyrics[0]);\n   * console.log(syncedLyrics.at(10_000));\n   * // subscribe to lyrics change\n   * const unsubscribe = syncedLyrics.onChange((lyrics, timestamp) => {\n   *    console.log(lyrics, timestamp);\n   * });\n   * // unsubscribe from lyrics change\n   * unsubscribe(); // or\n   * syncedLyrics.unsubscribe();\n   */\n  public syncedLyrics(lyrics: LrcGetResult | LrcSearchResult) {\n    this.syncedLyricsProvider.load(lyrics?.syncedLyrics ?? '');\n    return this.syncedLyricsProvider;\n  }\n\n  /**\n   * Write a debug message to this queue\n   * @param m The message to write\n   */\n  public debug(m: string) {\n    this.emit(GuildQueueEvent.Debug, this, m);\n  }\n\n  /**\n   * The metadata of this queue\n   */\n  public get metadata() {\n    return this.options.metadata!;\n  }\n\n  public set metadata(m: Meta) {\n    this.options.metadata = m;\n  }\n\n  /**\n   * Set metadata for this queue\n   * @param m Metadata to set\n   */\n  public setMetadata(m: Meta) {\n    this.options.metadata = m;\n  }\n\n  /**\n   * Indicates current track of this queue\n   */\n  public get currentTrack() {\n    return this.dispatcher?.audioResource?.metadata || this.__current;\n  }\n\n  /**\n   * Indicates if this queue was deleted previously\n   */\n  public get deleted() {\n    return this.#deleted;\n  }\n\n  /**\n   * The voice channel of this queue\n   */\n  public get channel() {\n    return this.dispatcher?.channel || null;\n  }\n\n  public set channel(c: VoiceBasedChannel | null) {\n    if (this.dispatcher) {\n      if (c) {\n        this.dispatcher.channel = c;\n      } else {\n        this.delete();\n      }\n    }\n  }\n\n  /**\n   * The voice connection of this queue\n   */\n  public get connection() {\n    return this.dispatcher?.voiceConnection || null;\n  }\n\n  /**\n   * The guild this queue belongs to\n   */\n  public get guild() {\n    return this.options.guild;\n  }\n\n  /**\n   * The id of this queue\n   */\n  public get id() {\n    return this.guild.id;\n  }\n\n  /**\n   * Set transition mode for this queue\n   * @param state The state to set\n   */\n  public setTransitioning(state: boolean) {\n    this.#transitioning = state;\n  }\n\n  /**\n   * if this queue is currently under transition mode\n   */\n  public isTransitioning() {\n    return this.#transitioning;\n  }\n\n  /**\n   * Set repeat mode for this queue\n   * @param mode The repeat mode to apply\n   */\n  public setRepeatMode(mode: QueueRepeatMode) {\n    this.repeatMode = mode;\n  }\n\n  /**\n   * Max size of this queue\n   */\n  public get maxSize() {\n    return this.options.maxSize ?? Infinity;\n  }\n\n  /**\n   * Max size of this queue\n   */\n  public getMaxSize() {\n    return this.maxSize;\n  }\n\n  /**\n   * Gets the size of the queue\n   */\n  public get size() {\n    return this.tracks.size;\n  }\n\n  /**\n   * The size of this queue\n   */\n  public getSize() {\n    return this.size;\n  }\n\n  /**\n   * Max history size of this queue\n   */\n  public get maxHistorySize() {\n    return this.options.maxHistorySize ?? Infinity;\n  }\n\n  /**\n   * Max history size of this queue\n   */\n  public getMaxHistorySize() {\n    return this.maxHistorySize;\n  }\n\n  /**\n   * Set max history size for this queue\n   * @param size The size to set\n   */\n  public setMaxHistorySize(size: number) {\n    if (!TypeUtil.isNumber(size)) {\n      throw new InvalidArgTypeError('size', 'number', typeof size);\n    }\n\n    if (size < 1) size = Infinity;\n\n    this.options.maxHistorySize = size;\n  }\n\n  /**\n   * Set max size for this queue\n   * @param size The size to set\n   */\n  public setMaxSize(size: number) {\n    if (!TypeUtil.isNumber(size)) {\n      throw new InvalidArgTypeError('size', 'number', typeof size);\n    }\n\n    if (size < 1) size = Infinity;\n\n    this.options.maxSize = size;\n  }\n\n  /**\n   * Clear this queue\n   */\n  public clear() {\n    this.tracks.clear();\n    this.history.clear();\n  }\n\n  /**\n   * Check if this queue has no tracks left in it\n   */\n  public isEmpty() {\n    return this.tracks.size < 1;\n  }\n\n  /**\n   * Check if this queue is full\n   */\n  public isFull() {\n    return this.tracks.size >= this.maxSize;\n  }\n\n  /**\n   * Get queue capacity\n   */\n  public getCapacity() {\n    if (this.isFull()) return 0;\n    const cap = this.maxSize - this.size;\n    return cap;\n  }\n\n  /**\n   * Check if this queue currently holds active audio resource\n   */\n  public isPlaying() {\n    return (\n      this.dispatcher?.audioResource != null &&\n      !this.dispatcher.audioResource.ended);\n\n  }\n\n  /**\n   * Add track to the queue. This will emit `audioTracksAdd` when multiple tracks are added, otherwise `audioTrackAdd`.\n   * @param track Track or playlist or array of tracks to add\n   */\n  public addTrack(track: Track | Track[] | Playlist) {\n    const toAdd = track instanceof Playlist ? track.tracks : track;\n    const isMulti = Array.isArray(toAdd);\n\n    VALIDATE_QUEUE_CAP(this, toAdd);\n\n    this.tracks.add(toAdd);\n\n    if (isMulti) {\n      this.emit(GuildQueueEvent.AudioTracksAdd, this, toAdd);\n    } else {\n      this.emit(GuildQueueEvent.AudioTrackAdd, this, toAdd);\n    }\n  }\n\n  /**\n   * Remove a track from queue\n   * @param track The track to remove\n   */\n  public removeTrack(track: TrackResolvable) {\n    return this.node.remove(track);\n  }\n\n  /**\n   * Prepends a track or track resolvable to the queue\n   * @param track The track resolvable to insert\n   * @param index The index to insert the track at (defaults to 0). If > 0, the inserted track will be placed before the track at the given index.\n   */\n  public prepend(track: Track | Queue<Track> | Array<Track>, index = 0): void {\n    if (index < 0 || index > this.tracks.size) {\n      throw new OutOfRangeError(\n        'index',\n        `${index}`,\n        '0',\n        `${this.tracks.size}`\n      );\n    }\n\n    const count = Array.isArray(track) ?\n    track.length :\n    track instanceof Queue ?\n    track.size :\n    1;\n\n    VALIDATE_QUEUE_CAP(this, count);\n\n    const insertionIndex = index === 0 ? 0 : index - 1;\n\n    if (track instanceof Track) {\n      this.node.insert(track, insertionIndex);\n      this.emit(GuildQueueEvent.AudioTrackAdd, this, track);\n      return;\n    }\n\n    const tracks = track instanceof Queue ? track.store : track;\n\n    this.tracks.store.splice(insertionIndex, 0, ...tracks);\n\n    if (!this.options.noEmitInsert) {\n      this.emit(GuildQueueEvent.AudioTracksAdd, this, tracks);\n    }\n  }\n\n  /**\n   * Appends a track or track resolvable to the queue\n   * @param track The track resolvable to insert\n   * @param index The index to insert the track at (defaults to 0). If > 0, the inserted track will be placed after the track at the given index.\n   */\n  public append(track: Track | Queue<Track> | Array<Track>, index = 0): void {\n    if (index < 0 || index > this.tracks.size) {\n      throw new OutOfRangeError(\n        'index',\n        `${index}`,\n        '0',\n        `${this.tracks.size}`\n      );\n    }\n\n    const count = Array.isArray(track) ?\n    track.length :\n    track instanceof Queue ?\n    track.size :\n    1;\n\n    VALIDATE_QUEUE_CAP(this, count);\n\n    if (track instanceof Track) {\n      this.node.insert(track, index);\n      this.emit(GuildQueueEvent.AudioTrackAdd, this, track);\n      return;\n    }\n\n    const tracks = track instanceof Queue ? track.store : track;\n\n    this.tracks.store.splice(index, 0, ...tracks);\n\n    if (!this.options.noEmitInsert) {\n      this.emit(GuildQueueEvent.AudioTracksAdd, this, tracks);\n    }\n  }\n\n  /**\n   * Inserts the track to the given index\n   * @param track The track to insert\n   * @param index The index to insert the track at (defaults to 0)\n   */\n  public insertTrack(track: Track, index = 0): void {\n    return this.node.insert(track, index);\n  }\n\n  /**\n   * Moves a track in the queue\n   * @param from The track to move\n   * @param to The position to move to\n   */\n  public moveTrack(track: TrackResolvable, index = 0): void {\n    return this.node.move(track, index);\n  }\n\n  /**\n   * Copy a track in the queue\n   * @param from The track to clone\n   * @param to The position to clone at\n   */\n  public copyTrack(track: TrackResolvable, index = 0): void {\n    return this.node.copy(track, index);\n  }\n\n  /**\n   * Swap two tracks in the queue\n   * @param src The first track to swap\n   * @param dest The second track to swap\n   */\n  public swapTracks(src: TrackResolvable, dest: TrackResolvable): void {\n    return this.node.swap(src, dest);\n  }\n\n  /**\n   * Create stream dispatcher from the given connection\n   * @param connection The connection to use\n   */\n  public createDispatcher(\n  connection: VoiceConnection,\n  options: Pick<VoiceConnectConfig, 'audioPlayer' | 'timeout'> = {})\n  {\n    if (connection.state.status === VoiceConnectionStatus.Destroyed) {\n      throw new VoiceConnectionDestroyedError();\n    }\n\n    const channel = this.player.client.channels.cache.get(\n      connection.joinConfig.channelId!\n    );\n    if (!channel) throw new NoVoiceChannelError();\n    if (!channel.isVoiceBased())\n    throw new InvalidArgTypeError(\n      'channel',\n      `VoiceBasedChannel (type ${ChannelType.GuildVoice}/${ChannelType.GuildStageVoice})`,\n      String(channel?.type)\n    );\n\n    if (this.dispatcher) {\n      this.#removeListeners(this.dispatcher);\n      this.dispatcher.destroy();\n      this.dispatcher = null;\n    }\n\n    this.dispatcher = new StreamDispatcher(\n      connection,\n      channel,\n      this,\n      options.timeout ?? this.options.connectionTimeout,\n      options.audioPlayer\n    );\n  }\n\n  /**\n   * Connect to a voice channel\n   * @param channelResolvable The voice channel to connect to\n   * @param options Join config\n   */\n  public async connect(\n  channelResolvable: GuildVoiceChannelResolvable,\n  options: VoiceConnectConfig = {})\n  {\n    const channel = this.player.client.channels.resolve(channelResolvable);\n    if (!channel || !channel.isVoiceBased()) {\n      throw new InvalidArgTypeError(\n        'channel',\n        `VoiceBasedChannel (type ${ChannelType.GuildVoice}/${ChannelType.GuildStageVoice})`,\n        String(channel?.type)\n      );\n    }\n\n    if (this.hasDebugger)\n    this.debug(\n      `Connecting to ${\n      channel.type === ChannelType.GuildStageVoice ? 'stage' : 'voice'} channel ${\n      channel.name} (ID: ${channel.id})`\n    );\n\n    if (this.dispatcher && channel.id !== this.dispatcher.channel.id) {\n      if (this.hasDebugger) this.debug('Destroying old connection');\n      this.#removeListeners(this.dispatcher);\n      this.dispatcher.destroy();\n      this.dispatcher = null;\n    }\n\n    this.dispatcher = await this.player.voiceUtils.connect(channel, {\n      deaf: options.deaf ?? this.options.selfDeaf ?? true,\n      maxTime: options?.timeout ?? this.options.connectionTimeout ?? 120_000,\n      queue: this,\n      audioPlayer: options?.audioPlayer,\n      group: options.group ?? this.player.client.user?.id,\n      daveEncryption: options.daveEncryption,\n      decryptionFailureTolerance: options.decryptionFailureTolerance\n    });\n\n    this.emit(GuildQueueEvent.Connection, this);\n\n    if (this.channel!.type === ChannelType.GuildStageVoice) {\n      await this.channel!.guild.members.me!.voice.setSuppressed(false).catch(\n        async () => {\n          return await this.channel!.guild.members.me!.voice.setRequestToSpeak(\n            true\n          ).catch(Util.noop);\n        }\n      );\n    }\n\n    this.#attachListeners(this.dispatcher);\n\n    return this;\n  }\n\n  /**\n   * Enable shuffle mode for this queue\n   * @param dynamic Whether to shuffle the queue dynamically. Defaults to `true`.\n   * Dynamic shuffling will shuffle the queue when the current track ends, without mutating the queue.\n   * If set to `false`, the queue will be shuffled immediately in-place, which cannot be undone.\n   */\n  public enableShuffle(dynamic = true) {\n    if (!dynamic) {\n      this.tracks.shuffle();\n      return true;\n    }\n\n    this.#shuffle = true;\n    return true;\n  }\n\n  /**\n   * Disable shuffle mode for this queue.\n   */\n  public disableShuffle() {\n    this.#shuffle = false;\n    return true;\n  }\n\n  /**\n   * Toggle shuffle mode for this queue.\n   * @param dynamic Whether to shuffle the queue dynamically. Defaults to `true`.\n   * @returns Whether shuffle is enabled or disabled.\n   */\n  public toggleShuffle(dynamic = true) {\n    if (dynamic) {\n      this.#shuffle = !this.#shuffle;\n      return this.#shuffle;\n    } else {\n      this.tracks.shuffle();\n      return true;\n    }\n  }\n\n  /**\n   * Whether shuffle mode is enabled for this queue.\n   */\n  public get isShuffling() {\n    return this.#shuffle;\n  }\n\n  /**\n   * The voice connection latency of this queue\n   */\n  public get ping() {\n    return this.connection?.ping.udp ?? -1;\n  }\n\n  /**\n   * Delete this queue\n   */\n  public delete() {\n    if (this.player.nodes.delete(this.id)) {\n      this.#deleted = true;\n      this.player.events.emit(GuildQueueEvent.QueueDelete, this);\n      this.node.tasksQueue.cancelAll();\n      this.tasksQueue.cancelAll();\n    }\n  }\n\n  /**\n   * Revives this queue\n   * @returns\n   */\n  public revive() {\n    if (!this.deleted || this.player.nodes.has(this.id)) return;\n    this.#deleted = false;\n    this.setTransitioning(false);\n    this.player.nodes.cache.set(this.id, this);\n    this.player.events.emit(GuildQueueEvent.QueueCreate, this);\n  }\n\n  /**\n   * Set self deaf\n   * @param mode On/Off state\n   * @param reason Reason\n   */\n  public setSelfDeaf(mode?: boolean, reason?: string) {\n    return this.guild.members.me!.voice.setDeaf(mode, reason);\n  }\n\n  /**\n   * Set self mute\n   * @param mode On/Off state\n   * @param reason Reason\n   */\n  public setSelfMute(mode?: boolean, reason?: string) {\n    return this.guild.members.me!.voice.setMute(mode, reason);\n  }\n\n  /**\n   * Play a track in this queue\n   * @param track The track to be played\n   * @param options Player node initialization options\n   */\n  public async play(\n  track: TrackLike,\n  options?: PlayerNodeInitializerOptions<Meta>)\n  {\n    if (!this.channel) throw new NoVoiceConnectionError();\n\n    return this.player.play(this.channel, track, options);\n  }\n\n  /**\n   * Emit an event on this queue\n   * @param event The event to emit\n   * @param args The args for the event\n   */\n  public emit<K extends keyof GuildQueueEvents<Meta>>(\n  event: K,\n  ...args: Parameters<GuildQueueEvents<Meta>[K]>)\n  : boolean {\n    if (this.deleted) return false;\n    return this.player.events.emit(event, ...args);\n  }\n\n  #attachListeners(dispatcher: StreamDispatcher) {\n    dispatcher.on('error', (e) => this.emit(GuildQueueEvent.Error, this, e));\n    dispatcher.on(\n      'debug',\n      (m) => this.hasDebugger && this.emit(GuildQueueEvent.Debug, this, m)\n    );\n    dispatcher.on('finish', (r) => this.#performFinish(r));\n    dispatcher.on('start', (r) => this.#performStart(r));\n    dispatcher.on('destroyed', () => {\n      this.#removeListeners(dispatcher);\n      this.dispatcher = null;\n    });\n    dispatcher.on('dsp', (f) => {\n      if (!Object.is(this.filters._lastFiltersCache.filters, f)) {\n        this.emit(\n          GuildQueueEvent.DSPUpdate,\n          this,\n          this.filters._lastFiltersCache.filters,\n          f\n        );\n      }\n      this.filters._lastFiltersCache.filters = f;\n    });\n    dispatcher.on('biquad', (f) => {\n      if (this.filters._lastFiltersCache.biquad !== f) {\n        this.emit(\n          GuildQueueEvent.BiquadFiltersUpdate,\n          this,\n          this.filters._lastFiltersCache.biquad,\n          f\n        );\n      }\n      this.filters._lastFiltersCache.biquad = f;\n    });\n    dispatcher.on('eqBands', (f) => {\n      if (!Object.is(f, this.filters._lastFiltersCache.equalizer)) {\n        this.emit(\n          GuildQueueEvent.EqualizerUpdate,\n          this,\n          this.filters._lastFiltersCache.equalizer,\n          f\n        );\n      }\n      this.filters._lastFiltersCache.equalizer = f;\n    });\n    dispatcher.on('volume', (f) => {\n      if (this.filters._lastFiltersCache.volume !== f)\n      this.emit(\n        GuildQueueEvent.VolumeChange,\n        this,\n        this.filters._lastFiltersCache.volume,\n        f\n      );\n      this.filters._lastFiltersCache.volume = f;\n    });\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const areObjectsDifferent = (a: any, b: any) => {\n      if (!a && !b) return false;\n      if (!a || !b) return true;\n      if (Object.keys(a).length !== Object.keys(b).length) return true;\n      return Object.keys(a).some((k) => a[k] !== b[k]);\n    };\n\n    dispatcher.on('sampleRate', (f) => {\n      if (this.filters._lastFiltersCache.sampleRate !== f.sampleRate) {\n        this.emit(\n          GuildQueueEvent.SampleRateUpdate,\n          this,\n          this.filters._lastFiltersCache.sampleRate,\n          f.sampleRate\n        );\n\n        this.filters._lastFiltersCache.sampleRate = f.sampleRate;\n\n        this.filters.seeker?.setSampleRate(f.sampleRate);\n        this.filters.seeker?.setTotalDuration(this.node.estimatedDuration);\n      }\n\n      if (f.currentFilter !== this.filters._lastFiltersCache.sampleRateFilter) {\n        this.emit(\n          GuildQueueEvent.SampleRateFilterUpdate,\n          this,\n          this.filters._lastFiltersCache.sampleRateFilter ?? null,\n          f.currentFilter\n        );\n        this.filters._lastFiltersCache.sampleRateFilter = f.currentFilter;\n      }\n    });\n    dispatcher.on('reverb', (f) => {\n      if (areObjectsDifferent(f, this.filters._lastFiltersCache.reverb)) {\n        this.emit(\n          GuildQueueEvent.ReverbUpdate,\n          this,\n          this.filters._lastFiltersCache.reverb ?? null,\n          f\n        );\n        this.filters._lastFiltersCache.reverb = f;\n      }\n    });\n    dispatcher.on('seeker', (f) => {\n      if (this.hasDebugger) {\n        this.debug(\n          `Seeker >> Seeked to ${f.seekTarget}ms for Track ${this.currentTrack?.title}`\n        );\n      }\n\n      if (f.seekTarget != null) this.node.setProgress(f.seekTarget);\n\n      this.emit(GuildQueueEvent.PlayerSeek, this, f);\n    });\n\n    dispatcher.on('compressor', (f) => {\n      if (areObjectsDifferent(f, this.filters._lastFiltersCache.compressor)) {\n        this.emit(\n          GuildQueueEvent.CompressorUpdate,\n          this,\n          this.filters._lastFiltersCache.compressor ?? null,\n          f\n        );\n        this.filters._lastFiltersCache.compressor = f;\n      }\n    });\n  }\n\n  public get hasDebugger() {\n    return this.player.events.hasDebugger;\n  }\n\n  #removeListeners<T extends {removeAllListeners: () => unknown;}>(target: T) {\n    target.removeAllListeners();\n  }\n\n  #performStart(resource?: AudioResource<Track>) {\n    const track = resource?.metadata || this.currentTrack;\n    const reason = this.isTransitioning() ? 'filters' : 'normal';\n\n    if (this.hasDebugger)\n    this.debug(\n      `Player triggered for Track ${JSON.stringify({\n        title: track?.title,\n        reason\n      })}`\n    );\n\n    this.emit(GuildQueueEvent.PlayerTrigger, this, track!, reason);\n    if (track && !this.isTransitioning())\n    this.emit(GuildQueueEvent.PlayerStart, this, track);\n    this.setTransitioning(false);\n  }\n\n  #getNextTrack() {\n    if (!this.isShuffling) {\n      return this.tracks.dispatch();\n    }\n\n    const store = this.tracks.store;\n\n    if (!store.length) return;\n\n    const track = Util.randomChoice(store);\n\n    this.tracks.removeOne((t) => {\n      return t.id === track.id;\n    });\n\n    return track;\n  }\n\n  #performFinish(resource?: AudioResource<Track>) {\n    const track = resource?.metadata || this.currentTrack;\n\n    if (this.hasDebugger)\n    this.debug(\n      `Track ${JSON.stringify({\n        title: track?.title,\n        isTransitionMode: this.isTransitioning()\n      })} was marked as finished`\n    );\n\n    if (!this.isTransitioning()) {\n      this.syncedLyricsProvider.unsubscribe();\n      this.syncedLyricsProvider.lyrics.clear();\n      if (this.hasDebugger)\n      this.debug(\n        'Adding track to history and emitting finish event since transition mode is disabled...'\n      );\n      if (track) {\n        this.history.push(track);\n        this.node.resetProgress();\n        this.emit(GuildQueueEvent.PlayerFinish, this, track);\n      }\n      if (this.#deleted) return this.#emitEnd();\n      if (this.tracks.size < 1 && this.repeatMode === QueueRepeatMode.OFF) {\n        if (this.hasDebugger)\n        this.debug(\n          'No more tracks left in the queue to play and repeat mode is off, initiating #emitEnd()'\n        );\n        this.#emitEnd();\n      } else {\n        if (this.repeatMode === QueueRepeatMode.TRACK) {\n          if (this.hasDebugger)\n          this.debug(\n            'Repeat mode is set to track, repeating last track from the history...'\n          );\n          this.__current = this.history.tracks.dispatch() || track;\n          return this.node.play(this.__current!, { queue: false });\n        }\n        if (this.repeatMode === QueueRepeatMode.QUEUE) {\n          if (this.hasDebugger)\n          this.debug(\n            'Repeat mode is set to queue, moving last track from the history to current queue...'\n          );\n          const next = this.history.tracks.dispatch() || track;\n          if (next) this.tracks.add(next);\n        }\n        if (!this.tracks.size && track) {\n          if (this.repeatMode === QueueRepeatMode.AUTOPLAY) {\n            if (this.hasDebugger)\n            this.debug(\n              'Repeat mode is set to autoplay, initiating autoplay handler...'\n            );\n            this.#handleAutoplay(track);\n            return;\n          }\n        } else {\n          if (this.hasDebugger)\n          this.debug('Initializing next track of the queue...');\n          this.__current = this.#getNextTrack()!;\n          this.node.play(this.__current, {\n            queue: false\n          });\n        }\n      }\n    }\n  }\n\n  #emitEnd() {\n    this.__current = null;\n    this.emit(GuildQueueEvent.EmptyQueue, this);\n    if (this.options.leaveOnEnd) {\n      const tm: NodeJS.Timeout = setTimeout(() => {\n        if (this.isPlaying()) return clearTimeout(tm);\n        this.dispatcher?.disconnect();\n      }, this.options.leaveOnEndCooldown).unref();\n    }\n  }\n\n  async #handleAutoplay(track: Track) {\n    try {\n      if (this.hasDebugger)\n      this.debug(\n        `Autoplay >> Finding related tracks for Track ${track.title} (${\n        track.url}) [ext:${\n        track.extractor?.identifier || 'N/A'}]`\n      );\n      const tracks =\n      (await track.extractor?.getRelatedTracks(track, this.history))?.\n      tracks ||\n      (\n      await this.player.extractors.run(async (ext) => {\n        if (this.hasDebugger)\n        this.debug(`Autoplay >> Querying extractor ${ext.identifier}`);\n        const res = await ext.getRelatedTracks(track, this.history);\n        if (!res.tracks.length) {\n          if (this.hasDebugger)\n          this.debug(\n            `Autoplay >> Extractor ${ext.identifier} failed to provide results.`\n          );\n          return false;\n        }\n\n        if (this.hasDebugger)\n        this.debug(\n          `Autoplay >> Extractor ${ext.identifier} successfully returned results.`\n        );\n\n        return res.tracks;\n      }))?.\n      result ||\n      [];\n\n      let resolver: (track: Track | null) => void = Util.noop;\n      const donePromise = new Promise<Track | null>(\n        (resolve) => resolver = resolve\n      );\n\n      const success = this.emit(\n        GuildQueueEvent.WillAutoPlay,\n        this,\n        tracks,\n        resolver!\n      );\n\n      // prevent dangling promise\n      if (!success) {\n        resolver(\n          tracks.length ?\n          (() => {\n            const unique = tracks.filter(\n              (tr) => !this.history.tracks.find((t) => t.url === tr.url)\n            );\n            return unique?.[0] ?? Util.randomChoice(tracks.slice(0, 5));\n          })() :\n          null\n        );\n      }\n\n      const nextTrack = await donePromise;\n\n      if (!nextTrack) {\n        if (this.hasDebugger)\n        this.debug('Autoplay >> No track was found, initiating #emitEnd()');\n        throw 'No track was found';\n      }\n\n      await this.node.play(nextTrack, {\n        queue: false,\n        seek: 0,\n        transitionMode: false\n      });\n    } catch {\n      return this.#emitEnd();\n    }\n  }\n}", "import {\n  AudioPlayer,\n  AudioPlayerError,\n  AudioPlayerStatus,\n  AudioResource,\n  createAudioPlayer,\n  createAudioResource,\n  entersState,\n  StreamType,\n  VoiceConnection,\n  VoiceConnectionStatus,\n  VoiceConnectionDisconnectReason } from\n'discord-voip';\nimport { StageChannel, VoiceChannel } from 'discord.js';\nimport type { Readable } from 'stream';\nimport { EventEmitter } from '@discord-player/utils';\nimport { Track } from '../fabric/Track';\nimport { Util } from '../utils/Util';\nimport {\n  EqualizerBand,\n  BiquadFilters,\n  PCMFilters,\n  FiltersChain,\n  CompressorParameters,\n  ReverbParameters,\n  SeekerParameters,\n  ResampleParameters,\n  CommonResamplerFilterPreset,\n  SeekEvent } from\n'@discord-player/equalizer';\nimport { GuildQueue, GuildQueueEvent, PostProcessedResult } from '../queue';\nimport { NoAudioResourceError } from '../errors';\nimport { InterceptedStream } from './InterceptedStream';\n\nexport interface CreateStreamOps {\n  type?: StreamType;\n  data: Track;\n  disableVolume?: boolean;\n  disableEqualizer?: boolean;\n  disableBiquad?: boolean;\n  disableCompressor?: boolean;\n  disableResampler?: boolean;\n  disableReverb?: boolean;\n  disableSeeker?: boolean;\n  eq?: EqualizerBand[];\n  biquadFilter?: BiquadFilters;\n  disableFilters?: boolean;\n  defaultFilters?: PCMFilters[];\n  volume?: number;\n  sampleRate?: number;\n  sampleRateFilters?: CommonResamplerFilterPreset;\n  skipFFmpeg?: boolean;\n  compressor?: {\n    threshold: number;\n    ratio: number;\n    attack: number;\n    release: number;\n    makeupGain: number;\n    kneeWidth: number;\n  };\n  reverb?: {\n    roomSize: number;\n    damping: number;\n    wetLevel: number;\n    dryLevel: number;\n  };\n  seeker?: {\n    seekTarget: number | null;\n    totalDuration: number;\n  };\n}\n\nexport interface VoiceEvents {\n  /* eslint-disable @typescript-eslint/no-explicit-any */\n  error: (error: AudioPlayerError) => any;\n  debug: (message: string) => any;\n  start: (resource: AudioResource<Track>) => any;\n  finish: (resource: AudioResource<Track>) => any;\n  dsp: (filters: PCMFilters[]) => any;\n  eqBands: (filters: EqualizerBand[]) => any;\n  sampleRate: (filters: ResampleParameters) => any;\n  biquad: (filters: BiquadFilters) => any;\n  compressor: (filters: CompressorParameters) => any;\n  reverb: (filters: ReverbParameters) => any;\n  seeker: (filters: SeekerParameters) => any;\n  volume: (volume: number) => any;\n  destroyed: () => any;\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n}\n\nclass StreamDispatcher extends EventEmitter<VoiceEvents> {\n  public voiceConnection: VoiceConnection;\n  public audioPlayer: AudioPlayer;\n  public channel: VoiceChannel | StageChannel;\n  public audioResource?: AudioResource<Track> | null;\n  public dsp = new FiltersChain();\n\n  #interceptor: InterceptedStream | null = null;\n\n  /**\n   * Creates new connection object\n   * @param {VoiceConnection} connection The connection\n   * @param {VoiceChannel|StageChannel} channel The connected channel\n   * @private\n   */\n  constructor(\n  connection: VoiceConnection,\n  channel: VoiceChannel | StageChannel,\n  public queue: GuildQueue,\n  public readonly connectionTimeout: number = 20000,\n  audioPlayer?: AudioPlayer)\n  {\n    super();\n\n    /**\n     * The voice connection\n     * @type {VoiceConnection}\n     */\n    this.voiceConnection = connection;\n\n    /**\n     * The audio player\n     * @type {AudioPlayer}\n     */\n    this.audioPlayer =\n    audioPlayer ||\n    createAudioPlayer({\n      debug: this.queue.hasDebugger\n    });\n\n    /**\n     * The voice channel\n     * @type {VoiceChannel|StageChannel}\n     */\n    this.channel = channel;\n\n    this.voiceConnection.on('debug', (m) => void this.emit('debug', m));\n    this.voiceConnection.on(\n      'error',\n      (error) => void this.emit('error', error as AudioPlayerError)\n    );\n    this.audioPlayer.on('debug', (m) => void this.emit('debug', m));\n    this.audioPlayer.on('error', (error) => void this.emit('error', error));\n\n    this.dsp.onUpdate = () => {\n      if (!this.dsp) return;\n\n      if (this.dsp.filters?.filters) {\n        this.emit('dsp', this.dsp.filters?.filters);\n      }\n\n      if (this.dsp.biquad?.filters) {\n        this.emit('biquad', this.dsp.biquad?.filters);\n      }\n\n      if (this.dsp.equalizer) {\n        this.emit('eqBands', this.dsp.equalizer.getEQ());\n      }\n\n      if (this.dsp.volume) {\n        this.emit('volume', this.dsp.volume.volume);\n      }\n\n      if (this.dsp.resampler) {\n        this.emit('sampleRate', this.dsp.resampler.getParameters());\n      }\n      if (this.dsp.compressor) {\n        this.emit('compressor', this.dsp.compressor.getParameters());\n      }\n\n      if (this.dsp.reverb) {\n        this.emit('reverb', this.dsp.reverb.getParameters());\n      }\n\n      if (this.dsp.seeker) {\n        this.emit('seeker', this.dsp.seeker.getParameters());\n      }\n    };\n\n    this.dsp.onError = (e) => this.emit('error', e as AudioPlayerError);\n\n    this.voiceConnection.\n    on(VoiceConnectionStatus.Disconnected, async (oldState, newState) => {\n      if (newState.reason === VoiceConnectionDisconnectReason.Manual) {\n        this.destroy();\n        return;\n      }\n\n      if (\n      newState.reason === VoiceConnectionDisconnectReason.WebSocketClose &&\n      newState.closeCode === 4014)\n      {\n        try {\n          await entersState(\n            this.voiceConnection,\n            VoiceConnectionStatus.Connecting,\n            this.connectionTimeout\n          );\n        } catch {\n          try {\n            if (\n            this.voiceConnection.state.status !==\n            VoiceConnectionStatus.Destroyed)\n\n            this.destroy();\n          } catch (err) {\n            this.emit('error', err as AudioPlayerError);\n          }\n        }\n      } else if (this.voiceConnection.rejoinAttempts < 5) {\n        await Util.wait((this.voiceConnection.rejoinAttempts + 1) * 5000);\n        this.voiceConnection.rejoin();\n      } else {\n        try {\n          if (\n          this.voiceConnection.state.status !==\n          VoiceConnectionStatus.Destroyed)\n\n          this.destroy();\n        } catch (err) {\n          this.emit('error', err as AudioPlayerError);\n        }\n      }\n    }).\n    on(VoiceConnectionStatus.Destroyed, () => {\n      this.end();\n      this.queue.emit(GuildQueueEvent.ConnectionDestroyed, this.queue);\n    });\n\n    this.audioPlayer.on('stateChange', (oldState, newState) => {\n      if (\n      oldState.status !== AudioPlayerStatus.Paused &&\n      newState.status === AudioPlayerStatus.Paused)\n      {\n        this.queue.emit(GuildQueueEvent.PlayerPause, this.queue);\n      }\n\n      if (\n      oldState.status === AudioPlayerStatus.Paused &&\n      newState.status !== AudioPlayerStatus.Paused)\n      {\n        this.queue.emit(GuildQueueEvent.PlayerResume, this.queue);\n      }\n\n      if (newState.status === AudioPlayerStatus.Playing) {\n        if (\n        oldState.status === AudioPlayerStatus.Idle ||\n        oldState.status === AudioPlayerStatus.Buffering)\n        {\n          return this.emit('start', this.audioResource!);\n        }\n      } else if (\n      newState.status === AudioPlayerStatus.Idle &&\n      oldState.status !== AudioPlayerStatus.Idle)\n      {\n        this.emit('finish', this.audioResource!);\n        this.dsp.destroy();\n        this.audioResource = null;\n      }\n    });\n\n    this.voiceConnection.subscribe(this.audioPlayer);\n  }\n\n  /**\n   * Check if the player has been paused manually\n   */\n  get paused() {\n    return this.audioPlayer.state.status === AudioPlayerStatus.Paused;\n  }\n\n  set paused(val: boolean) {\n    val ? this.pause(true) : this.resume();\n  }\n\n  /**\n   * Whether or not the player is currently paused automatically or manually.\n   */\n  isPaused() {\n    return (\n      this.paused ||\n      this.audioPlayer.state.status === AudioPlayerStatus.AutoPaused);\n\n  }\n\n  /**\n   * Whether or not the player is currently buffering\n   */\n  isBuffering() {\n    return this.audioPlayer.state.status === AudioPlayerStatus.Buffering;\n  }\n\n  /**\n   * Whether or not the player is currently playing\n   */\n  isPlaying() {\n    return this.audioPlayer.state.status === AudioPlayerStatus.Playing;\n  }\n\n  /**\n   * Whether or not the player is currently idle\n   */\n  isIdle() {\n    return this.audioPlayer.state.status === AudioPlayerStatus.Idle;\n  }\n\n  /**\n   * Whether or not the voice connection has been destroyed\n   */\n  isDestroyed() {\n    return (\n      this.voiceConnection.state.status === VoiceConnectionStatus.Destroyed);\n\n  }\n\n  /**\n   * Whether or not the voice connection has been destroyed\n   */\n  isDisconnected() {\n    return (\n      this.voiceConnection.state.status === VoiceConnectionStatus.Disconnected);\n\n  }\n\n  /**\n   * Whether or not the voice connection is ready to play\n   */\n  isReady() {\n    return this.voiceConnection.state.status === VoiceConnectionStatus.Ready;\n  }\n\n  /**\n   * Whether or not the voice connection is signalling\n   */\n  isSignalling() {\n    return (\n      this.voiceConnection.state.status === VoiceConnectionStatus.Signalling);\n\n  }\n\n  /**\n   * Whether or not the voice connection is connecting\n   */\n  isConnecting() {\n    return (\n      this.voiceConnection.state.status === VoiceConnectionStatus.Connecting);\n\n  }\n\n  /**\n   * Creates stream\n   * @param {Readable} src The stream source\n   * @param {object} [ops] Options\n   * @returns {AudioResource}\n   */\n  async createStream(src: Readable, ops: CreateStreamOps) {\n    if (!ops?.disableFilters && this.queue.hasDebugger)\n    this.queue.debug('Initiating DSP filters pipeline...');\n    const stream = !ops?.disableFilters ?\n    this.dsp.create(src, {\n      dsp: {\n        filters: ops?.defaultFilters,\n        disabled: ops?.disableFilters\n      },\n      biquad: ops?.biquadFilter ?\n      {\n        filter: ops.biquadFilter,\n        disabled: ops?.disableBiquad\n      } :\n      undefined,\n      resampler: ops?.sampleRate ?\n      {\n        inputSampleRate: 48000,\n        targetSampleRate: ops?.sampleRate,\n        disabled: ops?.disableResampler\n      } :\n      undefined,\n      equalizer: {\n        bandMultiplier: ops?.eq,\n        disabled: ops?.disableEqualizer\n      },\n      volume: {\n        volume: ops?.volume,\n        disabled: ops?.disableVolume\n      },\n      compressor: ops?.compressor ?\n      {\n        threshold: ops?.compressor.threshold,\n        ratio: ops?.compressor.ratio,\n        attack: ops?.compressor.attack,\n        release: ops?.compressor.release,\n        makeupGain: ops?.compressor.makeupGain,\n        disabled: ops?.disableCompressor,\n        kneeWidth: ops?.compressor.kneeWidth\n      } :\n      undefined,\n      reverb: ops?.reverb ?\n      {\n        roomSize: ops?.reverb.roomSize,\n        damping: ops?.reverb.damping,\n        wetLevel: ops?.reverb.wetLevel,\n        dryLevel: ops?.reverb.dryLevel,\n        disabled: ops?.disableReverb\n      } :\n      undefined,\n      seeker: ops?.seeker ?\n      {\n        disabled: ops?.disableSeeker,\n        seekTarget: ops?.seeker.seekTarget,\n        sampleRate: 48000,\n        channels: 2,\n        totalDuration: ops?.seeker.totalDuration\n      } :\n      undefined\n    }) :\n    src;\n\n    if (this.dsp.seeker) {\n      // used to handle backward seeking\n      this.dsp.seeker.on('seek', (data: SeekEvent) => {\n        this.queue.node.requestSeek(data).catch(() => {});\n      });\n    }\n\n    if (this.queue.hasDebugger) {\n      this.queue.debug('Executing onAfterCreateStream hook...');\n    }\n\n    const postStream = await this.queue.\n    onAfterCreateStream?.(stream, this.queue, ops?.data).\n    catch(\n      () =>\n      ({\n        stream: stream,\n        type: ops?.type ?? StreamType.Arbitrary\n      }) as PostProcessedResult\n    );\n\n    if (this.queue.hasDebugger) this.queue.debug('Preparing AudioResource...');\n\n    const format = postStream?.type ?? ops?.type ?? StreamType.Arbitrary;\n\n    let _stream: Readable;\n\n    if (this.queue.canIntercept()) {\n      this.#interceptor = new InterceptedStream();\n\n      // @ts-ignore\n      (postStream?.stream ?? stream).pipe(this.#interceptor);\n\n      _stream = this.#interceptor;\n\n      await this.queue.player.handleInterceptingStream(\n        this.queue,\n        ops?.data,\n        format,\n        this.#interceptor\n      );\n    } else {\n      _stream = postStream?.stream ?? stream;\n    }\n\n    this.audioResource = createAudioResource(_stream, {\n      inputType: format,\n      metadata: ops?.data as Track,\n      // volume controls happen from AudioFilter DSP utility\n      inlineVolume: false\n    });\n\n    return this.audioResource;\n  }\n\n  public get resampler() {\n    return this.dsp?.resampler;\n  }\n\n  public get filters() {\n    return this.dsp?.filters;\n  }\n\n  public get biquad() {\n    return this.dsp?.biquad || null;\n  }\n\n  public get equalizer() {\n    return this.dsp?.equalizer || null;\n  }\n\n  public get compressor() {\n    return this.dsp?.compressor || null;\n  }\n\n  public get reverb() {\n    return this.dsp?.reverb || null;\n  }\n\n  public get seeker() {\n    return this.dsp?.seeker || null;\n  }\n\n  /**\n   * The player status\n   * @type {AudioPlayerStatus}\n   */\n  get status() {\n    return this.audioPlayer.state.status;\n  }\n\n  /**\n   * Disconnects from voice\n   * @returns {void}\n   */\n  disconnect() {\n    try {\n      if (this.audioPlayer) this.audioPlayer.stop(true);\n      if (this.voiceConnection.state.status !== VoiceConnectionStatus.Destroyed)\n      this.voiceConnection.destroy();\n    } catch {} // eslint-disable-line no-empty\n  }\n\n  /**\n   * Destroys this dispatcher\n   */\n  public destroy() {\n    this.disconnect();\n    // @ts-ignore\n    this.audioPlayer.removeAllListeners();\n    // @ts-ignore\n    this.voiceConnection.removeAllListeners();\n    this.dsp.destroy();\n    this.audioResource = null;\n    this.emit('destroyed');\n  }\n\n  /**\n   * Stops the player\n   * @returns {void}\n   */\n  end() {\n    try {\n      this.audioPlayer.stop();\n      this.dsp.destroy();\n    } catch {\n\n      //\n    }}\n\n  /**\n   * Pauses the stream playback\n   * @param {boolean} [interpolateSilence=false] If true, the player will play 5 packets of silence after pausing to prevent audio glitches.\n   * @returns {boolean}\n   */\n  pause(interpolateSilence?: boolean) {\n    const success = this.audioPlayer.pause(interpolateSilence);\n    return success;\n  }\n\n  /**\n   * Resumes the stream playback\n   * @returns {boolean}\n   */\n  resume() {\n    const success = this.audioPlayer.unpause();\n    return success;\n  }\n\n  /**\n   * Play stream\n   * @param {AudioResource<Track>} [resource=this.audioResource] The audio resource to play\n   * @param {boolean} [opus=false] Whether or not to use opus\n   * @returns {Promise<StreamDispatcher>}\n   */\n  async playStream(resource: AudioResource<Track> = this.audioResource!) {\n    if (!resource) {\n      throw new NoAudioResourceError();\n    }\n    if (resource.ended) {\n      return void this.emit('finish', resource);\n    }\n    if (!this.audioResource) this.audioResource = resource;\n    if (this.voiceConnection.state.status !== VoiceConnectionStatus.Ready) {\n      try {\n        await entersState(\n          this.voiceConnection,\n          VoiceConnectionStatus.Ready,\n          this.connectionTimeout\n        );\n      } catch (err) {\n        return void this.emit('error', err as AudioPlayerError);\n      }\n    }\n\n    try {\n      this.audioPlayer.play(resource);\n    } catch (e) {\n      this.emit('error', e as AudioPlayerError);\n    }\n\n    return this;\n  }\n\n  /**\n   * Sets playback volume\n   * @param {number} value The volume amount\n   * @returns {boolean}\n   */\n  setVolume(value: number) {\n    if (!this.dsp.volume) return false;\n    return this.dsp.volume.setVolume(value);\n  }\n\n  /**\n   * The current volume\n   * @type {number}\n   */\n  get volume() {\n    if (!this.dsp.volume) return 100;\n    return this.dsp.volume.volume;\n  }\n\n  /**\n   * The playback time\n   * @type {number}\n   */\n  get streamTime() {\n    if (!this.audioResource) return 0;\n    return this.audioResource.playbackDuration;\n  }\n}\n\nexport { StreamDispatcher };", "import { Transform, type TransformCallback, type Writable } from 'node:stream';\n\n/**\n * Represents a stream that can be intercepted and consumed without affecting the original consumer.\n * @example const stream = new InterceptedStream();\n *\n * // real consumer\n * stream.pipe(fs.createWriteStream('file.txt'));\n *\n * // man in the middle consumer\n * const manInTheMiddle = new Writable({\n *  write(chunk, encoding, callback) {\n *   console.log(chunk.toString());\n *   callback();\n *  }\n * });\n *\n * // stream.interceptors is a Set of Writable streams\n * stream.interceptors.add(manInTheMiddle);\n */\nexport class InterceptedStream extends Transform {\n  public readonly interceptors = new Set<Writable>();\n  #intercepting = true;\n\n  /**\n   * Start intercepting the stream. This is the default state of InterceptedStream.\n   */\n  public startIntercepting(): void {\n    this.#intercepting = true;\n  }\n\n  /**\n   * Stop intercepting the stream. This will prevent the stream from being consumed by the interceptors.\n   * This can be useful when you want to temporarily stop the interception. The stopped state can be resumed by calling startIntercepting again.\n   */\n  public stopIntercepting(): void {\n    this.#intercepting = false;\n  }\n\n  /**\n   * Whether the stream is being intercepted\n   */\n  public isIntercepting(): boolean {\n    return this.#intercepting;\n  }\n\n  public _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  callback: TransformCallback)\n  : void {\n    this.push(chunk, encoding);\n\n    if (this.#intercepting && this.interceptors.size > 0) {\n      for (const consumer of this.interceptors) {\n        consumer.write(chunk, encoding);\n      }\n    }\n\n    callback();\n  }\n\n  _final(callback: TransformCallback): void {\n    for (const consumer of this.interceptors) {\n      consumer.end();\n    }\n\n    callback();\n  }\n\n  public _destroy(error: Error, callback: TransformCallback): void {\n    const ignoreError = String(error).includes('ERR_STREAM_PREMATURE_CLOSE');\n    const err = ignoreError ? undefined : error;\n\n    for (const consumer of this.interceptors) {\n      consumer.destroy(err);\n    }\n\n    this.interceptors.clear();\n\n    callback(err);\n  }\n}", "import { Queue } from '@discord-player/utils';\nimport { NoResultError } from '../errors';\nimport { Track } from '../fabric/Track';\nimport { GuildQueue, TrackSkipReason } from './GuildQueue';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class GuildQueueHistory<Meta = any> {\n  public tracks = new Queue<Track>('LIFO');\n  public constructor(public queue: GuildQueue<Meta>) {}\n\n  /**\n   * Current track in the queue\n   */\n  public get currentTrack() {\n    return (\n      this.queue.dispatcher?.audioResource?.metadata ||\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (this.queue as any).__current as Track | null);\n\n  }\n\n  /**\n   * Next track in the queue\n   */\n  public get nextTrack() {\n    return this.queue.tracks.at(0) || null;\n  }\n\n  /**\n   * Previous track in the queue\n   */\n  public get previousTrack() {\n    return this.tracks.at(0) || null;\n  }\n\n  /**\n   * If history is disabled\n   */\n  public get disabled() {\n    return this.queue.options.disableHistory;\n  }\n\n  /**\n   * Gets the size of the queue\n   */\n  public get size() {\n    return this.tracks.size;\n  }\n\n  public getSize() {\n    return this.size;\n  }\n\n  /**\n   * If history is empty\n   */\n  public isEmpty() {\n    return this.tracks.size < 1;\n  }\n\n  /**\n   * Add track to track history\n   * @param track The track to add\n   */\n  public push(track: Track | Track[]) {\n    if (this.disabled) return false;\n    this.tracks.add(track);\n\n    this.resize();\n\n    return true;\n  }\n\n  /**\n   * Clear history\n   */\n  public clear() {\n    this.tracks.clear();\n  }\n\n  /**\n   * Play the next track in the queue\n   */\n  public async next() {\n    const track = this.nextTrack;\n    if (!track) {\n      throw new NoResultError('No next track in the queue');\n    }\n\n    this.queue.node.skip({\n      reason: TrackSkipReason.HistoryNext,\n      description: 'Skipped by GuildQueueHistory.next()'\n    });\n  }\n\n  /**\n   * Play the previous track in the queue\n   */\n  public async previous(preserveCurrent = true) {\n    const track = this.tracks.dispatch();\n    if (!track) {\n      throw new NoResultError('No previous track in the queue');\n    }\n\n    const current = this.currentTrack;\n\n    await this.queue.node.play(track, { queue: false });\n    if (current && preserveCurrent) this.queue.node.insert(current, 0);\n  }\n\n  /**\n   * Alias to [GuildQueueHistory].previous()\n   */\n  public back(preserveCurrent = true) {\n    return this.previous(preserveCurrent);\n  }\n\n  /**\n   * Resize history store\n   */\n  public resize() {\n    if (!Number.isFinite(this.queue.maxHistorySize)) return;\n    if (this.tracks.store.length < this.queue.maxHistorySize) return;\n    this.tracks.store.splice(this.queue.maxHistorySize);\n  }\n}", "import { AudioResource, StreamType } from 'discord-voip';\nimport { Readable } from 'stream';\nimport { QueryResolver, SearchQueryType } from '../utils/QueryResolver';\nimport { Util, VALIDATE_QUEUE_CAP } from '../utils/Util';\nimport { Track, TrackResolvable } from '../fabric/Track';\nimport { GuildQueue, GuildQueueEvent, TrackSkipReason } from './GuildQueue';\nimport { setTimeout as waitFor } from 'timers/promises';\nimport { AsyncQueue } from '../utils/AsyncQueue';\nimport {\n  InvalidArgTypeError,\n  NoResultError,\n  NoVoiceConnectionError,\n  OutOfRangeError } from\n'../errors';\nimport { TypeUtil } from '../utils/TypeUtil';\nimport { CreateStreamOps } from '../stream/StreamDispatcher';\nimport { ExtractorStreamable } from '../extractors/BaseExtractor';\nimport { OggDemuxer, OpusDecoder, WebmDemuxer } from '@discord-player/opus';\nimport { SeekEvent } from '@discord-player/equalizer';\n\nexport const FFMPEG_SRATE_REGEX = /asetrate=\\d+\\*(\\d(\\.\\d)?)/;\n\nexport interface PlayerProgressbarOptions {\n  /**\n   * If it should render time codes\n   */\n  timecodes?: boolean;\n  /**\n   * If it should create progress bar for the whole queue\n   */\n  length?: number;\n  /**\n   * The bar length\n   */\n  leftChar?: string;\n  /**\n   * The elapsed time track\n   */\n  rightChar?: string;\n  /**\n   * The remaining time track\n   */\n  separator?: string;\n  /**\n   * The separation between timestamp and line\n   */\n  indicator?: string;\n  /**\n   * The indicator\n   */\n  queue?: boolean;\n}\n\nexport interface ResourcePlayOptions {\n  queue?: boolean;\n  seek?: number;\n  transitionMode?: boolean;\n}\n\nexport interface SkipOptions {\n  reason: TrackSkipReason;\n  description: string;\n}\n\nexport interface PlayerTimestamp {\n  current: {\n    label: string;\n    value: number;\n  };\n  total: {\n    label: string;\n    value: number;\n  };\n  progress: number;\n}\n\nexport interface StreamConfig {\n  dispatcherConfig: CreateStreamOps;\n  playerConfig: ResourcePlayOptions;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class GuildQueuePlayerNode<Meta = any> {\n  #progress = 0;\n  #hasFFmpegOptimization = false;\n  public tasksQueue = new AsyncQueue();\n  public constructor(public queue: GuildQueue<Meta>) {\n    this.#hasFFmpegOptimization = /libopus: (yes|true)/.test(\n      this.queue.player.scanDeps()\n    );\n  }\n\n  /**\n   * If the player is currently in idle mode\n   */\n  public isIdle() {\n    return !!this.queue.dispatcher?.isIdle();\n  }\n\n  /**\n   * If the player is currently buffering the track\n   */\n  public isBuffering() {\n    return !!this.queue.dispatcher?.isBuffering();\n  }\n\n  /**\n   * If the player is currently playing a track\n   */\n  public isPlaying() {\n    return !!this.queue.dispatcher?.isPlaying();\n  }\n\n  /**\n   * If the player is currently paused\n   */\n  public isPaused() {\n    return !!this.queue.dispatcher?.isPaused();\n  }\n\n  /**\n   * Reset progress history\n   */\n  public resetProgress() {\n    this.#progress = 0;\n  }\n\n  /**\n   * Set player progress\n   */\n  public setProgress(progress: number) {\n    this.#progress = progress;\n  }\n\n  /**\n   * The stream time for current session\n   */\n  public get streamTime() {\n    return this.queue.dispatcher?.streamTime ?? 0;\n  }\n\n  /**\n   * Current playback duration with history included\n   */\n  public get playbackTime() {\n    if (this.queue.filters.seeker) {\n      const pos = this.queue.filters.seeker.getPosition();\n      if (pos > 0) return pos;\n    }\n\n    const dur = this.#progress + this.streamTime;\n\n    return dur;\n  }\n\n  /**\n   * Get duration multiplier\n   */\n  public getDurationMultiplier() {\n    const srateFilters = this.queue.filters.ffmpeg.\n    toArray().\n    filter((ff) => FFMPEG_SRATE_REGEX.test(ff));\n    const multipliers = srateFilters.\n    map((m) => {\n      return parseFloat(FFMPEG_SRATE_REGEX.exec(m)?.[1] as string);\n    }).\n    filter((f) => !isNaN(f));\n\n    return !multipliers.length ?\n    1 :\n    multipliers.reduce((accumulator, current) => current + accumulator);\n  }\n\n  /**\n   * Estimated progress of the player\n   */\n  public get estimatedPlaybackTime() {\n    const dur = this.playbackTime;\n    const val = this.getDurationMultiplier() * dur;\n\n    return val;\n  }\n\n  /**\n   * Estimated total duration of the player\n   */\n  public get estimatedDuration() {\n    const dur = this.totalDuration;\n\n    // duration multiplier checks ffmpeg filters that may affect the duration\n    const val = Math.round(dur / this.getDurationMultiplier());\n\n    // we also need to check if we have a native resampler filter as it may also affect the duration\n    if (this.queue.filters.resampler) {\n      // get the resampler ratio if we have one\n      const ratio = this.queue.filters.resampler.getRatio();\n      if (ratio <= 0) return val;\n\n      return Math.round(val / ratio);\n    }\n\n    return val;\n  }\n\n  /**\n   * Total duration of the current audio track\n   */\n  public get totalDuration() {\n    const prefersBridgedMetadata = this.queue.options.preferBridgedMetadata;\n    const track = this.queue.currentTrack;\n\n    if (prefersBridgedMetadata) {\n      const trackHasLegacyMetadata =\n      track?.metadata != null &&\n      typeof track.metadata === 'object' &&\n      'bridge' in track.metadata &&\n      track.metadata.bridge != null;\n      const trackHasMetadata = track?.bridgedTrack != null;\n\n      if (trackHasLegacyMetadata || trackHasMetadata) {\n        const duration =\n        track.bridgedTrack?.durationMS ??\n        (\n        track as Track<{\n          bridge: {\n            duration: number;\n          };\n        }>).\n        metadata?.bridge.duration;\n\n        if (TypeUtil.isNumber(duration)) return duration;\n      }\n    }\n\n    return track?.durationMS ?? 0;\n  }\n\n  /**\n   * Get stream progress\n   * @param ignoreFilters Ignore filters\n   */\n  public getTimestamp(ignoreFilters = false): PlayerTimestamp | null {\n    if (!this.queue.currentTrack) return null;\n\n    const current = ignoreFilters ?\n    this.playbackTime :\n    this.estimatedPlaybackTime;\n    const total = ignoreFilters ? this.totalDuration : this.estimatedDuration;\n\n    return {\n      current: {\n        label: Util.buildTimeCode(Util.parseMS(current)),\n        value: current\n      },\n      total: {\n        label: Util.buildTimeCode(Util.parseMS(total)),\n        value: total\n      },\n      progress: Math.round(current / total * 100)\n    };\n  }\n\n  /**\n   * Create progress bar for current progress\n   * @param options Progress bar options\n   */\n  public createProgressBar(options?: PlayerProgressbarOptions) {\n    const timestamp = this.getTimestamp();\n    if (!timestamp) return null;\n    const {\n      indicator = '\\u{1F518}',\n      leftChar = '\\u25AC',\n      rightChar = '\\u25AC',\n      length = 15,\n      timecodes = true,\n      separator = '\\u2503'\n    } = options || {};\n    if (isNaN(length) || length < 0 || !Number.isFinite(length)) {\n      throw new OutOfRangeError(\n        '[PlayerProgressBarOptions.length]',\n        String(length),\n        '0',\n        'Finite Number'\n      );\n    }\n    const index = Math.round(\n      timestamp.current.value / timestamp.total.value * length\n    );\n    if (index >= 1 && index <= length) {\n      const bar = leftChar.repeat(index - 1).split('');\n      bar.push(indicator);\n      bar.push(rightChar.repeat(length - index));\n      if (timecodes) {\n        return `${timestamp.current.label} ${separator} ${bar.join(\n          ''\n        )} ${separator} ${timestamp.total.label}`;\n      } else {\n        return `${bar.join('')}`;\n      }\n    } else {\n      if (timecodes) {\n        return `${\n        timestamp.current.label} ${\n        separator} ${indicator}${rightChar.repeat(\n          length - 1\n        )} ${separator} ${timestamp.total.label}`;\n      } else {\n        return `${indicator}${rightChar.repeat(length - 1)}`;\n      }\n    }\n  }\n\n  /**\n   * Seek the player\n   * @param duration The duration to seek to\n   */\n  public async seek(duration: number) {\n    if (!this.queue.currentTrack) return false;\n    if (duration === this.estimatedPlaybackTime) return true;\n    if (duration > this.totalDuration) {\n      return this.skip({\n        reason: TrackSkipReason.SEEK_OVER_THRESHOLD,\n        description: new OutOfRangeError(\n          '[duration]',\n          String(duration),\n          '0',\n          String(this.totalDuration)\n        ).message\n      });\n    }\n    if (duration < 0) duration = 0;\n\n    const seeker = this.queue.filters.seeker;\n\n    if (seeker) {\n      seeker.seek(duration);\n      return true;\n    }\n\n    return this.queue.filters.triggerReplay(duration).then((v) => {\n      if (v) {\n        this.queue.emit(GuildQueueEvent.PlayerSeek, this.queue, {\n          currentPosition: this.estimatedPlaybackTime,\n          seekTarget: duration,\n          totalDuration: this.estimatedDuration\n        });\n      }\n\n      return v;\n    });\n  }\n\n  /**\n   * Current volume\n   */\n  public get volume() {\n    return this.queue.dispatcher?.volume ?? 100;\n  }\n\n  /**\n   * Set volume\n   * @param vol Volume amount to set\n   */\n  public setVolume(vol: number) {\n    if (!this.queue.dispatcher) return false;\n    const res = this.queue.dispatcher.setVolume(vol);\n    if (res) this.queue.filters._lastFiltersCache.volume = vol;\n    return res;\n  }\n\n  /**\n   * Set bit rate\n   * @param rate The bit rate to set\n   */\n  public setBitrate(rate: number | 'auto') {\n    this.queue.dispatcher?.audioResource?.encoder?.setBitrate(\n      rate === 'auto' ? this.queue.channel?.bitrate ?? 64000 : rate\n    );\n  }\n\n  /**\n   * Set paused state\n   * @param state The state\n   */\n  public setPaused(state: boolean) {\n    if (state) return this.queue.dispatcher?.pause(true) || false;\n    return this.queue.dispatcher?.resume() || false;\n  }\n\n  /**\n   * Pause the playback\n   */\n  public pause() {\n    return this.setPaused(true);\n  }\n\n  /**\n   * Resume the playback\n   */\n  public resume() {\n    return this.setPaused(false);\n  }\n\n  /**\n   * Skip current track\n   */\n  public skip(options?: SkipOptions) {\n    if (!this.queue.dispatcher) return false;\n    const track = this.queue.currentTrack;\n    if (!track) return false;\n    this.queue.setTransitioning(false);\n    this.queue.dispatcher.end();\n    const { reason, description } = options || {\n      reason: TrackSkipReason.Manual,\n      description: 'The track was skipped manually'\n    };\n    this.queue.emit(\n      GuildQueueEvent.PlayerSkip,\n      this.queue,\n      track,\n      reason,\n      description\n    );\n    return true;\n  }\n\n  /**\n   * Remove the given track from queue\n   * @param track The track to remove\n   * @param emitEvent Whether or not to emit the event @defaultValue true\n   */\n  public remove(track: TrackResolvable, emitEvent = true) {\n    const foundTrack = this.queue.tracks.find((t, idx) => {\n      if (track instanceof Track || typeof track === 'string') {\n        return (typeof track === 'string' ? track : track.id) === t.id;\n      }\n      if (typeof track === 'string') return track === t.id;\n      return idx === track;\n    });\n    if (!foundTrack) return null;\n\n    this.queue.tracks.removeOne((t) => t.id === foundTrack.id);\n\n    if (emitEvent)\n    this.queue.emit(GuildQueueEvent.AudioTrackRemove, this.queue, foundTrack);\n\n    return foundTrack;\n  }\n\n  /**\n   * Jump to specific track on the queue\n   * @param track The track to jump to without removing other tracks\n   */\n  public jump(track: TrackResolvable) {\n    const removed = this.remove(track, false);\n    if (!removed) return false;\n    this.queue.tracks.store.unshift(removed);\n    return this.skip({\n      reason: TrackSkipReason.Jump,\n      description: 'The track was jumped to manually'\n    });\n  }\n\n  /**\n   * Get track position\n   * @param track The track\n   */\n  public getTrackPosition(track: TrackResolvable): number {\n    return this.queue.tracks.toArray().findIndex((t, idx) => {\n      if (track instanceof Track || typeof track === 'string') {\n        return (typeof track === 'string' ? track : track.id) === t.id;\n      }\n      if (typeof track === 'string') return track === t.id;\n      return idx === track;\n    });\n  }\n\n  /**\n   * Skip to the given track, removing others on the way\n   * @param track The track to skip to\n   */\n  public skipTo(track: TrackResolvable) {\n    const idx = this.getTrackPosition(track);\n    if (idx < 0) return false;\n    const removed = this.remove(idx);\n    if (!removed) return false;\n    const toRemove = this.queue.tracks.store.filter((_, i) => i <= idx);\n    this.queue.tracks.store.splice(0, idx, removed);\n    this.queue.emit(GuildQueueEvent.AudioTracksRemove, this.queue, toRemove);\n    return this.skip({\n      reason: TrackSkipReason.SkipTo,\n      description: 'The player was skipped to another track manually'\n    });\n  }\n\n  /**\n   * Insert a track on the given position in queue\n   * @param track The track to insert\n   * @param index The position to insert to, defaults to 0.\n   */\n  public insert(track: Track, index = 0) {\n    if (!(track instanceof Track))\n    throw new InvalidArgTypeError(\n      'track value',\n      'instance of Track',\n      String(track)\n    );\n    VALIDATE_QUEUE_CAP(this.queue, track);\n    this.queue.tracks.store.splice(index, 0, track);\n    if (!this.queue.options.noEmitInsert) {\n      this.queue.emit(GuildQueueEvent.AudioTrackAdd, this.queue, track);\n    }\n  }\n\n  /**\n   * Moves a track in the queue\n   * @param from The track to move\n   * @param to The position to move to\n   */\n  public move(from: TrackResolvable, to: number) {\n    const removed = this.remove(from);\n    if (!removed) {\n      throw new NoResultError('invalid track to move');\n    }\n    this.insert(removed, to);\n  }\n\n  /**\n   * Copy a track in the queue\n   * @param from The track to clone\n   * @param to The position to clone at\n   */\n  public copy(from: TrackResolvable, to: number) {\n    const src = this.queue.tracks.at(this.getTrackPosition(from));\n    if (!src) {\n      throw new NoResultError('invalid track to copy');\n    }\n    this.insert(src, to);\n  }\n\n  /**\n   * Swap two tracks in the queue\n   * @param first The first track to swap\n   * @param second The second track to swap\n   */\n  public swap(first: TrackResolvable, second: TrackResolvable) {\n    const src = this.getTrackPosition(first);\n    if (src < 0) throw new NoResultError('invalid src track to swap');\n\n    const dest = this.getTrackPosition(second);\n    if (dest < 0) throw new NoResultError('invalid dest track to swap');\n\n    const srcT = this.queue.tracks.store[src];\n    const destT = this.queue.tracks.store[dest];\n\n    this.queue.tracks.store[src] = destT;\n    this.queue.tracks.store[dest] = srcT;\n  }\n\n  /**\n   * Stop the playback\n   * @param force Whether or not to forcefully stop the playback\n   */\n  public stop(force = false) {\n    this.queue.tracks.clear();\n    this.queue.history.clear();\n    if (!this.queue.dispatcher) return false;\n    this.queue.dispatcher.end();\n    if (force) {\n      this.queue.dispatcher.destroy();\n      return true;\n    }\n    if (this.queue.options.leaveOnStop) {\n      const tm: NodeJS.Timeout = setTimeout(() => {\n        if (this.isPlaying() || this.queue.tracks.size) return clearTimeout(tm);\n        this.queue.dispatcher?.destroy();\n      }, this.queue.options.leaveOnStopCooldown).unref();\n    }\n    return true;\n  }\n\n  /**\n   * Request the source to seek\n   * @param data The seek parameters\n   */\n  public async requestSeek(data: SeekEvent) {\n    const track = this.queue.currentTrack;\n    if (!track) return false;\n\n    if (track.seekable) {\n      return track.seek(data);\n    }\n\n    return this.queue.filters.triggerReplay(data.position);\n  }\n\n  /**\n   * Play the given track\n   * @param res The track to play\n   * @param options Options for playing the track\n   */\n  public async play(res?: Track | null, options?: ResourcePlayOptions) {\n    if (!this.queue.dispatcher?.voiceConnection) {\n      throw new NoVoiceConnectionError();\n    }\n\n    if (this.queue.hasDebugger)\n    this.queue.debug(\n      `Received play request from guild ${this.queue.guild.name} (ID: ${this.queue.guild.id})`\n    );\n\n    options = Object.assign(\n      {},\n      {\n        queue: this.queue.currentTrack != null,\n        transitionMode: false,\n        seek: 0\n      } as ResourcePlayOptions,\n      options\n    )!;\n\n    if (res && options.queue) {\n      if (this.queue.hasDebugger)\n      this.queue.debug(\n        'Requested option requires to queue the track, adding the given track to queue instead...'\n      );\n      return this.queue.addTrack(res);\n    }\n\n    const track = res || this.queue.tracks.dispatch();\n    if (!track) {\n      const error = new NoResultError(\n        'Play request received but track was not provided'\n      );\n      this.queue.emit(GuildQueueEvent.Error, this.queue, error);\n      return;\n    }\n\n    if (this.queue.hasDebugger)\n    this.queue.debug(\n      'Requested option requires to play the track, initializing...'\n    );\n\n    try {\n      const assignedResource = track.resource;\n\n      if (assignedResource) {\n        if (this.queue.hasDebugger)\n        this.queue.debug(\n          'Track has an audio resource assigned, player will now play the resource directly...'\n        );\n\n        this.queue.setTransitioning(!!options.transitionMode);\n\n        return this.#performPlay(assignedResource);\n      }\n\n      if (this.queue.hasDebugger)\n      this.queue.debug(`Initiating stream extraction process...`);\n      const src = track.raw?.source || track.source;\n      const qt: SearchQueryType =\n      track.queryType || (\n      src === 'spotify' ?\n      'spotifySong' :\n      src === 'apple_music' ?\n      'appleMusicSong' :\n      src);\n      if (this.queue.hasDebugger)\n      this.queue.debug(\n        `Executing onBeforeCreateStream hook (QueryType: ${qt})...`\n      );\n\n      const streamSrc = {\n        error: null as Error | null,\n        stream: null as ExtractorStreamable | null\n      };\n\n      await this.queue.\n      onBeforeCreateStream?.(track, qt || 'arbitrary', this.queue).\n      then(\n        (s) => {\n          if (s) {\n            streamSrc.stream = s;\n          }\n        },\n        (e: Error) => streamSrc.error = e\n      );\n\n      // throw if 'onBeforeCreateStream' panics\n      if (!streamSrc.stream && streamSrc.error)\n      return this.#throw(track, streamSrc.error);\n\n      // default behavior when 'onBeforeCreateStream' did not panic\n      if (!streamSrc.stream) {\n        if (this.queue.hasDebugger)\n        this.queue.debug(\n          'Failed to get stream from onBeforeCreateStream, attempting to extract stream using extractors...'\n        );\n        await this.queue.player.extractors.context.provide(\n          {\n            id: crypto.randomUUID(),\n            attemptedExtractors: new Set<string>(),\n            bridgeAttemptedExtractors: new Set<string>()\n          },\n          () =>\n          this.#createGenericStream(track).\n          then(async (r) => {\n            if (r?.result) {\n              streamSrc.stream =\n              <Readable> (\n              await this.queue.onStreamExtracted?.(\n                r.result,\n                track,\n                this.queue\n              )) ??\n              r.result;\n              return;\n            }\n\n            if (r?.error) {\n              streamSrc.error = r.error;\n              return;\n            }\n\n            streamSrc.stream = streamSrc.error = null;\n          }).\n          catch((e: Error) => streamSrc.error = e)\n        );\n      }\n\n      if (!streamSrc.stream) return this.#throw(track, streamSrc.error);\n\n      if (typeof options.seek === 'number' && options.seek >= 0) {\n        this.#progress = options.seek;\n      } else {\n        this.#progress = 0;\n      }\n\n      const trackStreamConfig: StreamConfig = {\n        dispatcherConfig: {\n          disableBiquad: this.queue.options.disableBiquad,\n          disableEqualizer: this.queue.options.disableEqualizer,\n          disableVolume: this.queue.options.disableVolume,\n          disableFilters: this.queue.options.disableFilterer,\n          disableResampler: this.queue.options.disableResampler,\n          disableCompressor: this.queue.options.disableCompressor,\n          disableReverb: this.queue.options.disableReverb,\n          disableSeeker: this.queue.options.disableSeeker,\n          compressor:\n          this.queue.filters._lastFiltersCache.compressor ?? undefined,\n          reverb: this.queue.filters._lastFiltersCache.reverb ?? undefined,\n          seeker: {\n            seekTarget:\n            options.transitionMode && options.seek != null ?\n            options.seek :\n            null,\n            totalDuration: track.durationMS ?? 0\n          },\n          sampleRate:\n          this.queue.filters._lastFiltersCache.sampleRate ?? (\n          typeof this.queue.options.resampler === 'number' &&\n          this.queue.options.resampler > 0 ?\n          this.queue.options.resampler :\n          undefined),\n          biquadFilter:\n          this.queue.filters._lastFiltersCache.biquad || undefined,\n          eq: this.queue.filters._lastFiltersCache.equalizer,\n          defaultFilters: this.queue.filters._lastFiltersCache.filters,\n          volume: this.queue.filters._lastFiltersCache.volume,\n          data: track,\n          type: StreamType.Raw,\n          skipFFmpeg: this.queue.player.options.skipFFmpeg\n        },\n        playerConfig: options\n      };\n\n      let resolver: () => void = Util.noop;\n      const donePromise = new Promise<void>((resolve) => resolver = resolve);\n\n      const success = this.queue.emit(\n        GuildQueueEvent.WillPlayTrack,\n        this.queue,\n        track,\n        trackStreamConfig,\n        resolver!\n      );\n\n      // prevent dangling promise\n      if (!success) resolver();\n\n      if (this.queue.hasDebugger)\n      this.queue.debug('Waiting for willPlayTrack event to resolve...');\n\n      await donePromise;\n\n      const daspDisabled = [\n      trackStreamConfig.dispatcherConfig.disableBiquad,\n      trackStreamConfig.dispatcherConfig.disableEqualizer,\n      trackStreamConfig.dispatcherConfig.disableFilters,\n      trackStreamConfig.dispatcherConfig.disableResampler,\n      trackStreamConfig.dispatcherConfig.disableVolume,\n      trackStreamConfig.dispatcherConfig.disableCompressor,\n      trackStreamConfig.dispatcherConfig.disableReverb,\n      trackStreamConfig.dispatcherConfig.disableSeeker].\n      every((e) => !!e === true);\n\n      const needsFilters =\n      !!trackStreamConfig.playerConfig.seek ||\n      !!this.queue.filters.ffmpeg.args.length;\n      const shouldSkipFFmpeg =\n      !!trackStreamConfig.dispatcherConfig.skipFFmpeg && !needsFilters;\n\n      let finalStream: Readable;\n\n      const demuxable = (fmt: string) =>\n      [\n      StreamType.Opus,\n      StreamType.WebmOpus,\n      StreamType.OggOpus,\n      StreamType.Raw,\n      'pcm'].\n      includes(fmt as StreamType);\n\n      // skip ffmpeg when possible\n      if (\n      shouldSkipFFmpeg &&\n      !(streamSrc.stream instanceof Readable) &&\n      typeof streamSrc.stream !== 'string' &&\n      demuxable(streamSrc.stream.$fmt))\n      {\n        const { $fmt, stream } = streamSrc.stream;\n        const shouldPCM = !daspDisabled;\n\n        if (this.queue.hasDebugger)\n        this.queue.debug(\n          `skipFFmpeg is set to true and stream is demuxable, creating stream with type ${\n          shouldPCM ? 'pcm' : 'opus'}`\n\n        );\n\n        const isRaw = $fmt === 'pcm' || $fmt === StreamType.Raw;\n\n        // prettier-ignore\n        const opusStream =\n        isRaw || $fmt === StreamType.Opus ?\n        stream :\n        $fmt === StreamType.OggOpus ?\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        stream.pipe(new OggDemuxer() as any) :\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        stream.pipe(new WebmDemuxer() as any);\n\n        if (shouldPCM) {\n          if (isRaw) {\n            finalStream = opusStream;\n          } else {\n            // if we have any filters enabled, we need to decode the opus stream to pcm\n            finalStream = opusStream.pipe(\n              new OpusDecoder({\n                channels: 2,\n                frameSize: 960,\n                rate: 48000\n              })\n            );\n            trackStreamConfig.dispatcherConfig.type = StreamType.Raw;\n          }\n        } else {\n          finalStream = opusStream;\n          trackStreamConfig.dispatcherConfig.type = StreamType.Opus;\n        }\n      } else {\n        // const opus = daspDisabled && this.#hasFFmpegOptimization;\n        // if (opus && this.queue.hasDebugger) this.queue.debug('Disabling PCM output since all filters are disabled and opus encoding is supported...');\n\n        finalStream = this.#createFFmpegStream(\n          streamSrc.stream instanceof Readable ||\n          typeof streamSrc.stream === 'string' ?\n          streamSrc.stream :\n          streamSrc.stream.stream,\n          track,\n          options.seek ?? 0\n          // opus\n        );\n        trackStreamConfig.dispatcherConfig.type = StreamType.Raw;\n        // FIXME: OggOpus results in static noise\n        // trackStreamConfig.dispatcherConfig.type = opus ? StreamType.OggOpus : StreamType.Raw;\n      }\n\n      if (options.transitionMode) {\n        if (this.queue.hasDebugger)\n        this.queue.debug(\n          `Transition mode detected, player will wait for buffering timeout to expire (Timeout: ${this.queue.options.bufferingTimeout}ms)`\n        );\n        await waitFor(this.queue.options.bufferingTimeout);\n        if (this.queue.hasDebugger)\n        this.queue.debug('Buffering timeout has expired!');\n      }\n\n      if (this.queue.hasDebugger)\n      this.queue.debug(\n        `Preparing final stream config: ${JSON.stringify(\n          trackStreamConfig,\n          null,\n          2\n        )}`\n      );\n\n      const dispatcher = this.queue.dispatcher;\n\n      if (!dispatcher) {\n        if (this.queue.hasDebugger) {\n          this.queue.debug(\n            'Dispatcher is not available, this is most likely due to the queue being deleted in the middle of operation. Cancelling the stream...'\n          );\n        }\n\n        finalStream.destroy();\n      } else {\n        const resource = await dispatcher.createStream(\n          finalStream,\n          trackStreamConfig.dispatcherConfig\n        );\n\n        this.queue.setTransitioning(!!options.transitionMode);\n\n        await this.#performPlay(resource);\n      }\n    } catch (e) {\n      if (this.queue.hasDebugger)\n      this.queue.debug(`Failed to initialize audio player: ${e}`);\n      throw e;\n    }\n  }\n\n  #throw(track: Track, error?: Error | null): void {\n    // prettier-ignore\n    const streamDefinitelyFailedMyDearT_TPleaseTrustMeItsNotMyFault =\n    new NoResultError(`Could not extract stream for this track${error ? `\\n\\n${error.stack || error}` : ''}`);\n\n\n    this.queue.emit(\n      GuildQueueEvent.PlayerSkip,\n      this.queue,\n      track,\n      TrackSkipReason.NoStream,\n      streamDefinitelyFailedMyDearT_TPleaseTrustMeItsNotMyFault.message\n    );\n    this.queue.emit(\n      GuildQueueEvent.PlayerError,\n      this.queue,\n      streamDefinitelyFailedMyDearT_TPleaseTrustMeItsNotMyFault,\n      track\n    );\n    const nextTrack = this.queue.tracks.dispatch();\n    if (nextTrack) return void this.play(nextTrack, { queue: false });\n    // @ts-expect-error should be resolved\n    this.queue.dispatcher?.emit('finish', null);\n  }\n\n  async #performPlay(resource: AudioResource<Track>) {\n    if (!this.queue.dispatcher) {\n      if (this.queue.hasDebugger) {\n        this.queue.debug(\n          'Dispatcher is not available, this is most likely due to the queue being deleted in the middle of operation. Cancelling the stream...'\n        );\n      }\n    } else {\n      if (this.queue.hasDebugger)\n      this.queue.debug('Initializing audio player...');\n      await this.queue.dispatcher.playStream(resource);\n      if (this.queue.hasDebugger) this.queue.debug('Dispatching audio...');\n    }\n  }\n\n  async #createGenericStream(track: Track) {\n    if (this.queue.hasDebugger)\n    this.queue.debug(\n      `Attempting to extract stream for Track { title: ${track.title}, url: ${track.url} } using registered extractors`\n    );\n\n    const attemptedExtractors =\n    this.queue.player.extractors.getContext()?.attemptedExtractors ||\n    new Set<string>();\n\n    const streamInfo = await this.queue.player.extractors.run(\n      async (extractor) => {\n        if (\n        this.queue.player.options.blockStreamFrom?.some(\n          (ext) => ext === extractor.identifier\n        ))\n\n        return false;\n        if (attemptedExtractors.has(extractor.identifier)) return false;\n        attemptedExtractors.add(extractor.identifier);\n        const canStream = await extractor.validate(\n          track.url,\n          track.queryType || QueryResolver.resolve(track.url).type\n        );\n        if (!canStream) return false;\n        return await extractor.stream(track);\n      },\n      false\n    );\n\n    if (!streamInfo || !streamInfo.result) {\n      if (this.queue.hasDebugger) {\n        this.queue.debug(\n          `Failed to extract stream for Track { title: ${track.title}, url: ${track.url} } using registered extractors`\n        );\n      }\n\n      if (!this.queue.options.disableFallbackStream) {\n        if (this.queue.hasDebugger)\n        this.queue.debug(\n          `Generic stream extraction failed and fallback stream extraction is enabled`\n        );\n        return this.#createFallbackStream(track);\n      }\n\n      return streamInfo || null;\n    }\n\n    if (this.queue.hasDebugger)\n    this.queue.debug(\n      `Stream extraction was successful for Track { title: ${\n      track.title}, url: ${\n      track.url} } (Extractor: ${\n      streamInfo.extractor?.identifier || 'N/A'})`\n\n    );\n\n    return streamInfo;\n  }\n\n  async #createFallbackStream(track: Track) {\n    if (this.queue.hasDebugger)\n    this.queue.debug(\n      `Attempting to extract stream for Track { title: ${track.title}, url: ${track.url} } using fallback streaming method...`\n    );\n\n    const verifyFallbackStream = this.queue.options.verifyFallbackStream;\n\n    const fallbackStream = await this.queue.player.extractors.run(\n      async (extractor) => {\n        if (extractor.identifier === track.extractor?.identifier) return false;\n        if (\n        this.queue.player.options.blockStreamFrom?.some(\n          (ext) => ext === extractor.identifier\n        ))\n        {\n          return false;\n        }\n\n        const query = `${track.title} ${track.author}`;\n\n        if (verifyFallbackStream) {\n          if (this.queue.hasDebugger) {\n            this.queue.debug(\n              `Fallback stream verification is enabled, validating query for Track { title: ${track.title}, url: ${track.url} } using ${extractor.identifier}...`\n            );\n          }\n\n          const shouldProceed = await extractor.validate(\n            query,\n            track.queryType || track.source\n          );\n\n          if (!shouldProceed) {\n            if (this.queue.hasDebugger)\n            this.queue.debug(\n              `Failed to validate query for Track { title: ${track.title}, url: ${track.url} } using ${extractor.identifier}`\n            );\n            return false;\n          } else {\n            if (this.queue.hasDebugger)\n            this.queue.debug(\n              `Query for Track { title: ${track.title}, url: ${track.url} } was validated using ${extractor.identifier}. Proceeding with extraction...`\n            );\n          }\n        }\n\n        const fallbackTracks = await extractor.handle(query, {\n          requestedBy: track.requestedBy\n        });\n\n        const fallbackTrack = fallbackTracks.tracks[0];\n\n        if (!fallbackTrack) return false;\n\n        const stream = await extractor.stream(fallbackTrack);\n\n        if (!stream) return false;\n\n        track.bridgedTrack = fallbackTrack;\n\n        return stream;\n      },\n      true\n    );\n\n    if (!fallbackStream || !fallbackStream.result) {\n      if (this.queue.hasDebugger)\n      this.queue.debug(\n        `Failed to extract stream for Track { title: ${track.title}, url: ${track.url} } using fallback streaming method`\n      );\n      return fallbackStream || null;\n    }\n\n    track.bridgedExtractor = fallbackStream.extractor;\n\n    return fallbackStream;\n  }\n\n  #createFFmpegStream(\n  stream: Readable | string,\n  track: Track,\n  seek = 0,\n  opus?: boolean)\n  {\n    const ffmpegStream = this.queue.filters.ffmpeg.\n    createStream(stream, {\n      encoderArgs: this.queue.filters.ffmpeg.args,\n      seek: seek / 1000,\n      fmt: opus ? 'opus' : 's16le',\n      requestOptions: track.raw?.requestOptions\n    }).\n    on('error', (err) => {\n      const m = `${err}`.toLowerCase();\n\n      if (this.queue.hasDebugger)\n      this.queue.debug(\n        `Stream closed due to an error from FFmpeg stream: ${\n        err.stack || err.message || err}`\n\n      );\n\n      if (m.includes('premature close') || m.includes('epipe')) return;\n\n      this.queue.emit(GuildQueueEvent.PlayerError, this.queue, err, track);\n    });\n\n    return ffmpegStream;\n  }\n}", "import { SnowflakeUtil } from 'discord.js';\n\nexport interface AsyncQueueAcquisitionOptions {\n  /**\n   * AbortSignal to cancel this entry\n   */\n  signal?: AbortSignal;\n}\n\nexport type AsyncQueueExceptionHandler = (exception: Error) => void;\n\nexport class AsyncQueue {\n  /**\n   * The queued entries\n   */\n  public entries: Array<AsyncQueueEntry> = [];\n\n  public exceptionHandler?: AsyncQueueExceptionHandler;\n\n  /**\n   * Clear entries queue\n   * @param consume Whether or not to consume all entries before clearing\n   */\n  public clear(consume = false) {\n    if (consume) {\n      this.entries.forEach((entry) => entry.consume());\n    }\n\n    this.entries = [];\n  }\n\n  /**\n   * The total number of entries in this queue. Returns `0` if no entries are available.\n   */\n  public get size() {\n    return this.entries.length;\n  }\n\n  /**\n   * Acquire an entry.\n   *\n   * @example // lock the queue\n   * const entry = asyncQueue.acquire();\n   * // wait until previous task is completed\n   * await entry.getTask();\n   * // do something expensive\n   * await performSomethingExpensive();\n   * // make sure to release the lock once done\n   * asyncQueue.release();\n   *\n   */\n  public acquire(options?: AsyncQueueAcquisitionOptions) {\n    const entry = new AsyncQueueEntry(this, options);\n\n    if (this.exceptionHandler) entry.getTask().catch(this.exceptionHandler);\n\n    if (this.entries.length === 0) {\n      this.entries.push(entry);\n      entry.consume();\n      return entry;\n    }\n\n    this.entries.push(entry);\n    return entry;\n  }\n\n  /**\n   * Release the current acquisition and move to next entry.\n   */\n  public release(): void {\n    if (!this.entries.length) return;\n\n    this.entries.shift();\n    this.entries[0]?.consume();\n  }\n\n  /**\n   * Cancel all entries\n   */\n  public cancelAll() {\n    this.entries.forEach((entry) => entry.cancel());\n  }\n\n  /**\n   * Remove the given entry from the queue\n   * @param entry The entry to remove\n   */\n  public removeEntry(entry: AsyncQueueEntry) {\n    const entryIdx = this.entries.indexOf(entry);\n\n    if (entryIdx !== -1) {\n      this.entries.splice(entryIdx, 1);\n      return true;\n    }\n\n    return false;\n  }\n}\n\nexport class AsyncQueueEntry {\n  public readonly id = SnowflakeUtil.generate().toString();\n  private readonly promise: Promise<void>;\n  public signal: AbortSignal | null = null;\n  public onAbort: (() => void) | null = null;\n  private resolve!: () => void;\n  private reject!: (err: Error) => void;\n\n  public constructor(\n  public queue: AsyncQueue,\n  public options?: AsyncQueueAcquisitionOptions)\n  {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve;\n      this.reject = reject;\n    });\n\n    if (this.options?.signal) {\n      this.setAbortSignal(this.options.signal);\n    }\n  }\n\n  public setAbortSignal(signal: AbortSignal) {\n    if (signal.aborted) return;\n    this.signal = signal;\n    this.onAbort = () => {\n      this.queue.removeEntry(this);\n      this.cancel();\n    };\n\n    this.signal.addEventListener('abort', this.onAbort);\n  }\n\n  public consume() {\n    this.cleanup();\n    this.resolve();\n  }\n\n  public release() {\n    this.consume();\n    this.queue.release();\n  }\n\n  public cancel() {\n    this.cleanup();\n    this.reject(new Error('Cancelled'));\n  }\n\n  public cleanup() {\n    if (this.onAbort) this.signal?.removeEventListener('abort', this.onAbort);\n    this.signal = null;\n    this.onAbort = null;\n  }\n\n  public getTask() {\n    return this.promise;\n  }\n}", "import { Readable } from 'stream';\nimport { AudioFilters, FiltersName, QueueFilters } from '../utils/AudioFilters';\nimport { GuildQueue, GuildQueueEvent } from './GuildQueue';\nimport {\n  BiquadFilters,\n  Equalizer,\n  EqualizerBand,\n  PCMFilters } from\n'@discord-player/equalizer';\nimport { FFmpegStreamOptions, createFFmpegStream } from '../utils/FFmpegStream';\nimport { InvalidArgTypeError } from '../errors';\nimport { StreamConfig } from './GuildQueuePlayerNode';\n\ntype Filters = keyof typeof AudioFilters.filters;\n\nconst makeBands = (arr: number[]) => {\n  return Array.from(\n    {\n      length: Equalizer.BAND_COUNT\n    },\n    (_, i) => ({\n      band: i,\n      gain: arr[i] ? arr[i] / 30 : 0\n    })\n  ) as EqualizerBand[];\n};\n\ntype EQPreset = {\n  Flat: EqualizerBand[];\n  Classical: EqualizerBand[];\n  Club: EqualizerBand[];\n  Dance: EqualizerBand[];\n  FullBass: EqualizerBand[];\n  FullBassTreble: EqualizerBand[];\n  FullTreble: EqualizerBand[];\n  Headphones: EqualizerBand[];\n  LargeHall: EqualizerBand[];\n  Live: EqualizerBand[];\n  Party: EqualizerBand[];\n  Pop: EqualizerBand[];\n  Reggae: EqualizerBand[];\n  Rock: EqualizerBand[];\n  Ska: EqualizerBand[];\n  Soft: EqualizerBand[];\n  SoftRock: EqualizerBand[];\n  Techno: EqualizerBand[];\n};\n\nexport const EqualizerConfigurationPreset: Readonly<EQPreset> = Object.freeze({\n  Flat: makeBands([]),\n  Classical: makeBands([\n  -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15,\n  -1.11022e-15, -7.2, -7.2, -7.2, -9.6]\n  ),\n  Club: makeBands([\n  -1.11022e-15, -1.11022e-15, 8.0, 5.6, 5.6, 5.6, 3.2, -1.11022e-15,\n  -1.11022e-15, -1.11022e-15]\n  ),\n  Dance: makeBands([\n  9.6, 7.2, 2.4, -1.11022e-15, -1.11022e-15, -5.6, -7.2, -7.2, -1.11022e-15,\n  -1.11022e-15]\n  ),\n  FullBass: makeBands([\n  -8.0, 9.6, 9.6, 5.6, 1.6, -4.0, -8.0, -10.4, -11.2, -11.2]\n  ),\n  FullBassTreble: makeBands([\n  7.2, 5.6, -1.11022e-15, -7.2, -4.8, 1.6, 8.0, 11.2, 12.0, 12.0]\n  ),\n  FullTreble: makeBands([\n  -9.6, -9.6, -9.6, -4.0, 2.4, 11.2, 16.0, 16.0, 16.0, 16.8]\n  ),\n  Headphones: makeBands([\n  4.8, 11.2, 5.6, -3.2, -2.4, 1.6, 4.8, 9.6, 12.8, 14.4]\n  ),\n  LargeHall: makeBands([\n  10.4, 10.4, 5.6, 5.6, -1.11022e-15, -4.8, -4.8, -4.8, -1.11022e-15,\n  -1.11022e-15]\n  ),\n  Live: makeBands([-4.8, -1.11022e-15, 4.0, 5.6, 5.6, 5.6, 4.0, 2.4, 2.4, 2.4]),\n  Party: makeBands([\n  7.2, 7.2, -1.11022e-15, -1.11022e-15, -1.11022e-15, -1.11022e-15,\n  -1.11022e-15, -1.11022e-15, 7.2, 7.2]\n  ),\n  Pop: makeBands([\n  -1.6, 4.8, 7.2, 8.0, 5.6, -1.11022e-15, -2.4, -2.4, -1.6, -1.6]\n  ),\n  Reggae: makeBands([\n  -1.11022e-15, -1.11022e-15, -1.11022e-15, -5.6, -1.11022e-15, 6.4, 6.4,\n  -1.11022e-15, -1.11022e-15, -1.11022e-15]\n  ),\n  Rock: makeBands([8.0, 4.8, -5.6, -8.0, -3.2, 4.0, 8.8, 11.2, 11.2, 11.2]),\n  Ska: makeBands([\n  -2.4, -4.8, -4.0, -1.11022e-15, 4.0, 5.6, 8.8, 9.6, 11.2, 9.6]\n  ),\n  Soft: makeBands([\n  4.8, 1.6, -1.11022e-15, -2.4, -1.11022e-15, 4.0, 8.0, 9.6, 11.2, 12.0]\n  ),\n  SoftRock: makeBands([\n  4.0, 4.0, 2.4, -1.11022e-15, -4.0, -5.6, -3.2, -1.11022e-15, 2.4, 8.8]\n  ),\n  Techno: makeBands([\n  8.0, 5.6, -1.11022e-15, -5.6, -4.8, -1.11022e-15, 8.0, 9.6, 9.6, 8.8]\n  )\n});\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class FFmpegFilterer<Meta = any> {\n  #ffmpegFilters: Filters[] = [];\n  #inputArgs: string[] = [];\n\n  public constructor(public af: GuildQueueAudioFilters<Meta>) {}\n\n  /**\n   * Indicates whether ffmpeg may be skipped\n   */\n  public get skippable() {\n    return !!this.af.queue.player.options.skipFFmpeg;\n  }\n\n  #setFilters(filters: Filters[]) {\n    const { queue } = this.af;\n    // skip if filters are the same\n    if (\n    filters.every((f) => this.#ffmpegFilters.includes(f)) &&\n    this.#ffmpegFilters.every((f) => filters.includes(f)))\n\n    return Promise.resolve(false);\n    const ignoreFilters =\n    this.filters.some((ff) => ff === 'nightcore' || ff === 'vaporwave') &&\n    !filters.some((ff) => ff === 'nightcore' || ff === 'vaporwave');\n    const seekTime = queue.node.getTimestamp(ignoreFilters)?.current.value || 0;\n    const prev = this.#ffmpegFilters.slice();\n    this.#ffmpegFilters = [...new Set(filters)];\n\n    return this.af.triggerReplay(seekTime).then((t) => {\n      queue.emit(\n        GuildQueueEvent.AudioFiltersUpdate,\n        queue,\n        prev,\n        this.#ffmpegFilters.slice()\n      );\n      return t;\n    });\n  }\n\n  /**\n   * Set input args for FFmpeg\n   */\n  public setInputArgs(args: string[]) {\n    if (!args.every((arg) => typeof arg === 'string'))\n    throw new InvalidArgTypeError('args', 'Array<string>', 'invalid item(s)');\n    this.#inputArgs = args;\n  }\n\n  /**\n   * Get input args\n   */\n  public get inputArgs() {\n    return this.#inputArgs;\n  }\n\n  /**\n   * Get encoder args\n   */\n  public get encoderArgs() {\n    if (!this.filters.length) return [];\n\n    return ['-af', this.toString()];\n  }\n\n  /**\n   * Get final ffmpeg args\n   */\n  public get args() {\n    return this.inputArgs.concat(this.encoderArgs);\n  }\n\n  /**\n   * Create ffmpeg stream\n   * @param source The stream source\n   * @param options The stream options\n   */\n  public createStream(source: string | Readable, options: FFmpegStreamOptions) {\n    if (this.#inputArgs.length)\n    options.encoderArgs = [\n    ...this.#inputArgs,\n    ...(options.encoderArgs || [])];\n\n\n    const stream = createFFmpegStream(source, options);\n\n    return stream;\n  }\n\n  /**\n   * Set ffmpeg filters\n   * @param filters The filters\n   */\n  public setFilters(\n  filters: Filters[] | Record<Filters, boolean> | string[] | boolean)\n  {\n    let _filters: Filters[] = [];\n    if (typeof filters === 'boolean') {\n      _filters = !filters ?\n      [] :\n      Object.keys(AudioFilters.filters) as Filters[];\n    } else if (Array.isArray(filters)) {\n      _filters = filters as Filters[];\n    } else {\n      _filters = Object.entries(filters).\n      filter((res) => res[1] === true).\n      map((m) => m[0]) as Filters[];\n    }\n\n    return this.#setFilters(_filters);\n  }\n\n  /**\n   * Currently active ffmpeg filters\n   */\n  public get filters() {\n    return this.#ffmpegFilters;\n  }\n\n  public set filters(filters: Filters[]) {\n    this.setFilters(filters);\n  }\n\n  /**\n   * Toggle given ffmpeg filter(s)\n   * @param filters The filter(s)\n   */\n  public toggle(filters: Filters[] | Filters) {\n    if (!Array.isArray(filters)) filters = [filters];\n    const fresh: Filters[] = [];\n\n    filters.forEach((f) => {\n      if (this.filters.includes(f)) return;\n      fresh.push(f);\n    });\n\n    return this.#setFilters(\n      this.#ffmpegFilters.filter((r) => !filters.includes(r)).concat(fresh)\n    );\n  }\n\n  /**\n   * Set default filters\n   * @param ff Filters list\n   */\n  public setDefaults(ff: Filters[]) {\n    this.#ffmpegFilters = ff;\n  }\n\n  /**\n   * Get list of enabled filters\n   */\n  public getFiltersEnabled() {\n    return this.#ffmpegFilters;\n  }\n\n  /**\n   * Get list of disabled filters\n   */\n  public getFiltersDisabled() {\n    return AudioFilters.names.filter((f) => !this.#ffmpegFilters.includes(f));\n  }\n\n  /**\n   * Check if the given filter is enabled\n   * @param filter The filter\n   */\n  public isEnabled<T extends Filters>(filter: T): boolean {\n    return this.#ffmpegFilters.includes(filter);\n  }\n\n  /**\n   * Check if the given filter is disabled\n   * @param filter The filter\n   */\n  public isDisabled<T extends Filters>(filter: T): boolean {\n    return !this.isEnabled(filter);\n  }\n\n  /**\n   * Check if the given filter is a valid filter\n   * @param filter The filter to test\n   */\n  public isValidFilter(filter: string): filter is FiltersName {\n    return AudioFilters.has(filter as Filters);\n  }\n\n  /**\n   * Convert current filters to array\n   */\n  public toArray() {\n    return this.filters.map((filter) => AudioFilters.get(filter));\n  }\n\n  /**\n   * Convert current filters to JSON object\n   */\n  public toJSON() {\n    const obj = {} as Record<keyof QueueFilters, string>;\n\n    this.filters.forEach((filter) => obj[filter] = AudioFilters.get(filter));\n\n    return obj;\n  }\n\n  /**\n   * String representation of current filters\n   */\n  public toString() {\n    return AudioFilters.create(this.filters);\n  }\n}\n\nexport interface GuildQueueAFiltersCache {\n  equalizer: EqualizerBand[];\n  biquad: BiquadFilters | null;\n  filters: PCMFilters[];\n  volume: number;\n  sampleRate: number;\n  sampleRateFilter:\n  StreamConfig['dispatcherConfig']['sampleRateFilters'] |\n  null;\n  compressor: StreamConfig['dispatcherConfig']['compressor'] | null;\n  reverb: StreamConfig['dispatcherConfig']['reverb'] | null;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class GuildQueueAudioFilters<Meta = any> {\n  public graph = new AFilterGraph<Meta>(this);\n  public ffmpeg = new FFmpegFilterer<Meta>(this);\n  public equalizerPresets = EqualizerConfigurationPreset;\n  public _lastFiltersCache: GuildQueueAFiltersCache = {\n    biquad: null,\n    equalizer: [],\n    filters: [],\n    volume: 100,\n    sampleRate: -1,\n    compressor: null,\n    reverb: null,\n    sampleRateFilter: null\n  };\n  public constructor(public queue: GuildQueue<Meta>) {\n    if (typeof this.queue.options.volume === 'number') {\n      this._lastFiltersCache.volume = this.queue.options.volume;\n    }\n  }\n\n  // TODO: enable this in the future\n  // public get ffmpeg(): FFmpegFilterer<Meta> | null {\n  //     if (this.queue.player.options.skipFFmpeg) {\n  //         if (this.#ffmpeg) this.#ffmpeg = null;\n  //         return null;\n  //     }\n\n  //     if (!this.#ffmpeg) {\n  //         this.#ffmpeg = new FFmpegFilterer<Meta>(this);\n  //     }\n\n  //     return this.#ffmpeg;\n  // }\n\n  /**\n   * Volume transformer\n   */\n  public get volume() {\n    return this.queue.dispatcher?.dsp?.volume || null;\n  }\n\n  /**\n   * 15 Band Equalizer\n   */\n  public get equalizer() {\n    return this.queue.dispatcher?.equalizer || null;\n  }\n\n  /**\n   * Digital biquad filters\n   */\n  public get biquad() {\n    return this.queue.dispatcher?.biquad || null;\n  }\n\n  /**\n   * DSP filters\n   */\n  public get filters() {\n    return this.queue.dispatcher?.filters || null;\n  }\n\n  /**\n   * Audio resampler\n   */\n  public get resampler() {\n    return this.queue.dispatcher?.resampler || null;\n  }\n\n  /**\n   * Compressor transformer\n   */\n  public get compressor() {\n    return this.queue.dispatcher?.compressor || null;\n  }\n\n  /**\n   * Reverb transformer\n   */\n  public get reverb() {\n    return this.queue.dispatcher?.reverb || null;\n  }\n\n  /**\n   * PCM Seeker transformer\n   */\n  public get seeker() {\n    return this.queue.dispatcher?.seeker || null;\n  }\n\n  /**\n   * Replay current track in transition mode\n   * @param seek The duration to seek to\n   */\n  public async triggerReplay(seek = 0) {\n    if (!this.queue.currentTrack) return false;\n    const entry = this.queue.node.tasksQueue.acquire();\n    try {\n      await entry.getTask();\n      await this.queue.node.play(this.queue.currentTrack, {\n        queue: false,\n        seek,\n        transitionMode: true\n      });\n      this.queue.node.tasksQueue.release();\n      return true;\n    } catch {\n      this.queue.node.tasksQueue.release();\n      return false;\n    }\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class AFilterGraph<Meta = any> {\n  public constructor(public af: GuildQueueAudioFilters<Meta>) {}\n\n  public get ffmpeg() {\n    return this.af.ffmpeg?.filters ?? [];\n  }\n\n  public get equalizer() {\n    return (this.af.equalizer?.bandMultipliers || []).map((m, i) => ({\n      band: i,\n      gain: m\n    })) as EqualizerBand[];\n  }\n\n  public get biquad() {\n    return (\n      this.af.biquad?.getFilterName() as Exclude<\n        BiquadFilters,\n        number> |\n      null || null);\n\n  }\n\n  public get filters() {\n    return this.af.filters?.filters || [];\n  }\n\n  public get volume() {\n    return this.af.volume;\n  }\n\n  public get resampler() {\n    return this.af.resampler;\n  }\n\n  public dump(): FilterGraph {\n    return {\n      ffmpeg: this.ffmpeg,\n      equalizer: this.equalizer,\n      biquad: this.biquad,\n      filters: this.filters,\n      sampleRate: this.resampler?.sampleRate || 48000,\n      volume: this.volume?.volume ?? 100\n    };\n  }\n}\n\nexport interface FilterGraph {\n  ffmpeg: Filters[];\n  equalizer: EqualizerBand[];\n  biquad: Exclude<BiquadFilters, number> | null;\n  filters: PCMFilters[];\n  volume: number;\n  sampleRate: number;\n}", "import type { Duplex, Readable } from 'stream';\nimport { FFmpeg, createFFmpegArgs } from '@discord-player/ffmpeg';\nimport type { RequestOptions } from 'http';\n\nexport interface FFmpegStreamOptions {\n  fmt?: string;\n  encoderArgs?: string[];\n  seek?: number;\n  skip?: boolean;\n  cookies?: string;\n  requestOptions?: RequestOptions;\n}\n\nexport function FFMPEG_ARGS_STRING(\nstream: string,\nfmt?: string,\ncookies?: string,\nrequestOptions?: RequestOptions)\n{\n  // Build array manually to handle HTTP options properly\n  const args: string[] = [];\n\n  // Add reconnection options\n  args.push('-reconnect', '1');\n  args.push('-reconnect_streamed', '1');\n  args.push('-reconnect_delay_max', '5');\n\n  // Add HTTP headers if provided - FFmpeg HTTP protocol format, thank god it started working...\n  if (requestOptions?.headers) {\n    const userAgent =\n    requestOptions.headers['user-agent'] ||\n    requestOptions.headers['User-Agent'];\n    if (userAgent) {\n      args.push('-user_agent', String(userAgent));\n    }\n\n    // Add other headers using FFmpeg's headers option\n    const formattedHeaders = formatFFmpegHeaders(\n      requestOptions.headers as NodeJS.Dict<string | string[]>\n    );\n    if (formattedHeaders) {\n      args.push('-headers', formattedHeaders);\n    }\n  }\n\n  // Add cookies if provided\n  if (typeof cookies === 'string') {\n    const cookieValue = !cookies.includes(' ') ? cookies : `\"${cookies}\"`;\n    args.push('-cookies', cookieValue);\n  }\n\n  // Add input URL\n  args.push('-i', stream);\n\n  // Add audio processing options\n  args.push('-analyzeduration', '0');\n  args.push('-loglevel', '0');\n  args.push('-ar', '48000');\n  args.push('-ac', '2');\n  args.push('-f', typeof fmt === 'string' ? fmt : 's16le');\n\n  if (fmt === 'opus') {\n    args.push('-acodec', 'libopus');\n  }\n  return args;\n}\n\nfunction formatFFmpegHeaders(\nheaders: NodeJS.Dict<string | string[]>)\n: string | null {\n  const headerPairs: string[] = [];\n\n  for (const [name, value] of Object.entries(headers)) {\n    if (value && name.toLowerCase() !== 'user-agent') {\n      const valueStr = Array.isArray(value) ? value.join(', ') : String(value);\n      headerPairs.push(`${name}: ${valueStr}`);\n    }\n  }\n\n  return headerPairs.length > 0 ? headerPairs.join('\\r\\n') : null;\n}\n\nexport function FFMPEG_ARGS_PIPED(fmt?: string) {\n  const args = createFFmpegArgs({\n    analyzeduration: 0,\n    loglevel: 0,\n    ar: 48000,\n    ac: 2,\n    f: `${typeof fmt === 'string' ? fmt : 's16le'}`,\n    acodec: fmt === 'opus' ? 'libopus' : null\n  });\n\n  return args;\n}\n\n/**\n * Creates FFmpeg stream\n * @param stream The source stream\n * @param options FFmpeg stream options\n */\nexport function createFFmpegStream(\nstream: Readable | Duplex | string,\noptions?: FFmpegStreamOptions)\n: Readable {\n  if (options?.skip && typeof stream !== 'string') return stream;\n  options ??= {};\n  const args =\n  typeof stream === 'string' ?\n  FFMPEG_ARGS_STRING(\n    stream,\n    options.fmt,\n    options.cookies,\n    options.requestOptions\n  ) :\n  FFMPEG_ARGS_PIPED(options.fmt);\n\n  if (!Number.isNaN(options.seek)) args.unshift('-ss', String(options.seek));\n  if (Array.isArray(options.encoderArgs)) args.push(...options.encoderArgs);\n\n  const transcoder = new FFmpeg({ shell: false, args });\n\n  transcoder.on('close', () => transcoder.destroy());\n\n  if (typeof stream !== 'string') {\n    stream.on('error', () => transcoder.destroy());\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    stream.pipe(transcoder as any);\n  }\n\n  return transcoder;\n}", "import { GuildQueue } from './GuildQueue';\n\nexport interface GuildQueueStatisticsMetadata {\n  latency: {\n    eventLoop: number;\n    voiceConnection: number;\n  };\n  status: {\n    buffering: boolean;\n    playing: boolean;\n    paused: boolean;\n    idle: boolean;\n  };\n  tracksCount: number;\n  historySize: number;\n  extractors: number;\n  listeners: number;\n  memoryUsage: NodeJS.MemoryUsage;\n  versions: {\n    node: string;\n    player: string;\n  };\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class GuildQueueStatistics<Meta = any> {\n  public constructor(public queue: GuildQueue<Meta>) {}\n\n  /**\n   * Generate statistics of this queue\n   */\n  public generate() {\n    return {\n      latency: {\n        eventLoop: this.queue.player.eventLoopLag,\n        voiceConnection: this.queue.ping\n      },\n      status: {\n        buffering: this.queue.node.isBuffering(),\n        playing: this.queue.node.isPlaying(),\n        paused: this.queue.node.isPaused(),\n        idle: this.queue.node.isIdle()\n      },\n      tracksCount: this.queue.tracks.size,\n      historySize: this.queue.history.tracks.size,\n      extractors: this.queue.player.extractors.size,\n      listeners:\n      this.queue.guild.members.me?.voice.channel?.members.filter(\n        (m) => !m.user.bot\n      ).size || 0,\n      memoryUsage: process.memoryUsage(),\n      versions: {\n        node: process.version,\n        player: this.queue.player.version\n      }\n    } as GuildQueueStatisticsMetadata;\n  }\n}", "import { NotExistingError } from '../errors';\nimport { LrcGetResult, LrcSearchResult } from '../lrclib/LrcLib';\nimport type { GuildQueue } from './GuildQueue';\n\nexport type LyricsData = Map<number, string>;\nexport type Unsubscribe = () => void;\nexport type LyricsCallback = (lyrics: string, timestamp: number) => unknown;\nexport type LyricsAt = {timestamp: number;line: string;};\n\nconst timestampPattern = /\\[(\\d{2}):(\\d{2})\\.(\\d{2})\\]/;\n\nexport class SyncedLyricsProvider {\n  #loop: NodeJS.Timeout | null = null;\n  #callback: LyricsCallback | null = null;\n  #onUnsubscribe: Unsubscribe | null = null;\n\n  public interval = 100;\n  public readonly lyrics: LyricsData = new Map();\n\n  public constructor(\n  public readonly queue: GuildQueue,\n  public readonly raw?: LrcGetResult | LrcSearchResult)\n  {\n    if (raw?.syncedLyrics) this.load(raw?.syncedLyrics);\n  }\n\n  public isSubscribed() {\n    return this.#callback !== null;\n  }\n\n  public load(lyrics: string) {\n    if (!lyrics) throw new NotExistingError('syncedLyrics');\n\n    this.lyrics.clear();\n    this.unsubscribe();\n\n    const lines = lyrics.split('\\n');\n\n    for (const line of lines) {\n      const match = line.match(timestampPattern);\n\n      if (match) {\n        const [, minutes, seconds, milliseconds] = match;\n        const timestamp =\n        parseInt(minutes) * 60 * 1000 +\n        parseInt(seconds) * 1000 +\n        parseInt(milliseconds);\n\n        this.lyrics.set(timestamp, line.replace(timestampPattern, '').trim());\n      }\n    }\n  }\n\n  /**\n   * Returns the lyrics at a specific time or at the closest time (\u00B12 seconds)\n   * @param time The time in milliseconds\n   */\n  public at(time: number): LyricsAt | null {\n    const lowestTime = this.lyrics.keys().next().value;\n    if (lowestTime == null || time < lowestTime) return null;\n    if (this.lyrics.has(time))\n    return { line: this.lyrics.get(time) as string, timestamp: time };\n\n    const keys = Array.from(this.lyrics.keys());\n\n    const closest = keys.reduce((a, b) =>\n    Math.abs(b - time) < Math.abs(a - time) ? b : a\n    );\n\n    if (closest > time) return null;\n\n    if (Math.abs(closest - time) > 2000) return null;\n\n    const line = this.lyrics.get(closest);\n\n    if (!line) return null;\n\n    return { timestamp: closest, line };\n  }\n\n  /**\n   * Callback for the lyrics change.\n   * @param callback The callback function\n   */\n  public onChange(callback: LyricsCallback) {\n    this.#callback = callback;\n  }\n\n  /**\n   * Callback to detect when the provider is unsubscribed.\n   * @param callback The callback function\n   */\n  public onUnsubscribe(callback: Unsubscribe) {\n    this.#onUnsubscribe = callback;\n  }\n\n  /**\n   * Unsubscribes from the queue.\n   */\n  public unsubscribe() {\n    if (this.#loop) clearInterval(this.#loop);\n    if (this.#onUnsubscribe) this.#onUnsubscribe();\n\n    this.#callback = null;\n    this.#onUnsubscribe = null;\n    this.#loop = null;\n  }\n\n  /**\n   * Subscribes to the queue to monitor the current time.\n   * @returns The unsubscribe function\n   */\n  public subscribe(): Unsubscribe {\n    if (this.#loop) return () => this.unsubscribe();\n\n    this.#createLoop();\n\n    return () => this.unsubscribe();\n  }\n\n  /**\n   * Pauses the lyrics provider.\n   */\n  public pause() {\n    const hasLoop = this.#loop !== null;\n\n    if (hasLoop) {\n      clearInterval(this.#loop!);\n      this.#loop = null;\n    }\n\n    return hasLoop;\n  }\n\n  /**\n   * Resumes the lyrics provider.\n   */\n  public resume() {\n    const hasLoop = this.#loop !== null;\n\n    if (!hasLoop) this.#createLoop();\n\n    return !hasLoop;\n  }\n\n  #createLoop() {\n    if (!this.#callback) return;\n    if (this.#loop) clearInterval(this.#loop);\n\n    let lastValue: LyricsAt | null = null;\n\n    this.#loop = setInterval(() => {\n      if (this.queue.deleted) return this.unsubscribe();\n\n      if (!this.#callback || !this.queue.isPlaying()) return;\n\n      const time = this.queue.node.getTimestamp();\n      if (!time) return;\n\n      const lyrics = this.at(time.current.value);\n\n      if (!lyrics) return;\n\n      if (\n      lastValue !== null &&\n      lyrics.line === lastValue.line &&\n      lyrics.timestamp === lastValue.timestamp)\n\n      return;\n\n      lastValue = lyrics;\n\n      this.#callback(lyrics.line, lyrics.timestamp);\n    }, this.interval).unref();\n  }\n}", "import { setTimeout } from 'timers/promises';\nimport { AsyncQueue } from './AsyncQueue';\n\nexport type RequestEntity = () => Promise<Response>;\n\nexport class SequentialBucket {\n  public limit = 1;\n  public remaining = 1;\n  public resetAfter = 0;\n  public queue = new AsyncQueue();\n  public MAX_RETRIES = 5;\n\n  /**\n   * Checks if the bucket is rate limited.\n   */\n  public isRateLimited() {\n    return this.remaining <= 0 && Date.now() < this.resetAfter;\n  }\n\n  /**\n   * Enqueues a request.\n   * @param req The request function to enqueue\n   */\n  public async enqueue(req: RequestEntity) {\n    const entry = this.queue.acquire();\n    await entry.getTask();\n\n    try {\n      return this._request(req);\n    } finally {\n      entry.release();\n    }\n  }\n\n  private async _request(req: RequestEntity, retries = 0): Promise<Response> {\n    while (this.isRateLimited()) {\n      const reset = this.resetAfter - Date.now();\n      await setTimeout(reset);\n    }\n\n    let pass = false;\n\n    try {\n      const res = await req();\n\n      this._patchHeaders(res);\n\n      if (res.status === 429) {\n        const reset = this.resetAfter - Date.now();\n        await setTimeout(reset);\n        return this._request(req);\n      }\n\n      if (!res.ok) {\n        let err: Error;\n\n        try {\n          const body: {\n            code: number;\n            name: string;\n            message: string;\n          } = await res.json();\n\n          const error = new Error(body.message) as Error & {code: number;};\n\n          error.name = body.name;\n          error.code = body.code;\n\n          err = error;\n        } catch {\n          err = new Error(`HTTP Error: ${res.status} ${res.statusText}`);\n        }\n\n        pass = true;\n\n        throw err;\n      }\n\n      return res;\n    } catch (e) {\n      if (pass) throw e;\n\n      const badReq = e instanceof Error && /Error: 4[0-9]{2}/.test(e.message);\n\n      if (!badReq && retries < this.MAX_RETRIES) {\n        return this._request(req, ++retries);\n      }\n\n      throw e;\n    }\n  }\n\n  private _patchHeaders(res: Response) {\n    const limit = Number(res.headers.get('X-RateLimit-Limit'));\n    const remaining = Number(res.headers.get('X-RateLimit-Remaining'));\n    const resetAfter =\n    Number(res.headers.get('X-RateLimit-Reset')) * 1000 + Date.now();\n\n    if (!Number.isNaN(limit)) this.limit = limit;\n    if (!Number.isNaN(remaining)) this.remaining = remaining;\n    if (!Number.isNaN(resetAfter)) this.resetAfter = resetAfter;\n  }\n}", "import { InvalidArgTypeError } from '../errors';\nimport type { Player } from '../Player';\nimport { Util } from '../utils/Util';\nimport { SequentialBucket } from '../utils/SequentialBucket';\n\nexport interface LrcSearchParams {\n  /**\n   * The query to search for. Either this or trackName is required.\n   */\n  q?: string;\n  /**\n   * The track name to search for. Either this or query is required.\n   */\n  trackName?: string;\n  /**\n   * The artist name\n   */\n  artistName?: string;\n  /**\n   * The album name\n   */\n  albumName?: string;\n}\n\nexport interface LrcGetParams extends Required<Omit<LrcSearchParams, 'query'>> {\n  /**\n   * The duration of the track\n   */\n  duration: number;\n}\n\nconst toSnakeCase = (obj: Record<string, string>): Record<string, string> => {\n  const snakeObj: Record<string, string> = {};\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (value == null) continue;\n    const newKey = key.replace(\n      /[A-Z]/g,\n      (letter) => `_${letter.toLowerCase()}`\n    );\n    snakeObj[newKey] = value;\n  }\n\n  return snakeObj;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst createQuery = (params: any) =>\nnew URLSearchParams(toSnakeCase(params)).toString();\n\nexport interface LrcSearchResult {\n  /**\n   * The track id\n   */\n  id: number;\n  /**\n   * The track name\n   */\n  name: string;\n  /**\n   * The artist name\n   */\n  trackName: string;\n  /**\n   * The album name\n   */\n  artistName: string;\n  /**\n   * The album name\n   */\n  albumName: string;\n  /**\n   * The duration of the track\n   */\n  duration: number;\n  /**\n   * The release date of the track\n   */\n  instrumental: boolean;\n  /**\n   * The release date of the track\n   */\n  plainLyrics: string;\n  /**\n   * The release date of the track\n   */\n  syncedLyrics?: string;\n}\n\nexport type LrcGetResult = Omit<LrcSearchResult, 'name'>;\n\nexport class LrcLib {\n  /**\n   * The API URL\n   */\n  public api = 'https://lrclib.net/api';\n  /**\n   * The request timeout. Default is 15 seconds.\n   */\n  public timeout = 15_000;\n  /**\n   * The request bucket\n   */\n  public bucket = new SequentialBucket();\n\n  /**\n   * Creates a new LrcLib instance\n   * @param {Player} player The player instance\n   */\n  public constructor(public readonly player: Player) {}\n\n  /**\n   * Sets the request timeout\n   * @param {number} timeout The timeout in milliseconds\n   */\n  public setRequestTimeout(timeout: number) {\n    this.timeout = timeout;\n  }\n\n  /**\n   * Sets the retry limit. Default is 5.\n   * @param {number} limit The retry limit\n   */\n  public setRetryLimit(limit: number) {\n    this.bucket.MAX_RETRIES = limit;\n  }\n\n  /**\n   * Gets lyrics\n   * @param params The get params\n   */\n  public get(params: LrcGetParams) {\n    const path = `get?${createQuery(params)}`;\n\n    return this.request<LrcSearchResult>(path);\n  }\n\n  /**\n   * Gets lyrics by ID\n   * @param id The lyrics ID\n   */\n  public getById(id: `${number}` | number) {\n    return this.request<LrcSearchResult>(`get/${id}`);\n  }\n\n  /**\n   * Gets cached lyrics\n   * @param params The get params\n   */\n  public getCached(params: LrcGetParams) {\n    const path = `get-cached?${createQuery(params)}`;\n\n    return this.request<LrcSearchResult>(path);\n  }\n\n  /**\n   * Searches for lyrics\n   * @param params The search params\n   */\n  public search(params: LrcSearchParams) {\n    if (!params.q && !params.trackName) {\n      throw new InvalidArgTypeError(\n        'one of q or trackName',\n        'string',\n        [String(params.q), String(params.trackName)].join(', ')\n      );\n    }\n\n    const path = `search?${createQuery(params)}`;\n\n    return this.request<LrcSearchResult[]>(path);\n  }\n\n  /**\n   * Requests the API\n   * @param path The path\n   * @param options The request options\n   */\n  public async request<T>(path: string, options?: RequestInit): Promise<T> {\n    const dispatcher = () => {\n      const { name, version } = Util.getRuntime();\n\n      const runtimeVersion =\n      name === 'unknown' ? version : `${name}/${version}`;\n\n      const init: RequestInit = {\n        method: 'GET',\n        redirect: 'follow',\n        signal: AbortSignal.timeout(this.timeout),\n        ...options,\n        headers: {\n          'User-Agent': `Discord-Player/${this.player.version} ${\n          runtimeVersion ?? ''}`.\n          trimEnd(),\n          'Content-Type': 'application/json',\n          ...options?.headers\n        }\n      };\n\n      this.player.debug(`[LrcLib] Requesting ${path}`);\n\n      return fetch(\n        `${this.api}${path.startsWith('/') ? path : '/' + path}`,\n        init\n      );\n    };\n\n    const res = await this.bucket.enqueue(dispatcher);\n\n    return res.json();\n  }\n}", "import { VoiceChannel, StageChannel, Snowflake } from 'discord.js';\nimport {\n  DiscordGatewayAdapterCreator,\n  joinVoiceChannel,\n  VoiceConnection,\n  getVoiceConnection,\n  VoiceConnectionStatus,\n  AudioPlayer } from\n'discord-voip';\nimport { StreamDispatcher } from './StreamDispatcher';\nimport { Collection } from '@discord-player/utils';\nimport { GuildQueue } from '../queue';\nimport type { Player } from '../Player';\nimport { NoGuildQueueError } from '../errors';\n\nclass VoiceUtils {\n  /**\n   * Voice connection cache to store voice connections of the Player components.\n   * This property is deprecated and will be removed in the future.\n   * It only exists for compatibility reasons.\n   * @deprecated\n   */\n  public cache: Collection<Snowflake, StreamDispatcher> = new Collection<\n    Snowflake,\n    StreamDispatcher>(\n  );\n\n  /**\n   * The voice utils constructor\n   */\n  constructor(public player: Player) {}\n\n  /**\n   * Joins a voice channel, creating basic stream dispatch manager\n   * @param {StageChannel|VoiceChannel} channel The voice channel\n   * @param {object} [options] Join options\n   * @returns {Promise<StreamDispatcher>}\n   */\n  public async connect(\n  channel: VoiceChannel | StageChannel,\n  options?: {\n    deaf?: boolean;\n    maxTime?: number;\n    queue: GuildQueue;\n    audioPlayer?: AudioPlayer;\n    group?: string;\n    daveEncryption?: boolean;\n    decryptionFailureTolerance?: number;\n  })\n  : Promise<StreamDispatcher> {\n    if (!options?.queue) throw new NoGuildQueueError();\n    const conn = await this.join(channel, options);\n    const sub = new StreamDispatcher(\n      conn,\n      channel,\n      options.queue,\n      options.maxTime,\n      options.audioPlayer\n    );\n    return sub;\n  }\n\n  /**\n   * Joins a voice channel\n   * @param {StageChannel|VoiceChannel} [channel] The voice/stage channel to join\n   * @param {object} [options] Join options\n   * @returns {VoiceConnection}\n   */\n  public async join(\n  channel: VoiceChannel | StageChannel,\n  options?: {\n    deaf?: boolean;\n    maxTime?: number;\n    group?: string;\n    daveEncryption?: boolean;\n    decryptionFailureTolerance?: number;\n  })\n  {\n    const existingConnection = this.getConnection(\n      channel.guild.id,\n      options?.group\n    );\n\n    if (\n    existingConnection?.joinConfig.channelId === channel?.id &&\n    existingConnection.state.status !== VoiceConnectionStatus.Destroyed)\n    {\n      return existingConnection;\n    }\n\n    const conn = joinVoiceChannel({\n      guildId: channel.guild.id,\n      channelId: channel.id,\n      adapterCreator: channel.guild.\n      voiceAdapterCreator as unknown as DiscordGatewayAdapterCreator,\n      selfDeaf: Boolean(options?.deaf),\n      debug: this.player.events.listenerCount('debug') > 0,\n      group: options?.group,\n      daveEncryption: options?.daveEncryption ?? true,\n      decryptionFailureTolerance: options?.decryptionFailureTolerance ?? 24\n    });\n\n    return conn;\n  }\n\n  /**\n   * Disconnects voice connection\n   * @param {VoiceConnection} connection The voice connection\n   * @returns {void}\n   */\n  public disconnect(connection: VoiceConnection | StreamDispatcher) {\n    if (connection instanceof StreamDispatcher)\n    connection = connection.voiceConnection;\n\n    try {\n      if (connection.state.status !== VoiceConnectionStatus.Destroyed)\n      return connection.destroy();\n    } catch {\n\n      //\n    }}\n\n  /**\n   * Returns Discord Player voice connection\n   * @param {Snowflake} guild The guild id\n   * @returns {StreamDispatcher}\n   */\n  public getConnection(guild: Snowflake, group?: string) {\n    return getVoiceConnection(guild, group);\n  }\n}\n\nexport { VoiceUtils };", "import { Player } from '../Player';\nimport { SearchResult } from '../fabric/SearchResult';\nimport { Track } from '../fabric/Track';\nimport { User } from 'discord.js';\nimport { SearchQueryType } from './QueryResolver';\n\nexport interface QueryCacheOptions {\n  checkInterval?: number;\n}\n\n// 5h\nconst DEFAULT_EXPIRY_TIMEOUT = 18_000_000;\n\nexport interface QueryCacheProvider<T> {\n  getData(): Promise<DiscordPlayerQueryResultCache<T>[]>;\n  addData(data: SearchResult): Promise<void>;\n  resolve(context: QueryCacheResolverContext): Promise<SearchResult>;\n}\n\nexport class QueryCache implements QueryCacheProvider<Track> {\n  #defaultCache = new Map<string, DiscordPlayerQueryResultCache<Track>>();\n  public timer: NodeJS.Timer;\n  public constructor(\n  public player: Player,\n  public options: QueryCacheOptions = {\n    checkInterval: DEFAULT_EXPIRY_TIMEOUT\n  })\n  {\n    this.timer = setInterval(\n      this.cleanup.bind(this),\n      this.checkInterval\n    ).unref();\n  }\n\n  public get checkInterval() {\n    return this.options.checkInterval ?? DEFAULT_EXPIRY_TIMEOUT;\n  }\n\n  public async cleanup() {\n    for (const [id, value] of this.#defaultCache) {\n      if (value.hasExpired()) {\n        this.#defaultCache.delete(id);\n      }\n    }\n  }\n\n  public async clear() {\n    this.#defaultCache.clear();\n  }\n\n  public async getData() {\n    return [...this.#defaultCache.values()];\n  }\n\n  public async addData(data: SearchResult) {\n    data.tracks.forEach((d) => {\n      if (this.#defaultCache.has(d.url)) return;\n      this.#defaultCache.set(d.url, new DiscordPlayerQueryResultCache(d));\n    });\n  }\n\n  public async resolve(context: QueryCacheResolverContext) {\n    const result = this.#defaultCache.get(context.query);\n    if (!result)\n    return new SearchResult(this.player, {\n      query: context.query,\n      requestedBy: context.requestedBy,\n      queryType: context.queryType\n    });\n\n    return new SearchResult(this.player, {\n      query: context.query,\n      tracks: [result.data],\n      playlist: null,\n      queryType: context.queryType,\n      requestedBy: context.requestedBy\n    });\n  }\n}\n\nexport class DiscordPlayerQueryResultCache<T = unknown> {\n  public expireAfter = DEFAULT_EXPIRY_TIMEOUT;\n  public constructor(\n  public data: T,\n  expireAfter: number = DEFAULT_EXPIRY_TIMEOUT)\n  {\n    if (typeof expireAfter === 'number') {\n      this.expireAfter = Date.now() + expireAfter;\n    }\n  }\n\n  public hasExpired() {\n    if (\n    typeof this.expireAfter !== 'number' ||\n    isNaN(this.expireAfter) ||\n    this.expireAfter < 1)\n\n    return false;\n    return Date.now() <= this.expireAfter;\n  }\n}\n\nexport interface QueryCacheResolverContext {\n  query: string;\n  requestedBy?: User;\n  queryType?: SearchQueryType | `ext:${string}`;\n}", "import { FFmpeg } from '@discord-player/ffmpeg';\nimport {\n  Client,\n  SnowflakeUtil,\n  VoiceState,\n  IntentsBitField,\n  User,\n  GuildVoiceChannelResolvable,\n  version as djsVersion,\n  Events } from\n'discord.js';\nimport {\n  Playlist,\n  Track,\n  SearchResult,\n  SearchOptions,\n  PlaylistInitData } from\n'./fabric';\nimport {\n  GuildQueueEvents,\n  VoiceConnectConfig,\n  GuildNodeCreateOptions,\n  GuildNodeManager,\n  GuildQueue,\n  ResourcePlayOptions,\n  GuildQueueEvent } from\n'./queue';\nimport { VoiceUtils } from './stream/VoiceUtils';\nimport {\n  QueryResolver,\n  QueryType,\n  ResolvedQuery,\n  SearchQueryType } from\n'./utils/QueryResolver';\nimport { Util } from './utils/Util';\nimport {\n  AudioResource,\n  version as dVoiceVersion,\n  StreamType } from\n'discord-voip';\nimport { ExtractorExecutionContext } from './extractors/ExtractorExecutionContext';\nimport { BaseExtractor } from './extractors/BaseExtractor';\nimport { QueryCache, QueryCacheProvider } from './utils/QueryCache';\nimport { PlayerEventsEmitter } from './utils/PlayerEventsEmitter';\nimport { InvalidArgTypeError, NoResultError } from './errors';\nimport { defaultVoiceStateHandler } from './DefaultVoiceStateHandler';\nimport { Context, createContext } from './hooks';\nimport { HooksCtx, SUPER_CONTEXT } from './hooks/common';\nimport { LrcLib } from './lrclib/LrcLib';\nimport { getCompatName, isClientProxy } from './compat/common';\nimport { DependencyReportGenerator } from './utils/DependencyReportGenerator';\nimport { getGlobalRegistry } from './utils/__internal__';\nimport { version as dpVersion } from './version';\nimport {\n  PlayerStreamInterceptor,\n  type PlayerStreamInterceptorOptions } from\n'./PlayerStreamInterceptor';\nimport type { InterceptedStream } from './stream/InterceptedStream';\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\nexport interface PlayerEvents {\n  debug: (message: string) => any;\n  error: (error: Error) => any;\n  voiceStateUpdate: (\n  queue: GuildQueue,\n  oldState: VoiceState,\n  newState: VoiceState)\n  => any;\n}\n\nexport const PlayerEvent = {\n  debug: 'debug',\n  Debug: 'debug',\n  error: 'error',\n  Error: 'error',\n  voiceStateUpdate: 'voiceStateUpdate',\n  VoiceStateUpdate: 'voiceStateUpdate'\n} as const;\nexport type PlayerEvent = (typeof PlayerEvent)[keyof typeof PlayerEvent];\n\nexport interface PlayerNodeInitializationResult<T = any> {\n  track: Track;\n  extractor: BaseExtractor | null;\n  searchResult: SearchResult;\n  queue: GuildQueue<T>;\n}\n\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\nexport type TrackLike =\nstring |\nTrack |\nSearchResult |\nTrack[] |\nPlaylist |\nAudioResource;\n\nexport interface PlayerNodeInitializerOptions<T> extends SearchOptions {\n  nodeOptions?: GuildNodeCreateOptions<T>;\n  connectionOptions?: VoiceConnectConfig;\n  audioPlayerOptions?: ResourcePlayOptions;\n  signal?: AbortSignal;\n  afterSearch?: (result: SearchResult) => Promise<SearchResult>;\n}\n\nexport type VoiceStateHandler = (\nplayer: Player,\nqueue: GuildQueue,\noldVoiceState: VoiceState,\nnewVoiceState: VoiceState)\n=> Awaited<void>;\n\nexport interface PlayerInitOptions {\n  /**\n   * The voice connection timeout\n   */\n  connectionTimeout?: number;\n  /**\n   * Time in ms to re-monitor event loop lag\n   */\n  lagMonitor?: number;\n  /**\n   * Prevent voice state handler from being overridden\n   */\n  lockVoiceStateHandler?: boolean;\n  /**\n   * List of extractors to disable querying metadata from\n   */\n  blockExtractors?: string[];\n  /**\n   * List of extractors to disable streaming from\n   */\n  blockStreamFrom?: string[];\n  /**\n   * Query cache provider\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  queryCache?: QueryCacheProvider<any> | null;\n  /**\n   * Skip ffmpeg process when possible\n   */\n  skipFFmpeg?: boolean;\n  /**\n   * The probe timeout in milliseconds. Defaults to 5000.\n   */\n  probeTimeout?: number;\n  /**\n   * Configure ffmpeg path\n   */\n  ffmpegPath?: string;\n  /**\n   * Whether to override the fallback context. Defaults to `true`.\n   */\n  overrideFallbackContext?: boolean;\n}\n\nexport class Player extends PlayerEventsEmitter<PlayerEvents> {\n  #lastLatency = -1;\n  #voiceStateUpdateListener = this.handleVoiceState.bind(this);\n  #lagMonitorTimeout: NodeJS.Timeout;\n  #lagMonitorInterval: NodeJS.Timeout;\n  #onVoiceStateUpdate: VoiceStateHandler = defaultVoiceStateHandler;\n  #hooksCtx: Context<HooksCtx> | null = null;\n  /**\n   * The version of discord-player\n   */\n  public static readonly version: string = dpVersion;\n  /**\n   * The unique identifier of this player instance\n   */\n  public readonly id = SnowflakeUtil.generate().toString();\n  /**\n   * The discord.js client\n   */\n  public readonly client!: Client;\n  /**\n   * The player options\n   */\n  public readonly options!: PlayerInitOptions;\n  /**\n   * The player nodes (queue) manager\n   */\n  public nodes = new GuildNodeManager(this);\n  /**\n   * The voice api utilities\n   */\n  public readonly voiceUtils = new VoiceUtils(this);\n  /**\n   * The extractors manager\n   */\n  public extractors = new ExtractorExecutionContext(this);\n  /**\n   * The player events channel\n   */\n  public events = new PlayerEventsEmitter<GuildQueueEvents>([\n  GuildQueueEvent.Error,\n  GuildQueueEvent.PlayerError]\n  );\n  /**\n   * The player version\n   */\n  public readonly version = Player.version;\n  /**\n   * The lyrics api\n   */\n  public readonly lyrics = new LrcLib(this);\n\n  #streamInterceptor: PlayerStreamInterceptor | null = null;\n\n  /**\n   * Creates new Discord Player\n   * @param {Client} client The Discord Client\n   * @param {PlayerInitOptions} [options] The player init options\n   */\n  public constructor(client: Client, options: PlayerInitOptions = {}) {\n    super([PlayerEvent.Error]);\n\n    if (options.ffmpegPath) {\n      if (typeof options.ffmpegPath !== 'string')\n      throw new TypeError(\n        `Expected type \"string\" for options.ffmpegPath. Got ${typeof options.ffmpegPath} instead`\n      );\n\n      process.env.FFMPEG_PATH = options.ffmpegPath;\n    }\n\n    const isCompatMode = isClientProxy(client);\n\n    /**\n     * The discord client\n     * @type {Client}\n     */\n    this.client = client;\n\n    if (!isCompatMode) {\n      try {\n        if (!(client instanceof Client)) {\n          Util.warn(\n            `Client is not an instance of discord.js@${djsVersion} client, some things may not work correctly. This can happen due to corrupt dependencies or having multiple installations of discord.js.`,\n            'InvalidClientInstance'\n          );\n        }\n\n        const ibf =\n        this.client.options.intents instanceof IntentsBitField ?\n        this.client.options.intents :\n        new IntentsBitField(this.client.options.intents);\n\n        if (!ibf.has(IntentsBitField.Flags.GuildVoiceStates)) {\n          Util.warn(\n            'client is missing \"GuildVoiceStates\" intent',\n            'InvalidIntentsBitField'\n          );\n        }\n      } catch {\n\n        // noop\n      }}\n\n    this.options = {\n      lockVoiceStateHandler: false,\n      blockExtractors: [],\n      blockStreamFrom: [],\n      connectionTimeout: 20000,\n      lagMonitor: 30000,\n      queryCache:\n      options.queryCache === null ?\n      null :\n      options.queryCache || new QueryCache(this),\n      skipFFmpeg: true,\n      probeTimeout: 5000,\n      overrideFallbackContext: true,\n      ...options\n    } satisfies PlayerInitOptions;\n\n    if (!isCompatMode) {\n      // @ts-ignore private method\n      this.client.incrementMaxListeners();\n      this.client.on(Events.VoiceStateUpdate, this.#voiceStateUpdateListener);\n    } else {\n      try {\n        // @ts-ignore private method\n        this.client.__dp_voiceStateUpdate_proxy(this.#voiceStateUpdateListener);\n      } catch (e) {\n        Util.warn(\n          'Failed to attach voice state update proxy, voice state handler will not work properly',\n          'CompatModeError'\n        );\n      }\n    }\n\n    if (\n    typeof this.options.lagMonitor === 'number' &&\n    this.options.lagMonitor > 0)\n    {\n      this.#lagMonitorInterval = setInterval(() => {\n        const start = performance.now();\n        this.#lagMonitorTimeout = setTimeout(() => {\n          this.#lastLatency = performance.now() - start;\n          if (this.hasDebugger)\n          this.debug(\n            `[Lag Monitor] Event loop latency: ${this.#lastLatency}ms`\n          );\n        }, 0).unref();\n      }, this.options.lagMonitor).unref();\n    }\n\n    if (this.options.overrideFallbackContext) {\n      getGlobalRegistry().set('@[player]', this);\n    }\n  }\n\n  /**\n   * The hooks context for this player instance.\n   */\n  public get context() {\n    if (!this.#hooksCtx) {\n      this.#hooksCtx = createContext();\n\n      const originalProvider = this.#hooksCtx.provide.bind(this.#hooksCtx);\n\n      this.#hooksCtx.provide = (value, receiver) => {\n        return SUPER_CONTEXT.provide(this, () => {\n          return originalProvider(value, () => {\n            return receiver();\n          });\n        });\n      };\n    }\n\n    return this.#hooksCtx;\n  }\n\n  /**\n   * Override default voice state update handler\n   * @param handler The handler callback\n   */\n  public onVoiceStateUpdate(handler: VoiceStateHandler) {\n    this.#onVoiceStateUpdate = handler;\n  }\n\n  public debug(m: string) {\n    return this.emit('debug', m);\n  }\n\n  /**\n   * Creates new discord-player instance.\n   * @param client The client that instantiated player\n   * @param options Player initializer options\n   */\n  public static create(client: Client, options: PlayerInitOptions = {}) {\n    return new Player(client, options);\n  }\n\n  /**\n   * The current query cache provider in use\n   */\n  public get queryCache() {\n    return this.options.queryCache ?? null;\n  }\n\n  /**\n   * Alias to `Player.nodes`.\n   */\n  public get queues() {\n    return this.nodes;\n  }\n\n  /**\n   * Event loop latency in ms. If your bot is laggy and this returns a number above 20ms for example,\n   * some expensive task is being executed on the current thread which is slowing down the event loop.\n   * @type {number}\n   */\n  public get eventLoopLag() {\n    return this.#lastLatency;\n  }\n\n  /**\n   * Generates statistics that could be useful. Statistics generator is still experimental.\n   * @example ```typescript\n   * const stats = player.generateStatistics();\n   *\n   * console.log(stats);\n   *\n   * // outputs something like\n   * // {\n   * //   queuesCount: number,\n   * //   queryCacheEnabled: boolean,\n   * //   queues: [\n   * //      GuildQueueStatisticsMetadata,\n   * //      GuildQueueStatisticsMetadata,\n   * //      GuildQueueStatisticsMetadata,\n   * //      ...\n   * //   ]\n   * // }\n   * ```\n   */\n  public generateStatistics() {\n    return {\n      queuesCount: this.queues.cache.size,\n      queryCacheEnabled: this.queryCache != null,\n      queues: this.queues.cache.map((m) => m.stats.generate())\n    };\n  }\n\n  /**\n   * Whether the player is in compatibility mode. Compatibility mode is enabled when non-discord.js client is used.\n   */\n  public isCompatMode() {\n    return isClientProxy(this.client);\n  }\n\n  /**\n   * Destroy every single queues managed by this master player instance\n   * @example ```typescript\n   * // use me when you want to immediately terminate every single queues in existence \uD83D\uDD2A\n   * await player.destroy();\n   * ```\n   */\n  public async destroy() {\n    this.nodes.cache.forEach((node) => node.delete());\n\n    if (!this.isCompatMode()) {\n      this.client.off(Events.VoiceStateUpdate, this.#voiceStateUpdateListener);\n      // @ts-ignore private method\n      this.client.decrementMaxListeners();\n    }\n\n    this.removeAllListeners();\n    this.events.removeAllListeners();\n    await this.extractors.unregisterAll();\n    if (this.#lagMonitorInterval) clearInterval(this.#lagMonitorInterval);\n    if (this.#lagMonitorTimeout) clearInterval(this.#lagMonitorTimeout);\n  }\n\n  private _handleVoiceState(oldState: VoiceState, newState: VoiceState) {\n    const queue = this.nodes.get(oldState.guild.id);\n    if (!queue || !queue.connection || !queue.channel) return;\n\n    // dispatch voice state update\n    const wasHandled = this.events.emit(\n      GuildQueueEvent.VoiceStateUpdate,\n      queue,\n      oldState,\n      newState\n    );\n    // if the event was handled, return assuming the listener implemented all of the logic below\n    if (wasHandled && !this.options.lockVoiceStateHandler) return;\n\n    return this.#onVoiceStateUpdate(this, queue, oldState, newState);\n  }\n\n  /**\n   * Handles voice state update\n   * @param {VoiceState} oldState The old voice state\n   * @param {VoiceState} newState The new voice state\n   * @returns {void}\n   * @example ```typescript\n   * // passing voice state update data to this method will trigger voice state handler\n   *\n   * client.on('voiceStateUpdate', (oldState, newState) => {\n   *   // this is definitely a rocket science, right here\n   *   player.handleVoiceState(oldState, newState);\n   * });\n   * ```\n   */\n  public handleVoiceState(oldState: VoiceState, newState: VoiceState): void {\n    this._handleVoiceState(oldState, newState);\n  }\n\n  /**\n   * Lock voice state handler. When this method is called, discord-player will keep using the default voice state update handler, even if custom implementation exists.\n   */\n  public lockVoiceStateHandler() {\n    this.options.lockVoiceStateHandler = true;\n  }\n\n  /**\n   * Unlock voice state handler. When this method is called, discord-player will stop using the default voice state update handler if custom implementation exists.\n   */\n  public unlockVoiceStateHandler() {\n    this.options.lockVoiceStateHandler = false;\n  }\n\n  /**\n   * Checks if voice state handler is locked.\n   */\n  public isVoiceStateHandlerLocked() {\n    return !!this.options.lockVoiceStateHandler;\n  }\n\n  /**\n   * Initiate audio player\n   * @param channel The voice channel on which the music should be played\n   * @param query The track or source to play\n   * @param options Options for player\n   * @example ```typescript\n   * // no need to worry about queue management, just use this method \uD83D\uDE04\n   * const query = 'this is my super cool search query that I want to play';\n   *\n   * try {\n   *    const { track } = await player.play(voiceChannel, query);\n   *   console.log(`\uD83C\uDF89 I am playing ${track.title} \uD83C\uDF89`);\n   * } catch(e) {\n   *   console.log(`\uD83D\uDE2D Failed to play error oh no:\\n\\n${e}`);\n   * }\n   * ```\n   */\n  public async play<T = unknown>(\n  channel: GuildVoiceChannelResolvable,\n  query: TrackLike,\n  options: PlayerNodeInitializerOptions<T> = {})\n  : Promise<PlayerNodeInitializationResult<T>> {\n    const vc = this.client.channels.resolve(channel);\n    if (!vc?.isVoiceBased())\n    throw new InvalidArgTypeError(\n      'channel',\n      'VoiceBasedChannel',\n      !vc ? 'undefined' : `channel type ${vc.type}`\n    );\n\n    const originalResult =\n    query instanceof SearchResult ? query : await this.search(query, options);\n    const result =\n    (await options.afterSearch?.(originalResult)) || originalResult;\n    if (result.isEmpty()) {\n      throw new NoResultError(\n        `No results found for \"${query}\" (Extractor: ${\n        result.extractor?.identifier || 'N/A'})`\n\n      );\n    }\n\n    const queue = this.nodes.create(vc.guild, options.nodeOptions);\n\n    if (this.hasDebugger) this.debug(`[AsyncQueue] Acquiring an entry...`);\n    const entry = queue.tasksQueue.acquire({ signal: options.signal });\n    if (this.hasDebugger)\n    this.debug(`[AsyncQueue] Entry ${entry.id} was acquired successfully!`);\n\n    if (this.hasDebugger)\n    this.debug(`[AsyncQueue] Waiting for the queue to resolve...`);\n    await entry.getTask();\n    if (this.hasDebugger)\n    this.debug(`[AsyncQueue] Entry ${entry.id} was resolved!`);\n\n    try {\n      if (!queue.channel) await queue.connect(vc, options.connectionOptions);\n\n      if (!result.playlist) {\n        queue.addTrack(result.tracks[0]);\n      } else {\n        queue.addTrack(result.playlist);\n      }\n      if (!queue.isPlaying())\n      await queue.node.play(null, options.audioPlayerOptions);\n    } finally {\n      if (this.hasDebugger)\n      this.debug(`[AsyncQueue] Releasing an entry from the queue...`);\n      queue.tasksQueue.release();\n    }\n\n    return {\n      track: result.tracks[0],\n      extractor: result.extractor,\n      searchResult: result,\n      queue\n    };\n  }\n\n  /**\n   * Search tracks\n   * @param {string | Track | Track[] | Playlist | SearchResult} query The search query\n   * @param {SearchOptions} options The search options\n   * @returns {Promise<SearchResult>}\n   * @example ```typescript\n   * const searchQuery = 'pass url or text or discord-player track constructable objects, we got you covered \uD83D\uDE0E';\n   * const result = await player.search(searchQuery);\n   *\n   * console.log(result); // Logs `SearchResult` object\n   * ```\n   */\n  public async search(\n  searchQuery: TrackLike,\n  options: SearchOptions = {})\n  : Promise<SearchResult> {\n    if (searchQuery instanceof SearchResult) return searchQuery;\n\n    if (searchQuery instanceof AudioResource) {\n      searchQuery = this.createTrackFromAudioResource(searchQuery);\n    }\n\n    if (options.requestedBy != null)\n    options.requestedBy = this.client.users.resolve(options.requestedBy)!;\n\n    options.blockExtractors ??= this.options.blockExtractors;\n    options.fallbackSearchEngine ??= QueryType.AUTO_SEARCH;\n\n    if (searchQuery instanceof Track) {\n      return new SearchResult(this, {\n        playlist: searchQuery.playlist || null,\n        tracks: [searchQuery],\n        query: searchQuery.title,\n        extractor: searchQuery.extractor,\n        queryType: searchQuery.queryType,\n        requestedBy: options.requestedBy\n      });\n    }\n\n    if (searchQuery instanceof Playlist) {\n      return new SearchResult(this, {\n        playlist: searchQuery,\n        tracks: searchQuery.tracks,\n        query: searchQuery.title,\n        extractor: searchQuery.tracks[0]?.extractor,\n        queryType: QueryType.AUTO,\n        requestedBy: options.requestedBy\n      });\n    }\n\n    if (Array.isArray(searchQuery)) {\n      const tracks = searchQuery.filter((t) => t instanceof Track);\n      return new SearchResult(this, {\n        playlist: null,\n        tracks,\n        query: '@@#%{{UserLoadedContent}}%#@@',\n        extractor: null,\n        queryType: QueryType.AUTO,\n        requestedBy: options.requestedBy\n      });\n    }\n\n    if (this.hasDebugger) this.debug(`Searching ${searchQuery}`);\n\n    let extractor: BaseExtractor | null = null,\n      protocol: string | null = null;\n\n    options.searchEngine ??= QueryType.AUTO;\n    options.fallbackSearchEngine ??= QueryType.AUTO_SEARCH;\n\n    if (this.hasDebugger)\n    this.debug(\n      `Search engine set to ${options.searchEngine}, fallback search engine set to ${options.fallbackSearchEngine}`\n    );\n\n    if (/^\\w+:/.test(searchQuery)) {\n      const [protocolName, ...query] = searchQuery.split(':');\n      if (this.hasDebugger)\n      this.debug(`Protocol ${protocolName} detected in query`);\n\n      const matchingExtractor = this.extractors.store.find(\n        (e) =>\n        !this.extractors.isDisabled(e.identifier) &&\n        e.protocols.includes(protocolName)\n      );\n\n      if (matchingExtractor) {\n        if (this.hasDebugger)\n        this.debug(\n          `Protocol ${protocolName} is supported by ${matchingExtractor.identifier} extractor!`\n        );\n        extractor = matchingExtractor;\n        searchQuery = query.join(':');\n        protocol = protocolName;\n      } else {\n        if (this.hasDebugger)\n        this.debug(\n          `Could not find an extractor that supports ${protocolName} protocol. Falling back to default behavior...`\n        );\n      }\n    }\n\n    const redirected = await QueryResolver.preResolve(searchQuery);\n    const { type: queryType, query } =\n    options.searchEngine === QueryType.AUTO ?\n    QueryResolver.resolve(redirected, options.fallbackSearchEngine) :\n    { type: options.searchEngine, query: redirected } as ResolvedQuery;\n\n    if (this.hasDebugger)\n    this.debug(\n      `Query type identified as ${queryType}${\n      extractor && protocol ?\n      ' but might not be used due to the presence of protocol' :\n      ''}`\n\n    );\n\n    // force particular extractor\n    if (options.searchEngine.startsWith('ext:')) {\n      if (this.hasDebugger)\n      this.debug(`Forcing ${options.searchEngine.substring(4)} extractor...`);\n      extractor = this.extractors.get(options.searchEngine.substring(4))!;\n      if (!extractor)\n      return new SearchResult(this, {\n        query,\n        queryType,\n        extractor,\n        requestedBy: options.requestedBy\n      });\n    }\n\n    // query all extractors\n    if (!extractor) {\n      // cache validation\n      if (!options.ignoreCache) {\n        if (this.hasDebugger) this.debug(`Checking cache...`);\n        const res = await this.queryCache?.resolve({\n          query,\n          queryType,\n          requestedBy: options.requestedBy\n        });\n        // cache hit\n        if (res?.hasTracks()) {\n          if (this.hasDebugger) this.debug(`Cache hit for query ${query}`);\n          return res;\n        }\n\n        if (this.hasDebugger) this.debug(`Cache miss for query ${query}`);\n      }\n\n      if (this.hasDebugger) this.debug(`Executing extractors...`);\n\n      // cache miss\n      extractor =\n      (\n      await this.extractors.run(async (ext) => {\n        if (options.blockExtractors?.includes(ext.identifier)) return false;\n        return ext.validate(query, queryType as SearchQueryType);\n      }))?.\n      extractor || null;\n    }\n\n    // no extractors available\n    if (!extractor) {\n      if (this.hasDebugger) this.debug('Failed to find appropriate extractor');\n      return new SearchResult(this, {\n        query,\n        queryType,\n        requestedBy: options.requestedBy\n      });\n    }\n\n    if (this.hasDebugger)\n    this.debug(\n      `Executing metadata query using ${extractor.identifier} extractor...`\n    );\n    const res = await extractor.\n    handle(query, {\n      type: queryType as SearchQueryType,\n      requestedBy: options.requestedBy as User,\n      requestOptions: options.requestOptions,\n      protocol\n    }).\n    catch(() => null);\n\n    if (res) {\n      if (this.hasDebugger) this.debug('Metadata query was successful!');\n      // Store RequestOptions in track raw data for later use during streaming\n      if (options.requestOptions && res.tracks) {\n        res.tracks.forEach((track) => {\n          if (track.raw) {\n            track.raw.requestOptions = options.requestOptions;\n          } else {\n            track.raw = { requestOptions: options.requestOptions };\n          }\n        });\n      }\n\n      const result = new SearchResult(this, {\n        query,\n        queryType,\n        playlist: res.playlist,\n        tracks: res.tracks,\n        extractor,\n        requestedBy: options.requestedBy\n      });\n\n      if (!options.ignoreCache) {\n        if (this.hasDebugger) this.debug(`Adding data to cache...`);\n        await this.queryCache?.addData(result);\n      }\n\n      return result;\n    }\n\n    if (this.hasDebugger)\n    this.debug(\n      'Failed to find result using appropriate extractor. Querying all extractors...'\n    );\n    const result = await this.extractors.run(\n      async (ext) =>\n      !options.blockExtractors?.includes(ext.identifier) && (\n      await ext.validate(query)) &&\n      ext.handle(query, {\n        type: queryType as SearchQueryType,\n        requestedBy: options.requestedBy as User,\n        requestOptions: options.requestOptions,\n        protocol\n      })\n    );\n    if (!result?.result) {\n      if (this.hasDebugger)\n      this.debug(\n        `Failed to query metadata query using ${\n        result?.extractor.identifier || 'N/A'} extractor.`\n\n      );\n      return new SearchResult(this, {\n        query,\n        queryType,\n        requestedBy: options.requestedBy,\n        extractor: result?.extractor\n      });\n    }\n\n    if (this.hasDebugger)\n    this.debug(\n      `Metadata query was successful using ${result.extractor.identifier}!`\n    );\n\n    // Store RequestOptions in track raw data for later use during streaming\n    if (options.requestOptions && result.result.tracks) {\n      result.result.tracks.forEach((track) => {\n        if (track.raw) {\n          track.raw.requestOptions = options.requestOptions;\n        } else {\n          track.raw = { requestOptions: options.requestOptions };\n        }\n      });\n    }\n\n    const data = new SearchResult(this, {\n      query,\n      queryType,\n      playlist: result.result.playlist,\n      tracks: result.result.tracks,\n      extractor: result.extractor,\n      requestedBy: options.requestedBy\n    });\n\n    if (!options.ignoreCache) {\n      if (this.hasDebugger) this.debug(`Adding data to cache...`);\n      await this.queryCache?.addData(data);\n    }\n\n    return data;\n  }\n\n  /**\n   * Generates a report of the dependencies used by the `discord-voip` module. Useful for debugging.\n   * @example ```typescript\n   * console.log(player.scanDeps());\n   * // -> logs dependencies report\n   * ```\n   * @returns {string}\n   */\n  public scanDeps() {\n    const line = '-'.repeat(50);\n    const runtime =\n    'Bun' in globalThis ? 'Bun' : 'Deno' in globalThis ? 'Deno' : 'Node';\n    const depsReport = [\n    'Discord Player',\n    line,\n    `- discord-player: ${Player.version}${\n    this.isCompatMode() ?\n    ` (${getCompatName(this.client)} compatibility mode)` :\n    ''}`,\n\n    `- discord-voip: ${dVoiceVersion}`,\n    `- discord.js: ${djsVersion}`,\n    `- Node version: ${process.version} (Detected Runtime: ${runtime}, Platform: ${process.platform} [${process.arch}])`,\n    (() => {\n      const info = FFmpeg.resolveSafe();\n      if (!info) return 'FFmpeg/Avconv not found';\n\n      return [\n      `- ffmpeg: ${info.version}`,\n      `- command: ${info.command}`,\n      `- static: ${info.module}`,\n      `- libopus: ${info.result!.includes('--enable-libopus')}`].\n      join('\\n');\n    })(),\n    '\\n',\n    'Loaded Extractors:',\n    line,\n    this.extractors.store.\n    map((m) => {\n      return m.identifier;\n    }).\n    join('\\n') || 'N/A',\n    '\\n\\ndiscord-voip',\n    DependencyReportGenerator.generateString()];\n\n\n    return depsReport.join('\\n');\n  }\n\n  public *[Symbol.iterator]() {\n    yield* this.nodes.cache.values();\n  }\n\n  /**\n   * Creates `Playlist` instance\n   * @param data The data to initialize a playlist\n   */\n  public createPlaylist(data: PlaylistInitData) {\n    return new Playlist(this, data);\n  }\n\n  /**\n   * Creates a track from an audio resource.\n   * @param resource The audio resource\n   */\n  public createTrackFromAudioResource(resource: AudioResource) {\n    const metadata = (resource.metadata || {}) as Record<string, unknown>;\n    const ref = SnowflakeUtil.generate().toString();\n    const maybeTitle =\n    'title' in metadata ? `${metadata.title}` : `Track ${ref}`;\n    const maybeAuthor =\n    'author' in metadata ? `${metadata.author}` : 'Unknown author';\n    const maybeDuration =\n    'duration' in metadata ? `${metadata.duration}` : '00:00';\n    const maybeThumbnail =\n    'thumbnail' in metadata ? `${metadata.thumbnail}` : undefined;\n    const maybeURL =\n    'url' in metadata ? `${metadata.url}` : `discord-player://blob/${ref}`;\n    const maybeDescription =\n    'description' in metadata ?\n    `${metadata.description}` :\n    'No description available.';\n    const maybeViews = 'views' in metadata ? Number(metadata.views) || 0 : 0;\n\n    const track = new Track(this, {\n      title: maybeTitle,\n      author: maybeAuthor,\n      duration: maybeDuration,\n      thumbnail: maybeThumbnail,\n      url: maybeURL,\n      description: maybeDescription,\n      queryType: QueryType.DISCORD_PLAYER_BLOB,\n      source: 'arbitrary',\n      metadata,\n      live: false,\n      views: maybeViews\n    });\n\n    resource.metadata = track;\n\n    track.setResource(resource as AudioResource<Track>);\n\n    return track;\n  }\n\n  /**\n   * Handles intercepting streams\n   * @param stream The stream to intercept\n   */\n  public async handleInterceptingStream(\n  queue: GuildQueue,\n  track: Track,\n  format: StreamType,\n  stream: InterceptedStream)\n  {\n    if (!this.#streamInterceptor) return;\n\n    return this.#streamInterceptor.handle(queue, track, format, stream);\n  }\n\n  /**\n   * Creates a global stream interceptor\n   * @param options The stream interceptor options\n   */\n  public createStreamInterceptor(options: PlayerStreamInterceptorOptions) {\n    if (this.#streamInterceptor) {\n      return this.#streamInterceptor;\n    }\n\n    this.#streamInterceptor = new PlayerStreamInterceptor(this, options);\n\n    return this.#streamInterceptor;\n  }\n}", "import { ChannelType, VoiceState } from 'discord.js';\nimport { GuildQueue, GuildQueueEvent } from './queue';\nimport { Player } from './Player';\nimport { Util } from './utils/Util';\n\nfunction handleEmptyChannel(\nplayer: Player,\nqueue: GuildQueue,\nguildId: string)\n{\n  const timeout = setTimeout(() => {\n    if (!Util.isVoiceEmpty(queue.channel!) || !player.nodes.has(queue.guild.id))\n    return;\n    if (queue.options.leaveOnEmpty) queue.delete();\n    player.events.emit(GuildQueueEvent.EmptyChannel, queue);\n  }, queue.options.leaveOnEmptyCooldown || 0).unref();\n  queue.timeouts.set(`empty_${guildId}`, timeout);\n}\n\nfunction handleChannelPopulate(\nplayer: Player,\nqueue: GuildQueue,\nguildId: string)\n{\n  const emptyTimeout = queue.timeouts.get(`empty_${guildId}`);\n  if (!Util.isVoiceEmpty(queue.channel!) && emptyTimeout) {\n    clearTimeout(emptyTimeout);\n    queue.timeouts.delete(`empty_${guildId}`);\n    player.events.emit(GuildQueueEvent.ChannelPopulate, queue);\n  }\n}\n\nfunction handlePauseOnEmpty(queue: GuildQueue) {\n  const isEmpty = Util.isVoiceEmpty(queue.channel!);\n  const wasPausedOnEmpty = Reflect.get(queue, '__pausedOnEmpty');\n\n  if (isEmpty && !wasPausedOnEmpty) {\n    queue.node.setPaused(true);\n    Reflect.set(queue, '__pausedOnEmpty', true);\n    if (queue.hasDebugger) {\n      queue.debug(\n        'Voice channel is empty and options#pauseOnEmpty is true, pausing...'\n      );\n    }\n  } else if (!isEmpty && wasPausedOnEmpty) {\n    queue.node.setPaused(false);\n    Reflect.set(queue, '__pausedOnEmpty', false);\n    if (queue.hasDebugger) {\n      queue.debug(\n        'Voice channel is not empty and options#pauseOnEmpty is true, resuming...'\n      );\n    }\n  }\n}\n\nfunction handleBotVoiceStateUpdate(\nqueue: GuildQueue,\noldState: VoiceState,\nnewState: VoiceState)\n{\n  if (\n  newState.serverMute != null &&\n  oldState.serverMute !== newState.serverMute)\n  {\n    queue.node.setPaused(newState.serverMute);\n    return;\n  }\n\n  if (\n  newState.channel?.type === ChannelType.GuildStageVoice &&\n  newState.suppress != null &&\n  oldState.suppress !== newState.suppress)\n  {\n    queue.node.setPaused(newState.suppress);\n    if (newState.suppress) {\n      newState.guild.members.me?.voice.setRequestToSpeak(true).catch(Util.noop);\n    }\n  }\n}\n\nexport async function defaultVoiceStateHandler(\nplayer: Player,\nqueue: GuildQueue,\noldState: VoiceState,\nnewState: VoiceState)\n{\n  if (!queue?.connection || !queue.channel) return;\n\n  const isBotState = newState.member?.id === newState.guild.members.me?.id;\n  const guildId = oldState.guild.id;\n\n  // Bot disconnected\n  if (isBotState && oldState.channelId && !newState.channelId) {\n    try {\n      queue.delete();\n    } catch {\n\n      /* noop */}\n    return void player.events.emit(GuildQueueEvent.Disconnect, queue);\n  }\n\n  if (queue.options.pauseOnEmpty) {\n    handlePauseOnEmpty(queue);\n  }\n\n  // Bot joined channel or changed state\n  if (\n  isBotState &&\n  newState.channelId && (\n  !oldState.channelId || oldState.channelId !== newState.channelId))\n  {\n    if (queue.connection) queue.channel = newState.channel!;\n    handleBotVoiceStateUpdate(queue, oldState, newState);\n  }\n\n  // Handle channel empty/populate events\n  if (!newState.channelId && oldState.channelId === queue.channel.id) {\n    if (!Util.isVoiceEmpty(queue.channel)) return;\n    handleEmptyChannel(player, queue, guildId);\n  } else if (newState.channelId === queue.channel.id) {\n    handleChannelPopulate(player, queue, guildId);\n  } else if (oldState.channelId !== newState.channelId) {\n    if (\n    newState.channelId !== queue.channel.id &&\n    !Util.isVoiceEmpty(queue.channel))\n\n    return;\n    if (!queue.timeouts.has(`empty_${guildId}`)) {\n      handleEmptyChannel(player, queue, guildId);\n    }\n  }\n}", "import { resolve, dirname } from 'node:path';\nimport { FFmpeg, FFmpegLib } from '@discord-player/ffmpeg';\nimport { version } from '../version';\n\nexport interface PackageJSON {\n  name: string;\n  version: string;\n}\n\nexport type MaybeNull<T> = T | null;\n\nexport interface DependenciesReport {\n  core: {\n    'discord-player': string;\n    'discord-voip': string;\n  };\n  libopus: {\n    mediaplex: MaybeNull<string>;\n    '@discordjs/opus': MaybeNull<string>;\n    '@evan/opus': MaybeNull<string>;\n    opusscript: MaybeNull<string>;\n    'node-opus': MaybeNull<string>;\n  };\n  libsodium: {\n    'sodium-native': MaybeNull<string>;\n    sodium: MaybeNull<string>;\n    'libsodium-wrappers': MaybeNull<string>;\n    'sodium-javascript': MaybeNull<string>;\n    '@stablelib/xchacha20poly1305': MaybeNull<string>;\n    '@noble/ciphers': MaybeNull<string>;\n  };\n  DAVE: {\n    '@snazzah/davey': MaybeNull<string>;\n  };\n  ffmpeg: FFmpegReport;\n}\n\nexport type FFmpegReport = Record<\n  FFmpegLib,\n  MaybeNull<{\n    version: string;\n    hasLibopus: boolean;\n  }>>;\n\n\n/**\n * A utility to generate a report of the dependencies used by the discord-player module.\n */\nexport const DependencyReportGenerator = {\n  /**\n   * Finds the package.json file of a package.\n   * @param dir - The directory to start searching from\n   * @param packageName - The name of the package to find\n   * @param depth - The maximum depth to search\n   * @returns The package.json file, or null if not found\n   */\n  findPackageJSON(\n  dir: string,\n  packageName: string,\n  depth: number)\n  : PackageJSON | null {\n    if (depth === 0) return null;\n\n    const target = resolve(dir, 'package.json');\n\n    const next = () =>\n    DependencyReportGenerator.findPackageJSON(\n      resolve(dir, '..'),\n      packageName,\n      depth - 1\n    );\n\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-var-requires\n      const pkgJSON: PackageJSON = require(target);\n\n      if (pkgJSON.name !== packageName) {\n        return next();\n      }\n\n      return pkgJSON;\n    } catch {\n      return next();\n    }\n  },\n  /**\n   * Tries to find the version of a dependency.\n   * @param name - The package to find the version of\n   * @param maxLookupDepth - The maximum depth to search for the package.json file\n   * @returns The version of the package, or null if not found\n   */\n  version(name: string, maxLookupDepth = 3): string | null {\n    try {\n      if (name === 'discord-player') {\n        return version;\n      }\n\n      const pkg = DependencyReportGenerator.findPackageJSON(\n        dirname(require.resolve(name)),\n        name,\n        maxLookupDepth\n      );\n      return pkg?.version ?? null;\n    } catch {\n      return null;\n    }\n  },\n  /**\n   * Generates a report of the dependencies used by the discord-player module.\n   * @returns The report object\n   */\n  generate(): DependenciesReport {\n    const ffmpegReport = {} as FFmpegReport;\n\n    for (const lib of FFmpeg.sources) {\n      ffmpegReport[lib.name] = null;\n    }\n\n    const ffmpeg = FFmpeg.resolveSafe();\n\n    if (ffmpeg) {\n      ffmpegReport[ffmpeg.name] = {\n        hasLibopus: ffmpeg.command.includes('--enable-libopus'),\n        version: ffmpeg.version\n      };\n    }\n\n    return {\n      core: {\n        'discord-player': DependencyReportGenerator.version(\n          'discord-player'\n        ) as string,\n        'discord-voip': DependencyReportGenerator.version(\n          'discord-voip'\n        ) as string\n      },\n      libopus: {\n        mediaplex: DependencyReportGenerator.version('mediaplex'),\n        '@discordjs/opus': DependencyReportGenerator.version('@discordjs/opus'),\n        '@evan/opus': DependencyReportGenerator.version('@evan/opus'),\n        opusscript: DependencyReportGenerator.version('opusscript'),\n        'node-opus': DependencyReportGenerator.version('node-opus')\n      },\n      libsodium: {\n        'sodium-native': DependencyReportGenerator.version('sodium-native'),\n        sodium: DependencyReportGenerator.version('sodium'),\n        'libsodium-wrappers':\n        DependencyReportGenerator.version('libsodium-wrappers'),\n        '@stablelib/xchacha20poly1305': DependencyReportGenerator.version(\n          '@stablelib/xchacha20poly1305'\n        ),\n        'sodium-javascript':\n        DependencyReportGenerator.version('sodium-javascript'),\n        '@noble/ciphers': DependencyReportGenerator.version('@noble/ciphers')\n      },\n      DAVE: {\n        '@snazzah/davey': DependencyReportGenerator.version('@snazzah/davey')\n      },\n      ffmpeg: ffmpegReport\n    };\n  },\n  /**\n   * Generates a string representation of the dependencies report.\n   * @returns The string representation\n   */\n  generateString(): string {\n    const report = DependencyReportGenerator.generate();\n    const line = '-'.repeat(50);\n\n    const output: string[] = [];\n\n    output.push('Dependencies Report');\n    output.push(line);\n\n    const keys = Object.keys(report) as (keyof DependenciesReport)[];\n\n    for (const _key of keys) {\n      const key = _key as keyof DependenciesReport;\n\n      output.push(key);\n\n      const subKeys = Object.keys(report[key]);\n\n      for (const _subKey of subKeys) {\n        const subKey = _subKey as keyof DependenciesReport[typeof key];\n        const value = report[key][subKey] ?? 'N/A';\n\n        output.push(\n          `- ${subKey}: ${\n          typeof value === 'object' ? JSON.stringify(value, null, 2) : value}`\n\n        );\n      }\n\n      output.push('');\n    }\n\n    output.push(line);\n\n    return output.join('\\n');\n  }\n};", "\n\n\n\n\n\nexport const version = /* @__MACRO__ getVersion */\"7.2.0\";", "import { StreamType } from 'discord-voip';\nimport type { Track } from './fabric';\nimport type { Player } from './Player';\nimport type { GuildQueue } from './queue';\nimport type { InterceptedStream } from './stream/InterceptedStream';\n\ntype Awaitable<T> = T | PromiseLike<T>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ShouldInterceptFunction = <T = any>(\nqueue: GuildQueue<T>,\ntrack: Track,\nformat: StreamType,\nstream: InterceptedStream)\n=> Awaitable<boolean>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type OnInterceptedStreamHandler = <T = any>(\nqueue: GuildQueue<T>,\ntrack: Track,\nformat: StreamType,\nstream: InterceptedStream)\n=> Awaitable<void>;\n\nexport interface PlayerStreamInterceptorOptions {\n  /**\n   * Determines whether the stream should be intercepted.\n   */\n  shouldIntercept?: ShouldInterceptFunction;\n}\n\nexport class PlayerStreamInterceptor {\n  #onStream = new Set<OnInterceptedStreamHandler>();\n\n  /**\n   * Creates a new PlayerStreamInterceptor instance.\n   * @param player The player instance\n   * @param options The interceptor options\n   */\n  public constructor(\n  public readonly player: Player,\n  private readonly options: PlayerStreamInterceptorOptions)\n  {}\n\n  /**\n   * Handles the intercepted stream.\n   * @param queue The guild queue\n   * @param track The track\n   * @param stream The intercepted stream\n   * @returns Whether the stream was intercepted\n   */\n  public async handle<T = unknown>(\n  queue: GuildQueue<T>,\n  track: Track,\n  type: StreamType,\n  stream: InterceptedStream)\n  : Promise<boolean> {\n    const filter = this.options.shouldIntercept;\n\n    if (filter) {\n      const result = await filter(queue, track, type, stream);\n      if (!result) return false;\n    }\n\n    const hasListeners = this.#onStream.size;\n\n    if (!hasListeners) return false;\n\n    await Promise.all(\n      [...this.#onStream].map((handler) => handler(queue, track, type, stream))\n    );\n\n    return true;\n  }\n\n  /**\n   * Adds a new intercepted stream listener.\n   * @param handler The handler\n   * @returns A function to remove the listener\n   */\n  public onStream(handler: OnInterceptedStreamHandler): () => void {\n    this.#onStream.add(handler);\n\n    return () => {\n      this.#onStream.delete(handler);\n    };\n  }\n}"],
  "mappings": "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",
  "names": ["GuildQueue", "SerializedType", "query", "version", "DiscordPlayerClientSymbol", "module", "DiscordPlayerClientSymbol", "import_v10", "DiscordPlayerClientSymbol", "declareProperty", "getProperty", "module", "DiscordPlayerClientSymbol", "import_utils", "import_utils", "result", "import_utils", "import_discord", "import_utils", "import_utils", "import_discord_voip", "import_utils", "import_discord_voip", "import_promises", "import_discord", "resolve", "resolve", "waitFor", "import_equalizer", "TrackSkipReason", "resolve", "GuildQueue", "GuildQueue", "import_promises", "version", "import_discord_voip", "import_utils", "import_ffmpeg", "import_discord", "import_discord_voip", "import_discord", "import_ffmpeg", "djsVersion", "query", "res", "result", "dVoiceVersion", "import_equalizer", "import_discord_voip"]
}
