discolink 1.0.0

package/lib/index.mjs

@@ -0,0 +1,2158 @@
+import { URL } from 'node:url';
+import { validateHeaderValue } from 'node:http';
+import Axios, { HttpStatusCode } from 'axios';
+import { EventEmitter, once } from 'node:events';
+import { clearTimeout, setTimeout } from 'node:timers';
+import { WebSocket } from 'ws';
+import { setTimeout as setTimeout$1 } from 'node:timers/promises';
+
+// src/Typings/API/Rest.ts
+var LoadType = /* @__PURE__ */ ((LoadType2) => {
+  LoadType2["Track"] = "track";
+  LoadType2["Playlist"] = "playlist";
+  LoadType2["Search"] = "search";
+  LoadType2["Empty"] = "empty";
+  LoadType2["Error"] = "error";
+  return LoadType2;
+})(LoadType || {});
+var RoutePlannerType = /* @__PURE__ */ ((RoutePlannerType2) => {
+  RoutePlannerType2["Rotating"] = "RotatingIpRoutePlanner";
+  RoutePlannerType2["Nano"] = "NanoIpRoutePlanner";
+  RoutePlannerType2["RotatingNano"] = "RotatingNanoIpRoutePlanner";
+  RoutePlannerType2["Balancing"] = "BalancingIpRoutePlanner";
+  return RoutePlannerType2;
+})(RoutePlannerType || {});
+var IPBlockType = /* @__PURE__ */ ((IPBlockType2) => {
+  IPBlockType2["V4"] = "Inet4Address";
+  IPBlockType2["V6"] = "Inet6Address";
+  return IPBlockType2;
+})(IPBlockType || {});
+
+// src/Typings/API/Websocket.ts
+var Severity = /* @__PURE__ */ ((Severity2) => {
+  Severity2["Common"] = "common";
+  Severity2["Suspicious"] = "suspicious";
+  Severity2["Fault"] = "fault";
+  return Severity2;
+})(Severity || {});
+var OPType = /* @__PURE__ */ ((OPType2) => {
+  OPType2["Ready"] = "ready";
+  OPType2["PlayerUpdate"] = "playerUpdate";
+  OPType2["Stats"] = "stats";
+  OPType2["Event"] = "event";
+  return OPType2;
+})(OPType || {});
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["TrackStart"] = "TrackStartEvent";
+  EventType2["TrackEnd"] = "TrackEndEvent";
+  EventType2["TrackException"] = "TrackExceptionEvent";
+  EventType2["TrackStuck"] = "TrackStuckEvent";
+  EventType2["WebSocketClosed"] = "WebSocketClosedEvent";
+  return EventType2;
+})(EventType || {});
+var TrackEndReason = /* @__PURE__ */ ((TrackEndReason2) => {
+  TrackEndReason2["Finished"] = "finished";
+  TrackEndReason2["LoadFailed"] = "loadFailed";
+  TrackEndReason2["Stopped"] = "stopped";
+  TrackEndReason2["Replaced"] = "replaced";
+  TrackEndReason2["Cleanup"] = "cleanup";
+  return TrackEndReason2;
+})(TrackEndReason || {});
+
+// src/Typings/Node/Node.ts
+var CloseCodes = /* @__PURE__ */ ((CloseCodes2) => {
+  CloseCodes2[CloseCodes2["Normal"] = 1e3] = "Normal";
+  CloseCodes2[CloseCodes2["GoingAway"] = 1001] = "GoingAway";
+  CloseCodes2[CloseCodes2["ProtocolError"] = 1002] = "ProtocolError";
+  CloseCodes2[CloseCodes2["UnsupportedData"] = 1003] = "UnsupportedData";
+  CloseCodes2[CloseCodes2["Reserved"] = 1004] = "Reserved";
+  CloseCodes2[CloseCodes2["NoStatusReceived"] = 1005] = "NoStatusReceived";
+  CloseCodes2[CloseCodes2["Abnormal"] = 1006] = "Abnormal";
+  CloseCodes2[CloseCodes2["InvalidFramePayloadData"] = 1007] = "InvalidFramePayloadData";
+  CloseCodes2[CloseCodes2["PolicyViolation"] = 1008] = "PolicyViolation";
+  CloseCodes2[CloseCodes2["MessageTooBig"] = 1009] = "MessageTooBig";
+  CloseCodes2[CloseCodes2["MandatoryExtension"] = 1010] = "MandatoryExtension";
+  CloseCodes2[CloseCodes2["InternalError"] = 1011] = "InternalError";
+  CloseCodes2[CloseCodes2["ServiceRestart"] = 1012] = "ServiceRestart";
+  CloseCodes2[CloseCodes2["TryAgainLater"] = 1013] = "TryAgainLater";
+  CloseCodes2[CloseCodes2["BadGateway"] = 1014] = "BadGateway";
+  CloseCodes2[CloseCodes2["TLSHandshake"] = 1015] = "TLSHandshake";
+  return CloseCodes2;
+})(CloseCodes || {});
+
+// src/Typings/Queue/QueueManager.ts
+var VoiceCloseCodes = /* @__PURE__ */ ((VoiceCloseCodes2) => {
+  VoiceCloseCodes2[VoiceCloseCodes2["UnknownOpcode"] = 4001] = "UnknownOpcode";
+  VoiceCloseCodes2[VoiceCloseCodes2["FailedToDecodePayload"] = 4002] = "FailedToDecodePayload";
+  VoiceCloseCodes2[VoiceCloseCodes2["NotAuthenticated"] = 4003] = "NotAuthenticated";
+  VoiceCloseCodes2[VoiceCloseCodes2["AuthenticationFailed"] = 4004] = "AuthenticationFailed";
+  VoiceCloseCodes2[VoiceCloseCodes2["AlreadyAuthenticated"] = 4005] = "AlreadyAuthenticated";
+  VoiceCloseCodes2[VoiceCloseCodes2["SessionNoLongerValid"] = 4006] = "SessionNoLongerValid";
+  VoiceCloseCodes2[VoiceCloseCodes2["SessionTimeout"] = 4009] = "SessionTimeout";
+  VoiceCloseCodes2[VoiceCloseCodes2["ServerNotFound"] = 4011] = "ServerNotFound";
+  VoiceCloseCodes2[VoiceCloseCodes2["UnknownProtocol"] = 4012] = "UnknownProtocol";
+  VoiceCloseCodes2[VoiceCloseCodes2["Disconnected"] = 4014] = "Disconnected";
+  VoiceCloseCodes2[VoiceCloseCodes2["VoiceServerCrashed"] = 4015] = "VoiceServerCrashed";
+  VoiceCloseCodes2[VoiceCloseCodes2["UnknownEncryptionMode"] = 4016] = "UnknownEncryptionMode";
+  VoiceCloseCodes2[VoiceCloseCodes2["BadRequest"] = 4020] = "BadRequest";
+  VoiceCloseCodes2[VoiceCloseCodes2["DisconnectedRateLimited"] = 4021] = "DisconnectedRateLimited";
+  VoiceCloseCodes2[VoiceCloseCodes2["DisconnectedCallTerminated"] = 4022] = "DisconnectedCallTerminated";
+  return VoiceCloseCodes2;
+})(VoiceCloseCodes || {});
+
+// src/Constants/NodeOptions.ts
+var DefaultNodeOptions = Object.seal({
+  statsInterval: 6e4,
+  highestLatency: 2e3,
+  reconnectDelay: 1e4,
+  reconnectLimit: 3,
+  handshakeTimeout: 5e3
+});
+
+// src/Constants/PlayerOptions.ts
+var DefaultPlayerOptions = Object.seal({
+  queryPrefix: "ytsearch",
+  relocateQueues: true,
+  async fetchRelatedTracks() {
+    return [];
+  }
+});
+
+// src/Constants/Regex.ts
+var SnowflakeRegex = /^\d{17,20}$/;
+var VoiceRegionIdRegex = /^((-?[a-z]+)+)(?=[a-z\d-]*\.discord\.media:\d+$)/;
+
+// src/Constants/RESTOptions.ts
+var DefaultRestOptions = Object.seal({
+  version: 4,
+  userAgent: "discolink/1.0.0 (https://github.com/execaman/discolink)",
+  stackTrace: false,
+  retryLimit: 0,
+  requestTimeout: 15e3
+});
+
+// src/Constants/Routes.ts
+var Routes = {
+  websocket() {
+    return "/websocket";
+  },
+  trackLoading() {
+    return "/loadtracks";
+  },
+  trackDecoding(multiple) {
+    if (multiple) return "/decodetracks";
+    return "/decodetrack";
+  },
+  player(sessionId, guildId) {
+    if (guildId) return `/sessions/${sessionId}/players/${guildId}`;
+    return `/sessions/${sessionId}/players`;
+  },
+  session(sessionId) {
+    return `/sessions/${sessionId}`;
+  },
+  info() {
+    return "/info";
+  },
+  stats() {
+    return "/stats";
+  },
+  routePlanner(free) {
+    if (free) return `/routeplanner/free/${free}`;
+    return "/routeplanner/status";
+  }
+};
+
+// src/Functions/formatting.ts
+function formatDuration(ms) {
+  ms = Math.floor(ms);
+  if (ms <= 0 || !Number.isFinite(ms)) return "00:00";
+  const ss = Math.floor(ms / 1e3) % 60;
+  const mm = Math.floor(ms / (60 * 1e3)) % 60;
+  const hh = Math.floor(ms / (60 * 60 * 1e3));
+  const mm_ss = `${mm < 10 ? `0${mm}` : mm}:${ss < 10 ? `0${ss}` : ss}`;
+  if (hh === 0) return mm_ss;
+  return `${hh < 10 ? `0${hh}` : hh}:${mm_ss}`;
+}
+
+// src/Functions/utility.ts
+function noop() {
+}
+function isNumber(input, type) {
+  if (type === void 0) return Number.isFinite(input);
+  switch (type) {
+    case "integer":
+      return Number.isSafeInteger(input) && !Object.is(input, -0);
+    case "natural":
+      return Number.isSafeInteger(input) && input > 0;
+    case "whole":
+      return Number.isSafeInteger(input) && input > -1 && !Object.is(input, -0);
+    default:
+      throw new SyntaxError(`Invalid number check type '${type}'`);
+  }
+}
+function isString(input, check) {
+  if (check === void 0) return typeof input === "string";
+  if (typeof input !== "string") return false;
+  if (check instanceof RegExp) return check.test(input);
+  switch (check) {
+    case "url": {
+      try {
+        return new URL(input).origin !== "null";
+      } catch {
+        return false;
+      }
+    }
+    case "non-empty":
+      return input.trim().length !== 0;
+    default:
+      throw new SyntaxError(`Invalid string check type '${check}'`);
+  }
+}
+function isRecord(input, type) {
+  if (type === void 0) return input !== null && typeof input === "object" && !Array.isArray(input);
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return false;
+  switch (type) {
+    case "non-empty":
+      return Object.keys(input).length !== 0;
+    default:
+      throw new SyntaxError(`Invalid object check type '${type}'`);
+  }
+}
+function isArray(input, check) {
+  if (check === void 0) return Array.isArray(input);
+  if (!Array.isArray(input)) return false;
+  switch (check) {
+    case "string":
+      if (input.length === 0) return false;
+      return input.every((i) => typeof i === "string" && i.length !== 0);
+    case "non-empty":
+      return input.length !== 0;
+    default:
+      throw new SyntaxError(`Invalid array check type '${check}'`);
+  }
+}
+var REST = class {
+  #axios = Axios.create({
+    headers: {
+      Accept: "application/json"
+    },
+    transitional: {
+      silentJSONParsing: false,
+      clarifyTimeoutError: true
+    },
+    responseType: "json"
+  });
+  #queue = [];
+  #queueIdling = true;
+  #sessionId = null;
+  #retryLimit;
+  origin;
+  version;
+  constructor(options) {
+    const _options = { ...DefaultRestOptions, ...options };
+    validateHeaderValue("User-Agent", _options.userAgent);
+    validateHeaderValue("Authorization", _options.password);
+    const url = new URL(_options.origin);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error("Protocol must be 'http' or 'https'");
+    }
+    if (typeof _options.stackTrace !== "boolean") {
+      throw new Error("Stack trace option must be a boolean");
+    }
+    if (!isNumber(_options.version, "natural")) {
+      throw new Error("Version must be a natural number");
+    }
+    if (!isNumber(_options.retryLimit, "whole")) {
+      throw new Error("Retry limit must be a whole number");
+    }
+    if (!isNumber(_options.requestTimeout, "natural")) {
+      throw new Error("Request timeout must be a natural number");
+    }
+    if (_options.sessionId !== void 0 && !isString(_options.sessionId, "non-empty")) {
+      throw new Error("Session Id must be a non-empty string");
+    }
+    this.#axios.defaults.timeout = _options.requestTimeout;
+    this.#axios.defaults.baseURL = `${url.origin}/v${_options.version}`;
+    this.#axios.defaults.headers.common["User-Agent"] = _options.userAgent;
+    this.#axios.defaults.headers.common["Authorization"] = _options.password;
+    if (_options.stackTrace === true) this.#axios.defaults.params = { trace: true };
+    this.origin = url.origin;
+    this.version = _options.version;
+    this.#retryLimit = _options.retryLimit;
+    if (_options.sessionId !== void 0) this.#sessionId = _options.sessionId;
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      origin: immutable,
+      version: immutable
+    });
+  }
+  get timeout() {
+    return this.#axios.defaults.timeout;
+  }
+  get sessionId() {
+    return this.#sessionId;
+  }
+  get retryLimit() {
+    return this.#retryLimit;
+  }
+  set timeout(ms) {
+    if (isNumber(ms, "natural")) this.#axios.defaults.timeout = ms;
+  }
+  set sessionId(id) {
+    if (id === null || isString(id, "non-empty")) this.#sessionId = id;
+  }
+  set retryLimit(count) {
+    if (isNumber(count, "whole")) this.#retryLimit = count;
+  }
+  #error(err, path) {
+    const res = err.response;
+    const data = "errors" in err ? err.errors[err.errors.length - 1] : err;
+    const error = new Error(res?.data.message ?? data.message);
+    error.name = `Error [${this.constructor.name}]`;
+    error.error = res?.data.error ?? res?.statusText ?? "Processing";
+    error.path = res?.data.path ?? path;
+    error.status = res?.data.status ?? res?.status ?? Axios.HttpStatusCode.Processing;
+    error.timestamp = res?.data.timestamp ?? Date.now();
+    if (res?.data.trace !== void 0) error.trace = res.data.trace;
+    return error;
+  }
+  async #makeRequest(config, retries = this.#retryLimit) {
+    try {
+      const response = await this.#axios.request(config);
+      return response;
+    } catch (err) {
+      if (config.signal?.aborted) err.message = "reason" in config.signal ? config.signal.reason : err.message;
+      else if (err.code === "ETIMEDOUT" && retries !== 0) return this.#makeRequest(config, retries - 1);
+      throw this.#error(err, config.url);
+    }
+  }
+  async #resumeQueue() {
+    this.#queueIdling = false;
+    while (this.#queue.length !== 0) {
+      const task = this.#queue[0];
+      if (!task.config.signal) {
+        task.controller = new AbortController();
+        task.config.signal = task.controller.signal;
+      }
+      try {
+        const response = await this.#makeRequest(task.config);
+        task.resolve(response);
+      } catch (err) {
+        task.reject(err);
+      }
+      task.controller?.abort();
+      this.#queue.shift();
+    }
+    this.#queueIdling = true;
+  }
+  dropSessionRequests(reason) {
+    if (this.#queue.length === 0) return;
+    const tasks = this.#queue.splice(0);
+    tasks.shift().controller?.abort(reason);
+    if (tasks.length === 0) return;
+    const err = { message: reason };
+    for (const task of tasks) task.reject(this.#error(err, task.config.url));
+  }
+  async request(method, endpoint, options) {
+    if (!isString(method, "non-empty")) throw new Error("Method must be a non-empty string");
+    if (!isString(endpoint, "non-empty")) throw new Error("Endpoint must be a non-empty string");
+    const config = { method, url: endpoint };
+    if (isRecord(options, "non-empty")) {
+      if ("data" in options) {
+        config.data = options.data;
+        config.headers = { "Content-Type": "application/json" };
+      }
+      if ("params" in options) {
+        if (isRecord(options.params, "non-empty")) config.params = options.params;
+        else throw new Error("Options.params must be a non-empty object");
+      }
+      if ("signal" in options) {
+        if (options.signal instanceof AbortSignal && !options.signal.aborted) config.signal = options.signal;
+        else throw new Error("Options.signal is either not a instance of AbortSignal or is already aborted");
+      }
+      if ("timeout" in options) {
+        if (isNumber(options.timeout, "natural")) config.timeout = options.timeout;
+        else throw new Error("Options.timeout must be a natural number");
+      }
+    }
+    if (this.#sessionId === null || !endpoint.includes(this.#sessionId)) {
+      return this.#makeRequest(config);
+    }
+    return new Promise((resolve, reject) => {
+      this.#queue.push({ config, reject, resolve });
+      if (this.#queueIdling) this.#resumeQueue();
+    });
+  }
+  async loadTracks(identifier) {
+    if (!isString(identifier, "non-empty")) throw new Error("Identifier must be a non-empty string");
+    const response = await this.request("GET", Routes.trackLoading(), { params: { identifier } });
+    return response.data;
+  }
+  async decodeTrack(encodedTrack) {
+    if (!isString(encodedTrack, "non-empty")) throw new Error("Encoded track must be a non-empty string");
+    const response = await this.request("GET", Routes.trackDecoding(), { params: { encodedTrack } });
+    return response.data;
+  }
+  async decodeTracks(tracks) {
+    if (!isArray(tracks, "string")) throw new Error("Tracks must be an array of non-empty strings");
+    const response = await this.request("POST", Routes.trackDecoding(true), { data: tracks });
+    return response.data;
+  }
+  async fetchPlayers(sessionId = this.sessionId) {
+    if (!isString(sessionId, "non-empty")) throw new Error("Session Id neither set nor provided");
+    const response = await this.request("GET", Routes.player(sessionId));
+    return response.data;
+  }
+  async fetchPlayer(guildId, sessionId = this.sessionId) {
+    if (!isString(guildId, "non-empty")) throw new Error("Guild Id must be a non-empty string");
+    if (!isString(sessionId, "non-empty")) throw new Error("Session Id neither set nor provided");
+    const response = await this.request("GET", Routes.player(sessionId, guildId));
+    return response.data;
+  }
+  async updatePlayer(guildId, options, params, sessionId = this.sessionId) {
+    if (!isString(guildId, "non-empty")) throw new Error("Guild Id must be a non-empty string");
+    if (!isString(sessionId, "non-empty")) throw new Error("Session Id neither set nor provided");
+    if (!isRecord(options, "non-empty")) throw new Error("Player update options cannot be empty");
+    const response = await this.request("PATCH", Routes.player(sessionId, guildId), {
+      data: options,
+      params: { noReplace: params?.noReplace === true }
+    });
+    return response.data;
+  }
+  async destroyPlayer(guildId, sessionId = this.sessionId) {
+    if (!isString(guildId, "non-empty")) throw new Error("Guild Id must be a non-empty string");
+    if (!isString(sessionId, "non-empty")) throw new Error("Session Id neither set nor provided");
+    const response = await this.request("DELETE", Routes.player(sessionId, guildId));
+    return response.status === Axios.HttpStatusCode.NoContent;
+  }
+  async updateSession(options, sessionId = this.sessionId) {
+    if (!isRecord(options, "non-empty")) throw new Error("Session update options cannot be empty");
+    if (!isString(sessionId, "non-empty")) throw new Error("Session Id neither set nor provided");
+    const response = await this.request("PATCH", Routes.session(sessionId), {
+      data: options
+    });
+    return response.data;
+  }
+  async fetchInfo() {
+    const response = await this.request("GET", Routes.info());
+    return response.data;
+  }
+  async fetchStats() {
+    const response = await this.request("GET", Routes.stats());
+    return response.data;
+  }
+  async fetchRoutePlannerStatus() {
+    const response = await this.request("GET", Routes.routePlanner());
+    if (response.status === Axios.HttpStatusCode.NoContent) return { class: null, details: null };
+    return response.data;
+  }
+  async unmarkFailedAddress(address) {
+    if (!isString(address, "non-empty")) throw new Error("Address must be a non-empty string");
+    const response = await this.request("POST", Routes.routePlanner("address"), { data: { address } });
+    return response.status === Axios.HttpStatusCode.NoContent;
+  }
+  async unmarkAllFailedAddresses() {
+    const response = await this.request("POST", Routes.routePlanner("all"));
+    return response.status === Axios.HttpStatusCode.NoContent;
+  }
+};
+var Node = class extends EventEmitter {
+  #socketConfig = {
+    headers: {
+      "Client-Name": "discolink/1.0.0"
+    },
+    perMessageDeflate: false
+  };
+  #connectPromise = null;
+  #disconnectPromise = null;
+  #pingTimer = null;
+  #reconnectTimer = null;
+  #stats = null;
+  #socket = null;
+  #ping = null;
+  #lastPingTime = null;
+  #manualDisconnect = false;
+  #reconnectInit = false;
+  #reconnectAttempts = 0;
+  #sessionId = null;
+  #socketURL;
+  #statsInterval;
+  #highestLatency;
+  #reconnectDelay;
+  #reconnectLimit;
+  name;
+  rest;
+  constructor(options) {
+    super({ captureRejections: false });
+    const _options = { ...DefaultNodeOptions, ...DefaultRestOptions, ...options };
+    if (!isString(_options.name, "non-empty")) {
+      throw new Error("Name must be a non-empty string");
+    }
+    if (!isString(_options.clientId, SnowflakeRegex)) {
+      throw new Error("Client Id is not a valid Discord Id");
+    }
+    if (!isNumber(_options.statsInterval, "natural")) {
+      throw new Error("Stats interval must be a natural number");
+    }
+    if (!isNumber(_options.highestLatency, "natural")) {
+      throw new Error("Highest latency must be a natural number");
+    }
+    if (!isNumber(_options.reconnectDelay, "natural")) {
+      throw new Error("Reconnect delay must be a natural number");
+    }
+    if (!isNumber(_options.reconnectLimit, "natural")) {
+      throw new Error("Reconnect limit must be a natural number");
+    }
+    if (!isNumber(_options.handshakeTimeout, "natural")) {
+      throw new Error("Handshake timeout must be a natural number");
+    }
+    this.#statsInterval = _options.statsInterval;
+    this.#highestLatency = _options.highestLatency;
+    this.#reconnectDelay = _options.reconnectDelay;
+    this.#reconnectLimit = _options.reconnectLimit;
+    this.#socketConfig.handshakeTimeout = _options.handshakeTimeout;
+    this.name = _options.name;
+    this.rest = new REST(_options);
+    this.#socketURL = `${this.rest.origin.replace("http", "ws")}/v${this.rest.version}${Routes.websocket()}`;
+    this.#socketConfig.headers["User-Id"] = _options.clientId;
+    this.#socketConfig.headers["User-Agent"] = _options.userAgent;
+    this.#socketConfig.headers["Authorization"] = _options.password;
+    if (this.rest.sessionId !== null) this.#socketConfig.headers["Session-Id"] = this.rest.sessionId;
+    Object.defineProperty(this.rest, "sessionId", {
+      get: () => this.#sessionId,
+      set: noop
+    });
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      name: immutable,
+      rest: immutable
+    });
+  }
+  get clientId() {
+    return this.#socketConfig.headers["User-Id"];
+  }
+  get sessionId() {
+    return this.#sessionId;
+  }
+  get ping() {
+    return this.#ping;
+  }
+  get stats() {
+    return this.#stats;
+  }
+  get state() {
+    if (this.connecting) return "connecting";
+    if (this.connected) return this.ready ? "ready" : "connected";
+    if (this.reconnecting) return "reconnecting";
+    return "disconnected";
+  }
+  get connecting() {
+    return this.#socket !== null && this.#socket.readyState === this.#socket.CONNECTING;
+  }
+  get connected() {
+    return this.#socket !== null && this.#socket.readyState === this.#socket.OPEN;
+  }
+  get ready() {
+    return this.#sessionId !== null && this.connected;
+  }
+  get reconnecting() {
+    return this.#socket === null && this.#reconnectTimer !== null;
+  }
+  get disconnected() {
+    return this.#socket === null && !this.reconnecting;
+  }
+  get reconnectAttempts() {
+    return this.#reconnectAttempts;
+  }
+  get handshakeTimeout() {
+    return this.#socketConfig.handshakeTimeout;
+  }
+  set handshakeTimeout(ms) {
+    if (isNumber(ms, "natural")) this.#socketConfig.handshakeTimeout = ms;
+  }
+  #error(err) {
+    const data = "errors" in err ? err.errors[err.errors.length - 1] : err;
+    const error = data instanceof Error ? data : new Error(`${data.message ?? data}`);
+    error.name = `Error [${this.constructor.name}]`;
+    return error;
+  }
+  #cleanup() {
+    this.#socket?.removeAllListeners();
+    if (this.#pingTimer !== null) clearTimeout(this.#pingTimer);
+    this.#socket = this.#pingTimer = this.#stats = null;
+    this.#sessionId = this.#lastPingTime = this.#ping = null;
+  }
+  #reconnect() {
+    this.#reconnectInit = false;
+    this.#reconnectTimer?.refresh();
+    this.#reconnectTimer ??= setTimeout(() => {
+      this.#reconnectInit = true;
+      this.connect();
+    }, this.#reconnectDelay);
+  }
+  #stopReconnecting(keepCount = false) {
+    if (this.#reconnectTimer === null) return;
+    clearTimeout(this.#reconnectTimer);
+    this.#reconnectTimer = null;
+    this.#reconnectInit = false;
+    if (!keepCount) this.#reconnectAttempts = 0;
+  }
+  #keepAliveAndPing() {
+    this.#pingTimer?.refresh();
+    this.#pingTimer ??= setTimeout(() => {
+      this.#socket?.terminate();
+      this.#cleanup();
+      this.rest.dropSessionRequests(`Connection to node '${this.name}' was zombie`);
+      this.#reconnect();
+    }, this.#statsInterval + this.#highestLatency).unref();
+    this.#socket?.ping();
+    this.#lastPingTime = Date.now();
+  }
+  #parseMessageData(data) {
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async connect() {
+    if (this.#socket !== null) return this.#connectPromise ?? this.connected;
+    if (this.reconnecting) {
+      this.#reconnectAttempts++;
+      if (!this.#reconnectInit) this.#stopReconnecting(true);
+    }
+    this.#socket = new WebSocket(this.#socketURL, this.#socketConfig);
+    this.#socket.once("open", () => {
+      this.emit("connect", this.#reconnectAttempts, this.name);
+    });
+    this.#socket.on("message", (data) => {
+      this.#onMessage(data.toString("utf8"));
+    });
+    this.#socket.on("error", (err) => {
+      this.emit("error", this.#error(err), this.name);
+    });
+    this.#socket.on("close", (code, reason) => {
+      this.#onClose(code, reason.toString("utf8"));
+    });
+    this.#socket.on("pong", () => {
+      if (this.#lastPingTime === null) return;
+      this.#ping = Math.max(0, Date.now() - this.#lastPingTime);
+    });
+    const resolver = Promise.withResolvers();
+    this.#connectPromise = resolver.promise;
+    const controller = new AbortController();
+    try {
+      await Promise.race([
+        once(this.#socket, "open", { signal: controller.signal }),
+        once(this.#socket, "close", { signal: controller.signal })
+      ]);
+      return this.connected;
+    } catch {
+      this.#cleanup();
+      return false;
+    } finally {
+      controller.abort();
+      this.#connectPromise = null;
+      resolver.resolve(this.connected);
+    }
+  }
+  async disconnect(reason = "disconnected") {
+    if (this.#disconnectPromise !== null) return this.#disconnectPromise;
+    this.#stopReconnecting();
+    if (this.#socket === null) return;
+    if (this.connecting) {
+      this.#manualDisconnect = true;
+      this.#socket.terminate();
+      return;
+    }
+    if (!this.connected) return;
+    this.#manualDisconnect = true;
+    this.#disconnectPromise = once(this.#socket, "close").then(noop, noop);
+    this.#socket.close(1e3 /* Normal */, reason);
+    await this.#disconnectPromise;
+    this.#disconnectPromise = null;
+  }
+  async #onMessage(data) {
+    const payload = this.#parseMessageData(data);
+    if (payload === null) return;
+    if (payload.op === "stats" /* Stats */) {
+      this.#stats = payload;
+      this.#keepAliveAndPing();
+    } else if (payload.op === "ready" /* Ready */) {
+      this.#stopReconnecting();
+      this.#socketConfig.headers["Session-Id"] = this.#sessionId = payload.sessionId;
+      this.emit("ready", payload.resumed, payload.sessionId, this.name);
+    }
+    this.emit("dispatch", payload, this.name);
+  }
+  #onClose(code, reason) {
+    this.#cleanup();
+    this.rest.dropSessionRequests(`Connection to node '${this.name}' closed`);
+    if (!this.#manualDisconnect && this.#reconnectAttempts < this.#reconnectLimit) {
+      this.#reconnect();
+      this.emit("close", code, reason, this.name);
+      return;
+    }
+    this.#stopReconnecting();
+    delete this.#socketConfig.headers["Session-Id"];
+    const byLocal = this.#manualDisconnect;
+    this.#manualDisconnect = false;
+    this.emit("disconnect", code, reason, byLocal, this.name);
+  }
+  toString() {
+    return this.name;
+  }
+};
+
+// src/Node/NodeManager.ts
+var NodeManager = class {
+  #player;
+  #nodes = /* @__PURE__ */ new Map();
+  #cache = /* @__PURE__ */ new Map();
+  info = /* @__PURE__ */ new Map();
+  constructor(player) {
+    this.#player = player;
+    Object.defineProperty(this, "info", {
+      writable: false,
+      configurable: false
+    });
+  }
+  get size() {
+    return this.#nodes.size;
+  }
+  get cache() {
+    return this.#cache;
+  }
+  get ready() {
+    return this.#nodes.values().some((n) => n.ready);
+  }
+  get(name) {
+    return this.#nodes.get(name);
+  }
+  has(name) {
+    return this.#nodes.has(name);
+  }
+  keys() {
+    return this.#nodes.keys();
+  }
+  values() {
+    return this.#nodes.values();
+  }
+  entries() {
+    return this.#nodes.entries();
+  }
+  state(name, equals) {
+    const node = this.#nodes.get(name);
+    if (!node) throw new Error(`Node '${name}' not found`);
+    return equals === void 0 ? node.state : node.state === equals;
+  }
+  create(options) {
+    if (this.#player.clientId === null) throw new Error("Player has not been initialized");
+    if (this.#nodes.has(options.name)) throw new Error(`Node '${options.name}' already exists`);
+    const node = new Node({ ...options, clientId: this.#player.clientId });
+    node.setMaxListeners(1);
+    this.#attachEvents(node);
+    this.#nodes.set(node.name, node);
+    return node;
+  }
+  delete(name) {
+    const node = this.#nodes.get(name);
+    if (!node) return false;
+    if (!node.disconnected) throw new Error(`Node '${name}' not disconnected`);
+    this.#detachEvents(node);
+    this.info.delete(name);
+    this.#cache.delete(name);
+    this.#nodes.delete(name);
+    return true;
+  }
+  relevant(weights = { memory: 0.3, workload: 0.2, streaming: 0.5 }) {
+    weights.memory = Math.min(1, Math.max(0, weights.memory ?? 0));
+    weights.workload = Math.min(1, Math.max(0, weights.workload ?? 0));
+    weights.streaming = Math.min(1, Math.max(0, weights.streaming ?? 0));
+    const nodes = this.#nodes.values().reduce((list, node) => {
+      if (node.ready) list.push(node);
+      return list;
+    }, []);
+    return nodes.sort((a, b) => {
+      const metricA = this.#cache.get(a.name);
+      const metricB = this.#cache.get(b.name);
+      if (metricA && !metricB) return 1;
+      if (metricB && !metricA) return -1;
+      if (!metricA || !metricB) return 0;
+      if (metricA.streaming !== -1 && metricB.streaming === -1) return 1;
+      if (metricB.streaming !== -1 && metricA.streaming === -1) return -1;
+      return (metricB.memory - metricA.memory) * weights.memory + (metricB.workload - metricA.workload) * weights.workload + (metricB.streaming - metricA.streaming) * weights.streaming;
+    });
+  }
+  async connect(name) {
+    if (typeof name === "string") {
+      const node = this.#nodes.get(name);
+      if (!node) throw new Error(`Node '${name}' not found`);
+      return node.connect();
+    }
+    for (const node of this.#nodes.values()) await node.connect();
+  }
+  async disconnect(name) {
+    if (typeof name === "string") {
+      const node = this.#nodes.get(name);
+      if (!node) throw new Error(`Node '${name}' not found`);
+      return node.disconnect();
+    }
+    for (const node of this.#nodes.values()) await node.disconnect();
+  }
+  async fetchInfo(name, force) {
+    if (!this.#nodes.has(name)) throw new Error(`Node '${name}' not found`);
+    if (force !== true && this.info.has(name)) return this.info.get(name);
+    const info = await this.#nodes.get(name).rest.fetchInfo();
+    this.info.set(name, info);
+    return info;
+  }
+  #memory(mem) {
+    const available = mem.free / mem.reservable;
+    const allocable = (mem.reservable - mem.allocated) / mem.reservable;
+    return Math.min(1, available * 0.7 + allocable * 0.3);
+  }
+  #workload(cpu) {
+    if (cpu.systemLoad === 0 || cpu.lavalinkLoad === 0) return 0;
+    return 1 - Math.min(1, cpu.systemLoad * 0.7 + cpu.lavalinkLoad * 0.3);
+  }
+  #streaming(frames) {
+    if (frames === null) return -1;
+    const expected = frames.sent + frames.nulled + frames.deficit;
+    const passRate = frames.sent / expected;
+    const lossRate = frames.nulled / expected;
+    const failRate = Math.max(0, frames.deficit) / expected;
+    return Math.min(1, passRate - (failRate * 0.7 + lossRate * 0.3));
+  }
+  #updateMetrics(name, stats) {
+    const metrics = this.#cache.get(name);
+    if (!metrics) {
+      this.#cache.set(name, {
+        memory: this.#memory(stats.memory),
+        workload: this.#workload(stats.cpu),
+        streaming: this.#streaming(stats.frameStats)
+      });
+      return;
+    }
+    metrics.memory = this.#memory(stats.memory);
+    metrics.workload = this.#workload(stats.cpu);
+    metrics.streaming = this.#streaming(stats.frameStats);
+  }
+  #onConnect = (reconnects, nodeName) => {
+    this.#player.emit("nodeConnect", this.#nodes.get(nodeName), reconnects);
+  };
+  #onReady = (resumed, sessionId, nodeName) => {
+    this.#player.emit("nodeReady", this.#nodes.get(nodeName), resumed, sessionId);
+    this.fetchInfo(nodeName).catch(noop);
+  };
+  #onDispatch = (payload, nodeName) => {
+    switch (payload.op) {
+      case "playerUpdate" /* PlayerUpdate */: {
+        this.#player.queues.onStateUpdate(payload);
+        break;
+      }
+      case "stats" /* Stats */: {
+        this.#updateMetrics(nodeName, payload);
+        break;
+      }
+      case "event" /* Event */: {
+        this.#player.queues.onEventUpdate(payload);
+        break;
+      }
+    }
+    this.#player.emit("nodeDispatch", this.#nodes.get(nodeName), payload);
+  };
+  #onError = (err, nodeName) => {
+    this.#player.emit("nodeError", this.#nodes.get(nodeName), err);
+  };
+  #onClose = (code, reason, nodeName) => {
+    this.#cache.delete(nodeName);
+    this.#player.emit("nodeClose", this.#nodes.get(nodeName), code, reason);
+    if (this.#player.options.relocateQueues) this.#player.queues.relocate(nodeName).catch(noop);
+  };
+  #onDisconnect = (code, reason, byLocal, nodeName) => {
+    this.#cache.delete(nodeName);
+    this.#player.voices.regions.forEach((r) => r.forgetNode(nodeName));
+    this.#player.emit("nodeDisconnect", this.#nodes.get(nodeName), code, reason, byLocal);
+    if (this.#player.options.relocateQueues) this.#player.queues.relocate(nodeName).catch(noop);
+  };
+  #attachEvents(node) {
+    node.on("connect", this.#onConnect);
+    node.on("ready", this.#onReady);
+    node.on("dispatch", this.#onDispatch);
+    node.on("error", this.#onError);
+    node.on("close", this.#onClose);
+    node.on("disconnect", this.#onDisconnect);
+  }
+  #detachEvents(node) {
+    node.removeListener("connect", this.#onConnect);
+    node.removeListener("ready", this.#onReady);
+    node.removeListener("dispatch", this.#onDispatch);
+    node.removeListener("error", this.#onError);
+    node.removeListener("close", this.#onClose);
+    node.removeListener("disconnect", this.#onDisconnect);
+  }
+  [Symbol.iterator]() {
+    return this.#nodes[Symbol.iterator]();
+  }
+};
+
+// src/Voice/VoiceState.ts
+var VoiceState = class {
+  #cache;
+  #player;
+  #node;
+  #reconnecting = false;
+  #changePromise = null;
+  constructor(player, node, guildId) {
+    const _node = player.nodes.get(node);
+    if (!_node) throw new Error(`Node '${node}' not found`);
+    if (!_node.ready) throw new Error(`Node '${node}' not ready`);
+    const info = player.voices.cache.get(guildId);
+    if (!info) throw new Error(`No connection found for guild '${guildId}'`);
+    this.#node = _node;
+    this.#cache = info;
+    this.#player = player;
+  }
+  get #info() {
+    this.#cache = this.#player.voices.cache.get(this.guildId) ?? this.#cache;
+    return this.#cache;
+  }
+  get node() {
+    return this.#node;
+  }
+  get valid() {
+    return this.#node.sessionId === this.#info.node_session_id;
+  }
+  get guildId() {
+    return this.#cache.guild_id;
+  }
+  get channelId() {
+    return this.#info.channel_id;
+  }
+  get regionId() {
+    return this.#info.region_id;
+  }
+  get sessionId() {
+    return this.#info.session_id;
+  }
+  get token() {
+    return this.#info.token;
+  }
+  get endpoint() {
+    return this.#info.endpoint;
+  }
+  get ping() {
+    return this.#info.ping;
+  }
+  get connected() {
+    return this.valid && this.#info.connected;
+  }
+  get destroyed() {
+    return this.#player.voices.get(this.guildId) !== this;
+  }
+  get selfDeaf() {
+    return this.#info.self_deaf;
+  }
+  get selfMute() {
+    return this.#info.self_mute;
+  }
+  get serverDeaf() {
+    return this.#info.deaf;
+  }
+  get serverMute() {
+    return this.#info.mute;
+  }
+  get muted() {
+    return this.selfMute || this.#cache.mute || this.#cache.suppress;
+  }
+  get deafened() {
+    return this.selfDeaf || this.#cache.deaf;
+  }
+  get suppressed() {
+    return this.#info.suppress;
+  }
+  get changingNode() {
+    return this.#changePromise !== null;
+  }
+  get reconnecting() {
+    return this.#reconnecting;
+  }
+  set reconnecting(value) {
+    if (typeof value === "boolean") this.#reconnecting = value;
+  }
+  async destroy(reason) {
+    return this.#player.voices.destroy(this.guildId, reason);
+  }
+  async connect(channelId = this.#info.channel_id) {
+    return this.#player.voices.connect(this.guildId, channelId);
+  }
+  async reconnect() {
+    await this.disconnect();
+    return this.connect();
+  }
+  async disconnect() {
+    return this.#player.voices.disconnect(this.guildId);
+  }
+  async changeNode(name) {
+    const node = this.#player.nodes.get(name);
+    if (!node) throw new Error(`Node '${name}' not found`);
+    if (!node.ready) throw new Error(`Node '${name}' not ready`);
+    if (this.#changePromise !== null) return this.#changePromise;
+    if (name === this.#node.name) throw new Error(`Already on node '${name}'`);
+    const queue = this.#player.queues.get(this.guildId);
+    if (!queue) throw new Error(`No queue found for guild '${this.guildId}'`);
+    const resolver = Promise.withResolvers();
+    this.#changePromise = resolver.promise;
+    const request = {
+      filters: queue.filters.data,
+      paused: queue.paused,
+      voice: { endpoint: this.#info.endpoint, sessionId: this.#cache.session_id, token: this.#cache.token },
+      volume: queue.volume
+    };
+    const wasPlaying = queue.isPlaying && queue.track !== null;
+    if (wasPlaying && this.#player.nodes.info.get(node.name)?.sourceManagers.includes(queue.track.sourceName)) {
+      request.track = { encoded: queue.track.encoded, userData: queue.track.userData };
+      request.position = queue.currentTime;
+    }
+    if (this.valid) await this.#node.rest.destroyPlayer(this.guildId).catch(noop);
+    const previousNode = this.#node;
+    this.#node = node;
+    try {
+      const player = await node.rest.updatePlayer(this.guildId, request);
+      this.#player.queues.cache.set(this.guildId, player);
+      this.#info.node_session_id = node.sessionId;
+      this.#player.emit("voiceChange", this, previousNode, wasPlaying);
+      resolver.resolve();
+    } catch (err) {
+      resolver.reject(err);
+      throw err;
+    } finally {
+      this.#changePromise = null;
+    }
+  }
+};
+
+// src/Voice/VoiceRegion.ts
+var VoiceRegion = class {
+  #player;
+  #records = /* @__PURE__ */ new Map();
+  id;
+  constructor(player, regionId) {
+    this.#player = player;
+    this.id = regionId;
+    Object.defineProperty(this, "id", {
+      writable: false,
+      configurable: false
+    });
+  }
+  get nodes() {
+    return this.#records.keys().toArray();
+  }
+  forgetNode(name) {
+    this.#records.delete(name);
+  }
+  onPingUpdate(name, ping, time) {
+    if (!this.#player.nodes.state(name, "ready")) return;
+    if (ping <= 0 || time <= 0) return;
+    const node = this.#records.get(name);
+    if (!node) {
+      this.#records.set(name, { pings: [ping], lastPingTime: time });
+      return;
+    }
+    if (time - node.lastPingTime < 12e3) return;
+    node.lastPingTime = time;
+    node.pings.push(ping);
+    if (node.pings.length > 5) node.pings.shift();
+  }
+  getAveragePing(name) {
+    const pings = this.#records.get(name)?.pings;
+    return !pings?.length ? 0 : pings.reduce((t, c) => t + c, 0) / pings.length;
+  }
+  getRelevantNode(...exclusions) {
+    return this.#player.nodes.relevant().filter((n) => !exclusions.includes(n.name)).sort((a, b) => {
+      if (!this.#records.has(a.name)) return -1;
+      if (!this.#records.has(b.name)) return 1;
+      return this.getAveragePing(a.name) - this.getAveragePing(b.name);
+    })[0];
+  }
+};
+var VoiceManager = class {
+  #player;
+  #voices = /* @__PURE__ */ new Map();
+  #joins = /* @__PURE__ */ new Map();
+  #destroys = /* @__PURE__ */ new Map();
+  #cache = /* @__PURE__ */ new Map();
+  regions = /* @__PURE__ */ new Map();
+  constructor(player) {
+    this.#player = player;
+    Object.defineProperty(this, "regions", {
+      writable: false,
+      configurable: false
+    });
+  }
+  get size() {
+    return this.#voices.size;
+  }
+  get cache() {
+    return this.#cache;
+  }
+  get(guildId) {
+    return this.#voices.get(guildId);
+  }
+  has(guildId) {
+    return this.#voices.has(guildId);
+  }
+  keys() {
+    return this.#voices.keys();
+  }
+  values() {
+    return this.#voices.values();
+  }
+  entries() {
+    return this.#voices.entries();
+  }
+  async destroy(guildId, reason = "destroyed") {
+    if (this.#player.queues.has(guildId)) return this.#player.queues.destroy(guildId, reason);
+    if (this.#destroys.has(guildId)) return this.#destroys.get(guildId);
+    const voice = this.#voices.get(guildId);
+    if (!voice) return;
+    const resolver = Promise.withResolvers();
+    this.#destroys.set(guildId, resolver.promise);
+    await voice.disconnect().catch(noop);
+    this.#voices.delete(guildId);
+    this.#player.emit("voiceDestroy", voice, reason);
+    this.#destroys.delete(guildId);
+    resolver.resolve();
+  }
+  async connect(guildId, voiceId, options) {
+    if (!isString(guildId, SnowflakeRegex)) throw new Error("Guild Id is not a valid Discord Id");
+    if (!isString(voiceId, SnowflakeRegex)) throw new Error("Voice Id is not a valid Discord Id");
+    if (this.#joins.has(guildId)) {
+      const request2 = this.#joins.get(guildId);
+      if (request2.voiceId === voiceId) return request2.promise;
+      throw new Error("Another connection to the same guild is in progress");
+    }
+    const voice = this.#voices.get(guildId);
+    const joined = voice?.channelId === voiceId;
+    if (joined && voice.connected && this.#cache.has(guildId)) return voice;
+    if (options?.node !== void 0 && !this.#player.nodes.state(options.node, "ready")) {
+      throw new Error(`Node '${options.node}' not ready`);
+    }
+    const request = Promise.withResolvers();
+    request.voiceId = voiceId;
+    if (options?.node !== void 0) request.node = options.node;
+    if (options?.context !== void 0) request.context = options.context;
+    if (options?.filters !== void 0) request.config = { filters: options.filters };
+    if (options?.volume !== void 0) {
+      request.config ??= {};
+      request.config.volume = options.volume;
+    }
+    this.#joins.set(guildId, request);
+    if (joined) {
+      voice.reconnecting = true;
+      await this.#sendVoiceUpdate(guildId, null);
+    }
+    await this.#sendVoiceUpdate(guildId, voiceId);
+    const controller = new AbortController();
+    try {
+      const state = await Promise.race([request.promise, setTimeout$1(3e4, null, { signal: controller.signal })]);
+      if (state === null) throw new Error(`Connection timed out - Guild[${guildId}] Voice[${voiceId}]`);
+      return state;
+    } catch (err) {
+      this.#cache.delete(guildId);
+      await this.#sendVoiceUpdate(guildId, null);
+      request.reject(err);
+      throw err;
+    } finally {
+      controller.abort();
+      if (voice?.reconnecting) voice.reconnecting = false;
+      this.#joins.delete(guildId);
+    }
+  }
+  async disconnect(guildId) {
+    if (!this.#voices.has(guildId)) throw new Error(`No connection found for guild '${guildId}'`);
+    this.#cache.delete(guildId);
+    return this.#sendVoiceUpdate(guildId, null);
+  }
+  #getVoiceRegion(id) {
+    if (this.regions.has(id)) return this.regions.get(id);
+    const region = new VoiceRegion(this.#player, id);
+    this.regions.set(id, region);
+    return region;
+  }
+  async #sendVoiceUpdate(guildId, channelId) {
+    return this.#player.options.forwardVoiceUpdate(guildId, {
+      op: 4,
+      d: {
+        guild_id: guildId,
+        channel_id: channelId,
+        self_deaf: channelId !== null,
+        self_mute: false
+      }
+    });
+  }
+  handleDispatch(payload) {
+    if (payload.op !== 0) return;
+    switch (payload.t) {
+      case "VOICE_STATE_UPDATE":
+        this.#onStateUpdate(payload.d);
+        return;
+      case "VOICE_SERVER_UPDATE":
+        this.#onServerUpdate(payload.d);
+        return;
+      case "READY":
+        this.#onClientReady(payload.d);
+        return;
+    }
+  }
+  async #onClientReady(data) {
+    if (this.#player.initialized) return;
+    return this.#player.init(data.user.id);
+  }
+  #onStateUpdate(data) {
+    if (!data.guild_id || data.user_id !== this.#player.clientId) return;
+    if (data.channel_id === null) {
+      this.#cache.delete(data.guild_id);
+      return;
+    }
+    if (!this.#voices.has(data.guild_id) && !this.#joins.has(data.guild_id)) return;
+    const state = this.#cache.get(data.guild_id);
+    if (!state) {
+      this.#cache.set(data.guild_id, {
+        channel_id: data.channel_id,
+        connected: false,
+        deaf: data.deaf,
+        endpoint: "",
+        guild_id: data.guild_id,
+        mute: data.mute,
+        node_session_id: "",
+        ping: -1,
+        region_id: "unknown",
+        self_deaf: data.self_deaf,
+        self_mute: data.self_mute,
+        session_id: data.session_id,
+        suppress: data.suppress,
+        token: ""
+      });
+      return;
+    }
+    state.channel_id = data.channel_id;
+    state.deaf = data.deaf;
+    state.mute = data.mute;
+    state.self_deaf = data.self_deaf;
+    state.self_mute = data.self_mute;
+    state.session_id = data.session_id;
+    state.suppress = data.suppress;
+  }
+  async #onServerUpdate(data) {
+    if (data.endpoint === null) return;
+    const state = this.#cache.get(data.guild_id);
+    const request = this.#joins.get(data.guild_id);
+    if (!state) return request?.reject(new Error("No voice state received"));
+    state.token = data.token;
+    state.endpoint = data.endpoint;
+    state.region_id = data.endpoint.match(VoiceRegionIdRegex)?.[0] ?? "unknown";
+    const region = this.#getVoiceRegion(state.region_id);
+    const reqNode = request?.node !== void 0;
+    let voice = this.#voices.get(data.guild_id);
+    const node = voice?.node ?? (reqNode ? this.#player.nodes.get(request.node) : region.getRelevantNode());
+    if (!node?.ready)
+      return request?.reject(new Error(reqNode ? `Node '${request.node}' unavailable` : "No nodes available"));
+    try {
+      const player = await node.rest.updatePlayer(data.guild_id, {
+        ...request?.config,
+        voice: {
+          endpoint: data.endpoint,
+          sessionId: state.session_id,
+          token: data.token
+        }
+      });
+      this.#player.queues.cache.set(data.guild_id, player);
+      state.node_session_id = node.sessionId;
+      state.connected = player.state.connected;
+      state.ping = player.state.ping;
+      if (!voice) {
+        voice = new VoiceState(this.#player, node.name, data.guild_id);
+        this.#voices.set(data.guild_id, voice);
+      }
+      this.#player.emit("voiceConnect", voice);
+      if (!this.#player.queues.has(data.guild_id)) {
+        const options = { guildId: data.guild_id, voiceId: state.channel_id };
+        if (request?.context !== void 0) options.context = request.context;
+        await this.#player.queues.create(options);
+      }
+      request?.resolve(voice);
+    } catch (err) {
+      request?.reject(err);
+    }
+  }
+  [Symbol.iterator]() {
+    return this.#voices[Symbol.iterator]();
+  }
+};
+
+// src/Queue/Track.ts
+var Track = class {
+  id;
+  title = "Unknown Track";
+  author = "Unknown Author";
+  isLive = false;
+  isSeekable = false;
+  duration = 0;
+  formattedDuration = "00:00";
+  uri = null;
+  isrc = null;
+  url = null;
+  artworkUrl = null;
+  userData = {};
+  pluginInfo = {};
+  encoded;
+  sourceName = "unknown";
+  constructor(data) {
+    if (!isRecord(data)) throw new Error("Track data must be an object");
+    if (!isRecord(data.info)) throw new Error("Track info is not an object");
+    if (isString(data.info.identifier, "non-empty")) this.id = data.info.identifier;
+    else throw new Error("Track does not have an identifier");
+    if (isString(data.encoded, "non-empty")) this.encoded = data.encoded;
+    else throw new Error("Track does not have an encoded data string");
+    if (isString(data.info.title, "non-empty")) this.title = data.info.title;
+    if (isString(data.info.author, "non-empty")) this.author = data.info.author;
+    if (data.info.isStream) this.isLive = true;
+    if (data.info.isSeekable) this.isSeekable = true;
+    if (this.isLive) {
+      this.duration = Number.POSITIVE_INFINITY;
+      this.formattedDuration = "Live";
+    } else if (isNumber(data.info.length, "natural")) {
+      this.duration = data.info.length;
+      this.formattedDuration = formatDuration(this.duration);
+    }
+    if (isString(data.info.uri, "non-empty")) this.uri = data.info.uri;
+    if (isString(data.info.isrc, "non-empty")) this.isrc = data.info.isrc;
+    if (isString(this.uri, "url")) this.url = this.uri;
+    if (isString(data.info.artworkUrl, "url")) this.artworkUrl = data.info.artworkUrl;
+    if (isRecord(data.userData, "non-empty")) this.userData = data.userData;
+    if (isRecord(data.pluginInfo, "non-empty")) this.pluginInfo = data.pluginInfo;
+    if (isString(data.info.sourceName, "non-empty")) this.sourceName = data.info.sourceName;
+  }
+  toString() {
+    return this.title;
+  }
+};
+
+// src/Queue/Playlist.ts
+var Playlist = class {
+  name = "Unknown Playlist";
+  selectedTrack = -1;
+  tracks = [];
+  pluginInfo = {};
+  duration = 0;
+  formattedDuration = "00:00";
+  constructor(data) {
+    if (!isRecord(data)) throw new Error("Playlist data must be an object");
+    if (!isRecord(data.info)) throw new Error("Playlist info is not an object");
+    if (isString(data.info.name, "non-empty")) this.name = data.info.name;
+    if (isNumber(data.info.selectedTrack, "whole")) this.selectedTrack = data.info.selectedTrack;
+    for (let i = 0, track; i < data.tracks.length; i++) {
+      track = new Track(data.tracks[i]);
+      if (!track.isLive) this.duration += track.duration;
+      this.tracks.push(track);
+    }
+    if (isRecord(data.pluginInfo, "non-empty")) this.pluginInfo = data.pluginInfo;
+    if (this.duration > 0) this.formattedDuration = formatDuration(this.duration);
+  }
+  toString() {
+    return this.name;
+  }
+};
+
+// src/Queue/FilterManager.ts
+var FilterManager = class {
+  #manager;
+  #cache;
+  #voice;
+  constructor(player, guildId) {
+    const cache = player.queues.cache.get(guildId);
+    if (!cache) throw new Error(`No player found for guild '${guildId}'`);
+    const voice = player.voices.get(guildId);
+    if (!voice) throw new Error(`No connection found for guild '${guildId}'`);
+    this.#manager = player.queues;
+    this.#cache = cache;
+    this.#voice = voice;
+  }
+  get #data() {
+    this.#cache = this.#manager.cache.get(this.#voice.guildId) ?? this.#cache;
+    return this.#cache;
+  }
+  set #data(data) {
+    this.#manager.cache.set(this.#voice.guildId, data);
+    this.#cache = data;
+  }
+  get data() {
+    return this.#data.filters;
+  }
+  get(name) {
+    return this.#data.filters[name] ?? this.#cache.filters.pluginFilters?.[name] ?? null;
+  }
+  async set(name, value, isPlugin = false) {
+    if (name === "pluginFilters") return null;
+    if (!isPlugin) this.#data.filters[name] = value;
+    else {
+      this.#cache.filters.pluginFilters ??= {};
+      this.#cache.filters.pluginFilters[name] = value;
+    }
+    await this.override(this.#cache.filters);
+    return (isPlugin ? this.#cache.filters.pluginFilters?.[name] : this.#cache.filters[name]) ?? null;
+  }
+  has(name) {
+    if (name === "pluginFilters") return false;
+    return name in this.#data.filters || this.#cache.filters.pluginFilters !== void 0 && name in this.#cache.filters.pluginFilters;
+  }
+  async merge(filters) {
+    return this.override({ ...this.#data.filters, ...filters });
+  }
+  async remove(...names) {
+    if (names.length === 0) return this.#data.filters;
+    for (const filter in this.#data.filters) {
+      if (names.includes(filter)) delete this.#cache.filters[filter];
+    }
+    for (const filter in this.#cache.filters.pluginFilters) {
+      if (names.includes(filter)) delete this.#cache.filters.pluginFilters?.[filter];
+    }
+    return this.override(this.#cache.filters);
+  }
+  async clear() {
+    return this.override({});
+  }
+  async override(filters) {
+    this.#data = await this.#voice.node.rest.updatePlayer(this.#voice.guildId, { filters });
+    return this.#cache.filters;
+  }
+};
+
+// src/Queue/Queue.ts
+var Queue = class {
+  #cache;
+  #player;
+  #autoplay = false;
+  #repeatMode = "none";
+  #tracks = [];
+  #previousTracks = [];
+  context = {};
+  voice;
+  filters;
+  constructor(player, guildId, context) {
+    if (player.voices.has(guildId)) {
+      this.voice = player.voices.get(guildId);
+    } else {
+      throw new Error(`No connection found for guild '${guildId}'`);
+    }
+    if (player.queues.cache.has(guildId)) {
+      this.#cache = player.queues.cache.get(guildId);
+    } else {
+      throw new Error(`No player found for guild '${guildId}'`);
+    }
+    this.#player = player;
+    this.filters = new FilterManager(player, guildId);
+    if (context !== void 0) this.context = context;
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      voice: immutable,
+      filters: immutable
+    });
+  }
+  get #data() {
+    this.#cache = this.#player.queues.cache.get(this.guildId) ?? this.#cache;
+    return this.#cache;
+  }
+  set #data(data) {
+    this.#player.queues.cache.set(this.guildId, data);
+    this.#cache = data;
+  }
+  get node() {
+    return this.voice.node;
+  }
+  get rest() {
+    return this.voice.node.rest;
+  }
+  get guildId() {
+    return this.voice.guildId;
+  }
+  get volume() {
+    return this.#data.volume;
+  }
+  get paused() {
+    return this.#data.paused;
+  }
+  get stopped() {
+    return this.track !== null && this.#data.track === null;
+  }
+  get autoplay() {
+    return this.#autoplay;
+  }
+  get finished() {
+    return this.#tracks.length === 0;
+  }
+  get destroyed() {
+    return this.#player.queues.get(this.guildId) !== this;
+  }
+  get repeatMode() {
+    return this.#repeatMode;
+  }
+  get isEmpty() {
+    return this.finished && !this.hasPrevious;
+  }
+  get isPlaying() {
+    return !this.paused && this.#data.track !== null;
+  }
+  get hasNext() {
+    return this.#tracks.length > 1;
+  }
+  get hasPrevious() {
+    return this.#previousTracks.length !== 0;
+  }
+  get track() {
+    return this.#tracks[0] ?? null;
+  }
+  get previousTrack() {
+    return this.#previousTracks[this.#previousTracks.length - 1] ?? null;
+  }
+  get tracks() {
+    return this.#tracks;
+  }
+  get previousTracks() {
+    return this.#previousTracks;
+  }
+  get length() {
+    return this.#tracks.length;
+  }
+  get totalLength() {
+    return this.length + this.#previousTracks.length;
+  }
+  get duration() {
+    return this.#tracks.reduce((time, track) => time + (track.isLive ? 0 : track.duration), 0);
+  }
+  get formattedDuration() {
+    return formatDuration(this.duration);
+  }
+  get currentTime() {
+    if (this.#data.paused) return this.#cache.state.position;
+    if (this.#cache.state.position === 0) return 0;
+    return this.#cache.state.position + (Date.now() - this.#cache.state.time);
+  }
+  get formattedCurrentTime() {
+    return formatDuration(this.currentTime);
+  }
+  #error(data) {
+    const explicit = typeof data === "string";
+    const message = explicit ? data : data.message ?? data.cause;
+    const error = new Error(message);
+    error.name = `Error [${this.constructor.name}]`;
+    error.cause = message;
+    error.severity = explicit ? "common" /* Common */ : data.severity;
+    return error;
+  }
+  async search(query, prefix = this.#player.options.queryPrefix) {
+    return this.#player.search(query, { prefix, node: this.node.name });
+  }
+  add(source, userData) {
+    if (source instanceof Track) {
+      Object.assign(source.userData, userData);
+      this.#tracks.push(source);
+    } else if (source instanceof Playlist) {
+      for (const track of source.tracks) {
+        Object.assign(track.userData, userData);
+        this.#tracks.push(track);
+      }
+    } else if (Array.isArray(source) && source.every((t) => t instanceof Track)) {
+      for (const track of source) {
+        Object.assign(track.userData, userData);
+        this.#tracks.push(track);
+      }
+    } else throw new Error("Source must be a track, playlist, or array of tracks");
+    return this;
+  }
+  async addRelated(refTrack) {
+    refTrack ??= this.track ?? this.previousTrack;
+    if (!refTrack) throw new Error("The queue is empty and there is no track to refer");
+    const relatedTracks = await this.#player.options.fetchRelatedTracks(this, refTrack);
+    this.add(relatedTracks);
+    return relatedTracks;
+  }
+  remove(input) {
+    if (isNumber(input, "integer")) {
+      if (input === 0) return;
+      if (input < 0) return this.#previousTracks.splice(input, 1)[0];
+      return this.#tracks.splice(input, 1)[0];
+    }
+    if (Array.isArray(input) && input.every((i) => isNumber(i, "integer"))) {
+      if (input.length === 0) return [];
+      const tracks = [];
+      for (let indices = input.toSorted((a, b) => a - b), index = indices[0], deletions = 0, i = 0; i < indices.length; index = indices[++i] - deletions) {
+        if (index === 0) continue;
+        if (index < 0) tracks.push(...this.#previousTracks.splice(index, 1));
+        else if (index < this.#tracks.length) tracks.push(...this.#tracks.splice(index, 1)), deletions++;
+      }
+      return tracks;
+    }
+    throw new Error("Input must be a index or array of indices");
+  }
+  async jump(index) {
+    if (this.isEmpty) throw this.#error("The queue is empty at the moment");
+    if (!isNumber(index, "integer")) throw this.#error("Index must be a integer");
+    const track = index < 0 ? this.#previousTracks[this.#previousTracks.length + index] : this.#tracks[index];
+    if (!track) throw this.#error("Specified index is out of range");
+    if (index < 0) this.#tracks.unshift(...this.#previousTracks.splice(index));
+    else this.#previousTracks.push(...this.#tracks.splice(0, index));
+    this.#data = await this.rest.updatePlayer(this.guildId, {
+      paused: false,
+      track: { encoded: track.encoded, userData: track.userData }
+    });
+    return track;
+  }
+  async pause() {
+    this.#data = await this.rest.updatePlayer(this.guildId, { paused: true });
+    return this.#cache.paused;
+  }
+  async resume() {
+    if (this.stopped) await this.jump(0);
+    else this.#data = await this.rest.updatePlayer(this.guildId, { paused: false });
+    return !this.#cache.paused;
+  }
+  async seek(ms) {
+    if (this.track === null) throw this.#error("No track's playing at the moment");
+    if (!this.track.isSeekable) throw this.#error("Current track is not seekable");
+    if (!isNumber(ms, "whole")) throw this.#error("Seek time must be a whole number");
+    if (ms > this.track.duration) throw this.#error("Specified time to seek is out of range");
+    const _body = { paused: false, position: ms };
+    if (this.#data.track?.info.identifier !== this.track.id) {
+      _body.track = { encoded: this.track.encoded, userData: this.track.userData };
+    }
+    this.#data = await this.rest.updatePlayer(this.guildId, _body);
+    return this.#cache.state.position;
+  }
+  async next() {
+    if (this.hasNext) return this.jump(1);
+    if (this.hasPrevious && this.#repeatMode === "queue") {
+      this.#tracks.push(this.#previousTracks.shift());
+      return this.jump(this.hasNext ? 1 : 0);
+    }
+    if (this.#autoplay) {
+      const related = await this.addRelated();
+      if (related.length > 0) return this.jump(this.length - related.length);
+    }
+    if (!this.finished) {
+      this.#previousTracks.push(this.#tracks.shift());
+      await this.stop();
+    }
+    return null;
+  }
+  async previous() {
+    if (this.hasPrevious) return this.jump(-1);
+    return null;
+  }
+  shuffle(includePrevious = false) {
+    if (includePrevious === true) this.#tracks.push(...this.#previousTracks.splice(0));
+    if (this.#tracks.length < 3) return this;
+    for (let arr = this.#tracks, i = arr.length - 1, j; i > 1; --i) {
+      j = Math.floor(Math.random() * i) + 1;
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return this;
+  }
+  async setVolume(volume) {
+    if (!isNumber(volume, "whole")) throw this.#error("Volume must be a whole number");
+    if (volume > 1e3) throw this.#error("Volume cannot be more than 1000");
+    this.#data = await this.rest.updatePlayer(this.guildId, { volume });
+    return this.#cache.volume;
+  }
+  setAutoplay(autoplay = false) {
+    if (typeof autoplay === "boolean") this.#autoplay = autoplay;
+    else throw this.#error("Autoplay must be a boolean value");
+    return this.#autoplay;
+  }
+  setRepeatMode(repeatMode = "none") {
+    if (repeatMode === "track" || repeatMode === "queue" || repeatMode === "none") this.#repeatMode = repeatMode;
+    else throw this.#error("Repeat mode can only be set to track, queue, or none");
+    return this.#repeatMode;
+  }
+  async stop() {
+    this.#data = await this.rest.updatePlayer(this.guildId, { track: { encoded: null } });
+  }
+  async destroy(reason) {
+    return this.#player.queues.destroy(this.guildId, reason);
+  }
+};
+
+// src/Queue/QueueManager.ts
+var QueueManager = class {
+  #player;
+  #queues = /* @__PURE__ */ new Map();
+  #cache = /* @__PURE__ */ new Map();
+  #destroys = /* @__PURE__ */ new Map();
+  #relocations = /* @__PURE__ */ new Map();
+  constructor(player) {
+    this.#player = player;
+  }
+  get size() {
+    return this.#queues.size;
+  }
+  get cache() {
+    return this.#cache;
+  }
+  get(guildId) {
+    return this.#queues.get(guildId);
+  }
+  has(guildId) {
+    return this.#queues.has(guildId);
+  }
+  keys() {
+    return this.#queues.keys();
+  }
+  values() {
+    return this.#queues.values();
+  }
+  entries() {
+    return this.#queues.entries();
+  }
+  async create(options) {
+    if (!isRecord(options)) throw new Error("Queue create options must be an object");
+    if (this.#queues.has(options.guildId)) return this.#queues.get(options.guildId);
+    if (!this.#player.voices.has(options.guildId)) {
+      await this.#player.voices.connect(options.guildId, options.voiceId, options);
+      return this.#queues.get(options.guildId);
+    }
+    const queue = new Queue(this.#player, options.guildId, options.context);
+    this.#queues.set(options.guildId, queue);
+    this.#player.emit("queueCreate", queue);
+    return queue;
+  }
+  async destroy(guildId, reason = "destroyed") {
+    if (this.#destroys.has(guildId)) return this.#destroys.get(guildId);
+    const queue = this.#queues.get(guildId);
+    if (!queue) return;
+    const resolver = Promise.withResolvers();
+    this.#destroys.set(guildId, resolver.promise);
+    if (queue.voice.valid) await queue.rest.destroyPlayer(guildId).catch(noop);
+    this.#cache.delete(guildId);
+    this.#queues.delete(guildId);
+    this.#player.emit("queueDestroy", queue, reason);
+    await this.#player.voices.destroy(guildId, reason);
+    this.#destroys.delete(guildId);
+    resolver.resolve();
+  }
+  async relocate(node) {
+    if (this.#relocations.has(node)) return this.#relocations.get(node);
+    const queues = this.#queues.values().filter((q) => q.node.name === node && !q.voice.changingNode).toArray().sort((a, b) => {
+      if (a.isPlaying && !b.isPlaying) return -1;
+      if (b.isPlaying && !a.isPlaying) return 1;
+      return 0;
+    });
+    if (queues.length === 0) return;
+    const nodes = this.#player.nodes.relevant({ memory: 0.6, workload: 0.4 }).reduce((t, n) => {
+      if (n.name !== node) t.push(n.name);
+      return t;
+    }, []);
+    const resolver = Promise.withResolvers();
+    this.#relocations.set(node, resolver.promise);
+    if (nodes.length === 0) {
+      for (const queue of queues) if (!queue.voice.valid) await queue.destroy("Session invalid, nowhere to relocate");
+      this.#relocations.delete(node);
+      const err = new Error("No other nodes available");
+      resolver.reject(err);
+      throw err;
+    }
+    const chunkSize = Math.floor(queues.length / nodes.length);
+    const remaining = queues.length % nodes.length;
+    const map = /* @__PURE__ */ new Map();
+    if (remaining !== 0) map.set(nodes.shift(), queues.splice(0, chunkSize + remaining));
+    while (nodes.length !== 0) map.set(nodes.shift(), queues.splice(0, chunkSize));
+    for (const [name, queues2] of map) {
+      for (const queue of queues2) {
+        if (name === queue.node.name) continue;
+        try {
+          await queue.voice.changeNode(name);
+        } catch (err) {
+          await this.destroy(queue.guildId, `${err.message ?? err}`);
+        }
+      }
+    }
+    this.#relocations.delete(node);
+    resolver.resolve();
+  }
+  onStateUpdate(payload) {
+    const state = payload.state;
+    const cache = this.#cache.get(payload.guildId);
+    if (cache !== void 0) cache.state = state;
+    const voice = this.#player.voices.cache.get(payload.guildId);
+    if (voice !== void 0) {
+      voice.connected = state.connected;
+      voice.ping = state.ping;
+    }
+    const queue = this.#queues.get(payload.guildId);
+    if (!queue) return;
+    this.#player.voices.regions.get(queue.voice.regionId)?.onPingUpdate(queue.node.name, state.ping, state.time);
+    this.#player.emit("queueUpdate", queue, state);
+  }
+  async onEventUpdate(payload) {
+    const cache = this.#cache.get(payload.guildId);
+    if (!cache) return;
+    const queue = this.#queues.get(payload.guildId);
+    if (!queue) return;
+    switch (payload.type) {
+      case "TrackStartEvent" /* TrackStart */: {
+        cache.track ??= payload.track;
+        this.#player.emit("trackStart", queue, new Track(payload.track));
+        return;
+      }
+      case "TrackEndEvent" /* TrackEnd */: {
+        cache.track = null;
+        return this.#onTrackEnd(payload, queue);
+      }
+      case "TrackExceptionEvent" /* TrackException */: {
+        cache.track = null;
+        this.#player.emit("trackError", queue, new Track(payload.track), payload.exception);
+        return;
+      }
+      case "TrackStuckEvent" /* TrackStuck */: {
+        cache.track ??= payload.track;
+        this.#player.emit("trackStuck", queue, new Track(payload.track), payload.thresholdMs);
+        return;
+      }
+      case "WebSocketClosedEvent" /* WebSocketClosed */:
+        return this.#onVoiceClosed(payload, queue.voice);
+    }
+  }
+  async #onTrackEnd(payload, queue) {
+    const track = new Track(payload.track);
+    switch (payload.reason) {
+      case "cleanup" /* Cleanup */:
+        if (payload.track.info.identifier !== queue.track?.id) break;
+        queue.previousTracks.push(queue.tracks.shift());
+        break;
+      case "finished" /* Finished */:
+        if (payload.track.info.identifier !== queue.track?.id) break;
+        if (queue.repeatMode !== "track") queue.previousTracks.push(queue.tracks.shift());
+        break;
+      default:
+        this.#player.emit("trackFinish", queue, track, payload.reason);
+        return;
+    }
+    this.#player.emit("trackFinish", queue, track, payload.reason);
+    try {
+      if (queue.finished) {
+        if (queue.hasPrevious && queue.repeatMode === "queue") queue.tracks.push(queue.previousTracks.shift());
+        else if (queue.autoplay) await queue.addRelated(track);
+      }
+      if (queue.finished) this.#player.emit("queueFinish", queue);
+      else await queue.resume();
+    } catch (err) {
+      return this.destroy(queue.guildId, `${err.message ?? err}`);
+    }
+  }
+  async #onVoiceClosed(payload, voice) {
+    let shouldReconnect;
+    switch (payload.code) {
+      case 4005 /* AlreadyAuthenticated */:
+      case 4020 /* BadRequest */:
+      case 4002 /* FailedToDecodePayload */:
+      case 4003 /* NotAuthenticated */:
+      case 4016 /* UnknownEncryptionMode */:
+      case 4001 /* UnknownOpcode */:
+      case 4012 /* UnknownProtocol */:
+        shouldReconnect = false;
+        break;
+      case 4004 /* AuthenticationFailed */:
+      case 4011 /* ServerNotFound */:
+      case 4006 /* SessionNoLongerValid */:
+      case 4009 /* SessionTimeout */:
+      case 4015 /* VoiceServerCrashed */:
+        shouldReconnect = true;
+        break;
+      case 4014 /* Disconnected */:
+      case 4022 /* DisconnectedCallTerminated */:
+      case 4021 /* DisconnectedRateLimited */:
+      default:
+        this.#player.emit("voiceClose", voice, payload.code, payload.reason, payload.byRemote);
+        return;
+    }
+    voice.reconnecting = shouldReconnect;
+    this.#player.emit("voiceClose", voice, payload.code, payload.reason, payload.byRemote);
+    try {
+      if (shouldReconnect) {
+        await voice.reconnect();
+        if (voice.connected) return;
+      }
+      throw new Error(payload.reason);
+    } catch (err) {
+      return this.destroy(voice.guildId, err.message);
+    } finally {
+      voice.reconnecting = false;
+    }
+  }
+  [Symbol.iterator]() {
+    return this.#queues[Symbol.iterator]();
+  }
+};
+var LavaLyrics = class {
+  name = "lavalyrics";
+  #player;
+  eventMap;
+  init(player) {
+    this.#player = player;
+    player.on("nodeDispatch", this.#onLavaLyrics);
+  }
+  async fetch(track, node, skipTrackSource = false) {
+    if (!isString(track, "non-empty")) throw new Error("Encoded track must be a non-empty string");
+    const _node = this.#player.nodes.get(node);
+    if (!_node) throw new Error(`Node '${node}' not found`);
+    try {
+      const response = await _node.rest.request("GET", "/lyrics", { params: { track, skipTrackSource } });
+      if (response.status === HttpStatusCode.Ok) return response.data;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async subscribe(guildId, skipTrackSource = false) {
+    const queue = this.#player.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    if (!queue.node.ready) throw new Error(`Node '${queue.node.name}' not ready`);
+    try {
+      const response = await queue.rest.request(
+        "POST",
+        Routes.player(queue.node.sessionId, guildId) + "/lyrics/subscribe",
+        {
+          params: { skipTrackSource }
+        }
+      );
+      return response.status === HttpStatusCode.NoContent;
+    } catch {
+      return false;
+    }
+  }
+  async unsubscribe(guildId) {
+    const queue = this.#player.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    if (!queue.node.ready) throw new Error(`Node '${queue.node.name}' not ready`);
+    try {
+      const response = await queue.rest.request(
+        "DELETE",
+        Routes.player(queue.node.sessionId, guildId) + "/lyrics/subscribe"
+      );
+      return response.status === HttpStatusCode.NoContent;
+    } catch {
+      return false;
+    }
+  }
+  async fetchCurrent(guildId, skipTrackSource = false) {
+    const queue = this.#player.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    if (queue.finished) return null;
+    if (!queue.node.ready) throw new Error(`Node '${queue.node.name}' not ready`);
+    const response = await queue.rest.request(
+      "GET",
+      Routes.player(queue.node.sessionId, guildId) + "/track/lyrics",
+      {
+        params: { skipTrackSource }
+      }
+    );
+    return response.status === HttpStatusCode.Ok ? response.data : null;
+  }
+  #onLavaLyrics(_node, payload) {
+    if (payload.op !== "event" /* Event */) return;
+    const queue = this.queues.get(payload.guildId);
+    if (!queue) return;
+    switch (payload.type) {
+      case "LyricsFoundEvent":
+        this.emit("lyricsFound", queue, payload.lyrics);
+        return;
+      case "LyricsLineEvent":
+        this.emit("lyricsLine", queue, payload.line, payload.lineIndex, payload.skipped);
+        return;
+      case "LyricsNotFoundEvent":
+        this.emit("lyricsNotFound", queue);
+        return;
+    }
+  }
+};
+var Player = class extends EventEmitter {
+  #initialized = false;
+  #clientId = null;
+  #initPromise = null;
+  nodes;
+  voices;
+  queues;
+  options;
+  plugins;
+  constructor(options) {
+    super({ captureRejections: false });
+    const _options = { ...DefaultPlayerOptions, ...options };
+    if (isRecord(_options, "non-empty")) this.options = _options;
+    else throw new Error("Player options must be a non-empty object");
+    if (_options.nodes.length === 0) throw new Error("Missing node options");
+    this.nodes = new NodeManager(this);
+    this.voices = new VoiceManager(this);
+    this.queues = new QueueManager(this);
+    this.plugins = {};
+    if (_options.plugins !== void 0) {
+      for (const plugin of _options.plugins) this.plugins[plugin.name] = plugin;
+      delete _options.plugins;
+    }
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      nodes: immutable,
+      voices: immutable,
+      queues: immutable,
+      options: immutable,
+      plugins: immutable
+    });
+  }
+  get clientId() {
+    return this.#clientId;
+  }
+  get initialized() {
+    return this.#initialized;
+  }
+  async init(clientId) {
+    if (this.#initPromise !== null) return this.#initPromise;
+    if (this.#initialized) return;
+    const resolver = Promise.withResolvers();
+    this.#initPromise = resolver.promise;
+    this.#clientId = clientId;
+    try {
+      for (const node of this.options.nodes) this.nodes.create(node);
+      for (const name in this.plugins) this.plugins[name].init(this);
+      await this.nodes.connect();
+      this.#initialized = true;
+      this.emit("init");
+      resolver.resolve();
+    } catch (err) {
+      resolver.reject(err);
+      throw err;
+    } finally {
+      this.#initPromise = null;
+    }
+  }
+  getQueue(guildId) {
+    return this.queues.get(guildId);
+  }
+  async createQueue(options) {
+    return this.queues.create(options);
+  }
+  async destroyQueue(guildId, reason) {
+    return this.queues.destroy(guildId, reason);
+  }
+  async search(query, options) {
+    if (!isString(query, "non-empty")) throw new Error("Query must be a non-empty string");
+    const node = options?.node !== void 0 ? this.nodes.get(options.node) : this.nodes.relevant()[0];
+    if (!node) {
+      if (options?.node === void 0) throw new Error("No nodes available");
+      throw new Error(`Node '${options.node}' not found`);
+    }
+    query = isString(query, "url") ? query : `${options?.prefix ?? this.options.queryPrefix}:${query}`;
+    const result = await node.rest.loadTracks(query);
+    switch (result.loadType) {
+      case "empty" /* Empty */:
+        return { type: "empty", data: [] };
+      case "error" /* Error */:
+        return { type: "error", data: result.data };
+      case "playlist" /* Playlist */:
+        return { type: "playlist", data: new Playlist(result.data) };
+      case "search" /* Search */:
+        return { type: "query", data: result.data.map((t) => new Track(t)) };
+      case "track" /* Track */:
+        return { type: "track", data: new Track(result.data) };
+      default:
+        throw new Error(`Unexpected load result type from node '${node.name}'`);
+    }
+  }
+  async play(source, options) {
+    let queue = this.queues.get(options.guildId);
+    if (typeof source === "string") {
+      let result;
+      if (!queue) result = await this.search(source, options);
+      else result = await queue.search(source, options.prefix);
+      if (result.type === "empty") throw new Error(`No results found for '${source}'`);
+      if (result.type === "error") throw new Error(result.data.message ?? result.data.cause, { cause: result.data });
+      source = result.type === "query" ? result.data[0] : result.data;
+    }
+    queue ??= await this.queues.create(options);
+    if (options.context !== void 0) Object.assign(queue.context, options.context);
+    queue.add(source, options.userData);
+    if (queue.stopped) await queue.resume();
+    return queue;
+  }
+  async jump(guildId, index) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.jump(index);
+  }
+  async pause(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.pause();
+  }
+  async previous(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.previous();
+  }
+  async resume(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.resume();
+  }
+  async seek(guildId, ms) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.seek(ms);
+  }
+  setAutoplay(guildId, autoplay) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.setAutoplay(autoplay);
+  }
+  setRepeatMode(guildId, repeatMode) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.setRepeatMode(repeatMode);
+  }
+  async setVolume(guildId, volume) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.setVolume(volume);
+  }
+  shuffle(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.shuffle();
+  }
+  async next(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.next();
+  }
+  async stop(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) throw new Error(`No queue found for guild '${guildId}'`);
+    return queue.stop();
+  }
+};
+
+// src/index.ts
+var version = "1.0.0";
+
+export { CloseCodes, DefaultNodeOptions, DefaultPlayerOptions, DefaultRestOptions, EventType, FilterManager, IPBlockType, LavaLyrics, LoadType, Node, NodeManager, OPType, Player, Playlist, Queue, QueueManager, REST, RoutePlannerType, Routes, Severity, SnowflakeRegex, Track, TrackEndReason, VoiceCloseCodes, VoiceManager, VoiceRegion, VoiceRegionIdRegex, VoiceState, formatDuration, isArray, isNumber, isRecord, isString, noop, version };