hoshimi 0.2.0

package/dist/index.js

@@ -0,0 +1,4577 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AudioOutput: () => AudioOutput,
+  DSPXPluginFilter: () => DSPXPluginFilter,
+  DebugLevels: () => DebugLevels,
+  DestroyReasons: () => DestroyReasons,
+  Events: () => Events,
+  FilterManager: () => FilterManager,
+  FilterType: () => FilterType,
+  Hoshimi: () => Hoshimi,
+  HttpMethods: () => HttpMethods,
+  HttpStatusCodes: () => HttpStatusCodes,
+  LavalinkPluginFilter: () => LavalinkPluginFilter,
+  LoadType: () => LoadType,
+  LoopMode: () => LoopMode,
+  ManagerError: () => ManagerError,
+  MemoryAdapter: () => MemoryAdapter,
+  Node: () => Node,
+  NodeDestroyReasons: () => NodeDestroyReasons,
+  NodeError: () => NodeError,
+  NodeSortTypes: () => NodeSortTypes,
+  OpCodes: () => OpCodes,
+  OptionError: () => OptionError,
+  Player: () => Player,
+  PlayerError: () => PlayerError,
+  PlayerEventType: () => PlayerEventType,
+  PluginInfoType: () => PluginInfoType,
+  PluginNames: () => PluginNames,
+  Queue: () => Queue,
+  ResolveError: () => ResolveError,
+  Rest: () => Rest,
+  SearchEngines: () => SearchEngines,
+  Severity: () => Severity,
+  SourceNames: () => SourceNames,
+  State: () => State,
+  StorageAdapter: () => StorageAdapter,
+  StorageError: () => StorageError,
+  Structures: () => Structures,
+  Track: () => Track,
+  TrackEndReason: () => TrackEndReason,
+  UnresolvedTrack: () => UnresolvedTrack,
+  WebsocketCloseCodes: () => WebsocketCloseCodes,
+  createHoshimi: () => createHoshimi
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/Node.ts
+var State = /* @__PURE__ */ ((State2) => {
+  State2[State2["Connecting"] = 1] = "Connecting";
+  State2[State2["Connected"] = 2] = "Connected";
+  State2[State2["Disconnected"] = 3] = "Disconnected";
+  State2[State2["Reconnecting"] = 4] = "Reconnecting";
+  State2[State2["Reconnected"] = 5] = "Reconnected";
+  State2[State2["Destroyed"] = 6] = "Destroyed";
+  State2[State2["Idle"] = 7] = "Idle";
+  return State2;
+})(State || {});
+var OpCodes = /* @__PURE__ */ ((OpCodes2) => {
+  OpCodes2["Ready"] = "ready";
+  OpCodes2["PlayerUpdate"] = "playerUpdate";
+  OpCodes2["Stats"] = "stats";
+  OpCodes2["Event"] = "event";
+  return OpCodes2;
+})(OpCodes || {});
+var LoadType = /* @__PURE__ */ ((LoadType2) => {
+  LoadType2["Track"] = "track";
+  LoadType2["Playlist"] = "playlist";
+  LoadType2["Search"] = "search";
+  LoadType2["Empty"] = "empty";
+  LoadType2["Error"] = "error";
+  return LoadType2;
+})(LoadType || {});
+var SourceNames = /* @__PURE__ */ ((SourceNames2) => {
+  SourceNames2["Youtube"] = "youtube";
+  SourceNames2["YoutubeMusic"] = "youtubemusic";
+  SourceNames2["Soundcloud"] = "soundcloud";
+  SourceNames2["Bandcamp"] = "bandcamp";
+  SourceNames2["Twitch"] = "twitch";
+  SourceNames2["Vimeo"] = "vimeo";
+  SourceNames2["Mixer"] = "mixer";
+  SourceNames2["Spotify"] = "spotify";
+  SourceNames2["Deezer"] = "deezer";
+  SourceNames2["VKMusic"] = "vkmusic";
+  SourceNames2["Tidal"] = "tidal";
+  SourceNames2["JioSaavn"] = "jiosaavn";
+  SourceNames2["AppleMusic"] = "applemusic";
+  SourceNames2["YandexMusic"] = "yandexmusic";
+  SourceNames2["FloweryTTS"] = "flowery-tts";
+  SourceNames2["HTTP"] = "http";
+  SourceNames2["PornHub"] = "pornhub";
+  SourceNames2["TextToSpeech"] = "tts";
+  SourceNames2["Clypit"] = "clypit";
+  SourceNames2["StreamDeckAudio"] = "StreamDeckAudio";
+  SourceNames2["GetYarn"] = "getyarn.io";
+  SourceNames2["MixCloud"] = "mixcloud";
+  SourceNames2["OCRemix"] = "ocremix";
+  SourceNames2["PixelDrain"] = "pixeldrain";
+  SourceNames2["Reddit"] = "reddit";
+  SourceNames2["SoundGasm"] = "soundgasm";
+  SourceNames2["TikTok"] = "tiktok";
+  return SourceNames2;
+})(SourceNames || {});
+var Severity = /* @__PURE__ */ ((Severity2) => {
+  Severity2["Common"] = "common";
+  Severity2["Suspicious"] = "suspicious";
+  Severity2["Fault"] = "fault";
+  return Severity2;
+})(Severity || {});
+var PluginInfoType = /* @__PURE__ */ ((PluginInfoType2) => {
+  PluginInfoType2["Album"] = "album";
+  PluginInfoType2["Playlist"] = "playlist";
+  PluginInfoType2["Artist"] = "artist";
+  PluginInfoType2["Recommendations"] = "recommendations";
+  return PluginInfoType2;
+})(PluginInfoType || {});
+var NodeDestroyReasons = /* @__PURE__ */ ((NodeDestroyReasons2) => {
+  NodeDestroyReasons2["Destroy"] = "Node-Destroy";
+  NodeDestroyReasons2["MissingSession"] = "Missing-Session";
+  return NodeDestroyReasons2;
+})(NodeDestroyReasons || {});
+var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
+  WebsocketCloseCodes2[WebsocketCloseCodes2["NormalClosure"] = 1e3] = "NormalClosure";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["GoingAway"] = 1001] = "GoingAway";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["ProtocolError"] = 1002] = "ProtocolError";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["UnsupportedData"] = 1003] = "UnsupportedData";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["NoStatusReceived"] = 1005] = "NoStatusReceived";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["AbnormalClosure"] = 1006] = "AbnormalClosure";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["InvalidFramePayloadData"] = 1007] = "InvalidFramePayloadData";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["PolicyViolation"] = 1008] = "PolicyViolation";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MessageTooBig"] = 1009] = "MessageTooBig";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MandatoryExtension"] = 1010] = "MandatoryExtension";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["InternalError"] = 1011] = "InternalError";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["ServiceRestart"] = 1012] = "ServiceRestart";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["TryAgainLater"] = 1013] = "TryAgainLater";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["BadGateway"] = 1014] = "BadGateway";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["TLSHandshakeFailure"] = 1015] = "TLSHandshakeFailure";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["Unauthorized"] = 3e3] = "Unauthorized";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["Forbidden"] = 3003] = "Forbidden";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["Timeout"] = 3008] = "Timeout";
+  return WebsocketCloseCodes2;
+})(WebsocketCloseCodes || {});
+var PluginNames = /* @__PURE__ */ ((PluginNames2) => {
+  PluginNames2["LavaSrc"] = "lavasrc-plugin";
+  PluginNames2["JavaLyrics"] = "java-lyrics-plugin";
+  PluginNames2["LavaLyrics"] = "lavalyrics-plugin";
+  PluginNames2["LavaSearch"] = "lavasearch-plugin";
+  PluginNames2["SponsorBlock"] = "sponsorblock-plugin";
+  PluginNames2["LavaDspx"] = "lavadspx-plugin";
+  PluginNames2["Youtube"] = "youtube-plugin";
+  PluginNames2["Skybot"] = "skybot-lavalink-plugin";
+  PluginNames2["LavaXm"] = "lava-xm-plugin";
+  PluginNames2["Jiosaavn"] = "jiosaavn-plugin";
+  PluginNames2["FilterPlugin"] = "lavalink-filter-plugin";
+  return PluginNames2;
+})(PluginNames || {});
+var NodeSortTypes = /* @__PURE__ */ ((NodeSortTypes2) => {
+  NodeSortTypes2["Memory"] = "memory";
+  NodeSortTypes2["Cpu"] = "cpu";
+  NodeSortTypes2["Players"] = "players";
+  NodeSortTypes2["PlayingPlayers"] = "playingPlayers";
+  NodeSortTypes2["SystemLoad"] = "systemLoad";
+  NodeSortTypes2["LavalinkLoad"] = "lavalinkLoad";
+  return NodeSortTypes2;
+})(NodeSortTypes || {});
+
+// src/classes/Errors.ts
+var ManagerError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Hoshimi [ManagerError]";
+  }
+};
+var OptionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Hoshimi [OptionError]";
+  }
+};
+var PlayerError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Hoshimi [PlayerError]";
+  }
+};
+var NodeError = class extends Error {
+  constructor({ message, id }) {
+    super(message);
+    this.name = `Hoshimi [NodeError | ${id}]`;
+  }
+};
+var StorageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Hoshimi [StorageError]";
+  }
+};
+var ResolveError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "Hoshimi [ResolveError]";
+  }
+};
+
+// src/types/Manager.ts
+var SearchEngines = /* @__PURE__ */ ((SearchEngines2) => {
+  SearchEngines2["Youtube"] = "ytsearch";
+  SearchEngines2["YoutubeMusic"] = "ytmsearch";
+  SearchEngines2["Spotify"] = "spsearch";
+  SearchEngines2["SpotifyRecommendations"] = "sprec";
+  SearchEngines2["SpotifyArtistMix"] = "sprec:mix:artist";
+  SearchEngines2["SpotifyAlbumMix"] = "sprec:mix:album";
+  SearchEngines2["SpotifyTrackMix"] = "sprec:mix:track";
+  SearchEngines2["SpotifyISRCMix"] = "sprec:mix:isrc";
+  SearchEngines2["SoundCloud"] = "scsearch";
+  SearchEngines2["AppleMusic"] = "amsearch";
+  SearchEngines2["BandCamp"] = "bcsearch";
+  SearchEngines2["Deezer"] = "dzsearch";
+  SearchEngines2["DeezerISRC"] = "dzisrc";
+  SearchEngines2["DeezerRecommendations"] = "dzrec";
+  SearchEngines2["YandexMusic"] = "ymsearch";
+  SearchEngines2["YandexMusicRecommendations"] = "ymrec";
+  SearchEngines2["VKMusic"] = "vksearch";
+  SearchEngines2["VKMusicRecommendations"] = "vkrec";
+  SearchEngines2["Tidal"] = "tdsearch";
+  SearchEngines2["TidalRecommendations"] = "tdrec";
+  SearchEngines2["Qobuz"] = "qbsearch";
+  SearchEngines2["QobuzISRC"] = "qbisrc";
+  SearchEngines2["QobuzRecommendations"] = "qbrec";
+  SearchEngines2["JioSaavn"] = "jssearch";
+  SearchEngines2["JioSaavnRecommendations"] = "jsrec";
+  SearchEngines2["Twitch"] = "twsearch";
+  SearchEngines2["Mixer"] = "mxsearch";
+  SearchEngines2["Vimeo"] = "vmsearch";
+  SearchEngines2["FloweryTTS"] = "ftts";
+  SearchEngines2["Local"] = "local";
+  SearchEngines2["PornHub"] = "phsearch";
+  SearchEngines2["TextToSpeech"] = "speak";
+  return SearchEngines2;
+})(SearchEngines || {});
+var DebugLevels = /* @__PURE__ */ ((DebugLevels2) => {
+  DebugLevels2[DebugLevels2["Manager"] = 1] = "Manager";
+  DebugLevels2[DebugLevels2["Node"] = 2] = "Node";
+  DebugLevels2[DebugLevels2["Player"] = 3] = "Player";
+  DebugLevels2[DebugLevels2["Rest"] = 4] = "Rest";
+  DebugLevels2[DebugLevels2["Queue"] = 5] = "Queue";
+  DebugLevels2[DebugLevels2["Test"] = 6] = "Test";
+  return DebugLevels2;
+})(DebugLevels || {});
+var Events = /* @__PURE__ */ ((Events2) => {
+  Events2["Debug"] = "debug";
+  Events2["Error"] = "error";
+  Events2["NodeRaw"] = "nodeRaw";
+  Events2["NodeError"] = "nodeError";
+  Events2["NodeReady"] = "nodeReady";
+  Events2["NodeDisconnect"] = "nodeDisconnect";
+  Events2["NodeReconnecting"] = "nodeReconnecting";
+  Events2["NodeDestroy"] = "nodeDestroy";
+  Events2["NodeResumed"] = "nodeResumed";
+  Events2["NodeCreate"] = "nodeCreate";
+  Events2["PlayerCreate"] = "playerCreate";
+  Events2["PlayerUpdate"] = "playerUpdate";
+  Events2["PlayerDestroy"] = "playerDestroy";
+  Events2["TrackStart"] = "trackStart";
+  Events2["TrackEnd"] = "trackEnd";
+  Events2["TrackStuck"] = "trackStuck";
+  Events2["TrackError"] = "trackError";
+  Events2["LyricsFound"] = "lyricsFound";
+  Events2["LyricsNotFound"] = "lyricsNotFound";
+  Events2["LyricsLine"] = "lyricsLine";
+  Events2["QueueEnd"] = "queueEnd";
+  Events2["QueueUpdate"] = "queueUpdate";
+  Events2["WebSocketClosed"] = "socketClosed";
+  return Events2;
+})(Events || {});
+var DestroyReasons = /* @__PURE__ */ ((DestroyReasons2) => {
+  DestroyReasons2["Stop"] = "Player-Stop";
+  DestroyReasons2["Requested"] = "Player-Requested";
+  DestroyReasons2["Empty"] = "Player-Empty";
+  DestroyReasons2["NodeDisconnected"] = "Player-NodeDisconnected";
+  DestroyReasons2["NodeDestroy"] = "Player-NodeDestroy";
+  DestroyReasons2["VoiceChannelDeleted"] = "Player-VoiceChannelDeleted";
+  return DestroyReasons2;
+})(DestroyReasons || {});
+
+// src/types/Player.ts
+var LoopMode = /* @__PURE__ */ ((LoopMode2) => {
+  LoopMode2[LoopMode2["Track"] = 1] = "Track";
+  LoopMode2[LoopMode2["Queue"] = 2] = "Queue";
+  LoopMode2[LoopMode2["Off"] = 3] = "Off";
+  return LoopMode2;
+})(LoopMode || {});
+var PlayerEventType = /* @__PURE__ */ ((PlayerEventType2) => {
+  PlayerEventType2["TrackStart"] = "TrackStartEvent";
+  PlayerEventType2["TrackEnd"] = "TrackEndEvent";
+  PlayerEventType2["TrackException"] = "TrackExceptionEvent";
+  PlayerEventType2["TrackStuck"] = "TrackStuckEvent";
+  PlayerEventType2["LyricsFound"] = "LyricsFoundEvent";
+  PlayerEventType2["LyricsNotFound"] = "LyricsNotFoundEvent";
+  PlayerEventType2["LyricsLine"] = "LyricsLineEvent";
+  PlayerEventType2["WebsocketClosed"] = "WebSocketClosedEvent";
+  return PlayerEventType2;
+})(PlayerEventType || {});
+var TrackEndReason = /* @__PURE__ */ ((TrackEndReason2) => {
+  TrackEndReason2["Finished"] = "finished";
+  TrackEndReason2["LoadFailed"] = "loadFailed";
+  TrackEndReason2["Stopped"] = "stopped";
+  TrackEndReason2["Replaced"] = "replaced";
+  TrackEndReason2["Cleanup"] = "cleanup";
+  return TrackEndReason2;
+})(TrackEndReason || {});
+
+// package.json
+var package_default = {
+  name: "hoshimi",
+  version: "0.2.0",
+  description: "A lavalink@v4 client easy to use, up-to-date and all ears.",
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  packageManager: "pnpm@10.20.0+sha512.cf9998222162dd85864d0a8102e7892e7ba4ceadebbf5a31f9c2fce48dfce317a9c53b9f6464d1ef9042cba2e02ae02a9f7c143a2b438cd93c91840f0192b9dd",
+  files: [
+    "dist"
+  ],
+  "lint-staged": {
+    "*.{ts,json}": [
+      "pnpm format"
+    ]
+  },
+  repository: {
+    url: "https://github.com/Ganyu-Studios/Hoshimi.git",
+    type: "git"
+  },
+  scripts: {
+    build: "pnpm typecheck && tsup",
+    typecheck: "tsc --noEmit",
+    lint: "biome lint .",
+    format: "biome format --write .",
+    prepare: "husky && pnpm build",
+    "tool:prepublish": "pnpm build && tsx ./scripts/prepublish.mts && cd .npm && npm pack",
+    "tool:publish": "cd .npm && npm publish"
+  },
+  keywords: [
+    "discord",
+    "lavalink",
+    "lavalink-v4",
+    "discord",
+    "distube",
+    "music-bot",
+    "lavalink-player",
+    "lavalink-client",
+    "music"
+  ],
+  author: "Ganyu Studios",
+  license: "MIT",
+  devDependencies: {
+    "@biomejs/biome": "^2.3.2",
+    "@types/node": "^24.9.2",
+    "@types/ws": "^8.18.1",
+    husky: "^9.1.7",
+    "lint-staged": "^16.2.6",
+    tsup: "^8.5.0",
+    tsx: "^4.20.6",
+    typescript: "^5.9.3"
+  },
+  dependencies: {
+    ws: "^8.18.3"
+  },
+  pnpm: {
+    onlyBuiltDependencies: [
+      "esbuild"
+    ]
+  }
+};
+
+// src/types/Filters.ts
+var AudioOutput = /* @__PURE__ */ ((AudioOutput2) => {
+  AudioOutput2["Mono"] = "mono";
+  AudioOutput2["Stereo"] = "stereo";
+  AudioOutput2["Left"] = "left";
+  AudioOutput2["Right"] = "right";
+  return AudioOutput2;
+})(AudioOutput || {});
+var FilterType = /* @__PURE__ */ ((FilterType2) => {
+  FilterType2["Volume"] = "volume";
+  FilterType2["AudioOutput"] = "audioOutput";
+  FilterType2["LowPass"] = "lowPass";
+  FilterType2["Karaoke"] = "karaoke";
+  FilterType2["Rotation"] = "rotation";
+  FilterType2["Tremolo"] = "tremolo";
+  FilterType2["Vibrato"] = "vibrato";
+  FilterType2["Custom"] = "custom";
+  FilterType2["Timescale"] = "timescale";
+  FilterType2["Distortion"] = "distortion";
+  FilterType2["Echo"] = "echo";
+  FilterType2["Reverb"] = "reverb";
+  FilterType2["DSPXLowpass"] = "low-pass";
+  FilterType2["DSPXHighpass"] = "high-pass";
+  FilterType2["DSPXEcho"] = "echo";
+  FilterType2["DSPXNormalization"] = "normalization";
+  return FilterType2;
+})(FilterType || {});
+
+// src/util/constants.ts
+var HoshimiAgent = `hoshimi/v${package_default.version} (${package_default.repository.url})`;
+var UrlRegex = /^(https?:\/\/)?([a-zA-Z0-9\-_]+\.)+[a-zA-Z]{2,}(\/[^\s]*)?$/;
+var ValidEngines = Object.values(SearchEngines);
+var ValidSources = new Map(
+  Object.entries({
+    ["youtube" /* Youtube */]: "ytsearch" /* Youtube */,
+    ["youtubemusic" /* YoutubeMusic */]: "ytmsearch" /* YoutubeMusic */,
+    ["soundcloud" /* Soundcloud */]: "scsearch" /* SoundCloud */,
+    ["bandcamp" /* Bandcamp */]: "bcsearch" /* BandCamp */,
+    ["twitch" /* Twitch */]: "twsearch" /* Twitch */,
+    ["vimeo" /* Vimeo */]: "vmsearch" /* Vimeo */,
+    ["mixer" /* Mixer */]: "mxsearch" /* Mixer */,
+    ["spotify" /* Spotify */]: "spsearch" /* Spotify */,
+    ["deezer" /* Deezer */]: "dzsearch" /* Deezer */,
+    ["applemusic" /* AppleMusic */]: "amsearch" /* AppleMusic */,
+    ["yandexmusic" /* YandexMusic */]: "ymsearch" /* YandexMusic */,
+    ["flowery-tts" /* FloweryTTS */]: "ftts" /* FloweryTTS */,
+    ["jiosaavn" /* JioSaavn */]: "jssearch" /* JioSaavn */,
+    ["vkmusic" /* VKMusic */]: "vksearch" /* VKMusic */,
+    ["tidal" /* Tidal */]: "tdsearch" /* Tidal */,
+    ["tts" /* TextToSpeech */]: "speak" /* TextToSpeech */,
+    ["pornhub" /* PornHub */]: "phsearch" /* PornHub */
+  })
+);
+var AudioOutputData = {
+  ["mono" /* Mono */]: {
+    leftToLeft: 0.5,
+    leftToRight: 0.5,
+    rightToLeft: 0.5,
+    rightToRight: 0.5
+  },
+  ["stereo" /* Stereo */]: {
+    leftToLeft: 1,
+    leftToRight: 0,
+    rightToLeft: 0,
+    rightToRight: 1
+  },
+  ["left" /* Left */]: {
+    leftToLeft: 1,
+    leftToRight: 0,
+    rightToLeft: 1,
+    rightToRight: 0
+  },
+  ["right" /* Right */]: {
+    leftToLeft: 0,
+    leftToRight: 1,
+    rightToLeft: 0,
+    rightToRight: 1
+  }
+};
+var DefaultFilterPreset = {
+  Karaoke: { level: 1, monoLevel: 1, filterBand: 220, filterWidth: 100 },
+  Vaporwave: { speed: 0.8500000238418579, pitch: 0.800000011920929, rate: 1 },
+  Nightcore: { speed: 1.289999523162842, pitch: 1.289999523162842, rate: 0.9365999523162842 },
+  Lowpass: { smoothing: 20 },
+  Tremolo: { frequency: 4, depth: 0.8 },
+  Vibrato: { frequency: 4, depth: 0.8 },
+  Distortion: { cosOffset: 0.4, sinOffset: 0.4, tanOffset: 0.4, offset: 0.4, scale: 1.5, cosScale: 1.5, sinScale: 1.5, tanScale: 1.5 },
+  DSPXHighPass: { boostFactor: 1, cutoffFrequency: 80 },
+  DSPXLowPass: { boostFactor: 1, cutoffFrequency: 80 },
+  DSPXNormalization: { adaptive: true, maxAmplitude: 0.1 },
+  DSPXEcho: { decay: 0.5, echoLength: 0.5 },
+  PluginEcho: { decay: 0.8, delay: 4 },
+  PluginReverb: { delays: [0.037, 0.042, 0.048, 0.053], gains: [0.84, 0.83, 0.82, 0.81] }
+};
+var DefaultPlayerFilters = {
+  volume: 1,
+  lowPass: {
+    smoothing: 0
+  },
+  karaoke: {
+    level: 0,
+    monoLevel: 0,
+    filterBand: 0,
+    filterWidth: 0
+  },
+  timescale: {
+    speed: 1,
+    pitch: 1,
+    rate: 1
+  },
+  rotation: {
+    rotationHz: 0
+  },
+  tremolo: {
+    frequency: 0,
+    depth: 0
+  },
+  vibrato: {
+    frequency: 0,
+    depth: 0
+  },
+  pluginFilters: {
+    "high-pass": {
+      boostFactor: 0,
+      cutoffFrequency: 0
+    },
+    "low-pass": {
+      boostFactor: 0,
+      cutoffFrequency: 0
+    },
+    "lavalink-filter-plugin": {
+      echo: {
+        delay: 0,
+        decay: 0
+      },
+      reverb: {
+        delays: [],
+        gains: []
+      }
+    },
+    echo: {
+      decay: 0,
+      delay: 0,
+      echoLength: 0
+    },
+    normalization: {
+      adaptive: false,
+      maxAmplitude: 0
+    }
+  },
+  equalizer: [],
+  distortion: {
+    cosOffset: 0,
+    sinOffset: 0,
+    tanOffset: 0,
+    offset: 0,
+    scale: 1,
+    cosScale: 1,
+    sinScale: 1,
+    tanScale: 1
+  },
+  channelMix: AudioOutputData.mono
+};
+
+// src/classes/Track.ts
+var escapeRegExp = (input) => input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var Track = class {
+  /**
+   * The base64 encoded track.
+   * @type {string}
+   */
+  encoded;
+  /**
+   * The track info.
+   * @type {TrackInfo}
+   */
+  info;
+  /**
+   * The plugin info of the track.
+   * @type {PluginInfo}
+   */
+  pluginInfo;
+  /**
+   * The track user data.
+   * @type {Record<string, unknown>}
+   */
+  userData;
+  /**
+   * The requester of the track.
+   * @type {TrackRequester}
+   */
+  requester;
+  /**
+   * The constructor for the track.
+   * @param {LavalinkTrack} track The track to construct the track from.
+   * @param {TrackRequester} requester The requester of the track.
+   * @example
+   * ```ts
+   * const track = new Track({
+   * 	encoded: "base64",
+   * 	info: {
+   * 		title: "Track Title",
+   * 		uri: "https://example.com",
+   * 		duration: 300000,
+   * 	},
+   * 	// the rest of the track info
+   * }, requester);
+   *
+   * console.log(track.encoded); // the track encoded in base64
+   * ```
+   */
+  constructor(track, requester) {
+    if (!track) throw new ResolveError("Track is not defined for construction.");
+    this.info = track.info;
+    this.encoded = track.encoded;
+    this.requester = requester ?? {};
+    this.pluginInfo = track.pluginInfo;
+    this.userData = track.userData ?? {};
+  }
+  /**
+   *
+   * Get the hyperlink of the track.
+   * @param {boolean} [embedable=true] Whether the hyperlink should be embedable or not.
+   * @returns {string} The hyperlink of the track.
+   * @example
+   * ```ts
+   * const track = queue.current;
+   * console.log(track.toHyperlink()); // [Track Title](https://example.com)
+   * console.log(track.toHyperlink(false)); // [Track Title](<https://example.com>)
+   * ```
+   */
+  toHyperlink(embedable = true) {
+    if (embedable) return `[${this.info.title}](${this.info.uri})`;
+    return `[${this.info.title}](<${this.info.uri}>)`;
+  }
+};
+var UnresolvedTrack = class {
+  /**
+   * The base64 encoded track.
+   * @type {string | undefined}
+   */
+  encoded;
+  /**
+   * The track info.
+   * @type {UnresolvedTrackInfo}
+   */
+  info;
+  /**
+   * The plugin info of the track.
+   * @type {Partial<PluginInfo>}
+   */
+  pluginInfo;
+  /**
+   * The track user data.
+   * @type {Record<string, unknown> | undefined}
+   */
+  userData;
+  /**
+   * The requester of the track.
+   * @type {TrackRequester | undefined}
+   */
+  requester;
+  /**
+   * The constructor for the track.
+   * @param {UnresolvedLavalinkTrack} track The track to construct the track from.
+   * @param {TrackRequester} requester The requester of the track.
+   * @example
+   * ```ts
+   * const track = new UnresolvedTrack({
+   * 	encoded: "base64",
+   * 	info: {
+   * 		title: "Track Title",
+   * 	},
+   * 	// the rest of the track info
+   * }, requester);
+   *
+   * console.log(track.encoded); // the track encoded in base64
+   * ```
+   */
+  constructor(track, requester) {
+    this.info = track.info;
+    this.encoded = track.encoded;
+    this.requester = requester;
+    this.pluginInfo = track.pluginInfo;
+    this.userData = track.userData ?? {};
+  }
+  /**
+   * Resolves the track to a playable track.
+   * @param {PlayerStructure} player The player to resolve the track for.
+   * @returns {Promise<Track>} The resolved track.
+   * @throws {ResolveError} If the track cannot be resolved.
+   */
+  async resolve(player) {
+    if (!player) throw new ResolveError("Player is not defined for track resolution.");
+    if (isTrack(this)) return new Track(this, this.requester);
+    if (!isUnresolvedTrack(this)) throw new ResolveError("Track is not an unresolved track.");
+    if (!this.requester) throw new ResolveError("Requester is not defined for track resolution.");
+    if (!this.info.title && !this.encoded && !this.info.uri)
+      throw new ResolveError("Track is missing required properties for resolution.");
+    player.manager.emit("debug" /* Debug */, 3 /* Player */, `[Unresolved] -> [Track] Resolving the track: ${this.info.title}`);
+    if (this.encoded) return player.node.decode.single(this.encoded, this.requester);
+    if (this.info.uri) {
+      const track = await player.search({ query: this.info.uri, requester: this.requester }).then((result) => result.tracks[0]);
+      if (!track) throw new ResolveError("Track could not be resolved from URI.");
+      player.manager.emit("debug" /* Debug */, 3 /* Player */, `[Unresolved] -> [Track] Resolved the track from URI: ${this.info.uri}`);
+      return track;
+    }
+    const query = [this.info.title, this.info.uri].filter(Boolean).join(" by ");
+    const excluded = ["twitch" /* Twitch */, "flowery-tts" /* FloweryTTS */, "mixer" /* Mixer */, "vimeo" /* Vimeo */];
+    const engine = this.info.sourceName && !excluded.includes(this.info.sourceName) ? validateEngine(this.info.sourceName) : player.manager.options.defaultSearchEngine;
+    player.manager.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Unresolved] -> [Track] Searching for track with query: ${query} using engine: ${engine}`
+    );
+    return player.search({ query, engine, requester: this.requester }).then((result) => {
+      let track = result.tracks[0] ?? null;
+      if (this.info.author && !track)
+        track = result.tracks.find(
+          (t) => [this.info.author ?? "", `${this.info.author} - Topic`].some(
+            (name) => new RegExp(`^${escapeRegExp(name)}$`, "i").test(t.info.author)
+          ) || new RegExp(`^${escapeRegExp(this.info.title)}$`, "i").test(t.info.title)
+        ) ?? null;
+      if (this.info.length && !track)
+        track = result.tracks.find((t) => {
+          const length = this.info.length;
+          if (!length) return false;
+          return t.info.length >= length - 1500 && t.info.length <= length + 1500;
+        }) ?? null;
+      if (this.info.isrc && !track) track = result.tracks.find((t) => t.info.isrc === this.info.isrc) ?? null;
+      if (!track) throw new ResolveError("Track could not be resolved from search query.");
+      player.manager.emit(
+        "debug" /* Debug */,
+        3 /* Player */,
+        `[Unresolved] -> [Track] Resolved the track ${track.info.title} from search query: ${query}`
+      );
+      return track;
+    });
+  }
+};
+
+// src/classes/queue/adapters/abstract.ts
+var StorageAdapter = class {
+};
+
+// src/util/functions/utils.ts
+function validateManagerOptions(options) {
+  if (!Array.isArray(options.nodes) || !options.nodes.every(isNode) || !options.nodes.length)
+    throw new OptionError("The manager option 'options.nodes' must be a valid array of nodes and atleast one valid node.");
+  if (typeof options.sendPayload !== "function")
+    throw new OptionError("The manager option 'options.sendPayload' must be a vaid function.");
+  if (typeof options.queueOptions !== "undefined" && typeof options.queueOptions.maxPreviousTracks !== "number")
+    throw new OptionError("The manager option 'options.queueOptions.maxPreviousTracks' must be a number.");
+  if (typeof options.queueOptions !== "undefined" && typeof options.queueOptions.autoplayFn !== "function")
+    throw new OptionError("The manager option 'options.queueOptions.autoplayFn' must be a function.");
+  if (typeof options.queueOptions?.storage !== "undefined" && !(options.queueOptions.storage instanceof StorageAdapter))
+    throw new OptionError("The manager option 'options.queueOptions.storage' must be a valid storage manager.");
+  if (typeof options.defaultSearchEngine !== "undefined" && !ValidEngines.includes(options.defaultSearchEngine))
+    throw new OptionError("The manager option 'options.defaultSearchEngine' Must be a valid search engine.");
+  if (typeof options.client !== "undefined" && typeof options.client !== "object")
+    throw new OptionError("The manager option 'options.client' Must be a valid object.");
+  if (typeof options.client !== "undefined" && typeof options.client.id !== "undefined" && typeof options.client.id !== "string")
+    throw new OptionError("The manager option 'options.client.id' Must be a valid string.");
+  if (typeof options.client !== "undefined" && typeof options.client.id !== "undefined" && typeof options.client.username !== "string")
+    throw new OptionError("The manager option 'options.client.username' must be a valid string.");
+}
+function validateQuery(search) {
+  if (typeof search !== "object") throw new OptionError("The 'query' must be a valid object.");
+  if (typeof search.query !== "string") throw new OptionError("The query option 'query.query' must be a valid string.");
+  if (typeof search.engine !== "string") throw new OptionError("The query option 'query.engine' must be a valid search engine.");
+  search.engine = validateEngine(search.engine);
+  if (!ValidEngines.includes(search.engine)) throw new OptionError(`The query option 'query.engine' must be a valid search engine.`);
+  const query = search.query.trim();
+  const engineKey = Object.values(SearchEngines).find((key) => query.toLowerCase().startsWith(key));
+  if (engineKey && query.toLowerCase().startsWith(`${engineKey}:`)) {
+    const sliced = query.slice(engineKey.length + 1).trim();
+    const isUrl2 = UrlRegex.test(sliced);
+    if (isUrl2) return sliced;
+    return `${engineKey}:${sliced}`;
+  }
+  const isUrl = UrlRegex.test(query);
+  if (isUrl) return query;
+  if (search.engine === "ftts" /* FloweryTTS */) return `${search.engine}://${query}`;
+  if (search.engine !== "local" /* Local */) return `${search.engine}:${query}`;
+  return query;
+}
+function validatePlayerOptions(options) {
+  if (typeof options.guildId !== "string") throw new OptionError("The player option 'options.guildId' must be a string.");
+  if (typeof options.voiceId !== "string") throw new OptionError("The player option 'options.voiceId' Must be a string.");
+  if (typeof options.textId !== "undefined" && typeof options.textId !== "string")
+    throw new OptionError("The player option 'options.textId' Must be a string.");
+  if (typeof options.selfDeaf !== "undefined" && typeof options.selfDeaf !== "boolean")
+    throw new OptionError("The player option 'options.selfDeaf' Must be a boolean.");
+  if (typeof options.selfMute !== "undefined" && typeof options.selfMute !== "boolean")
+    throw new OptionError("The player option 'options.selfMute' Mute must be a boolean.");
+  if (typeof options.volume !== "undefined" && typeof options.volume !== "number")
+    throw new OptionError("The player option 'options.volume' Must be a number.");
+}
+function validatePlayerData(data) {
+  if (typeof data === "object" && typeof data.playerOptions === "object" && typeof data.guildId === "string" && Object.keys(data.playerOptions).length > 0) {
+    const player = this.nodeManager.manager.getPlayer(data.guildId);
+    if (!player) return;
+    if (typeof data.playerOptions.voice === "object") player.voice = data.playerOptions.voice;
+    if (typeof data.playerOptions.paused === "boolean") {
+      player.paused = data.playerOptions.paused;
+      player.playing = !data.playerOptions.paused;
+    }
+    if (typeof data.playerOptions.volume === "number") player.volume = data.playerOptions.volume;
+    if (typeof data.playerOptions.position === "number") player.position = data.playerOptions.position;
+  }
+}
+function validateNodePlugins(node, plugins) {
+  const info = node.info;
+  if (!info) throw new NodeError({ id: node.id, message: "Node is not ready yet." });
+  if (!info.plugins.length)
+    throw new NodeError({
+      id: node.id,
+      message: "No plugins found in the node."
+    });
+  const missings = plugins.filter((name) => !info.plugins.some((p) => p.name === name));
+  if (missings.length)
+    throw new NodeError({
+      id: node.id,
+      message: `The node does not support the following plugins: ${missings.join(", ")}.`
+    });
+}
+function validateEngine(type) {
+  const source = ValidEngines.find((engine) => engine === type) ?? ValidSources.get(type);
+  if (!source) throw new OptionError(`The engine '${type}' is not a valid engine.`);
+  return source;
+}
+function validateTrack(player, track) {
+  if (!track) return Promise.resolve(null);
+  if (isTrack(track)) return Promise.resolve(new Track(track, track.requester));
+  if (!isUnresolvedTrack(track)) throw new ResolveError("The track is not a valid unresolved track.");
+  if (!track.resolve || typeof track.resolve !== "function") return new UnresolvedTrack(track, track.requester).resolve(player);
+  return track.resolve(player);
+}
+var isTrack = (track) => {
+  if (!track) return false;
+  return typeof track.encoded === "string" && typeof track.info === "object" && !("resolve" in track && typeof track.resolve === "function");
+};
+function isUnresolvedTrack(track) {
+  if (!track) return false;
+  return typeof track.encoded === "string" || typeof track.info === "object" && typeof track.info.title === "string" && "resolve" in track && typeof track.resolve === "function";
+}
+function isValid(value) {
+  return typeof value !== "undefined" && value !== null;
+}
+function isNode(options) {
+  return typeof options.host === "string" && typeof options.port === "number" && typeof options.password === "string" && (typeof options.id === "string" || typeof options.id === "undefined") && (typeof options.secure === "boolean" || typeof options.secure === "undefined") && (typeof options.sessionId === "string" || typeof options.sessionId === "undefined") && (typeof options.retryAmount === "number" || typeof options.retryAmount === "undefined") && (typeof options.retryDelay === "number" || typeof options.retryDelay === "undefined");
+}
+
+// src/util/events/player.ts
+async function onEnd() {
+  if (this.queue.current && !this.queue.history.find(
+    (x) => x.info.identifier === this.queue.current.info.identifier && x.info.title === this.queue.current.info.title
+  )) {
+    this.queue.history.unshift(this.queue.current);
+    if (this.queue.history.length > this.manager.options.queueOptions.maxPreviousTracks)
+      this.queue.history.splice(this.manager.options.queueOptions.maxPreviousTracks, this.queue.history.length);
+    await this.queue.utils.save();
+    this.manager.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Player] -> [Previous] The track: ${this.queue.current.info.title} has been added to the previous track list.`
+    );
+  }
+  if (this.loop === 1 /* Track */ && this.queue.current) this.queue.unshift(this.queue.current);
+  if (this.loop === 2 /* Queue */ && this.queue.current) this.queue.add(this.queue.current);
+  if (!this.queue.current) this.queue.current = await validateTrack(this, this.queue.shift());
+  await this.queue.utils.save();
+  return;
+}
+async function queueEnd(track, payload) {
+  this.playing = false;
+  this.paused = false;
+  this.queue.current = null;
+  if (typeof this.manager.options.queueOptions.autoplayFn === "function") {
+    await this.manager.options.queueOptions.autoplayFn(this, track);
+    this.manager.emit("debug" /* Debug */, 3 /* Player */, "[Queue] -> [Autoplay] Autoplay function executed.");
+    if (this.queue.size > 0) await onEnd.call(this);
+    if (this.queue.current) {
+      if (payload.type === "TrackEndEvent" /* TrackEnd */) this.manager.emit("trackEnd" /* TrackEnd */, this, track, payload);
+      this.manager.emit("debug" /* Debug */, 3 /* Player */, "[Queue] -> [Autoplay] Track(s) queued from autoplay function.");
+      return this.play({ noReplace: true, paused: false });
+    }
+  }
+  if (track) await this.queue.utils.save();
+  if (payload.type === "TrackEndEvent" /* TrackEnd */ && payload.reason !== "stopped" /* Stopped */) await this.queue.utils.save();
+  this.manager.emit("queueEnd" /* QueueEnd */, this, this.queue);
+  this.manager.emit("debug" /* Debug */, 3 /* Player */, "[Player] -> [Queue] The queue has ended.");
+}
+async function trackStart(payload) {
+  this.paused = false;
+  this.playing = true;
+  this.manager.emit("trackStart" /* TrackStart */, this, this.queue.current, payload);
+  this.manager.emit(
+    "debug" /* Debug */,
+    3 /* Player */,
+    `[Player] -> [Start] The track: ${this.queue.current?.info.title ?? "Unknown"} has started playing.`
+  );
+}
+async function trackEnd(payload) {
+  const current = this.queue.current;
+  if (!this.queue.size && this.loop === 3 /* Off */) return queueEnd.call(this, current, payload);
+  switch (payload.reason) {
+    case "stopped" /* Stopped */:
+      break;
+    case "replaced" /* Replaced */: {
+      this.manager.emit("trackEnd" /* TrackEnd */, this, current, payload);
+      return;
+    }
+    case "loadFailed" /* LoadFailed */:
+    case "cleanup" /* Cleanup */: {
+      this.playing = false;
+      await onEnd.call(this);
+      if (!this.queue.size || !this.queue.current) return queueEnd.call(this, current, payload);
+      this.manager.emit("trackEnd" /* TrackEnd */, this, current, payload);
+      this.manager.emit(
+        "debug" /* Debug */,
+        3 /* Player */,
+        `[Player] -> [End] The track: ${current?.info.title ?? "Unknown"} has ended.`
+      );
+      this.queue.current = null;
+      return this.play();
+    }
+  }
+  if (current) await this.queue.utils.save();
+  await onEnd.call(this);
+  this.queue.current = null;
+  if (!this.queue.size) {
+    this.playing = false;
+    return queueEnd.call(this, current, payload);
+  }
+  this.manager.emit("trackEnd" /* TrackEnd */, this, current, payload);
+  this.manager.emit("debug" /* Debug */, 3 /* Player */, `[Player] -> [End] The track: ${current?.info.title ?? "Uhknown"} has ended.`);
+  return this.play();
+}
+async function trackStuck(payload) {
+  this.manager.emit("trackStuck" /* TrackStuck */, this, this.queue.current, payload);
+  this.manager.emit(
+    "debug" /* Debug */,
+    3 /* Player */,
+    `[Player] -> [Stuck] The track: ${this.queue.current?.info.title ?? "Unknown"} has stuck.`
+  );
+  if (!this.queue.size && this.loop === 3 /* Off */) {
+    try {
+      await this.node.updatePlayer({
+        guildId: this.guildId,
+        playerOptions: { track: { encoded: null } }
+      });
+      return;
+    } catch {
+      return queueEnd.call(this, this.queue.current, payload);
+    }
+  }
+  await onEnd.call(this);
+  if (!this.queue.current) return queueEnd.call(this, this.queue.current, payload);
+}
+async function trackError(payload) {
+  this.manager.emit("trackError" /* TrackError */, this, this.queue.current, payload);
+  this.manager.emit(
+    "debug" /* Debug */,
+    3 /* Player */,
+    `[Player] -> [Error] The track: ${this.queue.current?.info.title ?? "Unknown"} has error.`
+  );
+}
+async function playerUpdate(payload) {
+  const player = this.nodeManager.manager.getPlayer(payload.guildId);
+  if (!player) return;
+  const oldPlayer = player.toJSON();
+  player.ping = payload.state.ping;
+  player.connected = payload.state.connected;
+  player.createdTimestamp = payload.state.time;
+  player.position = payload.state.position;
+  this.nodeManager.manager.emit("playerUpdate" /* PlayerUpdate */, player, oldPlayer, payload);
+  this.nodeManager.manager.emit(
+    "debug" /* Debug */,
+    2 /* Node */,
+    `[Player] -> [Update] Player updated: ${player.guildId} | Payload: ${JSON.stringify(payload)}`
+  );
+}
+async function lyricsFound(track, payload) {
+  this.manager.emit("lyricsFound" /* LyricsFound */, this, track, payload);
+  this.manager.emit(
+    "debug" /* Debug */,
+    3 /* Player */,
+    `[Player] -> [Lyrics] The lyrics have been found: ${this.guildId} | Payload: ${JSON.stringify(payload)}`
+  );
+}
+async function lyricsLine(track, payload) {
+  this.manager.emit("lyricsLine" /* LyricsLine */, this, track, payload);
+  this.manager.emit(
+    "debug" /* Debug */,
+    3 /* Player */,
+    `[Player] -> [Lyrics] The lyrics line has been found: ${this.guildId} | Payload: ${JSON.stringify(payload)}`
+  );
+}
+async function lyricsNotFound(track, payload) {
+  this.manager.emit("lyricsNotFound" /* LyricsNotFound */, this, track, payload);
+  this.manager.emit(
+    "debug" /* Debug */,
+    3 /* Player */,
+    `[Player] -> [Lyrics] The lyrics were not found: ${this.guildId} | Payload: ${JSON.stringify(payload)}`
+  );
+}
+async function socketClosed(payload) {
+  this.manager.emit("socketClosed" /* WebSocketClosed */, this, payload);
+  this.manager.emit(
+    "debug" /* Debug */,
+    3 /* Player */,
+    `[Player] -> [Socket] The socket has closed: ${this.guildId} | Payload: ${JSON.stringify(payload)}`
+  );
+}
+
+// src/util/events/websocket.ts
+function onOpen(res) {
+  const isResume = res.headers["session-resumed"] === "true";
+  const apiVersion = res.headers["lavalink-api-version"] ?? "unknown";
+  this.retryAmount = this.options.retryAmount;
+  this.nodeManager.manager.emit(
+    "debug" /* Debug */,
+    2 /* Node */,
+    `[Socket] -> [${this.id}]: Connection handshake complete with ${this.address}. | API Version: ${apiVersion} | Resumed: ${isResume}`
+  );
+}
+function onClose(code, reason) {
+  this.nodeManager.manager.emit(
+    "debug" /* Debug */,
+    2 /* Node */,
+    `[Socket] -> [${this.id}]: Connection closed with ${this.address}. | Code: ${code} | Reason: ${reason}`
+  );
+  this.nodeManager.manager.emit("nodeDisconnect" /* NodeDisconnect */, this);
+  if (code !== 1e3 /* NormalClosure */ || reason !== "Node-Destroy" /* Destroy */) {
+    if (this.nodeManager.nodes.has(this.id)) this.reconnect();
+  }
+}
+function onError(error) {
+  if (!error) return;
+  if (this.reconnectTimeout) {
+    clearInterval(this.reconnectTimeout);
+    this.reconnectTimeout = null;
+  }
+  this.nodeManager.manager.emit(
+    "debug" /* Debug */,
+    2 /* Node */,
+    `[Socket] -> [${this.id}]: Connection error with ${this.address}. | Error: ${error.message}`
+  );
+  this.nodeManager.manager.emit("nodeError" /* NodeError */, this, error);
+}
+async function onMessage(message) {
+  if (Array.isArray(message)) message = Buffer.concat(message);
+  else if (message instanceof ArrayBuffer) message = Buffer.from(message);
+  try {
+    const payload = JSON.parse(message.toString());
+    if (!payload.op) return;
+    this.nodeManager.manager.emit("nodeRaw" /* NodeRaw */, this, payload);
+    switch (payload.op) {
+      case "stats" /* Stats */:
+        {
+          this.stats = payload;
+          this.nodeManager.manager.emit(
+            "debug" /* Debug */,
+            2 /* Node */,
+            `[Socket] <- [${this.id}]: Received stats. | System load: ${this.penalties}`
+          );
+        }
+        break;
+      case "ready" /* Ready */:
+        {
+          if (!payload.sessionId) {
+            this.nodeManager.manager.emit(
+              "debug" /* Debug */,
+              2 /* Node */,
+              `[Socket] -> [${this.id}]: Session id was not provided. Breaking up the connection...`
+            );
+            this.nodeManager.manager.emit("nodeDestroy" /* NodeDestroy */, this, {
+              code: 1006 /* AbnormalClosure */,
+              reason: "Missing-Session" /* MissingSession */
+            });
+            return this.disconnect();
+          }
+          this.state = 2 /* Connected */;
+          this.sessionId = payload.sessionId;
+          this.session.resuming = payload.resumed;
+          if (payload.resumed) {
+            const players = await this.rest.request({
+              endpoint: `/sessions/${payload.sessionId}/players`
+            }) ?? [];
+            const timeout = this.nodeManager.manager.options.nodeOptions.resumeTimeout;
+            this.nodeManager.manager.emit("nodeResumed" /* NodeResumed */, this, players, payload);
+            this.nodeManager.manager.emit(
+              "debug" /* Debug */,
+              2 /* Node */,
+              `[Socket] <- [${this.id}]: Resumed session. | Session id: ${payload.sessionId} | Players: ${players.length} | Resumed: ${payload.resumed} | Timeout: ${timeout}ms`
+            );
+          }
+          this.info = await this.rest.request({ endpoint: "/info" });
+          this.nodeManager.manager.emit(
+            "debug" /* Debug */,
+            2 /* Node */,
+            `[Socket] <- [${this.id}]: Received ready event. | Session id: ${payload.sessionId} | Resumed: ${payload.resumed}`
+          );
+          this.nodeManager.manager.emit("nodeReady" /* NodeReady */, this, this.retryAmount, payload);
+          const isResumable = this.nodeManager.manager.options.nodeOptions.resumable;
+          if (isResumable) {
+            const timeout = this.nodeManager.manager.options.nodeOptions.resumeTimeout;
+            this.nodeManager.manager.emit(
+              "debug" /* Debug */,
+              2 /* Node */,
+              `[Socket] -> [${this.id}]: Resuming session... | Timeout: ${timeout}ms`
+            );
+            await this.updateSession(isResumable, timeout);
+          }
+        }
+        break;
+      case "event" /* Event */: {
+        const player = this.nodeManager.manager.getPlayer(payload.guildId);
+        if (!player) return;
+        switch (payload.type) {
+          //
+          // Events related to tracks.
+          //
+          case "TrackEndEvent" /* TrackEnd */:
+            await trackEnd.call(player, payload);
+            break;
+          case "TrackStartEvent" /* TrackStart */:
+            await trackStart.call(player, payload);
+            break;
+          case "TrackExceptionEvent" /* TrackException */:
+            await trackError.call(player, payload);
+            break;
+          case "TrackStuckEvent" /* TrackStuck */:
+            await trackStuck.call(player, payload);
+            break;
+          //
+          // Events related to lyrics.
+          //
+          case "LyricsFoundEvent" /* LyricsFound */:
+            await lyricsFound.call(player, player.queue.current, payload);
+            break;
+          case "LyricsNotFoundEvent" /* LyricsNotFound */:
+            await lyricsNotFound.call(player, player.queue.current, payload);
+            break;
+          case "LyricsLineEvent" /* LyricsLine */:
+            await lyricsLine.call(player, player.queue.current, payload);
+            break;
+          //
+          // Events related to the websocket.
+          //
+          case "WebSocketClosedEvent" /* WebsocketClosed */:
+            await socketClosed.call(player, payload);
+            break;
+        }
+        break;
+      }
+      case "playerUpdate" /* PlayerUpdate */: {
+        await playerUpdate.call(this, payload);
+        break;
+      }
+    }
+    this.nodeManager.manager.emit(
+      "debug" /* Debug */,
+      2 /* Node */,
+      `[Socket] -> [${this.id}]: Received payload: ${JSON.stringify(payload)}`
+    );
+  } catch (error) {
+    this.nodeManager.manager.emit("nodeError" /* NodeError */, this, error);
+  }
+}
+
+// src/types/Rest.ts
+var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
+  HttpMethods2["Get"] = "GET";
+  HttpMethods2["Post"] = "POST";
+  HttpMethods2["Put"] = "PUT";
+  HttpMethods2["Patch"] = "PATCH";
+  HttpMethods2["Delete"] = "DELETE";
+  HttpMethods2["Head"] = "HEAD";
+  return HttpMethods2;
+})(HttpMethods || {});
+var HttpStatusCodes = /* @__PURE__ */ ((HttpStatusCodes2) => {
+  HttpStatusCodes2[HttpStatusCodes2["OK"] = 200] = "OK";
+  HttpStatusCodes2[HttpStatusCodes2["Created"] = 201] = "Created";
+  HttpStatusCodes2[HttpStatusCodes2["Accepted"] = 202] = "Accepted";
+  HttpStatusCodes2[HttpStatusCodes2["NoContent"] = 204] = "NoContent";
+  HttpStatusCodes2[HttpStatusCodes2["MovedPermanently"] = 301] = "MovedPermanently";
+  HttpStatusCodes2[HttpStatusCodes2["Found"] = 302] = "Found";
+  HttpStatusCodes2[HttpStatusCodes2["NotModified"] = 304] = "NotModified";
+  HttpStatusCodes2[HttpStatusCodes2["BadRequest"] = 400] = "BadRequest";
+  HttpStatusCodes2[HttpStatusCodes2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatusCodes2[HttpStatusCodes2["Forbidden"] = 403] = "Forbidden";
+  HttpStatusCodes2[HttpStatusCodes2["NotFound"] = 404] = "NotFound";
+  HttpStatusCodes2[HttpStatusCodes2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+  HttpStatusCodes2[HttpStatusCodes2["RequestTimeout"] = 408] = "RequestTimeout";
+  HttpStatusCodes2[HttpStatusCodes2["Conflict"] = 409] = "Conflict";
+  HttpStatusCodes2[HttpStatusCodes2["Gone"] = 410] = "Gone";
+  HttpStatusCodes2[HttpStatusCodes2["TooManyRequests"] = 429] = "TooManyRequests";
+  HttpStatusCodes2[HttpStatusCodes2["InternalServerError"] = 500] = "InternalServerError";
+  HttpStatusCodes2[HttpStatusCodes2["NotImplemented"] = 501] = "NotImplemented";
+  HttpStatusCodes2[HttpStatusCodes2["BadGateway"] = 502] = "BadGateway";
+  HttpStatusCodes2[HttpStatusCodes2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  HttpStatusCodes2[HttpStatusCodes2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  return HttpStatusCodes2;
+})(HttpStatusCodes || {});
+
+// src/classes/node/Node.ts
+var import_ws = require("ws");
+
+// src/classes/node/Lyrics.ts
+var LyricsManager = class {
+  /**
+   * The node instance.
+   * @type {NodeStructure}
+   * @readonly
+   */
+  node;
+  /**
+   * Create a new LyricsManager instance.
+   * @param {NodeStructure} node The node instance.
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("nodeId");
+   * const lyricsManager = new LyricsManager(node);
+   * ```
+   */
+  constructor(node) {
+    this.node = node;
+  }
+  /**
+   *
+   * Get the current lyrics for the current track.
+   * @param {boolean} skipSource Whether to skip the track source or not.
+   * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * const lyrics = await player.lyricsManager.current();
+   * ```
+   */
+  async current(guildId, skipSource = false) {
+    if (!this.node.sessionId) return null;
+    validateNodePlugins(this.node, ["lavalyrics-plugin" /* LavaLyrics */, "java-lyrics-plugin" /* JavaLyrics */, "lavasrc-plugin" /* LavaSrc */]);
+    return this.node.rest.request({
+      endpoint: `/sessions/${this.node.sessionId}/players/${guildId}/track/lyrics`,
+      params: {
+        skipTrackSource: `${skipSource}`
+      }
+    });
+  }
+  /**
+   *
+   * Get the lyrics for a specific track.
+   * @param {Track} track The track to get the lyrics for.
+   * @param {boolean} skipSource Whether to skip the track source or not.
+   * @returns {Promise<LyricsResult | null>} The lyrics result or null if not found.
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("nodeId");
+   * const lyrics = await node.lyricsManager.get(track);
+   * ```
+   */
+  async get(track, skipSource = false) {
+    if (!this.node.sessionId) return null;
+    validateNodePlugins(this.node, ["lavalyrics-plugin" /* LavaLyrics */, "java-lyrics-plugin" /* JavaLyrics */, "lavasrc-plugin" /* LavaSrc */]);
+    return this.node.rest.request({
+      endpoint: "/lyrics",
+      params: {
+        track: track.encoded,
+        skipTrackSource: `${skipSource}`
+      }
+    });
+  }
+  /**
+   *
+   * Subscribe to the lyrics for a specific guild.
+   * @param {string} guildId The guild id to subscribe to.
+   * @param {boolean} skipSource Whether to skip the track source or not.
+   * @returns {Promise<void>} Let's start the sing session!
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("nodeId");
+   * await node.lyricsManager.subscribe("guildId");
+   * ```
+   */
+  async subscribe(guildId, skipSource = false) {
+    if (!this.node.sessionId) return;
+    validateNodePlugins(this.node, ["lavalyrics-plugin" /* LavaLyrics */, "java-lyrics-plugin" /* JavaLyrics */, "lavasrc-plugin" /* LavaSrc */]);
+    await this.node.rest.request({
+      endpoint: `/sessions/${this.node.sessionId}/players/${guildId}/lyrics/subscribe`,
+      method: "POST" /* Post */,
+      params: {
+        skipTrackSource: `${skipSource}`
+      }
+    });
+  }
+  /**
+   *
+   * Unsubscribe from the lyrics for a specific guild.
+   * @param {string} guildId The guild id to unsubscribe from.
+   * @returns {Promise<void>} Let's stop the sing session!
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("nodeId");
+   * await node.lyricsManager.unsubscribe("guildId");
+   * ```
+   */
+  async unsubscribe(guildId) {
+    if (!this.node.sessionId) return;
+    validateNodePlugins(this.node, ["lavalyrics-plugin" /* LavaLyrics */, "java-lyrics-plugin" /* JavaLyrics */, "lavasrc-plugin" /* LavaSrc */]);
+    await this.node.rest.request({
+      endpoint: `/sessions/${this.node.sessionId}/players/${guildId}/lyrics/subscribe`,
+      method: "DELETE" /* Delete */
+    });
+  }
+};
+
+// src/util/collection.ts
+var Collection = class extends Map {
+  /**
+   * Removes elements from the collection based on a filter function.
+   * @param fn The filter function that determines which elements to remove.
+   * @param thisArg The value to use as `this` when executing the filter function.
+   * @returns The number of elements removed from the collection.
+   * @example
+   * const collection = new Collection<number, string>();
+   * collection.set(1, 'one');
+   * collection.set(2, 'two');
+   * collection.set(3, 'three');
+   * const removedCount = collection.sweep((value, key) => key % 2 === 0);
+   * console.log(removedCount); // Output: 1
+   * console.log(collection.size); // Output: 2
+   */
+  sweep(fn) {
+    if (typeof fn !== "function") throw new TypeError("The filter function must be a function.");
+    const previous = this.size;
+    for (const [key, val] of this) {
+      if (fn(val, key, this)) this.delete(key);
+    }
+    return previous - this.size;
+  }
+  /**
+   * Creates a new array with the results of calling a provided function on every element in the collection.
+   * @param fn The function that produces an element of the new array.
+   * @param thisArg The value to use as `this` when executing the map function.
+   * @returns A new array with the results of calling the provided function on every element in the collection.
+   * @example
+   * const collection = new Collection<number, string>();
+   * collection.set(1, 'one');
+   * collection.set(2, 'two');
+   * collection.set(3, 'three');
+   * const mappedArray = collection.map((value, key) => `${key}: ${value}`);
+   * console.log(mappedArray); // Output: ['1: one', '2: two', '3: three']
+   */
+  map(fn) {
+    if (typeof fn !== "function") throw new TypeError("The filter function must be a function.");
+    const result = [];
+    for (const [key, value] of this.entries()) {
+      result.push(fn(value, key, this));
+    }
+    return result;
+  }
+  /**
+   * Creates a new array with all elements that pass the test implemented by the provided function.
+   * @param fn The function to test each element of the collection.
+   * @param thisArg The value to use as `this` when executing the filter function.
+   * @returns A new array with the elements that pass the test.
+   * @example
+   * const collection = new Collection<number, string>();
+   * collection.set(1, 'one');
+   * collection.set(2, 'two');
+   * collection.set(3, 'three');
+   * const filteredArray = collection.filter((value, key) => key % 2 === 0);
+   * console.log(filteredArray); // Output: ['two']
+   */
+  filter(fn) {
+    if (typeof fn !== "function") throw new TypeError("The filter function must be a function.");
+    const result = [];
+    for (const [key, value] of this.entries()) {
+      if (fn(value, key, this)) result.push(value);
+    }
+    return result;
+  }
+  /**
+   * Returns the value of the first element in the collection that satisfies the provided testing function.
+   * @param fn The function to test each element of the collection.
+   * @returns The value of the first element that passes the test. `undefined` if no element passes the test.
+   * @example
+   * const collection = new Collection<number, number>();
+   * collection.set(1, 1);
+   * collection.set(2, 2);
+   * collection.set(3, 3);
+   * const firstEvenValue = collection.find(value => value % 2 === 0);
+   * console.log(firstEvenValue); // Output: 2
+   */
+  find(fn) {
+    if (typeof fn !== "function") throw new TypeError("The filter function must be a function.");
+    for (const [key, value] of this.entries()) {
+      if (fn(value, key, this)) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/classes/node/Manager.ts
+var NodeManager = class {
+  /**
+   * The manager for the node.
+   * @type {Hoshimi}
+   * @readonly
+   */
+  manager;
+  /**
+   * The nodes for the manager.
+   * @type {Collection<string, Node>}
+   * @readonly
+   */
+  nodes = new Collection();
+  /**
+   *
+   * The constructor for the node manager.
+   * @param {Hoshimi} manager The manager for the node.
+   * @example
+   * ```ts
+   * const manager = new Hoshimi();
+   * const nodeManager = new NodeManager(manager);
+   *
+   * console.log(nodeManager.nodes.size); // 0
+   * ```
+   */
+  constructor(manager) {
+    this.manager = manager;
+  }
+  /**
+   *
+   * Delete the node.
+   * @param {string} id The id of the node to delete.
+   * @returns {boolean} If the node was deleted.
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) manager.nodeManager.delete(node.id); // true if the node was deleted
+   * ```
+   */
+  delete(id) {
+    return this.nodes.delete(id);
+  }
+  /**
+   *
+   * Get the node by id.
+   * @param {string} id The id of the node.
+   * @returns {NodeStructure | undefined} The node or undefined if not found.
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) console.log(node.id); // node1
+   * ```
+   */
+  get(id) {
+    return this.nodes.get(id);
+  }
+  /**
+   *
+   * Get the least used node.
+   * @returns {NodeStructure} The least used node.
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.getLeastUsed();
+   * if (node) {
+   * 	console.log(node.id); // node1
+   * 	console.log(node.penalties); // the penalties of the node
+   * 	console.log(node.state); // the state of the node
+   * }
+   * ```
+   */
+  getLeastUsed(sortType = "players" /* Players */) {
+    const nodes = this.nodes.filter((node2) => node2.state === 2 /* Connected */);
+    if (!nodes.length) throw new Error("No connected nodes available.");
+    let node;
+    switch (sortType) {
+      case "players" /* Players */: {
+        const sorted = nodes.sort((a, b) => (a.stats?.players ?? 0) - (b.stats?.players ?? 0));
+        node = sorted[0];
+        break;
+      }
+      case "playingPlayers" /* PlayingPlayers */: {
+        const sorted = nodes.sort((a, b) => (a.stats?.playingPlayers ?? 0) - (b.stats?.playingPlayers ?? 0));
+        node = sorted[0];
+        break;
+      }
+      case "systemLoad" /* SystemLoad */: {
+        const sorted = nodes.sort((a, b) => (a.stats?.cpu.systemLoad ?? 0) - (b.stats?.cpu.systemLoad ?? 0));
+        node = sorted[0];
+        break;
+      }
+      case "lavalinkLoad" /* LavalinkLoad */: {
+        const sorted = nodes.sort((a, b) => (a.stats?.cpu.lavalinkLoad ?? 0) - (b.stats?.cpu.lavalinkLoad ?? 0));
+        node = sorted[0];
+        break;
+      }
+    }
+    if (!node) node = nodes.reduce((a, b) => a.penalties < b.penalties ? a : b);
+    return node;
+  }
+  /**
+   *
+   * Create a new node.
+   * @param {NodeOptions} options The options for the node.
+   * @returns {NodeStructure} The created node.
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.create({
+   * 	host: "localhost",
+   * 	port: 2333,
+   * 	password: "password",
+   * 	secure: false,
+   * });
+   *
+   * console.log(node.id); // localhost:2333
+   */
+  create(options) {
+    options.id ??= `${options.host}:${options.port}`;
+    const oldNode = this.nodes.get(options.id);
+    if (oldNode) return oldNode;
+    const node = Structures.Node(this, options);
+    this.nodes.set(node.id, node);
+    this.manager.emit("nodeCreate" /* NodeCreate */, node);
+    return node;
+  }
+  /**
+   *
+   * Reconnect the nodes.
+   * @returns {void}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) node.reconnect();
+   * ```
+   */
+  reconnect() {
+    if (!this.nodes.size) return;
+    for (const node of this.nodes.filter((node2) => node2.state !== 2 /* Connected */)) {
+      node.reconnect();
+    }
+  }
+  /**
+   * Disconnect the nodes.
+   * @returns {void}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) node.disconnect();
+   * ```
+   */
+  disconnect() {
+    if (!this.nodes.size) return;
+    for (const node of this.nodes.filter((node2) => node2.state !== 3 /* Disconnected */)) {
+      node.disconnect();
+    }
+  }
+  /**
+   * Connect the nodes.
+   * @returns {void}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) node.connect();
+   * ```
+   */
+  connect() {
+    if (!this.nodes.size) return;
+    for (const node of this.nodes.filter((node2) => node2.state !== 2 /* Connected */)) {
+      node.connect();
+    }
+  }
+  /**
+   * Destroy the nodes.
+   * @returns {void}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) node.destroy();
+   * ```
+   */
+  destroy() {
+    if (!this.nodes.size) return;
+    for (const node of this.nodes.values()) {
+      node.destroy();
+    }
+  }
+};
+
+// src/classes/node/Rest.ts
+var RestError = class extends Error {
+  /**
+   * The timestamp of the response.
+   * @type {number}
+   */
+  timestamp;
+  /**
+   * The status of the response.
+   * @type {number}
+   */
+  status;
+  /**
+   * The error of the response.
+   * @type {string}
+   */
+  error;
+  /**
+   * The message of the response.
+   * @type {string}
+   */
+  path;
+  /**
+   * The trace of the response.
+   * @type {string}
+   */
+  trace;
+  /**
+   *
+   * Create a new REST error.
+   */
+  constructor({ timestamp, status, error, trace, message, path }) {
+    super(`Rest request failed with response code: ${status}${message ? ` | message: ${message}` : ""}`);
+    this.name = "Hoshimi [RestError]";
+    this.timestamp = timestamp;
+    this.status = status;
+    this.error = error;
+    this.trace = trace;
+    this.message = message;
+    this.path = path;
+  }
+};
+var Rest = class {
+  /**
+   * The URL for the REST.
+   * @type {string}
+   */
+  url;
+  /**
+   * The version for the REST.
+   * @type {string}
+   */
+  version = "v4";
+  /**
+   * The timeout for the REST.
+   * @type {number}
+   */
+  restTimeout;
+  /**
+   * The user agent for the REST.
+   * @type {UserAgent}
+   */
+  userAgent;
+  /**
+   * The node for the REST.
+   * @type {Node}
+   */
+  node;
+  /**
+   *
+   * Create a new REST.
+   * @param {NodeStructure} node The node for the REST.
+   * @example
+   * ```ts
+   * const node = new Node({
+   * 	host: "localhost",
+   * 	port: 2333,
+   * 	password: "youshallnotpass",
+   * 	secure: false,
+   * });
+   *
+   * const rest = new Rest(node);
+   * console.log(rest.restUrl); // http://localhost:2333/v4
+   * ```
+   */
+  constructor(node) {
+    const manager = node.nodeManager.manager;
+    this.url = `${node.options.secure ? "https" : "http"}://${node.options.host}:${node.options.port}/${this.version}`;
+    this.restTimeout = node.options.restTimeout ?? manager.options.restOptions.resumeTimeout ?? 1e4;
+    this.userAgent = manager.options.nodeOptions.userAgent ?? HoshimiAgent;
+    this.node = node;
+  }
+  /**
+   * The REST URL to make requests.
+   * @type {string}
+   */
+  get restUrl() {
+    return this.url;
+  }
+  /**
+   * The session id of the node.
+   * @type {string}
+   */
+  get sessionId() {
+    return this.node.sessionId;
+  }
+  /**
+   *
+   * Make a request to the node.
+   * @param {RestOptions} options The options to make the request.
+   * @returns {Promise<T | null>} The response from the node.
+   */
+  async request(options) {
+    const headers = {
+      ...options.headers,
+      "Content-Type": "application/json",
+      "User-Agent": this.userAgent,
+      Authorization: this.node.options.password
+    };
+    options.method ??= "GET" /* Get */;
+    const url = new URL(`${this.url}${options.endpoint}`);
+    if (options.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        url.searchParams.append(key, value);
+      }
+    }
+    url.searchParams.append("trace", "true");
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), this.restTimeout);
+    const fetchOptions = {
+      headers,
+      method: options.method,
+      signal: abortController.signal
+    };
+    if (!["GET" /* Get */, "HEAD" /* Head */].includes(options.method) && options.body) {
+      if (typeof options.body === "string") fetchOptions.body = options.body;
+      else fetchOptions.body = JSON.stringify(options.body);
+    }
+    this.node.nodeManager.manager.emit(
+      "debug" /* Debug */,
+      4 /* Rest */,
+      `[Rest] -> [${this.node.id} : ${options.method}]: Url: ${this.restUrl} | Endpoint: ${options.endpoint} | Params: ${url.search} | Body: ${options.body ? JSON.stringify(options.body) : "None"} | Headers: ${JSON.stringify(headers)}`
+    );
+    const response = await fetch(url.toString(), fetchOptions).finally(() => clearTimeout(timeout));
+    if (!response.ok) {
+      const restError = await response.json().catch(() => null);
+      throw new RestError(
+        restError ?? {
+          timestamp: Date.now(),
+          status: response.status,
+          error: "Unknown Error",
+          message: "Unexpected error response from Lavalink server",
+          path: options.endpoint
+        }
+      );
+    }
+    if (response.status === 204 /* NoContent */) return null;
+    return response.json().catch(() => null);
+  }
+  /**
+   *
+   * Update the player data.
+   * @param {Partial<UpdatePlayerInfo>} data The player data to update.
+   * @returns {LavalinkPlayer | null} The updated player data.
+   * @example
+   * ```ts
+   * const player = await node.rest.updatePlayer({
+   * 	guildId: "guildId",
+   * 	noReplace: true,
+   * 	playerOptions: {
+   * 		paused: false,
+   * 		track: { encoded: "encoded track" },
+   * 	},
+   * });
+   *
+   * console.log(player); // The updated lavalink player data
+   * ```
+   */
+  updatePlayer(data) {
+    if (!this.sessionId) return Promise.resolve(null);
+    this.node.nodeManager.manager.emit(
+      "debug" /* Debug */,
+      4 /* Rest */,
+      `[Rest] -> [${this.node.id}]: Updated player data for guild: ${data.guildId} | Payload: ${JSON.stringify(data)}`
+    );
+    validatePlayerData.call(this.node, data);
+    return this.request({
+      method: "PATCH" /* Patch */,
+      endpoint: `/sessions/${this.sessionId}/players/${data.guildId}`,
+      body: { ...data.playerOptions },
+      params: { noReplace: `${data.noReplace ?? false}` }
+    });
+  }
+  /**
+   *
+   * Stop the track in player for the guild.
+   * @param {string} guildId the guild id to stop the player
+   * @returns {Promise<LavalinkPlayer | null>} The updated player data.
+   * @example
+   * ```ts
+   * const player = await node.rest.stopPlayer("guildId");
+   * if (player) console.log(player); // The lavalink player
+   * ```
+   */
+  stopPlayer(guildId) {
+    if (!this.sessionId) return Promise.resolve(null);
+    this.node.nodeManager.manager.emit(
+      "debug" /* Debug */,
+      4 /* Rest */,
+      `[Rest] -> [${this.node.id}]: Stopped player for guild: ${guildId}`
+    );
+    return this.updatePlayer({
+      guildId,
+      playerOptions: {
+        paused: false,
+        track: { encoded: null }
+      }
+    });
+  }
+  /**
+   *
+   * Destroy the player for the guild.
+   * @param {string} guildId The guild id to destroy the player.
+   * @returns {Promise<void>} The updated player data.
+   * @example
+   * ```ts
+   * await node.rest.destroyPlayer("guildId");
+   * ```
+   * @example
+   */
+  async destroyPlayer(guildId) {
+    if (!this.sessionId) return;
+    this.node.nodeManager.manager.emit(
+      "debug" /* Debug */,
+      4 /* Rest */,
+      `[Rest] -> [${this.node.id}]: Destroyed player for guild: ${guildId}`
+    );
+    await this.request({
+      method: "DELETE" /* Delete */,
+      endpoint: `/sessions/${this.sessionId}/players/${guildId}`
+    });
+  }
+  /**
+   *
+   * Update the session for the node
+   * @param {boolean} resuming Enable resuming for the session.
+   * @param {number | null} timeout The timeout for the session.
+   * @returns {Promise<LavalinkSession | null>} The updated session data.
+   * @example
+   * ```ts
+   * const session = await node.rest.updateSession(true, 10000);
+   * if (session) console.log(session); // The lavalink session data
+   * ```
+   */
+  updateSession(resuming, timeout = null) {
+    if (!this.sessionId) return Promise.resolve(null);
+    this.node.nodeManager.manager.emit(
+      "debug" /* Debug */,
+      4 /* Rest */,
+      `[Rest] -> [${this.node.id}]: Updated session for resumed: ${resuming} | Timeout: ${timeout ?? "None"}`
+    );
+    return this.request({
+      method: "PATCH" /* Patch */,
+      endpoint: `/sessions/${this.sessionId}`,
+      body: { resuming, timeout }
+    });
+  }
+};
+
+// src/classes/player/filters/DSPXPlugin.ts
+var DSPXPluginFilter = class {
+  /**
+   * The filter manager instance.
+   * @type {FilterManagerStructure}
+   * @readonly
+   */
+  manager;
+  /**
+   * Create a new DSPXPluginFilter instance.
+   * @param {FilterManagerStructure} manager The filter manager instance.
+   */
+  constructor(manager) {
+    this.manager = manager;
+  }
+  /**
+   *
+   * Set the low-pass filter with the given settings.
+   * @param {FilterPluginPassSettings} [settings=DefaultFilter.DSPXLowPass] The settings for the low-pass filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setLowPass(settings = DefaultFilterPreset.DSPXLowPass) {
+    validateNodePlugins(this.manager.player.node, ["lavadspx-plugin" /* LavaDspx */]);
+    if (!this.manager.player.node.info?.filters?.includes("low-pass" /* DSPXLowpass */))
+      throw new PlayerError("Node filters does not include the 'low-pass' filter. (Or the node doesn't have it enabled)");
+    if (!this.manager.data) this.manager.data = {};
+    if (!this.manager.data.pluginFilters) this.manager.data.pluginFilters = {};
+    if (!this.manager.data.pluginFilters["low-pass"]) this.manager.data.pluginFilters["low-pass"] = {};
+    if (this.manager.filters.lavalinkLavaDspxPlugin.lowPass) {
+      delete this.manager.data.pluginFilters["low-pass"];
+    } else {
+      this.manager.data.pluginFilters["low-pass"] = { ...settings };
+    }
+    this.manager.filters.lavalinkLavaDspxPlugin.lowPass = !this.manager.filters.lavalinkLavaDspxPlugin.lowPass;
+    await this.manager.apply();
+    return this.manager.filters.lavalinkLavaDspxPlugin.lowPass;
+  }
+  /**
+   *
+   * Set the high-pass filter with the given settings.
+   * @param {FilterPluginPassSettings} [settings=DefaultFilter.DSPXHighPass] The settings for the high-pass filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setHighPass(settings = DefaultFilterPreset.DSPXHighPass) {
+    validateNodePlugins(this.manager.player.node, ["lavadspx-plugin" /* LavaDspx */]);
+    if (this.manager.player.node.info && !this.manager.player.node.info?.filters?.includes("high-pass" /* DSPXHighpass */))
+      throw new PlayerError("Node filters does not include the 'high-pass' filter. (Or the node doesn't have it enabled)");
+    if (!this.manager.data) this.manager.data = {};
+    if (!this.manager.data.pluginFilters) this.manager.data.pluginFilters = {};
+    if (!this.manager.data.pluginFilters["high-pass"]) this.manager.data.pluginFilters["high-pass"] = {};
+    if (this.manager.filters.lavalinkLavaDspxPlugin.highPass) {
+      delete this.manager.data.pluginFilters["high-pass"];
+    } else {
+      this.manager.data.pluginFilters["high-pass"] = { ...settings };
+    }
+    this.manager.filters.lavalinkLavaDspxPlugin.highPass = !this.manager.filters.lavalinkLavaDspxPlugin.highPass;
+    await this.manager.apply();
+    return this.manager.filters.lavalinkLavaDspxPlugin.highPass;
+  }
+  /**
+   *
+   * Set the normalization filter with the given settings.
+   * @param {NormalizationSettings} [settings=DefaultFilter.DSPXNormalization] The settings for the normalization filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setNormalization(settings = DefaultFilterPreset.DSPXNormalization) {
+    validateNodePlugins(this.manager.player.node, ["lavadspx-plugin" /* LavaDspx */]);
+    if (!this.manager.player.node.info?.filters?.includes("normalization" /* DSPXNormalization */))
+      throw new PlayerError("Node filters does not include the 'normalization' filter. (Or the node doesn't have it enabled)");
+    if (!this.manager.data) this.manager.data = {};
+    if (!this.manager.data.pluginFilters) this.manager.data.pluginFilters = {};
+    if (!this.manager.data.pluginFilters.normalization) this.manager.data.pluginFilters.normalization = {};
+    if (this.manager.filters.lavalinkLavaDspxPlugin.normalization) {
+      delete this.manager.data.pluginFilters.normalization;
+    } else {
+      this.manager.data.pluginFilters.normalization = { ...settings };
+    }
+    this.manager.filters.lavalinkLavaDspxPlugin.normalization = !this.manager.filters.lavalinkLavaDspxPlugin.normalization;
+    await this.manager.apply();
+    return this.manager.filters.lavalinkLavaDspxPlugin.normalization;
+  }
+  /**
+   *
+   * Set the echo filter with the given settings.
+   * @param {EchoSettings} [settings=DefaultFilter.DSPXEcho] The settings for the echo filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setEcho(settings = DefaultFilterPreset.DSPXEcho) {
+    validateNodePlugins(this.manager.player.node, ["lavadspx-plugin" /* LavaDspx */]);
+    if (!this.manager.player.node.info?.filters?.includes("echo" /* DSPXEcho */))
+      throw new PlayerError("Node filters does not include the 'echo' filter. (Or the node doesn't have it enabled)");
+    if (!this.manager.data) this.manager.data = {};
+    if (!this.manager.data.pluginFilters) this.manager.data.pluginFilters = {};
+    if (!this.manager.data.pluginFilters.echo) this.manager.data.pluginFilters.echo = {};
+    if (this.manager.filters.lavalinkLavaDspxPlugin.echo) {
+      delete this.manager.data.pluginFilters.echo;
+    } else {
+      this.manager.data.pluginFilters.echo = { ...settings };
+    }
+    this.manager.filters.lavalinkLavaDspxPlugin.echo = !this.manager.filters.lavalinkLavaDspxPlugin.echo;
+    await this.manager.apply();
+    return this.manager.filters.lavalinkLavaDspxPlugin.echo;
+  }
+};
+
+// src/classes/player/filters/LavalinkPlugin.ts
+var LavalinkPluginFilter = class {
+  /**
+   * The filter manager instance.
+   * @type {FilterManagerStructure}
+   * @private
+   * @readonly
+   */
+  manager;
+  /**
+   * Creates an instance of LavalinkPluginFilter.
+   * @param {FilterManagerStructure} filters - The filter manager instance.
+   */
+  constructor(filters) {
+    this.manager = filters;
+  }
+  /**
+   *
+   * Set the echo filter with the given settings.
+   * @param {Omit<EchoSettings, "echoLength">} [settings=DefaultFilter.PluginEcho] The settings for the echo filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setEcho(settings = DefaultFilterPreset.PluginEcho) {
+    validateNodePlugins(this.manager.player.node, ["lavalink-filter-plugin" /* FilterPlugin */]);
+    if (!this.manager.player.node.info?.filters?.includes("echo" /* Echo */))
+      throw new PlayerError("Node filters does not include the 'echo' filter. (Or the node doesn't have it enabled)");
+    if (!this.manager.data) this.manager.data = {};
+    if (!this.manager.data.pluginFilters) this.manager.data.pluginFilters = {};
+    if (!this.manager.data.pluginFilters["lavalink-filter-plugin"])
+      this.manager.data.pluginFilters["lavalink-filter-plugin"] = { echo: { decay: 0, delay: 0 }, reverb: { delays: [], gains: [] } };
+    if (!this.manager.data.pluginFilters["lavalink-filter-plugin"].echo)
+      this.manager.data.pluginFilters["lavalink-filter-plugin"].echo = { decay: 0, delay: 0 };
+    this.manager.data.pluginFilters["lavalink-filter-plugin"].echo.delay = this.manager.filters.lavalinkFilterPlugin.echo ? 0 : settings.delay;
+    this.manager.data.pluginFilters["lavalink-filter-plugin"].echo.decay = this.manager.filters.lavalinkFilterPlugin.echo ? 0 : settings.decay;
+    this.manager.filters.lavalinkFilterPlugin.echo = !this.manager.filters.lavalinkFilterPlugin.echo;
+    await this.manager.apply();
+    return this.manager.filters.lavalinkFilterPlugin.echo;
+  }
+  /**
+   *
+   * Set the reverb filter with the given settings.
+   * @param {Partial<LavalinkFilterPluginReverbSettings>} [settings=DefaultFilter.PluginReverb] The settings for the reverb filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setReverb(settings = DefaultFilterPreset.PluginReverb) {
+    validateNodePlugins(this.manager.player.node, ["lavalink-filter-plugin" /* FilterPlugin */]);
+    if (!this.manager.player.node.info?.filters?.includes("reverb" /* Reverb */))
+      throw new PlayerError("Node filters does not include the 'reverb' filter. (Or the node doesn't have it enabled)");
+    if (!this.manager.data) this.manager.data = {};
+    if (!this.manager.data.pluginFilters) this.manager.data.pluginFilters = {};
+    if (!this.manager.data.pluginFilters["lavalink-filter-plugin"])
+      this.manager.data.pluginFilters["lavalink-filter-plugin"] = { echo: { decay: 0, delay: 0 }, reverb: { delays: [], gains: [] } };
+    if (!this.manager.data.pluginFilters["lavalink-filter-plugin"].reverb)
+      this.manager.data.pluginFilters["lavalink-filter-plugin"].reverb = { delays: [], gains: [] };
+    this.manager.data.pluginFilters["lavalink-filter-plugin"].reverb.delays = this.manager.filters.lavalinkFilterPlugin.reverb ? [] : settings.delays;
+    this.manager.data.pluginFilters["lavalink-filter-plugin"].reverb.gains = this.manager.filters.lavalinkFilterPlugin.reverb ? [] : settings.gains;
+    this.manager.filters.lavalinkFilterPlugin.reverb = !this.manager.filters.lavalinkFilterPlugin.reverb;
+    await this.manager.apply();
+    return this.manager.filters.lavalinkFilterPlugin.reverb;
+  }
+};
+
+// src/classes/player/filters/Manager.ts
+var FilterManager = class {
+  /**
+   * The player this filter manager belongs to.
+   * @type {PlayerStructure}
+   * @public
+   * @readonly
+   */
+  player;
+  /**
+   * The bands applied to the player.
+   * @type {EQBandSettings[]}
+   * @readonly
+   */
+  bands = [];
+  /**
+   * The current filter settings applied to the player.
+   * @type {FilterSettings}
+   * @public
+   */
+  data = { ...DefaultPlayerFilters };
+  /**
+   * The enabled filters for the player.
+   * @type {EnabledPlayerFilters}
+   */
+  filters = {
+    audioOutput: "stereo" /* Stereo */,
+    volume: false,
+    vaporwave: false,
+    custom: false,
+    nightcore: false,
+    rotation: false,
+    karaoke: false,
+    tremolo: false,
+    vibrato: false,
+    lowPass: false,
+    distortion: false,
+    timescale: false,
+    lavalinkFilterPlugin: {
+      echo: false,
+      reverb: false
+    },
+    lavalinkLavaDspxPlugin: {
+      lowPass: false,
+      highPass: false,
+      normalization: false,
+      echo: false
+    }
+  };
+  /**
+   * The lavalink plugin filters manager.
+   * @type {LavalinkPluginFilter}
+   * @readonly
+   */
+  plugin;
+  /**
+   * The DSPX plugin filters manager.
+   * @type {DSPXPluginFilter}
+   * @readonly
+   */
+  dspx;
+  /**
+   *
+   * Creates a new filter manager.
+   * @param {PlayerStructure} player The player this filter manager belongs to.
+   */
+  constructor(player) {
+    this.player = player;
+    this.plugin = new LavalinkPluginFilter(this);
+    this.dspx = new DSPXPluginFilter(this);
+  }
+  /**
+   *
+   * Checks if a custom filter is active.
+   * @returns {boolean} True if a custom filter is active, false otherwise.
+   */
+  isCustom() {
+    this.filters.custom = !this.filters.nightcore && !this.filters.vaporwave && Object.values(this.data.timescale ?? {}).some((d) => d !== 1);
+    return this.filters.custom;
+  }
+  /**
+   * Resets all filters to their default values.
+   * @returns {Promise<void>} A promise that resolves when the filters have been reset.
+   */
+  async reset() {
+    this.filters = {
+      audioOutput: "stereo" /* Stereo */,
+      volume: false,
+      vaporwave: false,
+      custom: false,
+      nightcore: false,
+      rotation: false,
+      karaoke: false,
+      tremolo: false,
+      vibrato: false,
+      lowPass: false,
+      distortion: false,
+      timescale: false,
+      lavalinkFilterPlugin: {
+        echo: false,
+        reverb: false
+      },
+      lavalinkLavaDspxPlugin: {
+        lowPass: false,
+        highPass: false,
+        normalization: false,
+        echo: false
+      }
+    };
+    for (const [key, value] of Object.entries(DefaultPlayerFilters)) {
+      this.data[key] = value;
+    }
+    await this.apply();
+  }
+  /**
+   *
+   * Applies the current filters to the player.
+   * @returns {Promise<void>} A promise that resolves when the filters have been applied.
+   */
+  async apply() {
+    if (!this.player.node.sessionId) return;
+    this.check();
+    this.isCustom();
+    const filters = { ...this.data };
+    if (!this.filters.volume) delete filters.volume;
+    if (!this.filters.tremolo) delete filters.tremolo;
+    if (!this.filters.vibrato) delete filters.vibrato;
+    if (!this.filters.lavalinkFilterPlugin.echo) delete filters.pluginFilters?.["lavalink-filter-plugin"]?.echo;
+    if (!this.filters.lavalinkFilterPlugin.reverb) delete filters.pluginFilters?.["lavalink-filter-plugin"]?.reverb;
+    if (!this.filters.lavalinkLavaDspxPlugin.echo) delete filters.pluginFilters?.echo;
+    if (!this.filters.lavalinkLavaDspxPlugin.normalization) delete filters.pluginFilters?.normalization;
+    if (!this.filters.lavalinkLavaDspxPlugin.highPass) delete filters.pluginFilters?.["high-pass"];
+    if (!this.filters.lavalinkLavaDspxPlugin.lowPass) delete filters.pluginFilters?.["low-pass"];
+    if (filters.pluginFilters?.["lavalink-filter-plugin"] && !Object.values(filters.pluginFilters["lavalink-filter-plugin"]).length)
+      delete filters.pluginFilters["lavalink-filter-plugin"];
+    if (filters.pluginFilters && Object.values(filters.pluginFilters).length === 0) delete filters.pluginFilters;
+    if (this.filters.audioOutput === "stereo" /* Stereo */) delete filters.channelMix;
+    if (!this.filters.lowPass) delete filters.lowPass;
+    if (!this.filters.karaoke) delete filters.karaoke;
+    if (!this.filters.rotation) delete filters.rotation;
+    if (!this.filters.distortion) delete filters.distortion;
+    if (!this.filters.timescale) delete filters.timescale;
+    if (this.data.timescale && Object.values(this.data.timescale).every((v) => v === 1)) delete filters.timescale;
+    filters.equalizer = [...this.bands];
+    if (!filters.equalizer.length) delete filters.equalizer;
+    for (const key in filters) {
+      if (!this.player.node.info?.filters?.includes(key)) delete filters[key];
+    }
+    await this.player.updatePlayer({ playerOptions: { filters } });
+  }
+  /**
+   * Checks if the current filters are active.
+   * @param {TimescaleSettings} timescale The timescale settings to check against.
+   * @returns {void} Nothing!
+   */
+  check(timescale) {
+    this.filters.rotation = this.data.rotation?.rotationHz !== 0;
+    this.filters.vibrato = this.data.vibrato?.frequency !== 0 || this.data.vibrato?.depth !== 0;
+    this.filters.tremolo = this.data.tremolo?.frequency !== 0 || this.data.tremolo?.depth !== 0;
+    const lavalinkPluginFilters = this.data.pluginFilters?.["lavalink-filter-plugin"] ?? {};
+    this.filters.lavalinkFilterPlugin.echo = lavalinkPluginFilters.echo?.decay !== 0 || lavalinkPluginFilters.echo?.delay !== 0;
+    this.filters.lavalinkFilterPlugin.reverb = lavalinkPluginFilters.reverb?.delays?.length !== 0 || lavalinkPluginFilters.reverb?.gains?.length !== 0;
+    this.filters.lavalinkLavaDspxPlugin.highPass = Object.values(this.data.pluginFilters?.["high-pass"] ?? {}).length > 0;
+    this.filters.lavalinkLavaDspxPlugin.lowPass = Object.values(this.data.pluginFilters?.["low-pass"] ?? {}).length > 0;
+    this.filters.lavalinkLavaDspxPlugin.normalization = Object.values(this.data.pluginFilters?.normalization ?? {}).length > 0;
+    this.filters.lavalinkLavaDspxPlugin.echo = Object.values(this.data.pluginFilters?.echo ?? {}).length > 0 && typeof this.data.pluginFilters?.echo?.delay === "undefined";
+    this.filters.lowPass = this.data.lowPass?.smoothing !== 0;
+    this.filters.karaoke = Object.values(this.data.karaoke ?? {}).some((v) => v !== 0);
+    this.filters.distortion = Object.values(this.data.distortion ?? {}).some((v) => v !== 0 && v !== 1);
+    this.filters.timescale = Object.values(this.data.timescale ?? {}).some((v) => v !== 1);
+    if ((this.filters.nightcore || this.filters.vaporwave) && timescale) {
+      if (timescale.pitch !== this.data.timescale?.pitch || timescale.rate !== this.data.timescale?.rate || timescale.speed !== this.data.timescale?.speed) {
+        this.filters.custom = Object.values(this.data.timescale ?? {}).some((v) => v !== 1);
+        this.filters.nightcore = false;
+        this.filters.vaporwave = false;
+      }
+    }
+  }
+  /**
+   *
+   * Checks if a specific filter is active.
+   * @param {FilterType} filter The filter type to check.
+   * @returns {boolean} True if the filter is active, false otherwise.
+   */
+  has(filter) {
+    const dspx = this.filters.lavalinkLavaDspxPlugin[filter];
+    if (isValid(dspx)) return dspx;
+    const plugin = this.filters.lavalinkFilterPlugin[filter];
+    if (isValid(plugin)) return plugin;
+    const kind = this.filters[filter];
+    if (typeof kind === "boolean") return kind;
+    if (typeof kind === "string") return kind !== "stereo" /* Stereo */;
+    return false;
+  }
+  /**
+   *
+   * Sets the volume for the player.
+   * @param {number} volume The volume level to set (between 0 and 5).
+   * @returns {Promise<boolean>} A promise that resolves to true if the volume was changed, false otherwise.
+   */
+  async setVolume(volume) {
+    if (typeof volume !== "number" || Number.isNaN(volume) || volume < 0 || volume > 5)
+      throw new PlayerError("Volume must be a number between 0 and 5.");
+    this.data = { volume };
+    this.filters.volume = volume !== 1;
+    await this.apply();
+    return this.filters.volume;
+  }
+  /**
+   * Sets the audio output for the player.
+   * @param {AudioOutput} output The audio output to set.
+   * @returns {Promise<AudioOutput>} A promise that resolves to the set audio output.
+   */
+  async setAudioOutput(output) {
+    const outputs = Object.values(AudioOutput);
+    if (!outputs.includes(output)) throw new PlayerError(`Audio output must be one of the following: ${outputs.join(", ")}.`);
+    this.filters.audioOutput = output;
+    this.data.channelMix = AudioOutputData[output];
+    await this.apply();
+    return this.filters.audioOutput;
+  }
+  /**
+   *
+   * Sets the speed for the player.
+   * @param {number} speed The speed to set (default is 1).
+   * @returns {Promise<boolean>} A promise that resolves to true if a custom filter is active, false otherwise.
+   */
+  async setSpeed(speed = 1) {
+    if (!this.player.node.info?.filters?.includes("timescale" /* Timescale */))
+      throw new PlayerError("Node filters does not include the 'timescale' filter. (Or the node doesn't have it enabled)");
+    if (this.filters.nightcore || this.filters.vaporwave) {
+      this.data.timescale = {
+        speed: 1,
+        pitch: 1,
+        rate: 1
+      };
+      this.filters.nightcore = false;
+      this.filters.vaporwave = false;
+    }
+    this.data.timescale.speed = speed;
+    await this.apply();
+    return this.filters.custom;
+  }
+  /**
+   *
+   * Sets the rate for the player.
+   * @param {number} rate The rate to set (default is 1).
+   * @returns {Promise<boolean>} A promise that resolves to true if a custom filter is active, false otherwise.
+   */
+  async setRate(rate = 1) {
+    if (!this.player.node.info?.filters?.includes("timescale" /* Timescale */))
+      throw new PlayerError("Node filters does not include the 'timescale' filter. (Or the node doesn't have it enabled)");
+    if (this.filters.nightcore || this.filters.vaporwave) {
+      this.data.timescale = {
+        speed: 1,
+        pitch: 1,
+        rate: 1
+      };
+      this.filters.nightcore = false;
+      this.filters.vaporwave = false;
+    }
+    this.data.timescale.rate = rate;
+    await this.apply();
+    return this.filters.custom;
+  }
+  /**
+   *
+   * Sets the pitch for the player.
+   * @param {number} pitch The pitch
+   * @returns {Promise<boolean>} A promise that resolves to true if a custom filter is active, false otherwise.
+   */
+  async setPitch(pitch = 1) {
+    if (!this.player.node.info?.filters?.includes("timescale" /* Timescale */))
+      throw new PlayerError("Node filters does not include the 'timescale' filter. (Or the node doesn't have it enabled)");
+    if (this.filters.nightcore || this.filters.vaporwave) {
+      this.data.timescale = {
+        speed: 1,
+        pitch: 1,
+        rate: 1
+      };
+      this.filters.nightcore = false;
+      this.filters.vaporwave = false;
+    }
+    this.data.timescale.pitch = pitch;
+    await this.apply();
+    return this.filters.custom;
+  }
+  /**
+   *
+   * Sets the EQ bands for the player.
+   * @param {RestOrArray<EQBandSettings>} bands The EQ band settings to set.
+   * @returns {Promise<this>} A promise that resolves to the instance of the manager.
+   */
+  async setEQBand(...bands) {
+    bands = bands.flat();
+    if (!bands.length || !bands.every((band) => typeof band.band === "number" && typeof band.gain === "number"))
+      throw new PlayerError("Bands must be a non-empty object array containing 'band' and 'gain' properties.");
+    for (const { band, gain } of bands) this.bands[band] = { band, gain };
+    await this.apply();
+    return this;
+  }
+  /**
+   *
+   * Clears all EQ bands for the player.
+   * @returns {Promise<this>} A promise that resolves to the instance of the manager.
+   */
+  async clearEQBands() {
+    return this.setEQBand(Array.from({ length: 15 }, (_, i) => ({ band: i, gain: 0 })));
+  }
+  /**
+   *
+   * Set the vibrato filter with the given settings.
+   * @param {TremoloSettings} [settings=DefaultFilterPreset.Vibrato] The settings for the vibrato filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setVibrato(settings = DefaultFilterPreset.Vibrato) {
+    if (!this.player.node.info?.filters?.includes("vibrato" /* Vibrato */))
+      throw new PlayerError("Node filters does not include the 'vibrato' filter. (Or the node doesn't have it enabled)");
+    this.data.vibrato = {
+      frequency: this.filters.vibrato ? 0 : settings.frequency,
+      depth: this.filters.vibrato ? 0 : settings.depth
+    };
+    this.filters.vibrato = !this.filters.vibrato;
+    await this.apply();
+    return this.filters.vibrato;
+  }
+  /**
+   *
+   * Set the tremolo filter with the given settings.
+   * @param {TremoloSettings} [settings=DefaultFilterPreset.Tremolo] The settings for the tremolo filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setTremolo(settings = DefaultFilterPreset.Tremolo) {
+    if (!this.player.node.info?.filters?.includes("tremolo" /* Tremolo */))
+      throw new PlayerError("Node filters does not include the 'tremolo' filter. (Or the node doesn't have it enabled)");
+    this.data.tremolo = {
+      frequency: this.filters.tremolo ? 0 : settings.frequency,
+      depth: this.filters.tremolo ? 0 : settings.depth
+    };
+    this.filters.tremolo = !this.filters.tremolo;
+    await this.apply();
+    return this.filters.tremolo;
+  }
+  /**
+   *
+   * Set the low-pass filter with the given settings.
+   * @param {LowPassSettings} [settings=DefaultFilterPreset.Lowpass] The settings for the low-pass filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setLowPass(settings = DefaultFilterPreset.Lowpass) {
+    if (!this.player.node.info?.filters?.includes("lowPass" /* LowPass */))
+      throw new PlayerError("Node filters does not include the 'lowPass' filter. (Or the node doesn't have it enabled)");
+    this.data.lowPass = { smoothing: this.filters.lowPass ? 0 : settings.smoothing };
+    this.filters.lowPass = !this.filters.lowPass;
+    await this.apply();
+    return this.filters.lowPass;
+  }
+  /**
+   * Set the nightcore filter with the given settings.
+   * @param {Partial<TimescaleSettings>} [settings=DefaultFilterPreset.Nightcore] The settings for the nightcore filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setNightcore(settings = DefaultFilterPreset.Nightcore) {
+    if (!this.player.node.info?.filters?.includes("timescale" /* Timescale */))
+      throw new PlayerError("Node filters does not include the 'timescale' filter. (Or the node doesn't have it enabled)");
+    this.data.timescale = {
+      speed: this.filters.nightcore ? 1 : settings.speed,
+      pitch: this.filters.nightcore ? 1 : settings.pitch,
+      rate: this.filters.nightcore ? 1 : settings.rate
+    };
+    this.filters.nightcore = !this.filters.nightcore;
+    this.filters.vaporwave = false;
+    this.filters.custom = false;
+    await this.apply();
+    return this.filters.nightcore;
+  }
+  /**
+   *
+   * Set the vaporwave filter with the given settings.
+   * @param {Partial<TimescaleSettings>} [settings=DefaultFilterPreset.Vaporwave] The settings for the vaporwave filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setVaporwave(settings = DefaultFilterPreset.Vaporwave) {
+    if (!this.player.node.info?.filters?.includes("timescale" /* Timescale */))
+      throw new PlayerError("Node filters does not include the 'timescale' filter. (Or the node doesn't have it enabled)");
+    this.data.timescale = {
+      speed: this.filters.vaporwave ? 1 : settings.speed,
+      pitch: this.filters.vaporwave ? 1 : settings.pitch,
+      rate: this.filters.vaporwave ? 1 : settings.rate
+    };
+    this.filters.vaporwave = !this.filters.vaporwave;
+    this.filters.nightcore = false;
+    this.filters.custom = false;
+    await this.apply();
+    return this.filters.vaporwave;
+  }
+  /**
+   *
+   * Set the karaoke filter with the given settings.
+   * @param {KaraokeSettings} [settings=DefaultFilterPreset.Karaoke] The settings for the karaoke filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setKaraoke(settings = DefaultFilterPreset.Karaoke) {
+    if (!this.player.node.info?.filters?.includes("karaoke" /* Karaoke */))
+      throw new PlayerError("Node filters does not include the 'karaoke' filter. (Or the node doesn't have it enabled)");
+    this.data.karaoke = {
+      level: this.data.karaoke.level ? 0 : settings.level,
+      monoLevel: this.data.karaoke.monoLevel ? 0 : settings.monoLevel,
+      filterBand: this.data.karaoke.filterBand ? 0 : settings.filterBand,
+      filterWidth: this.data.karaoke.filterWidth ? 0 : settings.filterWidth
+    };
+    this.filters.karaoke = !this.filters.karaoke;
+    await this.apply();
+    return this.filters.karaoke;
+  }
+  /**
+   *
+   * Set the distortion filter with the given settings.
+   * @param {Partial<DistortionSettings>} [settings=DefaultFilterPreset.Distortion] The settings for the distortion filter.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setDistortion(settings = DefaultFilterPreset.Distortion) {
+    if (!this.player.node.info?.filters?.includes("distortion" /* Distortion */))
+      throw new PlayerError("Node filters does not include the 'distortion' filter. (Or the node doesn't have it enabled)");
+    this.data.distortion = {
+      sinOffset: this.filters.distortion ? 0 : settings.sinOffset,
+      sinScale: this.filters.distortion ? 1 : settings.sinScale,
+      cosOffset: this.filters.distortion ? 0 : settings.cosOffset,
+      cosScale: this.filters.distortion ? 1 : settings.cosScale,
+      tanOffset: this.filters.distortion ? 0 : settings.tanOffset,
+      offset: this.filters.distortion ? 0 : settings.offset,
+      scale: this.filters.distortion ? 1 : settings.scale
+    };
+    this.filters.distortion = !this.filters.distortion;
+    await this.apply();
+    return this.filters.distortion;
+  }
+  /**
+   * Set the timescale filter with the given settings.
+   * @param {Partial<TimescaleSettings>} settings The timescale settings to set.
+   * @returns {Promise<boolean>} Whether the filter is now active.
+   */
+  async setTimescale(settings) {
+    if (!this.player.node.info?.filters?.includes("timescale" /* Timescale */))
+      throw new PlayerError("Node filters does not include the 'timescale' filter. (Or the node doesn't have it enabled)");
+    this.data.timescale = {
+      pitch: settings.pitch ?? 1,
+      rate: settings.rate ?? 1,
+      speed: settings.speed ?? 1
+    };
+    this.filters.timescale = !this.filters.timescale;
+    await this.apply();
+    return this.filters.timescale;
+  }
+};
+
+// src/classes/player/Storage.ts
+var PlayerStorage = class {
+  /**
+   * The internal storage.
+   * @type {Map<K, V>}
+   * @private
+   * @readonly
+   * @internal
+   */
+  internal = /* @__PURE__ */ new Map();
+  /**
+   *
+   * Get the value for a key in the storage.
+   * @param {K} key The key to get the value for.
+   * @returns {V | undefined} The value for the key, or undefined if it doesn't exist.
+   */
+  get(key) {
+    return this.internal.get(key);
+  }
+  /**
+   * Set the value for a key in the storage.
+   * @param {K} key The key to set the value for.
+   * @param {V} value The value to set for the key.
+   */
+  set(key, value) {
+    this.internal.set(key, value);
+  }
+  /**
+   * Check if the storage has a key.
+   * @param {K} key The key to check for.
+   * @returns {boolean} True if the storage has the key, false otherwise.
+   */
+  has(key) {
+    return this.internal.has(key);
+  }
+  /**
+   * Delete a key from the storage.
+   * @param {K} key The key to delete.
+   * @returns {boolean} True if the key was deleted, false otherwise.
+   */
+  delete(key) {
+    return this.internal.delete(key);
+  }
+  /**
+   * Get all keys in the storage.
+   * @returns {K[]} The keys in the storage.
+   */
+  keys() {
+    return [...this.internal.keys()];
+  }
+  /**
+   * Get all values in the storage.
+   * @returns {V[]} The values in the storage.
+   */
+  values() {
+    return [...this.internal.values()];
+  }
+  /**
+   * Get all entries in the storage.
+   * @returns {[K, V][]} The entries in the storage.
+   */
+  entries() {
+    return [...this.internal.entries()];
+  }
+  /**
+   *
+   * Get all key-value pairs in the storage.
+   * @returns {Record<K[number], V>} An object containing all key-value pairs in the storage, excluding internal keys.
+   */
+  all() {
+    return Object.fromEntries([...this.internal.entries()].filter(([key]) => !key.startsWith("internal_")));
+  }
+  /**
+   * Clear the storage.
+   */
+  clear() {
+    this.internal.clear();
+  }
+  /**
+   * Get the size of the storage.
+   * @returns {number} The number of entries in the storage.
+   */
+  get size() {
+    return this.internal.size;
+  }
+};
+
+// src/classes/player/Player.ts
+var Player = class {
+  /**
+   * The data for the player.
+   * @type {PlayerStorage}
+   * @readonly
+   */
+  data = new PlayerStorage();
+  /**
+   * The options for the player.
+   * @type {PlayerOptions}
+   * @readonly
+   */
+  options;
+  /**
+   * The manager for the player.
+   * @type {Hoshimi}
+   * @readonly
+   */
+  manager;
+  /**
+   * The queue for the player.
+   * @type {Queue}
+   * @readonly
+   */
+  queue;
+  /**
+   * The filter manager for the player.
+   * @type {FilterManager}
+   * @readonly
+   */
+  filterManager;
+  /**
+   * The node for the player.
+   * @type {NodeStructure}
+   */
+  node;
+  /**
+   * Check if the player is self deafened.
+   * @type {boolean}
+   */
+  selfDeaf = false;
+  /**
+   * Check if the player is self muted.
+   * @type {boolean}
+   */
+  selfMute = false;
+  /**
+   * Loop mode of the player.
+   * @type {LoopMode}
+   * @default LoopMode.Off
+   */
+  loop = 3 /* Off */;
+  /**
+   * Check if the player is playing.
+   * @type {boolean}
+   * @default false
+   */
+  playing = false;
+  /**
+   * Check if the player is paused.
+   * @type {boolean}
+   * @default false
+   */
+  paused = false;
+  /**
+   * Check if the player is connected.
+   * @type {boolean}
+   * @default false
+   */
+  connected = false;
+  /**
+   * Volume of the player.
+   * @type {number}
+   * @default 100
+   */
+  volume = 100;
+  /**
+   * Guild ig of the player.
+   * @type {string}
+   */
+  guildId;
+  /**
+   * Voice channel idof the player.
+   * @type {string | undefined}
+   */
+  voiceId = void 0;
+  /**
+   * Text channel id of the player.
+   * @type {string | undefined}
+   */
+  textId = void 0;
+  /**
+   * The ping of the player.
+   * @type {number}
+   */
+  ping = 0;
+  /**
+   * The timestamp when the player was created.
+   * @type {number}
+   */
+  createdTimestamp = 0;
+  /**
+   * The position of the player.
+   * @type {number}
+   */
+  position = 0;
+  /**
+   * The voice connection details.
+   * @type {PlayerVoice}
+   */
+  voice = {
+    endpoint: null,
+    sessionId: null,
+    token: null
+  };
+  /**
+   *
+   * Create a new player.
+   * @param {Hoshimi} manager The manager for the player.
+   * @param {PlayOptions} options The options for the player.
+   * @example
+   * ```ts
+   * const player = new Player(manager, {
+   * 	guildId: "guildId",
+   * 	voiceId: "voiceId",
+   * 	textId: "textId",
+   * 	selfDeaf: true,
+   * 	selfMute: false,
+   * 	volume: 100,
+   * });
+   *
+   * console.log(player.guildId); // guildId
+   * console.log(player.voiceId); // voiceId
+   * console.log(player.textId); // textId
+   */
+  constructor(manager, options) {
+    this.manager = manager;
+    this.options = options;
+    this.guildId = options.guildId;
+    this.voiceId = options.voiceId;
+    this.selfDeaf = options.selfDeaf ?? true;
+    this.selfMute = options.selfMute ?? false;
+    this.volume = options.volume ?? 100;
+    this.textId = options.textId;
+    this.node = (typeof this.options.node === "string" ? this.manager.nodeManager.get(this.options.node) : this.options.node) ?? this.manager.nodeManager.getLeastUsed();
+    validatePlayerOptions(this.options);
+    this.queue = Structures.Queue(this);
+    this.filterManager = Structures.FilterManager(this);
+  }
+  /**
+   * The lyrics methods for the player.
+   * @type {LyricsMethods}
+   * @readonly
+   */
+  lyrics = {
+    subscribe: (skipSource) => this.node.lyricsManager.subscribe(this.guildId, skipSource),
+    unsubscribe: () => this.node.lyricsManager.unsubscribe(this.guildId),
+    current: (skipSource) => this.node.lyricsManager.current(this.guildId, skipSource),
+    get: (track, skipSource) => this.node.lyricsManager.get(track, skipSource)
+  };
+  /**
+   *
+   * Search for a track or playlist.
+   * @param {SearchOptions} options The options for the search.
+   * @returns {Promise<QueryResult>} The search result.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * const result = await player.search({
+   * 	query: "track name",
+   * 	engine: SearchEngine.Youtube,
+   * 	requester: {},
+   * });
+   *
+   * console.log(result) // the search result
+   * ```
+   */
+  search(options) {
+    return this.manager.search({
+      ...options,
+      node: this.node
+    });
+  }
+  /**
+   *
+   * Play the next track in the queue.
+   * @param {number} [to=0] The amount of tracks to skip.
+   * @param {boolean} [throwError=true] Whether to throw an error if there are no tracks to skip.
+   * @returns {Promise<void>}
+   * @throws {PlayerError} If there are no tracks to skip.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.skip(2); // skip 2 tracks
+   * player.skip(); // skip 1 track
+   * ```
+   */
+  async skip(to = 0, throwError = true) {
+    if (!this.queue.size) {
+      this.manager.emit("debug" /* Debug */, 3 /* Player */, "[Player] -> [Skip] No tracks to skip.");
+      if (throwError) throw new PlayerError("No tracks to skip.");
+    }
+    if (typeof to === "number" && to > 0) {
+      if (to > this.queue.size) throw new PlayerError("Cannot skip to a track that doesn't exist.");
+      if (to < 0) throw new PlayerError("Cannot skip to a negative number.");
+      this.queue.splice(0, to - 1);
+    }
+    if (!this.playing && !this.queue.current) return this.play();
+    this.manager.emit("debug" /* Debug */, 3 /* Player */, `[Player] -> [Skip] Skipping to next track for guild: ${this.guildId}`);
+    await this.node.stopPlayer(this.guildId);
+  }
+  /**
+   *
+   * Seek to a specific position in the current track.
+   * @param {number} position The position to seek to in milliseconds.
+   * @returns {Promise<void>}
+   * @throws {PlayerError} If the position is invalid.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.seek(30000); // seek to 30 seconds
+   * ```
+   */
+  async seek(position) {
+    if (typeof position !== "number" || Number.isNaN(position) || position < 0)
+      throw new PlayerError("Position must be a positive number.");
+    this.manager.emit("debug" /* Debug */, 3 /* Player */, `[Player] -> [Seek] Seeking to ${position} for guild: ${this.guildId}`);
+    await this.updatePlayer({ playerOptions: { position } });
+  }
+  /**
+   *
+   * Disconnect the player from the voice channel.
+   * @returns {Promise<this>} The player instance.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.disconnect();
+   * ```
+   */
+  async disconnect() {
+    if (!this.voiceId) return this;
+    await this.manager.options.sendPayload(this.guildId, {
+      op: 4,
+      d: {
+        guild_id: this.guildId,
+        channel_id: null,
+        self_deaf: this.selfDeaf,
+        self_mute: this.selfMute
+      }
+    });
+    this.manager.emit("debug" /* Debug */, 3 /* Player */, `[Player] -> [Disconnect] Player disconnected for guild: ${this.guildId}`);
+    this.connected = false;
+    return this;
+  }
+  /**
+   *
+   * Destroy and disconnect the player.
+   * @param {DestroyReasons} [reason] The reason for destroying the player.
+   * @returns {Promise<void>}
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.destroy(DestroyReasons.Stop);
+   * ```
+   */
+  async destroy(reason = "Player-Stop" /* Stop */) {
+    await this.disconnect();
+    await this.node.destroyPlayer(this.guildId);
+    this.manager.emit("playerDestroy" /* PlayerDestroy */, this, reason);
+    this.manager.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Player] -> [Destroy] Destroyed player for guild: ${this.guildId} | Reason: ${reason}`
+    );
+    return this.manager.deletePlayer(this.guildId);
+  }
+  /**
+   *
+   * Play a track in the player.
+   * @param {Partial<PlayOptions>} [options] The options to play the track.
+   * @returns {Promise<void>}
+   * @throws {PlayerError} If there are no tracks to play.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   *
+   * player.play({
+   * 	track: track,
+   * 	noReplace: true,
+   * });
+   * ```
+   */
+  async play(options = {}) {
+    if (typeof options !== "object") throw new PlayerError("The play options must be an object.");
+    if (options.track) this.queue.current = await validateTrack(this, options.track);
+    else if (!this.queue.current) this.queue.current = await validateTrack(this, this.queue.shift());
+    if (!this.queue.current) throw new PlayerError("No track to play.");
+    if (!isTrack(this.queue.current) && !isUnresolvedTrack(this.queue.current))
+      throw new PlayerError("The track must be a valid Track or UnresolvedTrack instance.");
+    this.manager.emit("debug" /* Debug */, 3 /* Player */, `[Player] -> [Play] A new track is playing: ${this.queue.current.info.title}`);
+    await this.updatePlayer({
+      noReplace: options.noReplace,
+      playerOptions: {
+        ...options,
+        track: {
+          userData: this.queue.current.userData,
+          encoded: this.queue.current.encoded
+        }
+      }
+    });
+    return;
+  }
+  /**
+   * Connect the player to the voice channel.
+   * @returns {Promise<this>} The player instance.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.connect();
+   * ```
+   */
+  async connect() {
+    if (!this.voiceId) return this;
+    await this.manager.options.sendPayload(this.guildId, {
+      op: 4,
+      d: {
+        guild_id: this.guildId,
+        channel_id: this.voiceId,
+        self_deaf: this.selfDeaf,
+        self_mute: this.selfMute
+      }
+    });
+    this.manager.emit("debug" /* Debug */, 3 /* Player */, `[Player] -> [Connect] Player connected for guild: ${this.guildId}`);
+    this.connected = true;
+    return this;
+  }
+  /**
+   *
+   * Stop the player from playing.
+   * @param {boolean} [destroy=true] Whether to destroy the player or not.
+   * @returns {Promise<void>}
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.stop();
+   * ```
+   */
+  async stop(destroy = true) {
+    await this.node.stopPlayer(this.guildId);
+    if (destroy) await this.destroy("Player-Stop" /* Stop */);
+    this.manager.emit("debug" /* Debug */, 3 /* Player */, `[Player] -> [Stop] Player stopped for guild: ${this.guildId}`);
+    this.playing = false;
+    this.paused = false;
+    this.position = 0;
+    this.queue.current = null;
+    return;
+  }
+  /**
+   *
+   * Pause or resume the player.
+   * @returns {Promise<void>}
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.setPaused();
+   * ```
+   */
+  async setPaused(paused = !this.paused) {
+    this.manager.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Player] -> [Pause] Player is now ${paused ? "paused" : "resumed"} for guild: ${this.guildId}`
+    );
+    await this.updatePlayer({ playerOptions: { paused } });
+    return paused;
+  }
+  /**
+   *
+   * Set the volume of the player.
+   * @param {number} volume The volume to set.
+   * @returns {Promise<void>}
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.setVolume(50); // set the volume to 50%
+   * ```
+   */
+  async setVolume(volume) {
+    if (typeof volume !== "number" || Number.isNaN(volume) || volume < 0 || volume > 100)
+      throw new PlayerError("Volume must be a number between 0 and 100.");
+    await this.updatePlayer({ playerOptions: { volume } });
+    this.volume = volume;
+    this.manager.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Player] -> [Volume] Player volume set to ${volume}% for guild: ${this.guildId}`
+    );
+    return;
+  }
+  /**
+   *
+   * Set the loop mode of the player.
+   * @param {LoopMode} mode The loop mode to set.
+   * @throws {PlayerError} If the loop mode is invalid.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.setLoop(LoopMode.Track);
+   * ```
+   */
+  setLoop(mode) {
+    const loopValues = Object.values(LoopMode).filter((v) => typeof v === "number");
+    if (!loopValues.includes(mode)) throw new PlayerError(`Invalid loop mode. Valid modes are: ${loopValues.join(", ")}`);
+    this.loop = mode;
+    this.manager.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Player] -> [Loop] Player loop mode set to ${mode} for guild: ${this.guildId}`
+    );
+    return this;
+  }
+  /**
+   * Set the voice of the player.
+   * @param {Partial<VoiceChannelUpdate>} voice The voice state to set.
+   * @returns {Promise<void>}
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.setVoice({ voiceId: "newVoiceId" });
+   * ```
+   */
+  async setVoice(voice) {
+    if (voice.voiceId === this.voiceId) return;
+    if (voice.voiceId) {
+      this.voiceId = voice.voiceId;
+      this.options.voiceId = voice.voiceId;
+    }
+    if (voice.selfDeaf) {
+      this.selfDeaf = voice.selfDeaf;
+      this.options.selfDeaf = voice.selfDeaf;
+    }
+    if (voice.selfMute) {
+      this.selfMute = voice.selfMute;
+      this.options.selfMute = voice.selfMute;
+    }
+    await this.manager.options.sendPayload(this.guildId, {
+      op: 4,
+      d: {
+        guild_id: this.guildId,
+        self_deaf: this.selfDeaf,
+        self_mute: this.selfMute,
+        channel_id: this.voiceId ?? null
+      }
+    });
+    this.manager.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Player] -> [VoiceState] Updated voice state for guild: ${this.guildId} with voiceId: ${this.voiceId}`
+    );
+  }
+  /**
+   *
+   * Change the node the player is connected to.
+   * @param {NodeIdentifier} node The node to change to.
+   * @returns {Promise<void>} A promise that resolves when the node has been changed.
+   * @throws {PlayerError} If the target node is not found, not connected, or missing source managers.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * player.move("newNodeId");
+   * ```
+   */
+  async move(node) {
+    const id = typeof node === "string" ? node : node.id;
+    const target = this.manager.nodeManager.get(id);
+    if (!target) throw new PlayerError("Target node not found.");
+    if (!target.info) throw new PlayerError("Target node info not available.");
+    if (target.state !== 2 /* Connected */) throw new PlayerError("Target node is not connected.");
+    if (target.id === this.node.id) return;
+    if (this.queue.current || this.queue.size) {
+      const sources = [this.queue.current, ...this.queue.tracks].filter((t) => t != null || typeof t !== "undefined").map((t) => t.info.sourceName).filter((s) => s != null || typeof s !== "undefined");
+      const missings = [...new Set(sources)].filter((s) => !target.info.sourceManagers.includes(s));
+      if (missings.length) throw new PlayerError(`Target node is missing source managers for: ${missings.join(", ")}`);
+    }
+    const current = this.queue.current;
+    if (!this.voice.endpoint || !this.voice.sessionId || !this.voice.token)
+      throw new PlayerError("Player voice connection data is incomplete.");
+    if (this.node.state === 2 /* Connected */) await this.node.destroyPlayer(this.guildId);
+    this.node = target;
+    await this.updatePlayer({
+      playerOptions: {
+        voice: this.voice,
+        ...current && {
+          track: current.encoded,
+          position: this.position,
+          volume: this.volume
+        }
+      }
+    });
+    await this.filterManager.apply();
+    this.manager.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Player] -> [Move] Player moved to node: ${target.id} for guild: ${this.guildId}`
+    );
+  }
+  /**
+   * Update the player with new data.
+   * @param {NonGuildUpdatePlayerInfo} data The data to update the player with.
+   * @returns {Promise<LavalinkPlayer | null>} The updated player data.
+   */
+  async updatePlayer(data) {
+    return this.node.updatePlayer({
+      guildId: this.guildId,
+      ...data
+    });
+  }
+  /**
+   *
+   * Return the player as a json object.
+   * @returns {PlayerJson}
+   * @example
+   * ```ts
+   * const player = manager.getPlayer("guildId");
+   * const json = player.toJSON();
+   * console.log(json); // the player as a json object
+   * ```
+   */
+  toJSON() {
+    return {
+      volume: this.volume,
+      loop: this.loop,
+      paused: this.paused,
+      playing: this.playing,
+      voiceId: this.voiceId,
+      guildId: this.guildId,
+      selfMute: this.selfMute,
+      selfDeaf: this.selfDeaf,
+      options: this.options,
+      voice: this.voice,
+      queue: this.queue.toJSON(),
+      node: this.node.toJSON()
+    };
+  }
+};
+
+// src/classes/queue/Store.ts
+var QueueStore = class {
+  /**
+   * Storage manager instance.
+   * @type {StorageAdapter}
+   * @private
+   * @readonly
+   * @internal
+   */
+  storage;
+  /**
+   *
+   * Constructor of the queue store.
+   * @param {StorageAdapter} storage Storage manager instance.
+   * @example
+   * ```ts
+   * const storage = new CustomStorage();
+   * const queueStore = new QueueStore(storage);
+   *
+   * console.log(queueStore);
+   * ```
+   */
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   *
+   * Get the value using the key.
+   * @param {string} key The key to get the value from.
+   * @returns <Awaitable<QueueJson | undefined>> The value of the key.
+   * @example
+   * ```ts
+   * const value = await queueStore.get("key");
+   * console.log(value); // { id: "key", data: "value" }
+   * ```
+   */
+  get(key) {
+    return this.storage.get(key);
+  }
+  /**
+   *
+   * Set the value using the key.
+   * @param {string} key The key to set the value to.
+   * @param {unknown} value The value to set.
+   * @returns <Awaitable<void>> Ganyu is the best waifu.
+   * @example
+   * ```ts
+   * await queueStore.set("key", { id: "key", data: "value" });
+   * ```
+   */
+  set(key, value) {
+    return this.storage.set(key, value);
+  }
+  /**
+   *
+   * Delete the value using the key.
+   * @param {string} key The key to delete the value from.
+   * @returns <Awaitable<boolean>> Returns true if the key was deleted.
+   * @example
+   * ```ts
+   * const success = await queueStore.delete("key");
+   * console.log(success); // true
+   * ```
+   */
+  delete(key) {
+    return this.storage.delete(key);
+  }
+};
+
+// src/classes/queue/Utils.ts
+var QueueUtils = class {
+  /**
+   * Player instance.
+   * @type {Queue}
+   * @private
+   * @readonly
+   * @internal
+   */
+  queue;
+  /**
+   * Queue store.
+   * @type {QueueStore}
+   * @private
+   * @readonly
+   * @internal
+   */
+  store;
+  /**
+   * Options for the queue.
+   * @type {HoshimiQueueOptions}
+   * @private
+   * @readonly
+   * @internal
+   */
+  options;
+  /**
+   *
+   * Constructor of the queue utils.
+   * @param {QueueStructure} queue The queue instance.
+   */
+  constructor(queue) {
+    this.queue = queue;
+    this.options = queue.player.manager.options.queueOptions;
+    this.store = new QueueStore(this.options.storage);
+  }
+  /**
+   *
+   * Save the queue.
+   * @returns {Awaitable<void>}
+   * @example
+   * ```ts
+   * await player.queue.utils.save();
+   * ```
+   */
+  save() {
+    const max = this.options.maxPreviousTracks;
+    const length = this.queue.tracks.length;
+    const json = this.queue.toJSON();
+    if (length > max) this.queue.history.splice(0, length - max);
+    this.queue.player.manager.emit(
+      "debug" /* Debug */,
+      5 /* Queue */,
+      `[Queue] -> [Adapter] Saving queue for ${this.queue.player.guildId} | Object: ${JSON.stringify(json)}`
+    );
+    return this.store.set(this.queue.player.guildId, json);
+  }
+  /**
+   *
+   * Destroy the queue.
+   * @returns {Promise<void>}
+   * @example
+   * ```ts
+   * await player.queue.utils.destroy();
+   * ```
+   */
+  destroy() {
+    this.queue.player.manager.emit(
+      "debug" /* Debug */,
+      5 /* Queue */,
+      `[Queue] -> [Adapter] Destroying queue for ${this.queue.player.guildId}`
+    );
+    return this.store.delete(this.queue.player.guildId);
+  }
+  /**
+   *
+   * Sync the queue.
+   * @returns {Awaitable<void>}
+   * @example
+   * ```ts
+   * await player.queue.utils.sync();
+   * ```
+   */
+  async sync(override = true, syncCurrent = false) {
+    const data = await this.store.get(this.queue.player.guildId);
+    if (!data) throw new StorageError(`No data found to sync for guildId: ${this.queue.player.guildId}`);
+    if (syncCurrent && data.current && !this.queue.current && isTrack(data.current)) this.queue.current = data.current;
+    const tracks = data.tracks.filter((track) => isTrack(track)) || [];
+    const history = data.history.filter((track) => isTrack(track)) || [];
+    const length = this.queue.tracks.length;
+    if (tracks.length) this.queue.tracks.splice(override ? 0 : length, override ? length : 0, ...tracks);
+    if (history.length) this.queue.history.splice(0, override ? length : 0, ...history);
+    this.queue.player.manager.emit(
+      "debug" /* Debug */,
+      5 /* Queue */,
+      `[Queue] -> [Adapter] Syncing queue for ${this.queue.player.guildId} | Object: ${JSON.stringify(data)}`
+    );
+    await this.save();
+  }
+};
+
+// src/classes/queue/Queue.ts
+var Queue = class {
+  /**
+   * Tracks of the queue.
+   * @type {HoshimiTrack[]}
+   */
+  tracks = [];
+  /**
+   * Previous tracks of the queue.
+   * @type {Track[]}
+   */
+  history = [];
+  /**
+   * Current track of the queue.
+   * @type {Track | null}
+   */
+  current = null;
+  /**
+   * The player instance.
+   * @type {PlayerStructure}
+   */
+  player;
+  /**
+   * The queue utils instance.
+   * @type {QueueUtils}
+   * @readonly
+   */
+  utils;
+  /**
+   *
+   * Constructor of the queue.
+   * @param {PlayerStructure} player Player instance.
+   * @example
+   * ```ts
+   * const player = new Player();
+   * const queue = new Queue(player);
+   *
+   * console.log(queue.size); // 0
+   * queue.add(track);
+   * console.log(queue.size); // 1
+   * ```
+   */
+  constructor(player) {
+    this.player = player;
+    this.utils = new QueueUtils(this);
+  }
+  /**
+   * Get the track size of the queue.
+   * @type {number}
+   * @returns {number} The track size of the queue.
+   * @readonly
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.size); // 0
+   * queue.add(track);
+   *
+   * console.log(queue.size); // 1
+   * queue.add([track1, track2]);
+   *
+   * console.log(queue.size); // 3
+   * queue.shift();
+   * console.log(queue.size); // 2
+   *
+   * queue.clear();
+   * console.log(queue.size); // 0
+   * ```
+   */
+  get size() {
+    return this.tracks.length;
+  }
+  /**
+   * Get the total track size of the queue (Includes the current track).
+   * @type {number}
+   * @returns {number} The total track size of the queue.
+   * @readonly
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.totalSize); // 0
+   * queue.add(track);
+   *
+   * console.log(queue.totalSize); // 1
+   * queue.add([track1, track2]);
+   *
+   * console.log(queue.totalSize); // 3
+   * queue.shift();
+   * console.log(queue.totalSize); // 2
+   *
+   * queue.clear();
+   * console.log(queue.totalSize); // 0
+   * ```
+   */
+  get totalSize() {
+    return this.size + Number(!!this.current);
+  }
+  /**
+   *
+   * Check if the queue is empty.
+   * @type {boolean}
+   * @returns {boolean} True if the queue is empty.
+   * @readonly
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.isEmpty()); // true
+   * queue.add(track);
+   *
+   * console.log(queue.isEmpty()); // false
+   * queue.clear();
+   *
+   * console.log(queue.isEmpty()); // true
+   * ```
+   */
+  isEmpty() {
+    return this.size === 0;
+  }
+  /**
+   *
+   * Get the previous track of the queue.
+   * @param {boolean} [remove=false] Whether to remove the track from the previous queue.
+   * @returns {Track | null} The previous track of the queue.
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.previous()); // null
+   * queue.add(track);
+   * queue.add(track2);
+   *
+   * console.log(queue.previous()); // track
+   * console.log(queue.previous(true)); // track and remove it from the previous tracks
+   * ```
+   */
+  previous(remove = false) {
+    if (remove) return this.history.shift() ?? null;
+    return this.history[0] ?? null;
+  }
+  /**
+   *
+   * Add a track or tracks to the queue.
+   * @param {Track | Track[]} track The track or tracks to add.
+   * @param {number} [position] The position to add the track or tracks.
+   * @returns {this} The queue instance.
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.size); // 0
+   *
+   * queue.add(track);
+   * console.log(queue.size); // 1
+   *
+   * queue.add([track1, track2]);
+   * console.log(queue.size); // 3
+   *
+   * queue.add(track3, 1);
+   * console.log(queue.size); // 4
+   * console.log(queue.tracks); // [track1, track3, track2, track]
+   * ```
+   */
+  add(track, position) {
+    const tracks = Array.isArray(track) ? track : [track];
+    if (typeof position === "number" && position >= 0 && position < this.tracks.length) return this.splice(position, 0, ...tracks);
+    this.tracks.push(...tracks);
+    this.player.manager.emit("queueUpdate" /* QueueUpdate */, this.player, this);
+    this.player.manager.emit("debug" /* Debug */, 5 /* Queue */, `[Queue] -> [Add] Added ${this.tracks.length} tracks to the queue.`);
+    return this;
+  }
+  /**
+   *
+   * Get the first track of the queue.
+   * @returns {HoshimiTrack | null} The first track of the queue.
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.shift()); // null
+   * queue.add(track);
+   *
+   * console.log(queue.shift()); // track
+   * queue.add(track2);
+   * ```
+   */
+  shift() {
+    return this.tracks.shift() ?? null;
+  }
+  /**
+   *
+   * Add tracks to the beginning of the queue.
+   * @param {Track[]} tracks The tracks to add.
+   * @returns {this} The queue instance.
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.size); // 0
+   * queue.unshift(track);
+   *
+   * console.log(queue.size); // 1
+   * queue.unshift([track1, track2]);
+   *
+   * console.log(queue.size); // 3
+   * console.log(queue.tracks); // [track1, track2, track]
+   * ```
+   */
+  unshift(...tracks) {
+    this.tracks.unshift(...tracks);
+    this.player.manager.emit("debug" /* Debug */, 5 /* Queue */, `[Queue] -> [Unshift] Added ${this.tracks.length} tracks to the queue.`);
+    return this;
+  }
+  /**
+   *
+   * Shuffle the queue.
+   * @returns {this} The queue instance.
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.size); // 0
+   * queue.add(track);
+   * queue.add([track1, track2]);
+   *
+   * console.log(queue.size); // 3
+   * console.log(queue.tracks); // [track, track1, track2]
+   *
+   * queue.shuffle();
+   * console.log(queue.tracks); // [track2, track, track1]
+   * ```
+   */
+  shuffle() {
+    if (this.size <= 1) return this;
+    if (this.size === 2) [this.tracks[0], this.tracks[1]] = [this.tracks[1], this.tracks[0]];
+    else {
+      for (let i = this.tracks.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [this.tracks[i], this.tracks[j]] = [this.tracks[j], this.tracks[i]];
+      }
+    }
+    this.player.manager.emit("queueUpdate" /* QueueUpdate */, this.player, this);
+    this.player.manager.emit("debug" /* Debug */, 5 /* Queue */, "[Queue] -> [Shuffle] Shuffled the queue.");
+    return this;
+  }
+  /**
+   *
+   * Clear the queue.
+   * @returns {this} The queue instance.
+   * @example
+   * ```ts
+   * const queue = player.queue;
+   *
+   * console.log(queue.size); // 0
+   * queue.add(track);
+   * queue.add([track1, track2]);
+   *
+   * console.log(queue.size); // 3
+   * queue.clear();
+   * console.log(queue.size); // 0
+   * ```
+   */
+  clear() {
+    this.tracks = [];
+    this.history = [];
+    this.current = null;
+    this.player.manager.emit("queueUpdate" /* QueueUpdate */, this.player, this);
+    this.player.manager.emit("debug" /* Debug */, 5 /* Queue */, "[Queue] -> [Clear] Cleared the queue.");
+    return this;
+  }
+  /**
+   *
+   * Move a track to a specific position in the queue.
+   * @param {Track} track The track to move.
+   * @param {number} to The position to move.
+   * @returns {this} The queue instance.
+   */
+  move(track, to) {
+    const index = this.tracks.indexOf(track);
+    if (index === -1) return this;
+    this.splice(index, 1);
+    this.add(track, to - 1);
+    this.player.manager.emit("queueUpdate" /* QueueUpdate */, this.player, this);
+    this.player.manager.emit("debug" /* Debug */, 5 /* Queue */, `[Queue] -> [Move] Moved track ${track.info.title} to position ${to}.`);
+    return this;
+  }
+  /**
+   *
+   * Delete tracks from the queue.
+   * @param {number} start The start index.
+   * @param {number} deleteCount The number of tracks to delete.
+   * @param {Track | Track[]} [tracks] The tracks to add.
+   * @returns {this} The queue instance.
+   */
+  splice(start, deleteCount, tracks) {
+    if (!this.size && tracks) this.add(tracks);
+    if (tracks) this.tracks.splice(start, deleteCount, ...Array.isArray(tracks) ? tracks : [tracks]);
+    else this.tracks.splice(start, deleteCount);
+    this.player.manager.emit("queueUpdate" /* QueueUpdate */, this.player, this);
+    this.player.manager.emit("debug" /* Debug */, 5 /* Queue */, `[Queue] -> [Splice] Removed ${deleteCount} tracks from the queue.`);
+    return this;
+  }
+  /**
+   *
+   * Convert the queue to a JSON object.
+   * @returns {QueueJson} The queue JSON object.
+   */
+  toJSON() {
+    const max = this.player.manager.options.queueOptions.maxPreviousTracks;
+    if (this.history.length > max) this.history.splice(max, this.history.length);
+    return {
+      tracks: this.tracks,
+      history: this.history,
+      current: this.current
+    };
+  }
+};
+
+// src/types/Structures.ts
+var Structures = {
+  Player(...args) {
+    return new Player(...args);
+  },
+  Rest(...args) {
+    return new Rest(...args);
+  },
+  Node(...args) {
+    return new Node(...args);
+  },
+  Queue(...args) {
+    return new Queue(...args);
+  },
+  LyricsManager(...args) {
+    return new LyricsManager(...args);
+  },
+  NodeManager(...args) {
+    return new NodeManager(...args);
+  },
+  FilterManager(...args) {
+    return new FilterManager(...args);
+  }
+};
+
+// src/classes/node/Node.ts
+var Node = class {
+  /**
+   * The options for the node.
+   * @type {Required<NodeOptions>}
+   */
+  options;
+  /**
+   * The REST for the node.
+   * @type {RestStructure}
+   */
+  rest;
+  /**
+   * The manager for the node.
+   * @type {NodeManagerStructure}
+   */
+  nodeManager;
+  /**
+   * The lyrics manager for the node.
+   * @type {LyricsManager}
+   */
+  lyricsManager;
+  /**
+   * The delay between reconnect attempts.
+   * @type {number}
+   */
+  retryDelay;
+  /**
+   * The amount of reconnect attempts left.
+   * @type {number}
+   */
+  retryAmount;
+  /**
+   * The WebSocket for the node.
+   * @type {WebSocket | null}
+   */
+  ws = null;
+  /**
+   * The state of the node.
+   * @type {State}
+   */
+  state = 7 /* Idle */;
+  /**
+   * The session id of the node.
+   */
+  sessionId = null;
+  /**
+   * The interval for the reconnect.
+   * @type {NodeJS.Timeout | null}
+   */
+  reconnectTimeout = null;
+  /**
+   * The public stats of the node.
+   * @type {Stats | null}
+   */
+  stats = null;
+  /**
+   * The public info of the node.
+   * @type {NodeInfo | null}
+   */
+  info = null;
+  /**
+   * The session of the node.
+   * @type {NullableLavalinkSession}
+   */
+  session = {
+    timeout: null,
+    resuming: false
+  };
+  /**
+   *
+   * Create a new Lavalink node.
+   * @param {NodeManagerStructure} nodeManager The manager for the node.
+   * @param {NodeOptions} options The options for the node.
+   * @example
+   * ```ts
+   * const node = new Node(nodeManager, {
+   * 	host: "localhost",
+   * 	port: 2333,
+   * 	password: "youshallnotpass",
+   * 	id: "node1",
+   * 	secure: false,
+   * 	retryAmount: 5,
+   * 	retryDelay: 20000,
+   * 	restTimeout: 10000,
+   * 	sessionId: null,
+   * });
+   *
+   * node.connect();
+   * console.log(node.id); // node1
+   * console.log(node.address); // ws://localhost:2333/v4/websocket
+   * console.log(node.penalties); // the penalties of the node
+   * console.log(node.state); // the state of the node
+   * ```
+   */
+  constructor(nodeManager, options) {
+    this.options = {
+      ...options,
+      sessionId: options.sessionId ?? "",
+      id: options.id ?? `${options.host}:${options.port}`,
+      restTimeout: options.restTimeout ?? 1e4,
+      secure: options.secure ?? false,
+      retryAmount: options.retryAmount ?? 5,
+      retryDelay: options.retryDelay ?? 2e4
+    };
+    this.retryAmount = this.options.retryAmount;
+    this.retryDelay = this.options.retryDelay;
+    this.nodeManager = nodeManager;
+    if (this.options.secure && this.options.port !== 443) this.options.port = 443;
+    this.rest = Structures.Rest(this);
+    this.lyricsManager = Structures.LyricsManager(this);
+  }
+  /**
+   * The decode methods for the node.
+   * @type {DecodeMethods}
+   * @readonly
+   */
+  decode = {
+    single: async (track, requester) => {
+      const raw = await this.rest.request({
+        endpoint: "/decodetrack",
+        params: { encodedTrack: track }
+      });
+      return new Track(raw, requester);
+    },
+    multiple: async (tracks, requester) => {
+      const raw = await this.rest.request({
+        endpoint: "/decodetracks",
+        method: "POST" /* Post */,
+        body: JSON.stringify(tracks)
+      }) ?? [];
+      return raw.map((track) => new Track(track, requester));
+    }
+  };
+  /**
+   * The id of the node.
+   * @type {string}
+   * @readonly
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) {
+   * 	console.log(node.id); // node1
+   * }
+   * ```
+   */
+  get id() {
+    return this.options.id;
+  }
+  /**
+   * The socket address to connect the node.
+   * @type {string}
+   * @readonly
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) {
+   * 	console.log(node.id); // node1
+   * 	console.log(node.address); // ws://localhost:2333/v4/websocket
+   * }
+   * }
+   */
+  get address() {
+    return `${this.options.secure ? "wss" : "ws"}://${this.options.host}:${this.options.port}/${this.rest.version}/websocket`;
+  }
+  /**
+   * The penalties of the node.
+   * @type {number}
+   * @readonly
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) {
+   * 	console.log(node.id); // node1
+   * 	console.log(node.address); // ws://localhost:2333/v4/websocket
+   * 	console.log(node.penalties); // the penalties of the node
+   * }
+   * ```
+   */
+  get penalties() {
+    if (!this.stats) return 0;
+    const { players, cpu, frameStats } = this.stats;
+    const cpuPenalty = Math.round(1.05 ** (100 * cpu.systemLoad) * 10 - 10);
+    const framePenalty = frameStats ? frameStats.deficit + frameStats.nulled * 2 : 0;
+    return players + cpuPenalty + framePenalty;
+  }
+  /**
+   *
+   * Search for a query.
+   * @param {SearchQuery} search The query to search for.
+   * @returns {Promise<LavalinkSearchResponse | null>}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) {
+   * 	const search = await node.search({
+   * 		query: "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+   * 		engine: SearchEngines.Youtube,
+   * 	});
+   *
+   * 	console.log(search); // the search result
+   * }
+   * ```
+   */
+  search(search) {
+    search.engine ??= this.nodeManager.manager.options.defaultSearchEngine;
+    const identifier = validateQuery(search);
+    return this.rest.request({
+      endpoint: "/loadtracks",
+      params: {
+        identifier,
+        ...search.params
+      }
+    });
+  }
+  /**
+   * Connect the node to the websocket.
+   * @returns {void}
+   * @throws {NodeError} If the client data is not valid
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) node.connect();
+   * ```
+   */
+  connect() {
+    if (!this.nodeManager.manager.options.client)
+      throw new NodeError({
+        message: "No valid client data provided.",
+        id: this.id
+      });
+    if (!this.nodeManager.manager.options.client.id)
+      throw new NodeError({
+        message: "No valid client id provided.",
+        id: this.id
+      });
+    this.state = 1 /* Connecting */;
+    const headers = {
+      Authorization: this.options.password,
+      "User-Id": this.nodeManager.manager.options.client.id,
+      "Client-Name": this.nodeManager.manager.options.client.username,
+      "User-Agent": this.rest.userAgent
+    };
+    if (this.options.sessionId) {
+      headers["Session-Id"] = this.options.sessionId;
+      this.sessionId = this.options.sessionId;
+      this.nodeManager.manager.emit(
+        "debug" /* Debug */,
+        2 /* Node */,
+        `[Socket] -> [${this.id}]: The session id is present. | Session: ${this.sessionId} | Resuming: ${this.session.resuming}`
+      );
+    }
+    this.ws = new import_ws.WebSocket(this.address, { headers: { ...headers } });
+    this.ws.on("upgrade", onOpen.bind(this));
+    this.ws.on("close", onClose.bind(this));
+    this.ws.on("error", onError.bind(this));
+    this.ws.on("message", onMessage.bind(this));
+    this.nodeManager.manager.emit(
+      "debug" /* Debug */,
+      2 /* Node */,
+      `[Socket] -> [${this.id}]: Connecting to ${this.address} | State: ${this.state} | Session: ${this.sessionId} | Resumed: ${this.session.resuming} | Penalties: ${this.penalties} | Reconnects: ${this.retryAmount} | Headers: ${JSON.stringify(headers)}`
+    );
+  }
+  /**
+   *
+   * Stop the track in player for the guild.
+   * @param {string} guildId the guild id to stop the player
+   * @returns {Promise<LavalinkPlayer | null>}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) {
+   * 	const player = await node.stopPlayer("guildId");
+   * 	console.log(player); // the lavalink player
+   * }
+   * ```
+   */
+  stopPlayer(guildId) {
+    return this.rest.stopPlayer(guildId);
+  }
+  /**
+   *
+   * Update the player data.
+   * @param {Partial<UpdatePlayerInfo>} data The player data to update.
+   * @returns {Promise<LavalinkPlayer | null>}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) {
+   * 	const player = await node.updatePlayer({
+   * 		guildId: "guildId",
+   * 		noReplace: true,
+   * 		playerOptions: {
+   * 			paused: false,
+   * 			track: { encoded: "encoded track" },
+   * 		},
+   * 	});
+   *
+   * 	console.log(player); // the lavalink player
+   * }
+   * ```
+   */
+  updatePlayer(data) {
+    return this.rest.updatePlayer(data);
+  }
+  /**
+   * Destroy the player.
+   * @returns {Promise<void>}
+   * @param {string} guildId The guild id to destroy the player.
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) await node.destroyPlayer("guildId");
+   * console.log("Player destroyed");
+   * ```
+   */
+  destroyPlayer(guildId) {
+    return this.rest.destroyPlayer(guildId);
+  }
+  /**
+   *
+   * Disconnect the node from the websocket.
+   * @param {NodeDisconnectInfo} [disconnect] The disconnect options for the node.
+   * @returns {void}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) node.disconnect();
+   * console.log("Node disconnected");
+   * ```
+   */
+  disconnect(disconnect = {}) {
+    if (this.state !== 2 /* Connected */) return;
+    this.ws?.close(disconnect.code, disconnect.reason);
+    this.ws?.removeAllListeners();
+    this.ws = null;
+    this.state = 3 /* Disconnected */;
+    this.retryAmount = this.options.retryAmount;
+    if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+    this.nodeManager.manager.emit("nodeDisconnect" /* NodeDisconnect */, this);
+  }
+  /**
+   *
+   * Destroy the node.
+   * @param {NodeDestroyInfo} [destroy] The destroy options for the node.
+   * @returns {void}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) node.destroy();
+   * console.log("Node destroyed");
+   * ```
+   */
+  destroy(destroy = {}) {
+    if (this.state !== 2 /* Connected */) return;
+    this.ws?.close(destroy.code, destroy.reason);
+    this.ws?.removeAllListeners();
+    this.ws = null;
+    this.state = 6 /* Destroyed */;
+    this.retryAmount = 0;
+    if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+    this.nodeManager.manager.emit("nodeDestroy" /* NodeDestroy */, this, destroy);
+    this.nodeManager.delete(this.id);
+  }
+  /**
+   *
+   * Update the session for the node
+   * @param {boolean} resuming Enable resuming for the session.
+   * @param {number | null} timeout The timeout for the session.
+   * @returns {Promise<LavalinkSession | null>}
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) {
+   * 	const session = await node.updateSession(true, 60);
+   * 	console.log(session); // the lavalink session
+   * }
+   * ```
+   */
+  async updateSession(resuming, timeout = null) {
+    if (!this.sessionId) return null;
+    const session = await this.rest.updateSession(resuming, timeout);
+    if (session) this.session = session;
+    return session;
+  }
+  /**
+   * Reconnect the node.
+   * @returns {void}
+   * @throws {NodeError} If the node is not connected
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) node.reconnect();
+   * console.log("Node reconnected");
+   * ```
+   */
+  reconnect() {
+    this.state = 7 /* Idle */;
+    this.nodeManager.manager.emit("nodeReconnecting" /* NodeReconnecting */, this, this.retryAmount, this.retryDelay);
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      if (this.retryAmount === 0) {
+        this.destroy({
+          code: 1e3 /* NormalClosure */,
+          reason: "Node-Destroy" /* Destroy */
+        });
+        this.nodeManager.manager.emit(
+          "nodeError" /* NodeError */,
+          this,
+          new NodeError({
+            message: `Failed to reconnect after ${this.options.retryAmount} retries.`,
+            id: this.id
+          })
+        );
+        return;
+      }
+      this.ws?.removeAllListeners();
+      this.ws = null;
+      this.retryAmount--;
+      this.connect();
+    }, this.options.retryDelay);
+  }
+  /**
+   *
+   * Convert the node to JSON.
+   * @returns {NodeJson} The JSON representation of the node.
+   * @example
+   * ```ts
+   * const node = manager.nodeManager.get("node1");
+   * if (node) {
+   * 	const json = node.toJSON();
+   * 	console.log(json);
+   * }
+   * ```
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      sessionId: this.sessionId
+    };
+  }
+};
+
+// src/classes/queue/adapters/memory.ts
+var MemoryAdapter = class extends StorageAdapter {
+  /**
+   * Memory storage.
+   * @type {Map<string, QueueJson>}
+   * @private
+   * @readonly
+   * @internal
+   */
+  storage = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.parse(this.storage.get(key));
+  }
+  set(key, value) {
+    this.storage.set(key, this.stringify(value));
+  }
+  delete(key) {
+    return this.storage.delete(key);
+  }
+  clear() {
+    this.storage.clear();
+  }
+  has(key) {
+    return this.storage.has(key);
+  }
+  parse(value) {
+    return value;
+  }
+  stringify(value) {
+    return value;
+  }
+};
+
+// src/classes/Hoshimi.ts
+var import_node_events = require("events");
+
+// src/util/functions/autoplay.ts
+var maxTracks = 10;
+async function autoplayFn(player, lastTrack) {
+  if (!lastTrack) return;
+  const isEnabled = !!player.data.get("enabledAutoplay") || player.manager.options.queueOptions.autoPlay;
+  if (!isEnabled) return;
+  const filter = (tracks) => tracks.filter(
+    (track) => !(player.queue.history.some((t) => t.info.identifier === track.info.identifier) || lastTrack.info.identifier === track.info.identifier)
+  );
+  switch (lastTrack.info.sourceName) {
+    case "spotify" /* Spotify */: {
+      const filtered = player.queue.history.filter(({ info }) => info.sourceName === "spotify" /* Spotify */).slice(0, 1);
+      if (!filtered.length) filtered.push(lastTrack);
+      const ids = filtered.map(
+        ({ info }) => info.identifier ?? info.uri?.split("/").reverse()?.[0] ?? info.uri?.split("/").reverse()?.[1]
+      );
+      const res = await player.search({
+        query: `seed_tracks=${ids.join(",")}`,
+        engine: "sprec" /* SpotifyRecommendations */,
+        requester: lastTrack.requester
+      });
+      if (res.tracks.length) {
+        const index = Math.floor(Math.random() * res.tracks.length);
+        const track = filter(res.tracks)[index];
+        if (!track) return;
+        player.queue.add(track);
+      }
+      break;
+    }
+    case "youtube" /* Youtube */:
+    case "youtubemusic" /* YoutubeMusic */: {
+      const search = `https://www.youtube.com/watch?v=${lastTrack.info.identifier}&list=RD${lastTrack.info.identifier}`;
+      const res = await player.search({
+        query: search,
+        requester: lastTrack.requester
+      });
+      if (res.tracks.length) {
+        const random = Math.floor(Math.random() * res.tracks.length);
+        const tracks = filter(res.tracks).slice(random, random + maxTracks);
+        player.queue.add(tracks);
+      }
+    }
+  }
+}
+
+// src/classes/Hoshimi.ts
+var Hoshimi = class extends import_node_events.EventEmitter {
+  /**
+   * The options for the manager.
+   * @type {HoshimiOptions}
+   */
+  options;
+  /**
+   * The players for the manager.
+   * @type {Collection<string, PlayerStructure>}
+   * @readonly
+   */
+  players = new Collection();
+  /**
+   * THe node manager for the manager.
+   * @type {NodeManager}
+   * @readonly
+   */
+  nodeManager;
+  /**
+   * If the manager is ready.
+   * @type {boolean}
+   */
+  ready = false;
+  /**
+   * The constructor for the manager.
+   * @param {HoshimiOptions} options The options for the manager.
+   * @throws {ManagerError} If the options are not provided.
+   * @example
+   * ```ts
+   * const manager = new Hoshimi({
+   * 	nodes: [
+   * 		{
+   * 			host: "localhost",
+   * 			port: 2333,
+   * 			password: "youshallnotpass",
+   * 			secure: false,
+   * 		},
+   * 	],
+   * 	client: {
+   * 		id: "clientId",
+   * 		username: "clientUsername",
+   * 	},
+   * 	defaultSearchEngine: SearchEngines.Youtube,
+   * 	restOptions: {
+   * 		resumeTimeout: 10000,
+   * 	},
+   * 	nodeOptions: {
+   * 		userAgent: HoshimiAgent,
+   * 		resumable: false,
+   * 		resumeByLibrary: false,
+   * 	},
+   * 	queueOptions: {
+   * 		maxPreviousTracks: 25,
+   * 		autoplayFn: autoplayFn,
+   * 		autoPlay: false,
+   * 	},
+   * });
+   *
+   * console.log(manager); // The manager instance
+   * ```
+   */
+  constructor(options) {
+    super();
+    if (!options) throw new ManagerError("You must provide the options for the manager.");
+    this.options = {
+      ...options,
+      defaultSearchEngine: options.defaultSearchEngine ?? "ytsearch" /* Youtube */,
+      restOptions: {
+        resumeTimeout: options.restOptions?.resumeTimeout ?? 1e4
+      },
+      nodeOptions: {
+        userAgent: options.nodeOptions?.userAgent ?? HoshimiAgent,
+        resumable: options.nodeOptions?.resumable ?? false,
+        resumeByLibrary: options.nodeOptions?.resumeByLibrary ?? false,
+        resumeTimeout: options.nodeOptions?.resumeTimeout ?? 1e4
+      },
+      queueOptions: {
+        maxPreviousTracks: options.queueOptions?.maxPreviousTracks ?? 25,
+        autoplayFn: options.queueOptions?.autoplayFn ?? autoplayFn,
+        autoPlay: options.queueOptions?.autoPlay ?? false,
+        storage: options.queueOptions?.storage ?? new MemoryAdapter()
+      },
+      client: {
+        id: options.client?.id ?? "",
+        username: options.client?.username ?? "hoshimi-client"
+      }
+    };
+    validateManagerOptions(this.options);
+    this.nodeManager = Structures.NodeManager(this);
+  }
+  /**
+   * Check if the manager is useable.
+   * @returns {boolean} If the manager is useable.
+   * @example
+   * ```ts
+   * if (manager.isUseable()) {
+   * 	console.log("The manager is useable.");
+   * } else {
+   * 	console.log("The manager is not useable.");
+   * }
+   * ```
+   */
+  isUseable() {
+    const nodes = this.nodeManager.nodes.filter((node) => node.state === 2 /* Connected */);
+    return this.ready && nodes.length > 0;
+  }
+  /**
+   *
+   * Get the player for the guild.
+   * @param {string} guildId The guild id to get the player.
+   * @returns {PlayerStructure | undefined} The player for the guild.
+   * @example
+   * ```ts
+   * const player = manager.getPlayer(guildId);
+   * if (player) {
+   * 	console.log(`The player for ${guildId} is ${player}`);
+   * } else {
+   * 	console.log(`The player for ${guildId} is not found.`);
+   * }
+   * ```
+   */
+  getPlayer(guildId) {
+    return this.players.get(guildId);
+  }
+  /**
+   * Delete the player for the guild.
+   * @param {string} guildId The guild id to delete the player.
+   * @returns {boolean} If the player was deleted.
+   * @example
+   * ```ts
+   * const player = manager.deletePlayer(guildId);
+   * if (player) {
+   * 	console.log(`The player for ${guildId} was deleted.`);
+   * } else {
+   * 	console.log(`The player for ${guildId} was not found.`);
+   * }
+   * ```
+   */
+  deletePlayer(guildId) {
+    return this.players.delete(guildId);
+  }
+  /**
+   *
+   * Handle the raw packet for voice state and voice server updates.
+   * @param {GatewayPackets} packet The packet to handle
+   * @returns {Promise<void>}
+   * @example
+   * ```ts
+   * client.on("raw", (packet) => manager.updateVoiceState(packet));
+   * ```
+   */
+  async updateVoiceState(packet) {
+    if (!this.ready) {
+      this.emit("debug" /* Debug */, 3 /* Player */, "[Player] -> [Manager] The manager is not ready.");
+      return;
+    }
+    if (!("t" in packet)) {
+      this.emit("debug" /* Debug */, 3 /* Player */, "[Player] -> [Voice] The packet does not have a type.");
+      return;
+    }
+    switch (packet.t) {
+      case "CHANNEL_DELETE": {
+        const data = packet.d;
+        const player = this.getPlayer(data.guild_id);
+        if (!player) {
+          this.emit("debug" /* Debug */, 3 /* Player */, "[Player] -> [Voice] The player is not found.");
+          return;
+        }
+        if (data.id === player.voiceId) {
+          this.emit(
+            "debug" /* Debug */,
+            3 /* Player */,
+            `[Player] -> [Voice] The channel ${data.id} was deleted, disconnecting the player.`
+          );
+          await player.destroy("Player-VoiceChannelDeleted" /* VoiceChannelDeleted */);
+        } else {
+          this.emit(
+            "debug" /* Debug */,
+            3 /* Player */,
+            `[Player] -> [Voice] The channel ${data.id} was deleted, but it is not the player's channel.`
+          );
+        }
+        break;
+      }
+      case "VOICE_SERVER_UPDATE":
+      case "VOICE_STATE_UPDATE":
+        {
+          const data = packet.d;
+          if (!("guild_id" in data)) {
+            this.emit("debug" /* Debug */, 3 /* Player */, "[Player] -> [Voice] The guild id is missing.");
+            return;
+          }
+          if ("user_id" in data && data.user_id !== this.options.client?.id) {
+            this.emit("debug" /* Debug */, 3 /* Player */, "[Player] -> [Voice] The user id does not match the client id.");
+            return;
+          }
+          const player = this.getPlayer(data.guild_id);
+          if (!player) {
+            this.emit("debug" /* Debug */, 3 /* Player */, "[Player] -> [Voice] The player is not found.");
+            return;
+          }
+          if ("session_id" in data) player.voice.sessionId = data.session_id;
+          if ("token" in data) player.voice.token = data.token;
+          if ("endpoint" in data) player.voice.endpoint = data.endpoint;
+          if (player.voice.sessionId && player.voice.token && player.voice.endpoint) {
+            await player.node.updatePlayer({
+              guildId: data.guild_id,
+              playerOptions: {
+                voice: player.voice
+              }
+            });
+            this.emit(
+              "debug" /* Debug */,
+              3 /* Player */,
+              `[Player] -> [Voice] Updated the player voice for: ${data.guild_id} | Session: ${player.voice.sessionId} | Token: ${player.voice.token} | Endpoint: ${player.voice.endpoint}`
+            );
+            return;
+          }
+          this.emit("debug" /* Debug */, 3 /* Player */, `[Player] -> [Voice] The player voice is missing for: ${data.guild_id}`);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  /**
+   *
+   * Initialize the manager.
+   * @param {ClientData} info The client data to use.
+   * @returns {void}
+   * @example
+   * ```ts
+   * manager.init({
+   * 	id: "clientId",
+   * 	username: "clientUsername",
+   * });
+   * ```
+   */
+  init(info) {
+    if (this.ready) return;
+    this.options.client = {
+      ...this.options.client,
+      ...info
+    };
+    if (!this.options.client.id) throw new ManagerError("You must provide the client id.");
+    if (typeof this.options.client.id !== "string") throw new OptionError("The client info 'info.client.id': must be a string.");
+    let amount = 0;
+    for (const options of this.options.nodes) {
+      const node = this.nodeManager.create(options);
+      try {
+        node.connect();
+        amount++;
+      } catch (error) {
+        this.emit("nodeError" /* NodeError */, node, error);
+      }
+    }
+    this.ready = amount > 0;
+    this.emit(
+      "debug" /* Debug */,
+      3 /* Player */,
+      `[Manager] -> [Init] The manager is ready: ${this.ready} | Nodes: ${amount} of ${this.nodeManager.nodes.size}`
+    );
+  }
+  /**
+   *
+   * Create a new player.
+   * @param {PlayerOptions} options The options for the player.
+   * @returns {Player} The created player.
+   * @example
+   * ```ts
+   * const player = manager.createPlayer({
+   * 	guildId: "guildId",
+   * 	voiceId: "voiceId",
+   * });
+   *
+   * console.log(player); // The created player
+   *
+   * player.connect();
+   * player.play(track);
+   * ```
+   */
+  createPlayer(options) {
+    const oldPlayer = this.getPlayer(options.guildId);
+    if (oldPlayer) return oldPlayer;
+    const player = Structures.Player(this, options);
+    this.players.set(options.guildId, player);
+    this.emit("playerCreate" /* PlayerCreate */, player);
+    return player;
+  }
+  /**
+   *
+   * Search for a track or playlist.
+   * @param {SearchOptions} options The options for the search.
+   * @returns {Promise<QueryResult>} The search result.
+   * @example
+   * ```ts
+   * const result = await manager.search({
+   * 	query: "track name",
+   * 	engine: SearchEngines.Youtube,
+   * });
+   *
+   * console.log(result); // The search result
+   * ```
+   */
+  async search(options) {
+    let node = null;
+    if (options.node) {
+      const nodeId = typeof options.node === "string" ? options.node : options.node.id;
+      node = this.nodeManager.get(nodeId) ?? null;
+    } else {
+      node = this.nodeManager.getLeastUsed();
+    }
+    if (!node) throw new ManagerError("No nodes are available.");
+    const res = await node.search(options);
+    if (!res)
+      return {
+        loadType: "empty" /* Empty */,
+        exception: null,
+        playlist: null,
+        pluginInfo: null,
+        tracks: []
+      };
+    this.emit(
+      "debug" /* Debug */,
+      1 /* Manager */,
+      `[Manager] -> [Search] Searching for: ${options.query} (${options.engine ?? "unknown"}) | Result: ${JSON.stringify(res)}`
+    );
+    switch (res.loadType) {
+      case "empty" /* Empty */: {
+        return {
+          loadType: res.loadType,
+          exception: null,
+          playlist: null,
+          pluginInfo: null,
+          tracks: []
+        };
+      }
+      case "error" /* Error */: {
+        return {
+          loadType: res.loadType,
+          exception: res.data,
+          playlist: null,
+          pluginInfo: null,
+          tracks: []
+        };
+      }
+      case "playlist" /* Playlist */: {
+        return {
+          loadType: res.loadType,
+          exception: null,
+          playlist: res.data,
+          pluginInfo: res.data.pluginInfo,
+          tracks: res.data.tracks.map((t) => new Track(t, options.requester))
+        };
+      }
+      case "search" /* Search */: {
+        return {
+          loadType: res.loadType,
+          exception: null,
+          playlist: null,
+          pluginInfo: null,
+          tracks: res.data.map((t) => new Track(t, options.requester))
+        };
+      }
+      case "track" /* Track */: {
+        return {
+          loadType: res.loadType,
+          exception: null,
+          playlist: null,
+          pluginInfo: res.data.pluginInfo,
+          tracks: [new Track(res.data, options.requester)]
+        };
+      }
+    }
+  }
+};
+function createHoshimi(...args) {
+  return new Hoshimi(...args);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioOutput,
+  DSPXPluginFilter,
+  DebugLevels,
+  DestroyReasons,
+  Events,
+  FilterManager,
+  FilterType,
+  Hoshimi,
+  HttpMethods,
+  HttpStatusCodes,
+  LavalinkPluginFilter,
+  LoadType,
+  LoopMode,
+  ManagerError,
+  MemoryAdapter,
+  Node,
+  NodeDestroyReasons,
+  NodeError,
+  NodeSortTypes,
+  OpCodes,
+  OptionError,
+  Player,
+  PlayerError,
+  PlayerEventType,
+  PluginInfoType,
+  PluginNames,
+  Queue,
+  ResolveError,
+  Rest,
+  SearchEngines,
+  Severity,
+  SourceNames,
+  State,
+  StorageAdapter,
+  StorageError,
+  Structures,
+  Track,
+  TrackEndReason,
+  UnresolvedTrack,
+  WebsocketCloseCodes,
+  createHoshimi
+});