ryanlink 1.0.2 → 2.0.0

package/dist/index.cjs

@@ -0,0 +1,4833 @@
+/* ryanlink v2.0.0 - High-performance, flexible and feature-rich lavalink-v4 wrapper for Discord bots, | Apache-2.0 License | https://github.com/ryanwtf7/ryanlink.git */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AudioNodeSymbol: () => AudioNodeSymbol,
+  AudioQueueSymbol: () => AudioQueueSymbol,
+  AudioTrackSymbol: () => AudioTrackSymbol,
+  Autoplay: () => Autoplay,
+  BuiltinSources: () => BuiltinSources,
+  DebugEvents: () => DebugEvents,
+  DefaultQueueStore: () => DefaultQueueStore,
+  DestroyReasons: () => DestroyReasons,
+  DisconnectReasons: () => DisconnectReasons,
+  EQList: () => EQList,
+  FilterManager: () => FilterManager,
+  LinkMatchers: () => LinkMatchers,
+  MiniMap: () => MiniMap,
+  NodeLinkExclusiveEvents: () => NodeLinkExclusiveEvents,
+  NodeLinkNode: () => NodeLinkNode,
+  NodeManager: () => NodeManager,
+  Player: () => Player,
+  Queue: () => Queue,
+  QueueSaver: () => QueueSaver,
+  RecommendationsStrings: () => RecommendationsStrings,
+  ReconnectionState: () => ReconnectionState,
+  RyanlinkManager: () => RyanlinkManager,
+  RyanlinkNode: () => RyanlinkNode,
+  RyanlinkUtils: () => RyanlinkUtils,
+  SourceMappings: () => SourceMappings,
+  UnresolvedAudioTrackSymbol: () => UnresolvedAudioTrackSymbol,
+  audioOutputsData: () => audioOutputsData,
+  parseConnectionUrl: () => parseConnectionUrl,
+  queueTrackEnd: () => queueTrackEnd,
+  safeStringify: () => safeStringify,
+  validSponsorBlocks: () => validSponsorBlocks,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/Manager.ts
+var import_node_events2 = require("events");
+
+// src/config/Constants.ts
+var DebugEvents = /* @__PURE__ */ ((DebugEvents2) => {
+  DebugEvents2["SetSponsorBlock"] = "SetSponsorBlock";
+  DebugEvents2["DeleteSponsorBlock"] = "DeleteSponsorBlock";
+  DebugEvents2["TrackEndReplaced"] = "TrackEndReplaced";
+  DebugEvents2["AutoplayExecution"] = "AutoplayExecution";
+  DebugEvents2["AutoplayNoSongsAdded"] = "AutoplayNoSongsAdded";
+  DebugEvents2["AutoplayThresholdSpamLimiter"] = "AutoplayThresholdSpamLimiter";
+  DebugEvents2["TriggerQueueEmptyInterval"] = "TriggerQueueEmptyInterval";
+  DebugEvents2["QueueEnded"] = "QueueEnded";
+  DebugEvents2["TrackStartNewSongsOnly"] = "TrackStartNewSongsOnly";
+  DebugEvents2["TrackStartNoTrack"] = "TrackStartNoTrack";
+  DebugEvents2["ResumingFetchingError"] = "ResumingFetchingError";
+  DebugEvents2["PlayerUpdateNoPlayer"] = "PlayerUpdateNoPlayer";
+  DebugEvents2["PlayerUpdateFilterFixApply"] = "PlayerUpdateFilterFixApply";
+  DebugEvents2["PlayerUpdateSuccess"] = "PlayerUpdateSuccess";
+  DebugEvents2["HeartBeatTriggered"] = "HeartBeatTriggered";
+  DebugEvents2["NoSocketOnDestroy"] = "NoSocketOnDestroy";
+  DebugEvents2["SocketCleanupError"] = "SocketCleanupError";
+  DebugEvents2["SocketTerminateHeartBeatTimeout"] = "SocketTerminateHeartBeatTimeout";
+  DebugEvents2["TryingConnectWhileConnected"] = "TryingConnectWhileConnected";
+  DebugEvents2["SearchNothingFound"] = "SearchNothingFound";
+  DebugEvents2["ValidatingBlacklistLinks"] = "ValidatingBlacklistLinks";
+  DebugEvents2["ValidatingWhitelistLinks"] = "ValidatingWhitelistLinks";
+  DebugEvents2["TrackErrorMaxTracksErroredPerTime"] = "TrackErrorMaxTracksErroredPerTime";
+  DebugEvents2["TrackStuckMaxTracksErroredPerTime"] = "TrackStuckMaxTracksErroredPerTime";
+  DebugEvents2["PlayerDestroyingSomewhereElse"] = "PlayerDestroyingSomewhereElse";
+  DebugEvents2["PlayerCreateNodeNotFound"] = "PlayerCreateNodeNotFound";
+  DebugEvents2["PlayerPlayQueueEmptyTimeoutClear"] = "PlayerPlayQueueEmptyTimeoutClear";
+  DebugEvents2["PlayerPlayWithTrackReplace"] = "PlayerPlayWithTrackReplace";
+  DebugEvents2["PlayerPlayUnresolvedTrack"] = "PlayerPlayUnresolvedTrack";
+  DebugEvents2["PlayerPlayUnresolvedTrackFailed"] = "PlayerPlayUnresolvedTrackFailed";
+  DebugEvents2["PlayerVolumeAsFilter"] = "PlayerVolumeAsFilter";
+  DebugEvents2["BandcampSearchLokalEngine"] = "BandcampSearchLokalEngine";
+  DebugEvents2["PlayerChangeNode"] = "PlayerChangeNode";
+  DebugEvents2["BuildTrackError"] = "BuildTrackError";
+  DebugEvents2["TransformRequesterFunctionFailed"] = "TransformRequesterFunctionFailed";
+  DebugEvents2["GetClosestTrackFailed"] = "GetClosestTrackFailed";
+  DebugEvents2["PlayerDeleteInsteadOfDestroy"] = "PlayerDeleteInsteadOfDestroy";
+  DebugEvents2["FailedToConnectToNodes"] = "FailedToConnectToNodes";
+  DebugEvents2["NoAudioDebug"] = "NoAudioDebug";
+  DebugEvents2["PlayerAutoReconnect"] = "PlayerAutoReconnect";
+  DebugEvents2["PlayerDestroyFail"] = "PlayerDestroyFail";
+  DebugEvents2["PlayerChangeNodeFailNoEligibleNode"] = "PlayerChangeNodeFailNoEligibleNode";
+  DebugEvents2["PlayerChangeNodeFail"] = "PlayerChangeNodeFail";
+  return DebugEvents2;
+})(DebugEvents || {});
+var DestroyReasons = /* @__PURE__ */ ((DestroyReasons2) => {
+  DestroyReasons2["QueueEmpty"] = "QueueEmpty";
+  DestroyReasons2["NodeDestroy"] = "NodeDestroy";
+  DestroyReasons2["NodeDeleted"] = "NodeDeleted";
+  DestroyReasons2["NodeNoVoice"] = "NodeNoVoice";
+  DestroyReasons2["NodeReconnectFail"] = "NodeReconnectFail";
+  DestroyReasons2["Disconnected"] = "Disconnected";
+  DestroyReasons2["PlayerReconnectFail"] = "PlayerReconnectFail";
+  DestroyReasons2["PlayerChangeNodeFail"] = "PlayerChangeNodeFail";
+  DestroyReasons2["PlayerChangeNodeFailNoEligibleNode"] = "PlayerChangeNodeFailNoEligibleNode";
+  DestroyReasons2["ChannelDeleted"] = "ChannelDeleted";
+  DestroyReasons2["DisconnectAllNodes"] = "DisconnectAllNodes";
+  DestroyReasons2["ReconnectAllNodes"] = "ReconnectAllNodes";
+  DestroyReasons2["TrackErrorMaxTracksErroredPerTime"] = "TrackErrorMaxTracksErroredPerTime";
+  DestroyReasons2["TrackStuckMaxTracksErroredPerTime"] = "TrackStuckMaxTracksErroredPerTime";
+  return DestroyReasons2;
+})(DestroyReasons || {});
+var DisconnectReasons = /* @__PURE__ */ ((DisconnectReasons2) => {
+  DisconnectReasons2["Disconnected"] = "Disconnected";
+  DisconnectReasons2["DisconnectAllNodes"] = "DisconnectAllNodes";
+  return DisconnectReasons2;
+})(DisconnectReasons || {});
+var validSponsorBlocks = ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"];
+var audioOutputsData = {
+  mono: {
+    leftToLeft: 0.5,
+    leftToRight: 0.5,
+    rightToLeft: 0.5,
+    rightToRight: 0.5
+  },
+  stereo: {
+    leftToLeft: 1,
+    leftToRight: 0,
+    rightToLeft: 0,
+    rightToRight: 1
+  },
+  left: {
+    leftToLeft: 1,
+    leftToRight: 0,
+    rightToLeft: 1,
+    rightToRight: 0
+  },
+  right: {
+    leftToLeft: 0,
+    leftToRight: 1,
+    rightToLeft: 0,
+    rightToRight: 1
+  }
+};
+var EQList = {
+  BassboostEarrape: [
+    { band: 0, gain: 0.6 * 0.375 },
+    { band: 1, gain: 0.67 * 0.375 },
+    { band: 2, gain: 0.67 * 0.375 },
+    { band: 3, gain: 0.4 * 0.375 },
+    { band: 4, gain: -0.5 * 0.375 },
+    { band: 5, gain: 0.15 * 0.375 },
+    { band: 6, gain: -0.45 * 0.375 },
+    { band: 7, gain: 0.23 * 0.375 },
+    { band: 8, gain: 0.35 * 0.375 },
+    { band: 9, gain: 0.45 * 0.375 },
+    { band: 10, gain: 0.55 * 0.375 },
+    { band: 11, gain: -0.6 * 0.375 },
+    { band: 12, gain: 0.55 * 0.375 },
+    { band: 13, gain: -0.5 * 0.375 },
+    { band: 14, gain: -0.75 * 0.375 }
+  ],
+  BassboostHigh: [
+    { band: 0, gain: 0.6 * 0.25 },
+    { band: 1, gain: 0.67 * 0.25 },
+    { band: 2, gain: 0.67 * 0.25 },
+    { band: 3, gain: 0.4 * 0.25 },
+    { band: 4, gain: -0.5 * 0.25 },
+    { band: 5, gain: 0.15 * 0.25 },
+    { band: 6, gain: -0.45 * 0.25 },
+    { band: 7, gain: 0.23 * 0.25 },
+    { band: 8, gain: 0.35 * 0.25 },
+    { band: 9, gain: 0.45 * 0.25 },
+    { band: 10, gain: 0.55 * 0.25 },
+    { band: 11, gain: -0.6 * 0.25 },
+    { band: 12, gain: 0.55 * 0.25 },
+    { band: 13, gain: -0.5 * 0.25 },
+    { band: 14, gain: -0.75 * 0.25 }
+  ],
+  BassboostMedium: [
+    { band: 0, gain: 0.6 * 0.1875 },
+    { band: 1, gain: 0.67 * 0.1875 },
+    { band: 2, gain: 0.67 * 0.1875 },
+    { band: 3, gain: 0.4 * 0.1875 },
+    { band: 4, gain: -0.5 * 0.1875 },
+    { band: 5, gain: 0.15 * 0.1875 },
+    { band: 6, gain: -0.45 * 0.1875 },
+    { band: 7, gain: 0.23 * 0.1875 },
+    { band: 8, gain: 0.35 * 0.1875 },
+    { band: 9, gain: 0.45 * 0.1875 },
+    { band: 10, gain: 0.55 * 0.1875 },
+    { band: 11, gain: -0.6 * 0.1875 },
+    { band: 12, gain: 0.55 * 0.1875 },
+    { band: 13, gain: -0.5 * 0.1875 },
+    { band: 14, gain: -0.75 * 0.1875 }
+  ],
+  BassboostLow: [
+    { band: 0, gain: 0.6 * 0.125 },
+    { band: 1, gain: 0.67 * 0.125 },
+    { band: 2, gain: 0.67 * 0.125 },
+    { band: 3, gain: 0.4 * 0.125 },
+    { band: 4, gain: -0.5 * 0.125 },
+    { band: 5, gain: 0.15 * 0.125 },
+    { band: 6, gain: -0.45 * 0.125 },
+    { band: 7, gain: 0.23 * 0.125 },
+    { band: 8, gain: 0.35 * 0.125 },
+    { band: 9, gain: 0.45 * 0.125 },
+    { band: 10, gain: 0.55 * 0.125 },
+    { band: 11, gain: -0.6 * 0.125 },
+    { band: 12, gain: 0.55 * 0.125 },
+    { band: 13, gain: -0.5 * 0.125 },
+    { band: 14, gain: -0.75 * 0.125 }
+  ],
+  BetterMusic: [
+    { band: 0, gain: 0.25 },
+    { band: 1, gain: 0.025 },
+    { band: 2, gain: 0.0125 },
+    { band: 3, gain: 0 },
+    { band: 4, gain: 0 },
+    { band: 5, gain: -0.0125 },
+    { band: 6, gain: -0.025 },
+    { band: 7, gain: -0.0175 },
+    { band: 8, gain: 0 },
+    { band: 9, gain: 0 },
+    { band: 10, gain: 0.0125 },
+    { band: 11, gain: 0.025 },
+    { band: 12, gain: 0.25 },
+    { band: 13, gain: 0.125 },
+    { band: 14, gain: 0.125 }
+  ],
+  Rock: [
+    { band: 0, gain: 0.3 },
+    { band: 1, gain: 0.25 },
+    { band: 2, gain: 0.2 },
+    { band: 3, gain: 0.1 },
+    { band: 4, gain: 0.05 },
+    { band: 5, gain: -0.05 },
+    { band: 6, gain: -0.15 },
+    { band: 7, gain: -0.2 },
+    { band: 8, gain: -0.1 },
+    { band: 9, gain: -0.05 },
+    { band: 10, gain: 0.05 },
+    { band: 11, gain: 0.1 },
+    { band: 12, gain: 0.2 },
+    { band: 13, gain: 0.25 },
+    { band: 14, gain: 0.3 }
+  ],
+  Classic: [
+    { band: 0, gain: 0.375 },
+    { band: 1, gain: 0.35 },
+    { band: 2, gain: 0.125 },
+    { band: 3, gain: 0 },
+    { band: 4, gain: 0 },
+    { band: 5, gain: 0.125 },
+    { band: 6, gain: 0.55 },
+    { band: 7, gain: 0.05 },
+    { band: 8, gain: 0.125 },
+    { band: 9, gain: 0.25 },
+    { band: 10, gain: 0.2 },
+    { band: 11, gain: 0.25 },
+    { band: 12, gain: 0.3 },
+    { band: 13, gain: 0.25 },
+    { band: 14, gain: 0.3 }
+  ],
+  Pop: [
+    { band: 0, gain: 0.2635 },
+    { band: 1, gain: 0.22141 },
+    { band: 2, gain: -0.21141 },
+    { band: 3, gain: -0.1851 },
+    { band: 4, gain: -0.155 },
+    { band: 5, gain: 0.21141 },
+    { band: 6, gain: 0.22456 },
+    { band: 7, gain: 0.237 },
+    { band: 8, gain: 0.237 },
+    { band: 9, gain: 0.237 },
+    { band: 10, gain: -0.05 },
+    { band: 11, gain: -0.116 },
+    { band: 12, gain: 0.192 },
+    { band: 13, gain: 0 },
+    { band: 14, gain: 0 }
+  ],
+  Electronic: [
+    { band: 0, gain: 0.375 },
+    { band: 1, gain: 0.35 },
+    { band: 2, gain: 0.125 },
+    { band: 3, gain: 0 },
+    { band: 4, gain: 0 },
+    { band: 5, gain: -0.125 },
+    { band: 6, gain: -0.125 },
+    { band: 7, gain: 0 },
+    { band: 8, gain: 0.25 },
+    { band: 9, gain: 0.125 },
+    { band: 10, gain: 0.15 },
+    { band: 11, gain: 0.2 },
+    { band: 12, gain: 0.25 },
+    { band: 13, gain: 0.35 },
+    { band: 14, gain: 0.4 }
+  ],
+  FullSound: [
+    { band: 0, gain: 0.25 + 0.375 },
+    { band: 1, gain: 0.25 + 0.025 },
+    { band: 2, gain: 0.25 + 0.0125 },
+    { band: 3, gain: 0.25 + 0 },
+    { band: 4, gain: 0.25 + 0 },
+    { band: 5, gain: 0.25 + -0.0125 },
+    { band: 6, gain: 0.25 + -0.025 },
+    { band: 7, gain: 0.25 + -0.0175 },
+    { band: 8, gain: 0.25 + 0 },
+    { band: 9, gain: 0.25 + 0 },
+    { band: 10, gain: 0.25 + 0.0125 },
+    { band: 11, gain: 0.25 + 0.025 },
+    { band: 12, gain: 0.25 + 0.375 },
+    { band: 13, gain: 0.25 + 0.125 },
+    { band: 14, gain: 0.25 + 0.125 }
+  ],
+  Gaming: [
+    { band: 0, gain: 0.35 },
+    { band: 1, gain: 0.3 },
+    { band: 2, gain: 0.25 },
+    { band: 3, gain: 0.2 },
+    { band: 4, gain: 0.15 },
+    { band: 5, gain: 0.1 },
+    { band: 6, gain: 0.05 },
+    { band: 7, gain: -0 },
+    { band: 8, gain: -0.05 },
+    { band: 9, gain: -0.1 },
+    { band: 10, gain: -0.15 },
+    { band: 11, gain: -0.2 },
+    { band: 12, gain: -0.25 },
+    { band: 13, gain: -0.3 },
+    { band: 14, gain: -0.35 }
+  ]
+};
+var RecommendationsStrings = {
+  highCPULoad: (cpuLoad) => `High CPU load (${(cpuLoad * 100).toFixed(1)}%). Consider reducing player count or upgrading CPU.`,
+  highSystemLoad: (systemLoad) => `High system load (${(systemLoad * 100).toFixed(1)}%). Check other processes on the server.`,
+  highMemoryUsage: (memoryUsagePercent) => `High memory usage (${memoryUsagePercent.toFixed(1)}%). Consider increasing allocated memory or reducing player count.`,
+  frameDeficit: (frameDeficit) => `Frame deficit detected (${frameDeficit}). Audio quality may be affected. Check network and CPU.`,
+  highLatency: (ping) => `High latency (${ping}ms). Check network connection to the node.`,
+  nodeRestart: "Node restart recommended to clear memory and reset connections.",
+  highPlayercount: (players) => `High player count (${players}). Consider load balancing across multiple nodes.`,
+  nodeOffline: "Node is offline or disconnected",
+  checkConnectivity: "Check node connectivity and restart if needed"
+};
+var NodeLinkExclusiveEvents = [
+  "PlayerCreatedEvent",
+  "PlayerDestroyedEvent",
+  "PlayerConnectedEvent",
+  "PlayerReconnectingEvent",
+  "VolumeChangedEvent",
+  "FiltersChangedEvent",
+  "SeekEvent",
+  "PauseEvent",
+  "ConnectionStatusEvent",
+  "MixStartedEvent",
+  "MixEndedEvent",
+  "LyricsFoundEvent",
+  "LyricsLineEvent",
+  "LyricsNotFoundEvent"
+];
+
+// src/node/NodeManager.ts
+var import_node_events = require("events");
+
+// src/node/Node.ts
+var import_node_path = require("path");
+var import_ws = __toESM(require("ws"), 1);
+
+// src/types/Node.ts
+var ReconnectionState = /* @__PURE__ */ ((ReconnectionState2) => {
+  ReconnectionState2["IDLE"] = "IDLE";
+  ReconnectionState2["RECONNECTING"] = "RECONNECTING";
+  ReconnectionState2["PENDING"] = "PENDING";
+  ReconnectionState2["DESTROYING"] = "DESTROYING";
+  return ReconnectionState2;
+})(ReconnectionState || {});
+
+// src/utils/Utils.ts
+var import_node_url = require("url");
+var import_types = require("util/types");
+
+// src/node/Sources.ts
+var SourceMappings = {
+  "youtube music": "ytmsearch",
+  youtubemusic: "ytmsearch",
+  ytmsearch: "ytmsearch",
+  ytm: "ytmsearch",
+  musicyoutube: "ytmsearch",
+  "music youtube": "ytmsearch",
+  youtube: "ytsearch",
+  yt: "ytsearch",
+  ytsearch: "ytsearch",
+  soundcloud: "scsearch",
+  scsearch: "scsearch",
+  sc: "scsearch",
+  "apple music": "amsearch",
+  apple: "amsearch",
+  applemusic: "amsearch",
+  amsearch: "amsearch",
+  am: "amsearch",
+  musicapple: "amsearch",
+  "music apple": "amsearch",
+  spotify: "spsearch",
+  spsearch: "spsearch",
+  sp: "spsearch",
+  "spotify.com": "spsearch",
+  spotifycom: "spsearch",
+  sprec: "sprec",
+  spsuggestion: "sprec",
+  deezer: "dzsearch",
+  dz: "dzsearch",
+  dzsearch: "dzsearch",
+  dzisrc: "dzisrc",
+  dzrec: "dzrec",
+  "yandex music": "ymsearch",
+  yandexmusic: "ymsearch",
+  yandex: "ymsearch",
+  ymsearch: "ymsearch",
+  ymrec: "ymrec",
+  vksearch: "vksearch",
+  vkmusic: "vksearch",
+  "vk music": "vksearch",
+  vkrec: "vkrec",
+  vk: "vksearch",
+  qbsearch: "qbsearch",
+  qobuz: "qbsearch",
+  qbisrc: "qbisrc",
+  qbrec: "qbrec",
+  pandora: "pdsearch",
+  pd: "pdsearch",
+  pdsearch: "pdsearch",
+  pdisrc: "pdisrc",
+  pdrec: "pdrec",
+  "pandora music": "pdsearch",
+  pandoramusic: "pdsearch",
+  speak: "speak",
+  tts: "tts",
+  ftts: "ftts",
+  flowery: "ftts",
+  "flowery.tts": "ftts",
+  flowerytts: "ftts",
+  bandcamp: "bcsearch",
+  bc: "bcsearch",
+  bcsearch: "bcsearch",
+  phsearch: "phsearch",
+  pornhub: "phsearch",
+  porn: "phsearch",
+  local: "local",
+  http: "http",
+  https: "https",
+  link: "link",
+  uri: "uri",
+  tidal: "tdsearch",
+  td: "tdsearch",
+  "tidal music": "tdsearch",
+  tdsearch: "tdsearch",
+  tdrec: "tdrec",
+  jiosaavn: "jssearch",
+  js: "jssearch",
+  jssearch: "jssearch",
+  jsrec: "jsrec",
+  audiomack: "admsearch",
+  adm: "admsearch",
+  admsearch: "admsearch",
+  admrec: "admrec",
+  shazam: "shsearch",
+  sh: "shsearch",
+  shsearch: "shsearch",
+  instagram: "igsearch",
+  ig: "igsearch",
+  igsearch: "igsearch",
+  bilibili: "blsearch",
+  bl: "blsearch",
+  blsearch: "blsearch",
+  lastfm: "lfsearch",
+  "last.fm": "lfsearch",
+  lf: "lfsearch",
+  lfsearch: "lfsearch",
+  "amazon music": "amzsearch",
+  amazonmusic: "amzsearch",
+  amz: "amzsearch",
+  amzsearch: "amzsearch",
+  amzrec: "amzrec",
+  gaana: "gnsearch",
+  gn: "gnsearch",
+  gnsearch: "gnsearch",
+  gnrec: "gnrec"
+};
+var BuiltinSources = {
+  DuncteBot_Plugin: "duncte-engine",
+  LavaSrc: "source-engine",
+  GoogleCloudTTS: "tts-engine",
+  LavaSearch: "search-engine",
+  JioSaavn_Engine: "jio-engine",
+  Filter_Engine: "filter-engine",
+  TimedLyrics_Engine: "lyrics-engine"
+};
+var LinkMatchers = {
+  YoutubeRegex: /https?:\/\/?(?:www\.)?(?:(m|www)\.)?(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|shorts|playlist\?|watch\?v=|watch\?.+(?:&|&);v=))([a-zA-Z0-9\-_]{11})?(?:(?:\?|&|&)index=((?:\d){1,3}))?(?:(?:\?|&|&)?list=([a-zA-Z\-_0-9]{34}))?(?:\S+)?/,
+  YoutubeMusicRegex: /https?:\/\/?(?:www\.)?(?:(music|m|www)\.)?(?:youtu\.be\/|youtube\.com\/(?:embed\/|v\/|shorts|playlist\?|watch\?v=|watch\?.+(?:&|&);v=))([a-zA-Z0-9\-_]{11})?(?:(?:\?|&|&)index=((?:\d){1,3}))?(?:(?:\?|&|&)?list=([a-zA-Z\-_0-9]{34}))?(?:\S+)?/,
+  SoundCloudRegex: /https?:\/\/(?:on\.)?soundcloud\.com\//,
+  SoundCloudMobileRegex: /https?:\/\/(soundcloud\.app\.goo\.gl)\/(\S+)/,
+  bandcamp: /https?:\/\/?(?:www\.)?([\d|\w]+)\.bandcamp\.com\/(\S+)/,
+  TwitchTv: /https?:\/\/?(?:www\.)?twitch\.tv\/\w+/,
+  vimeo: /https?:\/\/(www\.)?vimeo.com\/(?:channels\/(?:\w+\/)?|groups\/([^/]*)\/videos\/|)(\d+)(?:|\/\?)/,
+  mp3Url: /(https?|ftp|file):\/\/(www.)?(.*?)\.(mp3)$/,
+  m3uUrl: /(https?|ftp|file):\/\/(www.)?(.*?)\.(m3u)$/,
+  m3u8Url: /(https?|ftp|file):\/\/(www.)?(.*?)\.(m3u8)$/,
+  mp4Url: /(https?|ftp|file):\/\/(www.)?(.*?)\.(mp4)$/,
+  m4aUrl: /(https?|ftp|file):\/\/(www.)?(.*?)\.(m4a)$/,
+  wavUrl: /(https?|ftp|file):\/\/(www.)?(.*?)\.(wav)$/,
+  aacpUrl: /(https?|ftp|file):\/\/(www.)?(.*?)\.(aacp)$/,
+  DeezerTrackRegex: /(https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?track\/(\d+)/,
+  DeezerPageLinkRegex: /(https?:\/\/|)?(?:www\.)?deezer\.page\.link\/(\S+)/,
+  DeezerPlaylistRegex: /(https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?playlist\/(\d+)/,
+  DeezerAlbumRegex: /(https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?album\/(\d+)/,
+  DeezerArtistRegex: /(https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?artist\/(\d+)/,
+  DeezerMixesRegex: /(https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?mixes\/genre\/(\d+)/,
+  DeezerEpisodeRegex: /(https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?episode\/(\d+)/,
+  AllDeezerRegexWithoutPageLink: /(https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?(track|playlist|album|artist|mixes\/genre|episode)\/(\d+)/,
+  AllDeezerRegex: /((https?:\/\/|)?(?:www\.)?deezer\.com\/(?:\w{2}\/)?(track|playlist|album|artist|mixes\/genre|episode)\/(\d+)|(https?:\/\/|)?(?:www\.)?deezer\.page\.link\/(\S+))/,
+  SpotifySongRegex: /(https?:\/\/)(www\.)?open\.spotify\.com\/((?<region>[a-zA-Z-]+)\/)?(user\/(?<user>[a-zA-Z0-9-_]+)\/)?track\/(?<identifier>[a-zA-Z0-9-_]+)/,
+  SpotifyPlaylistRegex: /(https?:\/\/)(www\.)?open\.spotify\.com\/((?<region>[a-zA-Z-]+)\/)?(user\/(?<user>[a-zA-Z0-9-_]+)\/)?playlist\/(?<identifier>[a-zA-Z0-9-_]+)/,
+  SpotifyArtistRegex: /(https?:\/\/)(www\.)?open\.spotify\.com\/((?<region>[a-zA-Z-]+)\/)?(user\/(?<user>[a-zA-Z0-9-_]+)\/)?artist\/(?<identifier>[a-zA-Z0-9-_]+)/,
+  SpotifyEpisodeRegex: /(https?:\/\/)(www\.)?open\.spotify\.com\/((?<region>[a-zA-Z-]+)\/)?(user\/(?<user>[a-zA-Z0-9-_]+)\/)?episode\/(?<identifier>[a-zA-Z0-9-_]+)/,
+  SpotifyShowRegex: /(https?:\/\/)(www\.)?open\.spotify\.com\/((?<region>[a-zA-Z-]+)\/)?(user\/(?<user>[a-zA-Z0-9-_]+)\/)?show\/(?<identifier>[a-zA-Z0-9-_]+)/,
+  SpotifyAlbumRegex: /(https?:\/\/)(www\.)?open\.spotify\.com\/((?<region>[a-zA-Z-]+)\/)?(user\/(?<user>[a-zA-Z0-9-_]+)\/)?album\/(?<identifier>[a-zA-Z0-9-_]+)/,
+  AllSpotifyRegex: /(https?:\/\/)(www\.)?open\.spotify\.com\/((?<region>[a-zA-Z-]+)\/)?(user\/(?<user>[a-zA-Z0-9-_]+)\/)?(?<type>track|album|playlist|artist|episode|show)\/(?<identifier>[a-zA-Z0-9-_]+)/,
+  appleMusic: /https?:\/\/?(?:www\.)?music\.apple\.com\/(\S+)/,
+  tidal: /https?:\/\/?(?:www\.)?(?:tidal|listen)\.tidal\.com\/(?<type>track|album|playlist|artist)\/(?<identifier>[a-zA-Z0-9-_]+)/,
+  jiosaavn: /(https?:\/\/)(www\.)?jiosaavn\.com\/(?<type>song|album|featured|artist)\/([a-zA-Z0-9-_/,]+)/,
+  PandoraTrackRegex: /^@?(?:https?:\/\/)?(?:www\.)?pandora\.com\/artist\/[\w-]+(?:\/[\w-]+)*\/(?<identifier>TR[A-Za-z0-9]+)(?:[?#].*)?$/,
+  PandoraAlbumRegex: /^@?(?:https?:\/\/)?(?:www\.)?pandora\.com\/artist\/[\w-]+(?:\/[\w-]+)*\/(?<identifier>AL[A-Za-z0-9]+)(?:[?#].*)?$/,
+  PandoraArtistRegex: /^@?(?:https?:\/\/)?(?:www\.)?pandora\.com\/artist\/[\w-]+\/(?<identifier>AR[A-Za-z0-9]+)(?:[?#].*)?$/,
+  PandoraPlaylistRegex: /^@?(?:https?:\/\/)?(?:www\.)?pandora\.com\/playlist\/(?<identifier>PL:[\d:]+)(?:[?#].*)?$/,
+  AllPandoraRegex: /^@?(?:https?:\/\/)?(?:www\.)?pandora\.com\/(?:playlist\/(?<playlistId>PL:[\d:]+)|artist\/[\w-]+(?:\/[\w-]+)*\/(?<identifier>(?:TR|AL|AR)[A-Za-z0-9]+))(?:[?#].*)?$/,
+  tiktok: /https:\/\/www\.tiktok\.com\//,
+  mixcloud: /https:\/\/www\.mixcloud\.com\//,
+  musicYandex: /https:\/\/music\.yandex\.ru\//,
+  radiohost: /https?:\/\/[^.\s]+\.radiohost\.de\/(\S+)/
+};
+
+// src/utils/Utils.ts
+var AudioTrackSymbol = /* @__PURE__ */ Symbol("Ryanlink-Track");
+var UnresolvedAudioTrackSymbol = /* @__PURE__ */ Symbol("Ryanlink-Track-Unresolved");
+var AudioQueueSymbol = /* @__PURE__ */ Symbol("Ryanlink-Queue");
+var AudioNodeSymbol = /* @__PURE__ */ Symbol("Ryanlink-Node");
+var escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function parseConnectionUrl(connectionUrl) {
+  if (!connectionUrl.startsWith("ryanlink://") && !connectionUrl.startsWith("nodelink://"))
+    throw new Error(`ConnectionUrl (${connectionUrl}) must start with 'ryanlink://' or 'nodelink://'`);
+  const parsed = new import_node_url.URL(connectionUrl.replace(/^ryanlink:\/\//, "https://").replace(/^nodelink:\/\//, "https://"));
+  return {
+    authorization: parsed.password,
+    nodeType: connectionUrl.startsWith("ryanlink://") ? "Core" : "NodeLink",
+    id: parsed.username,
+    host: parsed.hostname,
+    port: Number(parsed.port)
+  };
+}
+var RyanlinkUtils = class {
+  RyanlinkManager = void 0;
+  constructor(RyanlinkManager2) {
+    this.RyanlinkManager = RyanlinkManager2;
+  }
+  buildPluginInfo(data, clientData = {}) {
+    return {
+      clientData,
+      ...data.pluginInfo || data.plugin
+    };
+  }
+  buildTrack(data, requester) {
+    if (!data?.encoded || typeof data.encoded !== "string") throw new RangeError("Argument 'data.encoded' must be present.");
+    if (!data.info) throw new RangeError("Argument 'data.info' must be present.");
+    try {
+      let transformedRequester = typeof requester === "object" ? this.getTransformedRequester(requester) : void 0;
+      if (!transformedRequester && typeof data?.userData?.requester === "object" && data.userData.requester !== null) {
+        transformedRequester = this.getTransformedRequester(data.userData.requester);
+      }
+      const r = {
+        encoded: data.encoded,
+        info: {
+          identifier: data.info.identifier,
+          title: data.info.title,
+          author: data.info.author,
+          duration: data.info?.duration || data.info?.length,
+          artworkUrl: data.info.artworkUrl || data.pluginInfo?.artworkUrl || data.plugin?.artworkUrl,
+          uri: data.info.uri,
+          sourceName: data.info.sourceName,
+          isSeekable: data.info.isSeekable,
+          isStream: data.info.isStream,
+          isrc: data.info.isrc
+        },
+        userData: {
+          ...data.userData,
+          requester: transformedRequester
+        },
+        pluginInfo: this.buildPluginInfo(data, "clientData" in data ? data.clientData : {}),
+        requester: transformedRequester || this.getTransformedRequester(this.RyanlinkManager?.options?.client)
+      };
+      Object.defineProperty(r, AudioTrackSymbol, { configurable: true, value: true });
+      return r;
+    } catch (error) {
+      if (this.RyanlinkManager?.options?.advancedOptions?.enableDebugEvents) {
+        this.RyanlinkManager?.emit("debug", "BuildTrackError" /* BuildTrackError */, {
+          error,
+          functionLayer: "RyanlinkUtils > buildTrack()",
+          message: "Error while building track",
+          state: "error"
+        });
+      }
+      throw new RangeError(`Argument "data" is not a valid track: ${error.message}`);
+    }
+  }
+  buildUnresolvedTrack(query, requester) {
+    if (typeof query === "undefined") throw new RangeError('Argument "query" must be present.');
+    const unresolvedTrack = {
+      encoded: query.encoded || void 0,
+      info: query.info ? query.info : query.title ? query : void 0,
+      pluginInfo: this.buildPluginInfo(query),
+      requester: this.getTransformedRequester(requester),
+      async resolve(player) {
+        const closest = await getClosestTrack(this, player);
+        if (!closest) throw new SyntaxError("No closest Track found");
+        for (const prop of Object.getOwnPropertyNames(this)) delete this[prop];
+        delete this[UnresolvedAudioTrackSymbol];
+        Object.defineProperty(this, AudioTrackSymbol, { configurable: true, value: true });
+        return Object.assign(this, closest);
+      }
+    };
+    if (!this.isUnresolvedTrack(unresolvedTrack)) throw SyntaxError("Could not build Unresolved Track");
+    Object.defineProperty(unresolvedTrack, UnresolvedAudioTrackSymbol, {
+      configurable: true,
+      value: true
+    });
+    return unresolvedTrack;
+  }
+  isNode(data) {
+    if (!data) return false;
+    const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(data));
+    if (!keys.includes("constructor")) return false;
+    if (!keys.length) return false;
+    if (![
+      "connect",
+      "destroy",
+      "destroyPlayer",
+      "fetchAllPlayers",
+      "fetchInfo",
+      "fetchPlayer",
+      "fetchStats",
+      "fetchVersion",
+      "request",
+      "updatePlayer",
+      "updateSession"
+    ].every((v) => keys.includes(v)))
+      return false;
+    return true;
+  }
+  getTransformedRequester(requester) {
+    try {
+      return typeof this.RyanlinkManager?.options?.playerOptions?.requesterTransformer === "function" ? this.RyanlinkManager?.options?.playerOptions?.requesterTransformer(requester) : requester;
+    } catch (e) {
+      if (this.RyanlinkManager?.options?.advancedOptions?.enableDebugEvents) {
+        this.RyanlinkManager?.emit("debug", "TransformRequesterFunctionFailed" /* TransformRequesterFunctionFailed */, {
+          error: e,
+          functionLayer: "RyanlinkUtils > getTransformedRequester()",
+          message: "Your custom transformRequesterFunction failed to execute, please check your function for errors.",
+          state: "error"
+        });
+      }
+      return requester;
+    }
+  }
+  isNodeOptions(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+    if (typeof data.host !== "string" || !data.host.length) return false;
+    if (typeof data.port !== "number" || isNaN(data.port) || data.port < 0 || data.port > 65535) return false;
+    if (typeof data.authorization !== "string" || !data.authorization.length) return false;
+    if ("secure" in data && typeof data.secure !== "boolean" && data.secure !== void 0) return false;
+    if ("sessionId" in data && typeof data.sessionId !== "string" && data.sessionId !== void 0) return false;
+    if ("id" in data && typeof data.id !== "string" && data.id !== void 0) return false;
+    if ("regions" in data && (!Array.isArray(data.regions) || !data.regions.every((v) => typeof v === "string") && data.regions !== void 0))
+      return false;
+    if ("poolOptions" in data && typeof data.poolOptions !== "object" && data.poolOptions !== void 0) return false;
+    if ("retryAmount" in data && (typeof data.retryAmount !== "number" || isNaN(data.retryAmount) || data.retryAmount <= 0 && data.retryAmount !== void 0))
+      return false;
+    if ("retryDelay" in data && (typeof data.retryDelay !== "number" || isNaN(data.retryDelay) || data.retryDelay <= 0 && data.retryDelay !== void 0))
+      return false;
+    if ("requestTimeout" in data && (typeof data.requestTimeout !== "number" || isNaN(data.requestTimeout) || data.requestTimeout <= 0 && data.requestTimeout !== void 0))
+      return false;
+    return true;
+  }
+  isNotBrokenTrack(data, minDuration = 29e3) {
+    if (typeof data?.info?.duration !== "number" || isNaN(data?.info?.duration)) return false;
+    if (data.info.duration <= Math.max(minDuration, 0)) return false;
+    if (!data.info) return false;
+    return this.isTrack(data);
+  }
+  isTrack(data) {
+    if (!data) return false;
+    if (data[AudioTrackSymbol] === true) return true;
+    return typeof data?.encoded === "string" && typeof data?.info === "object" && !("resolve" in data);
+  }
+  isUnresolvedTrack(data) {
+    if (!data) return false;
+    if (data[UnresolvedAudioTrackSymbol] === true) return true;
+    return typeof data === "object" && ("info" in data && typeof data.info.title === "string" || typeof data.encoded === "string") && "resolve" in data && typeof data.resolve === "function";
+  }
+  isUnresolvedTrackQuery(data) {
+    return typeof data === "object" && !("info" in data) && typeof data.title === "string";
+  }
+  async getClosestTrack(data, player) {
+    try {
+      return getClosestTrack(data, player);
+    } catch (e) {
+      if (this.RyanlinkManager?.options?.advancedOptions?.enableDebugEvents) {
+        this.RyanlinkManager?.emit("debug", "GetClosestTrackFailed" /* GetClosestTrackFailed */, {
+          error: e,
+          functionLayer: "RyanlinkUtils > getClosestTrack()",
+          message: "Failed to resolve track because the getClosestTrack function failed.",
+          state: "error"
+        });
+      }
+      throw e;
+    }
+  }
+  validateQueryString(node, queryString, sourceString) {
+    if (!node.info) throw new Error("No Audio Node was provided");
+    if (node._checkForSources && !node.info.sourceManagers?.length) throw new Error("Audio Node, has no sourceManagers enabled");
+    if (!queryString.trim().length) throw new Error(`Query string is empty, please provide a valid query string.`);
+    if (sourceString === "speak" && queryString.length > 100) throw new Error(`Query is speak, which is limited to 100 characters.`);
+    if (this.RyanlinkManager.options?.linksBlacklist?.length > 0) {
+      if (this.RyanlinkManager.options?.advancedOptions?.enableDebugEvents) {
+        this.RyanlinkManager.emit("debug", "ValidatingBlacklistLinks" /* ValidatingBlacklistLinks */, {
+          state: "log",
+          message: `Validating Query against RyanlinkManager.options.linksBlacklist, query: "${queryString}"`,
+          functionLayer: "(RyanlinkNode > node | player) > search() > validateQueryString()"
+        });
+      }
+      if (this.RyanlinkManager.options?.linksBlacklist.some(
+        (v) => typeof v === "string" && queryString.toLowerCase().includes(v.toLowerCase()) || (0, import_types.isRegExp)(v) && v.test(queryString)
+      )) {
+        throw new Error(`Query string contains a link / word which is blacklisted.`);
+      }
+    }
+    if (/^https?:\/\//.test(queryString) && this.RyanlinkManager.options?.linksAllowed === false)
+      throw new Error("Using links to make a request is not allowed.");
+    if (this.RyanlinkManager.options?.linksWhitelist?.length > 0) {
+      if (this.RyanlinkManager.options?.advancedOptions?.enableDebugEvents) {
+        this.RyanlinkManager.emit("debug", "ValidatingWhitelistLinks" /* ValidatingWhitelistLinks */, {
+          state: "log",
+          message: `Link was provided to the Query, validating against RyanlinkManager.options.linksWhitelist, query: "${queryString}"`,
+          functionLayer: "(RyanlinkNode > node | player) > search() > validateQueryString()"
+        });
+      }
+      if (!this.RyanlinkManager.options?.linksWhitelist.some(
+        (v) => typeof v === "string" && queryString.toLowerCase().includes(v.toLowerCase()) || (0, import_types.isRegExp)(v) && v.test(queryString)
+      )) {
+        throw new Error(`Query string contains a link / word which isn't whitelisted.`);
+      }
+    }
+    if (!node._checkForSources) return;
+    if ((LinkMatchers.YoutubeMusicRegex.test(queryString) || LinkMatchers.YoutubeRegex.test(queryString)) && !node.info?.sourceManagers?.includes("youtube")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'youtube' enabled");
+    }
+    if ((LinkMatchers.SoundCloudMobileRegex.test(queryString) || LinkMatchers.SoundCloudRegex.test(queryString)) && !node.info?.sourceManagers?.includes("soundcloud")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'soundcloud' enabled");
+    }
+    if (LinkMatchers.bandcamp.test(queryString) && !node.info?.sourceManagers?.includes("bandcamp")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'bandcamp' enabled (introduced with audio-engine 2.2.0+)");
+    }
+    if (LinkMatchers.TwitchTv.test(queryString) && !node.info?.sourceManagers?.includes("twitch")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'twitch' enabled");
+    }
+    if (LinkMatchers.vimeo.test(queryString) && !node.info?.sourceManagers?.includes("vimeo")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'vimeo' enabled");
+    }
+    if (LinkMatchers.tiktok.test(queryString) && !node.info?.sourceManagers?.includes("tiktok")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'tiktok' enabled");
+    }
+    if (LinkMatchers.mixcloud.test(queryString) && !node.info?.sourceManagers?.includes("mixcloud")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'mixcloud' enabled");
+    }
+    if (LinkMatchers.AllSpotifyRegex.test(queryString) && !node.info?.sourceManagers?.includes("spotify")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'spotify' enabled");
+    }
+    if (LinkMatchers.appleMusic.test(queryString) && !node.info?.sourceManagers?.includes("applemusic")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'applemusic' enabled");
+    }
+    if (LinkMatchers.AllDeezerRegex.test(queryString) && !node.info?.sourceManagers?.includes("deezer")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'deezer' enabled");
+    }
+    if (LinkMatchers.musicYandex.test(queryString) && !node.info?.sourceManagers?.includes("yandexmusic")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'yandexmusic' enabled");
+    }
+    if (LinkMatchers.jiosaavn.test(queryString) && !node.info?.sourceManagers?.includes("jiosaavn")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'jiosaavn' (via jio-engine) enabled");
+    }
+    if (LinkMatchers.tidal.test(queryString) && !node.info?.sourceManagers?.includes("tidal")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'tidal' enabled");
+    }
+    if (LinkMatchers.AllPandoraRegex.test(queryString) && !node.info?.sourceManagers?.includes("pandora")) {
+      throw new Error("Query / Link Provided for this Source but Audio Node has not 'pandora' enabled");
+    }
+    return;
+  }
+  findSourceOfQuery(queryString) {
+    const foundSource = Object.keys(SourceMappings).find((source) => queryString?.toLowerCase?.()?.startsWith(`${source}:`.toLowerCase()))?.trim?.()?.toLowerCase?.();
+    if (foundSource && !["https", "http"].includes(foundSource) && SourceMappings[foundSource]) {
+      return foundSource;
+    }
+    return null;
+  }
+  extractSourceOfQuery(searchQuery) {
+    const foundSource = this.findSourceOfQuery(searchQuery.query);
+    if (foundSource) {
+      searchQuery.source = SourceMappings[foundSource];
+      searchQuery.query = searchQuery.query.slice(`${foundSource}:`.length, searchQuery.query.length);
+    }
+    return searchQuery;
+  }
+  typedLowerCase(input) {
+    if (!input) return input;
+    if (typeof input === "string") return input.toLowerCase();
+    return input;
+  }
+  transformQuery(query) {
+    const typedDefault = this.typedLowerCase(this.RyanlinkManager?.options?.playerOptions?.defaultSearchPlatform);
+    if (typeof query === "string") {
+      const Query = {
+        query,
+        extraQueryUrlParams: void 0,
+        source: typedDefault
+      };
+      return this.extractSourceOfQuery(Query);
+    }
+    const providedSource = query?.source?.trim?.()?.toLowerCase?.();
+    const validSourceExtracted = SourceMappings[providedSource ?? typedDefault];
+    return this.extractSourceOfQuery({
+      query: query.query,
+      extraQueryUrlParams: query.extraQueryUrlParams,
+      source: validSourceExtracted ?? providedSource ?? typedDefault
+    });
+  }
+  transformAudioSearchQuery(query) {
+    const typedDefault = this.typedLowerCase(this.RyanlinkManager?.options?.playerOptions?.defaultSearchPlatform);
+    if (typeof query === "string") {
+      const Query2 = {
+        query,
+        types: [],
+        extraQueryUrlParams: void 0,
+        source: typedDefault
+      };
+      return this.extractSourceOfQuery(Query2);
+    }
+    const providedSource = query?.source?.trim?.()?.toLowerCase?.();
+    const validSourceExtracted = SourceMappings[providedSource ?? typedDefault];
+    const Query = {
+      query: query.query,
+      types: query.types ? ["track", "playlist", "artist", "album", "text"].filter((v) => query.types?.find((x) => x.toLowerCase().startsWith(v))) : ["track", "playlist", "artist", "album"],
+      source: validSourceExtracted ?? providedSource ?? typedDefault
+    };
+    return this.extractSourceOfQuery(Query);
+  }
+  validateSourceString(node, sourceString) {
+    if (!sourceString) throw new Error(`No SourceString was provided`);
+    const source = SourceMappings[sourceString.toLowerCase().trim()];
+    if (!source && !!this.RyanlinkManager.options.playerOptions.allowCustomSources)
+      throw new Error(
+        `Ryanlink does not support SearchQuerySource: '${sourceString}'. You can disable this check by setting 'ManagerOptions.PlayerOptions.allowCustomSources' to true`
+      );
+    if (!node.info) throw new Error("Audio Node does not have any info cached yet, not ready yet!");
+    if (!node._checkForSources) return;
+    if (source === "amsearch" && !node.info?.sourceManagers?.includes("applemusic")) {
+      throw new Error("Audio Node has not 'applemusic' enabled, which is required to have 'amsearch' work");
+    }
+    if (source === "dzisrc" && !node.info?.sourceManagers?.includes("deezer")) {
+      throw new Error("Audio Node has not 'deezer' enabled, which is required to have 'dzisrc' work");
+    }
+    if (source === "dzsearch" && !node.info?.sourceManagers?.includes("deezer")) {
+      throw new Error("Audio Node has not 'deezer' enabled, which is required to have 'dzsearch' work");
+    }
+    if (source === "dzisrc" && node.info?.sourceManagers?.includes("deezer") && !node.info?.sourceManagers?.includes("http")) {
+      throw new Error("Audio Node has not 'http' enabled, which is required to have 'dzisrc' to work");
+    }
+    if (source === "jsrec" && !node.info?.sourceManagers?.includes("jiosaavn")) {
+      throw new Error("Audio Node has not 'jiosaavn' (via jio-engine) enabled, which is required to have 'jsrec' to work");
+    }
+    if (source === "jssearch" && !node.info?.sourceManagers?.includes("jiosaavn")) {
+      throw new Error("Audio Node has not 'jiosaavn' (via jio-engine) enabled, which is required to have 'jssearch' to work");
+    }
+    if (source === "scsearch" && !node.info?.sourceManagers?.includes("soundcloud")) {
+      throw new Error("Audio Node has not 'soundcloud' enabled, which is required to have 'scsearch' work");
+    }
+    if (source === "speak" && node._checkForPlugins && !node.info?.plugins?.find((c) => c.name.toLowerCase().includes(BuiltinSources.DuncteBot_Plugin.toLowerCase()))) {
+      throw new Error("Audio Node has not 'speak' enabled, which is required to have 'speak' work");
+    }
+    if (source === "tdsearch" && !node.info?.sourceManagers?.includes("tidal")) {
+      throw new Error("Audio Node has not 'tidal' enabled, which is required to have 'tdsearch' work");
+    }
+    if (source === "tdrec" && !node.info?.sourceManagers?.includes("tidal")) {
+      throw new Error("Audio Node has not 'tidal' enabled, which is required to have 'tdrec' work");
+    }
+    if (source === "tts" && node._checkForPlugins && !node.info?.plugins?.find((c) => c.name.toLowerCase().includes(BuiltinSources.GoogleCloudTTS.toLowerCase()))) {
+      throw new Error("Audio Node has not 'tts' enabled, which is required to have 'tts' work");
+    }
+    if (source === "ftts" && !(node.info?.sourceManagers?.includes("ftts") || node.info?.sourceManagers?.includes("flowery-tts") || node.info?.sourceManagers?.includes("flowerytts"))) {
+      throw new Error("Audio Node has not 'flowery-tts' enabled, which is required to have 'ftts' work");
+    }
+    if (source === "ymsearch" && !node.info?.sourceManagers?.includes("yandexmusic")) {
+      throw new Error("Audio Node has not 'yandexmusic' enabled, which is required to have 'ymsearch' work");
+    }
+    if (source === "ytmsearch" && !node.info?.sourceManagers?.includes("youtube")) {
+      throw new Error("Audio Node has not 'youtube' enabled, which is required to have 'ytmsearch' work");
+    }
+    if (source === "ytsearch" && !node.info?.sourceManagers?.includes("youtube")) {
+      throw new Error("Audio Node has not 'youtube' enabled, which is required to have 'ytsearch' work");
+    }
+    if (source === "vksearch" && !node.info?.sourceManagers?.includes("vkmusic")) {
+      throw new Error("Audio Node has not 'vkmusic' enabled, which is required to have 'vksearch' work");
+    }
+    if (source === "vkrec" && !node.info?.sourceManagers?.includes("vkmusic")) {
+      throw new Error("Audio Node has not 'vkmusic' enabled, which is required to have 'vkrec' work");
+    }
+    if (source === "qbsearch" && !node.info?.sourceManagers?.includes("qobuz")) {
+      throw new Error("Audio Node has not 'qobuz' enabled, which is required to have 'qbsearch' work");
+    }
+    if (source === "qbisrc" && !node.info?.sourceManagers?.includes("qobuz")) {
+      throw new Error("Audio Node has not 'qobuz' enabled, which is required to have 'qbisrc' work");
+    }
+    if (source === "qbrec" && !node.info?.sourceManagers?.includes("qobuz")) {
+      throw new Error("Audio Node has not 'qobuz' enabled, which is required to have 'qbrec' work");
+    }
+    if (["pdsearch", "pdisrc", "pdrec"].includes(source) && !node.info?.sourceManagers?.includes("pandora")) {
+      throw new Error("Audio Node has not 'pandora' enabled, which is required to have '" + source + "' work");
+    }
+    return;
+  }
+};
+var MiniMap = class extends Map {
+  constructor(data = []) {
+    super(data);
+  }
+  filter(fn, thisArg) {
+    if (typeof thisArg !== "undefined") fn = fn.bind(thisArg);
+    const results = new this.constructor[Symbol.species]();
+    for (const [key, val] of this) {
+      if (fn(val, key, this)) results.set(key, val);
+    }
+    return results;
+  }
+  toJSON() {
+    return [...this.entries()];
+  }
+  map(fn, thisArg) {
+    if (typeof thisArg !== "undefined") fn = fn.bind(thisArg);
+    const iter = this.entries();
+    return Array.from({ length: this.size }, () => {
+      const [key, value] = iter.next().value;
+      return fn(value, key, this);
+    });
+  }
+};
+async function queueTrackEnd(player, dontShiftQueue = false) {
+  if (player.queue.current && !player.queue.current?.pluginInfo?.clientData?.previousTrack) {
+    player.queue.previous.unshift(player.queue.current);
+    if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
+      player.queue.previous.splice(player.queue.options.maxPreviousTracks, player.queue.previous.length);
+    await player.queue.utils.save();
+  }
+  if (player.repeatMode === "queue" && player.queue.current) player.queue.tracks.push(player.queue.current);
+  const nextSong = dontShiftQueue ? null : player.queue.tracks.shift();
+  try {
+    if (nextSong && player.RyanlinkManager.utils.isUnresolvedTrack(nextSong)) await nextSong.resolve(player);
+    player.queue.current = nextSong || null;
+    await player.queue.utils.save();
+  } catch (error) {
+    if (player.RyanlinkManager.options?.advancedOptions?.enableDebugEvents) {
+      player.RyanlinkManager.emit("debug", "PlayerPlayUnresolvedTrackFailed" /* PlayerPlayUnresolvedTrackFailed */, {
+        state: "error",
+        error,
+        message: `queueTrackEnd Util was called, tried to resolve the next track, but failed to find the closest matching song`,
+        functionLayer: "Player > play() > resolve currentTrack"
+      });
+    }
+    player.RyanlinkManager.emit("trackError", player, player.queue.current, error);
+    if (!dontShiftQueue && player.RyanlinkManager.options?.autoSkipOnResolveError === true && player.queue.tracks[0]) return queueTrackEnd(player);
+  }
+  return player.queue.current;
+}
+async function applyUnresolvedData(resTrack, data, utils) {
+  if (!resTrack?.info || !data?.info) return;
+  if (data.info.uri) resTrack.info.uri = data.info.uri;
+  if (utils?.RyanlinkManager?.options?.playerOptions?.useUnresolvedData === true) {
+    if (data.info.artworkUrl?.length) resTrack.info.artworkUrl = data.info.artworkUrl;
+    if (data.info.title?.length) resTrack.info.title = data.info.title;
+    if (data.info.author?.length) resTrack.info.author = data.info.author;
+  } else {
+    if ((resTrack.info.title === "Unknown title" || resTrack.info.title === "Unspecified description") && resTrack.info.title != data.info.title)
+      resTrack.info.title = data.info.title;
+    if (resTrack.info.author !== data.info.author) resTrack.info.author = data.info.author;
+    if (resTrack.info.artworkUrl !== data.info.artworkUrl) resTrack.info.artworkUrl = data.info.artworkUrl;
+  }
+  for (const key of Object.keys(data.info))
+    if (typeof resTrack.info[key] === "undefined" && key !== "resolve" && data.info[key]) resTrack.info[key] = data.info[key];
+  return resTrack;
+}
+async function getClosestTrack(data, player) {
+  if (!player || !player.node) throw new RangeError("No player with a ryanlink node was provided");
+  if (player.RyanlinkManager.utils.isTrack(data)) return player.RyanlinkManager.utils.buildTrack(data, data.requester);
+  if (!player.RyanlinkManager.utils.isUnresolvedTrack(data)) throw new RangeError("Track is not an unresolved Track");
+  if (!data?.info?.title && typeof data.encoded !== "string" && !data.info.uri)
+    throw new SyntaxError("the track uri / title / encoded Base64 string is required for unresolved tracks");
+  if (!data.requester) throw new SyntaxError("The requester is required");
+  if (typeof data.encoded === "string") {
+    const r = await player.node.decode.singleTrack(data.encoded, data.requester);
+    if (r) return applyUnresolvedData(r, data, player.RyanlinkManager.utils);
+  }
+  if (typeof data.info.uri === "string") {
+    const r = await player.search({ query: data?.info?.uri }, data.requester).then((v) => v.tracks?.[0]);
+    if (r) return applyUnresolvedData(r, data, player.RyanlinkManager.utils);
+  }
+  const query = [data.info?.title, data.info?.author].filter((str) => !!str).join(" by ");
+  const sourceName = data.info?.sourceName;
+  return await player.search(
+    {
+      query,
+      source: sourceName !== "twitch" && sourceName !== "flowery-tts" ? sourceName : player.RyanlinkManager.options?.playerOptions?.defaultSearchPlatform
+    },
+    data.requester
+  ).then((res) => {
+    let trackToUse = null;
+    if ((data.info?.title || data.info?.author) && !trackToUse)
+      trackToUse = res.tracks.find(
+        (track) => [data.info?.author || "", `${data.info?.author} - Topic`].some(
+          (name) => new RegExp(`^${escapeRegExp(name)}$`, "i").test(track.info?.author)
+        ) || new RegExp(`^${escapeRegExp(data.info?.title)}$`, "i").test(track.info?.title)
+      );
+    if (data.info?.isrc && !trackToUse) trackToUse = res.tracks.find((track) => track.info?.isrc === data.info?.isrc);
+    if (data.info?.duration && !trackToUse)
+      trackToUse = res.tracks.find(
+        (track) => track.info?.duration >= data.info?.duration - 1500 && track?.info.duration <= data.info?.duration + 1500
+      );
+    return applyUnresolvedData(trackToUse || res.tracks[0], data, player.RyanlinkManager.utils);
+  });
+}
+function safeStringify(obj, padding = 0) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    obj,
+    (key, value) => {
+      if (typeof value === "function") return void 0;
+      if (typeof value === "symbol") return void 0;
+      if (typeof value === "bigint") return value.toString();
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) return "[Circular]";
+        seen.add(value);
+      }
+      return value;
+    },
+    padding
+  );
+}
+
+// src/node/Node.ts
+var RyanlinkNode = class _RyanlinkNode {
+  heartBeatPingTimestamp = 0;
+  heartBeatPongTimestamp = 0;
+  heartBeatInterval;
+  pingTimeout;
+  nodeType = "Core";
+  isAlive = false;
+  static _NodeLinkClass = null;
+  options;
+  calls = 0;
+  stats = {
+    players: 0,
+    playingPlayers: 0,
+    cpu: {
+      cores: 0,
+      audioLoad: 0,
+      systemLoad: 0
+    },
+    memory: {
+      allocated: 0,
+      free: 0,
+      reservable: 0,
+      used: 0
+    },
+    uptime: 0,
+    detailedStats: {
+      api: {
+        requests: {},
+        errors: {}
+      },
+      sources: {},
+      playback: {
+        events: {}
+      }
+    },
+    frameStats: {
+      deficit: 0,
+      nulled: 0,
+      sent: 0
+    }
+  };
+  sessionId = null;
+  resuming = { enabled: true, timeout: null };
+  info = null;
+  reconnectionState = "IDLE" /* IDLE */;
+  NodeManager = null;
+  reconnectTimeout = void 0;
+  reconnectAttempts = [];
+  socket = null;
+  version = "v4";
+  get _LManager() {
+    return this.NodeManager.RyanlinkManager;
+  }
+  get heartBeatPing() {
+    return this.heartBeatPongTimestamp - this.heartBeatPingTimestamp;
+  }
+  get _checkForPlugins() {
+    if (this.nodeType === "NodeLink") return false;
+    return !!this.options?.autoChecks?.pluginValidations;
+  }
+  get _checkForSources() {
+    return !!this.options?.autoChecks?.sourcesValidations;
+  }
+  dispatchDebug(name, eventData) {
+    if (!this._LManager.options?.advancedOptions?.enableDebugEvents) return;
+    this._LManager.emit("debug", name, eventData);
+  }
+  get connected() {
+    return this.socket && this.socket.readyState === import_ws.default.OPEN;
+  }
+  get connectionStatus() {
+    if (!this.socket) throw new Error("no websocket was initialized yet");
+    return ["CONNECTING", "OPEN", "CLOSING", "CLOSED"][this.socket.readyState] || "UNKNOWN";
+  }
+  constructor(options, manager) {
+    this.options = {
+      secure: false,
+      retryAmount: 5,
+      retryDelay: 1e4,
+      retryTimespan: -1,
+      requestSignalTimeoutMS: 1e4,
+      heartBeatInterval: 3e4,
+      enablePingOnStatsCheck: true,
+      closeOnError: true,
+      ...options,
+      autoChecks: {
+        sourcesValidations: options?.autoChecks?.sourcesValidations ?? true,
+        pluginValidations: options?.autoChecks?.pluginValidations ?? true
+      }
+    };
+    if (this.options.nodeType === "NodeLink" && this.constructor.name === "RyanlinkNode" && _RyanlinkNode._NodeLinkClass) {
+      return new _RyanlinkNode._NodeLinkClass(options, manager);
+    }
+    this.nodeType = this.options.nodeType || "Core";
+    this.NodeManager = manager;
+    this.validate();
+    if (this.options.secure && this.options.port !== 443) throw new SyntaxError("If secure is true, then the port must be 443");
+    this.options.regions = (this.options.regions || []).map((a) => a.toLowerCase());
+    Object.defineProperty(this, AudioNodeSymbol, { configurable: true, value: true });
+  }
+  async rawRequest(endpoint, modify) {
+    const options = {
+      path: `/${this.version}/${endpoint.startsWith("/") ? endpoint.slice(1) : endpoint}`,
+      method: "GET",
+      headers: {
+        Authorization: this.options.authorization
+      },
+      signal: this.options.requestSignalTimeoutMS && this.options.requestSignalTimeoutMS > 0 ? AbortSignal.timeout(this.options.requestSignalTimeoutMS) : void 0
+    };
+    modify?.(options);
+    const url = new URL(`${this.restAddress}${options.path}`);
+    url.searchParams.append("trace", "true");
+    if (options.extraQueryUrlParams && options.extraQueryUrlParams?.size > 0) {
+      for (const [paramKey, paramValue] of options.extraQueryUrlParams.entries()) {
+        url.searchParams.append(paramKey, paramValue);
+      }
+    }
+    const urlToUse = url.toString();
+    const { path, extraQueryUrlParams, ...fetchOptions } = options;
+    const response = await fetch(urlToUse, fetchOptions);
+    this.calls++;
+    return { response, options };
+  }
+  async request(endpoint, modify, parseAsText) {
+    if (!this.connected) throw new Error("The node is not connected to the Ryanlink Server!, Please call node.connect() first!");
+    const { response, options } = await this.rawRequest(endpoint, modify);
+    if (["DELETE", "PUT"].includes(options.method)) return;
+    if (response.status === 204) return;
+    if (response.status === 404)
+      throw new Error(`Node Request resulted into an error, request-PATH: ${options.path} | headers: ${safeStringify(response.headers)}`);
+    return parseAsText ? await response.text() : await response.json();
+  }
+  async search(query, requestUser, throwOnEmpty = false) {
+    const Query = this._LManager.utils.transformQuery(query);
+    this._LManager.utils.validateQueryString(this, Query.query, Query.source);
+    if (Query.source) this._LManager.utils.validateSourceString(this, Query.source);
+    if (["bcsearch", "bandcamp"].includes(Query.source) && this._checkForSources && !this.info.sourceManagers.includes("bandcamp")) {
+      throw new Error("Bandcamp Search only works on the player (audio-engine version < 2.2.0!");
+    }
+    const requestUrl = new URL(`${this.restAddress}/loadtracks`);
+    if (/^https?:\/\//.test(Query.query)) {
+      requestUrl.searchParams.append("identifier", Query.query);
+    } else {
+      const fttsPrefix = Query.source === "ftts" ? "//" : "";
+      const prefix = Query.source !== "local" ? `${Query.source}:${fttsPrefix}` : "";
+      requestUrl.searchParams.append("identifier", `${prefix}${Query.query}`);
+    }
+    const requestPathAndSearch = requestUrl.pathname + requestUrl.search;
+    const res = await this.request(requestPathAndSearch, (options) => {
+      if (typeof query === "object" && typeof query.extraQueryUrlParams?.size === "number" && query.extraQueryUrlParams?.size > 0) {
+        options.extraQueryUrlParams = query.extraQueryUrlParams;
+      }
+    });
+    const resTracks = res.loadType === "playlist" ? res.data?.tracks : res.loadType === "track" ? [res.data] : res.loadType === "search" ? Array.isArray(res.data) ? res.data : [res.data] : [];
+    if (throwOnEmpty === true && (res.loadType === "empty" || !resTracks.length)) {
+      this.dispatchDebug("SearchNothingFound" /* SearchNothingFound */, {
+        state: "warn",
+        message: `Search found nothing for Request: "${Query.source ? `${Query.source}:` : ""}${Query.query}"`,
+        functionLayer: "(RyanlinkNode > node | player) > search()"
+      });
+      throw new Error("Nothing found");
+    }
+    return {
+      loadType: res.loadType,
+      exception: res.loadType === "error" ? res.data : null,
+      pluginInfo: res.pluginInfo || {},
+      playlist: res.loadType === "playlist" ? {
+        name: res.data.info?.name || res.data.pluginInfo?.name || null,
+        title: res.data.info?.name || res.data.pluginInfo?.name || null,
+        author: res.data.info?.author || res.data.pluginInfo?.author || null,
+        thumbnail: res.data.info?.artworkUrl || res.data.pluginInfo?.artworkUrl || (typeof res.data?.info?.selectedTrack !== "number" || res.data?.info?.selectedTrack === -1 ? null : resTracks[res.data?.info?.selectedTrack] ? resTracks[res.data?.info?.selectedTrack]?.info?.artworkUrl || resTracks[res.data?.info?.selectedTrack]?.info?.pluginInfo?.artworkUrl : null) || null,
+        uri: res.data.info?.url || res.data.info?.uri || res.data.info?.link || res.data.pluginInfo?.url || res.data.pluginInfo?.uri || res.data.pluginInfo?.link || null,
+        selectedTrack: typeof res.data?.info?.selectedTrack !== "number" || res.data?.info?.selectedTrack === -1 ? null : resTracks[res.data?.info?.selectedTrack] ? this._LManager.utils.buildTrack(resTracks[res.data?.info?.selectedTrack], requestUser) : null,
+        duration: resTracks.length ? resTracks.reduce(
+          (acc, cur) => acc + (cur?.info?.duration || cur?.info?.length || 0),
+          0
+        ) : 0
+      } : null,
+      tracks: resTracks.length ? resTracks.map((t) => this._LManager.utils.buildTrack(t, requestUser)) : []
+    };
+  }
+  async audioSearch(query, requestUser, throwOnEmpty = false) {
+    const Query = this._LManager.utils.transformAudioSearchQuery(query);
+    if (Query.source) this._LManager.utils.validateSourceString(this, Query.source);
+    if (/^https?:\/\//.test(Query.query)) return this.search({ query: Query.query, source: Query.source }, requestUser);
+    if (!["spsearch", "sprec", "amsearch", "dzsearch", "dzisrc", "ytmsearch", "ytsearch"].includes(Query.source))
+      throw new SyntaxError(
+        `Query.source must be a source from LavaSrc: "spsearch" | "sprec" | "amsearch" | "dzsearch" | "dzisrc" | "ytmsearch" | "ytsearch"`
+      );
+    if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "search-engine"))
+      throw new RangeError(`there is no search-engine available in the ryanlink node: ${this.id}`);
+    if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "source-engine"))
+      throw new RangeError(`there is no source-engine available in the ryanlink node: ${this.id}`);
+    const { response } = await this.rawRequest(
+      `/loadsearch?query=${Query.source ? `${Query.source}:` : ""}${encodeURIComponent(Query.query)}${Query.types?.length ? `&types=${Query.types.join(",")}` : ""}`
+    );
+    const res = response.status === 204 ? {} : await response.json();
+    if (throwOnEmpty === true && !Object.entries(res).flat().filter(Boolean).length) {
+      this.dispatchDebug("SearchNothingFound" /* SearchNothingFound */, {
+        state: "warn",
+        message: `LavaSearch found nothing for Request: "${Query.source ? `${Query.source}:` : ""}${Query.query}"`,
+        functionLayer: "(RyanlinkNode > node | player) > audioSearch()"
+      });
+      throw new Error("Nothing found");
+    }
+    return {
+      tracks: res.tracks?.map((v) => this._LManager.utils.buildTrack(v, requestUser)) || [],
+      albums: res.albums?.map((v) => ({
+        info: v.info,
+        pluginInfo: v?.plugin || v.pluginInfo,
+        tracks: v.tracks.map((v2) => this._LManager.utils.buildTrack(v2, requestUser))
+      })) || [],
+      artists: res.artists?.map((v) => ({
+        info: v.info,
+        pluginInfo: v?.plugin || v.pluginInfo,
+        tracks: v.tracks.map((v2) => this._LManager.utils.buildTrack(v2, requestUser))
+      })) || [],
+      playlists: res.playlists?.map((v) => ({
+        info: v.info,
+        pluginInfo: v?.plugin || v.pluginInfo,
+        tracks: v.tracks.map((v2) => this._LManager.utils.buildTrack(v2, requestUser))
+      })) || [],
+      texts: res.texts?.map((v) => ({
+        text: v.text,
+        pluginInfo: v?.plugin || v.pluginInfo
+      })) || [],
+      pluginInfo: res.pluginInfo || res?.plugin
+    };
+  }
+  async updatePlayer(data) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    this.syncPlayerData(data);
+    const res = await this.request(`/sessions/${this.sessionId}/players/${data.guildId}`, (r) => {
+      r.method = "PATCH";
+      r.headers["Content-Type"] = "application/json";
+      r.body = safeStringify(data.playerOptions);
+      if (data.noReplace) {
+        const url = new URL(`${this.restAddress}${r.path}`);
+        url.searchParams.append("noReplace", data.noReplace === true && typeof data.noReplace === "boolean" ? "true" : "false");
+        r.path = url.pathname + url.search;
+      }
+    });
+    this.dispatchDebug("PlayerUpdateSuccess" /* PlayerUpdateSuccess */, {
+      state: "log",
+      message: `Player get's updated with following payload :: ${safeStringify(data.playerOptions, 3)}`,
+      functionLayer: "RyanlinkNode > node > updatePlayer()"
+    });
+    this.syncPlayerData({}, res);
+    return res;
+  }
+  async destroyPlayer(guildId) {
+    if (!this.sessionId) throw new Error("The Ryanlink-Node is either not ready, or not up to date!");
+    return this.request(`/sessions/${this.sessionId}/players/${guildId}`, (r) => {
+      r.method = "DELETE";
+    });
+  }
+  connect(sessionId) {
+    if (this.connected) {
+      this.dispatchDebug("TryingConnectWhileConnected" /* TryingConnectWhileConnected */, {
+        state: "warn",
+        message: `Tryed to connect to node, but it's already connected!`,
+        functionLayer: "RyanlinkNode > node > connect()"
+      });
+      return;
+    }
+    const headers = {
+      Authorization: this.options.authorization,
+      "User-Id": this._LManager.options.client.id,
+      "Client-Name": `${"ryanlink"}/${"2.0.0"}`
+    };
+    if (typeof this.options.sessionId === "string" || typeof sessionId === "string") {
+      headers["Session-Id"] = this.options.sessionId || sessionId;
+      this.sessionId = this.options.sessionId || sessionId;
+    }
+    this.socket = new import_ws.default(`ws${this.options.secure ? "s" : ""}://${this.options.host}:${this.options.port}`, { headers });
+    this.socket.on("open", this.open.bind(this));
+    this.socket.on("close", (code, reason) => this.close(code, reason?.toString()));
+    this.socket.on("message", this.message.bind(this));
+    this.socket.on("error", this.error.bind(this));
+  }
+  heartBeat() {
+    if (this.nodeType !== "Core") return;
+    this.dispatchDebug("HeartBeatTriggered" /* HeartBeatTriggered */, {
+      state: "log",
+      message: `Node Socket Heartbeat triggered, resetting old Timeout to 65000ms (should happen every 60s due to /stats event)`,
+      functionLayer: "RyanlinkNode > nodeEvent > stats > heartBeat()"
+    });
+    this.resetAckTimeouts(false, true);
+    this.pingTimeout = setTimeout(() => {
+      this.pingTimeout = null;
+      if (!this.socket) {
+        return this.dispatchDebug("NoSocketOnDestroy" /* NoSocketOnDestroy */, {
+          state: "error",
+          message: `Heartbeat registered a disconnect, but socket didn't exist therefore can't terminate`,
+          functionLayer: "RyanlinkNode > nodeEvent > stats > heartBeat() > timeoutHit"
+        });
+      }
+      this.dispatchDebug("SocketTerminateHeartBeatTimeout" /* SocketTerminateHeartBeatTimeout */, {
+        state: "warn",
+        message: `Heartbeat registered a disconnect, because timeout wasn't resetted in time. Terminating Web-Socket`,
+        functionLayer: "RyanlinkNode > nodeEvent > stats > heartBeat() > timeoutHit"
+      });
+      this.isAlive = false;
+      this.socket.terminate();
+    }, 65e3);
+  }
+  get id() {
+    return this.options.id || `${this.options.host}:${this.options.port}`;
+  }
+  destroy(destroyReason, deleteNode = true, movePlayers = false) {
+    this.reconnectionState = "IDLE" /* IDLE */;
+    const players = this._LManager.players.filter((p) => p.node.id === this.id);
+    if (!players?.size) {
+      this.socket?.close(1e3, "Node-Destroy");
+      this.socket?.removeAllListeners();
+      this.socket = null;
+      this.resetReconnectionAttempts();
+      if (!deleteNode)
+        return void this.NodeManager.emit("disconnect", this, {
+          code: 1e3,
+          reason: destroyReason
+        });
+      this.NodeManager.emit("destroy", this, destroyReason);
+      this.NodeManager.nodes.delete(this.id);
+      this.resetAckTimeouts(true, true);
+      return;
+    }
+    const handlePlayerOperations = () => {
+      if (!movePlayers) {
+        return Promise.allSettled(
+          Array.from(players.values()).map(
+            (player) => player.destroy(destroyReason || "NodeDestroy" /* NodeDestroy */).catch((error) => {
+              this.dispatchDebug("PlayerDestroyFail" /* PlayerDestroyFail */, {
+                state: "error",
+                message: `Failed to destroy player ${player.guildId}: ${error.message}`,
+                error,
+                functionLayer: "Node > destroy() > movePlayers"
+              });
+            })
+          )
+        );
+      }
+      const nodeToMove = Array.from(this.NodeManager.leastUsedNodes("playingPlayers")).find((n) => n.connected && n.options.id !== this.id);
+      if (!nodeToMove) {
+        return Promise.allSettled(
+          Array.from(players.values()).map(
+            (player) => player.destroy("PlayerChangeNodeFailNoEligibleNode" /* PlayerChangeNodeFailNoEligibleNode */).catch((error) => {
+              this.dispatchDebug("PlayerChangeNodeFailNoEligibleNode" /* PlayerChangeNodeFailNoEligibleNode */, {
+                state: "error",
+                message: `Failed to destroy player ${player.guildId}: ${error.message}`,
+                error,
+                functionLayer: "Node > destroy() > movePlayers"
+              });
+            })
+          )
+        );
+      }
+      return Promise.allSettled(
+        Array.from(players.values()).map(
+          (player) => player.changeNode(nodeToMove.options.id).catch((error) => {
+            this.dispatchDebug("PlayerChangeNodeFail" /* PlayerChangeNodeFail */, {
+              state: "error",
+              message: `Failed to move player ${player.guildId}: ${error.message}`,
+              error,
+              functionLayer: "Node > destroy() > movePlayers"
+            });
+            return player.destroy(error.message ?? "PlayerChangeNodeFail" /* PlayerChangeNodeFail */).catch((destroyError) => {
+              this.dispatchDebug("PlayerDestroyFail" /* PlayerDestroyFail */, {
+                state: "error",
+                message: `Failed to destroy player ${player.guildId} after move failure: ${destroyError.message}`,
+                error: destroyError,
+                functionLayer: "Node > destroy() > movePlayers"
+              });
+            });
+          })
+        )
+      );
+    };
+    return void handlePlayerOperations().finally(() => {
+      this.socket?.close(1e3, "Node-Destroy");
+      this.socket?.removeAllListeners();
+      this.socket = null;
+      this.resetReconnectionAttempts();
+      if (!deleteNode)
+        return void this.NodeManager.emit("disconnect", this, {
+          code: 1e3,
+          reason: destroyReason
+        });
+      this.NodeManager.emit("destroy", this, destroyReason);
+      this.NodeManager.nodes.delete(this.id);
+      this.resetAckTimeouts(true, true);
+      return;
+    });
+  }
+  disconnect(disconnectReason) {
+    if (!this.connected) return;
+    this.socket?.close(1e3, "Node-Disconnect");
+    this.socket?.removeAllListeners();
+    this.socket = null;
+    this.reconnectionState = "IDLE" /* IDLE */;
+    this.resetReconnectionAttempts();
+    this.NodeManager.emit("disconnect", this, { code: 1e3, reason: disconnectReason });
+  }
+  async fetchAllPlayers() {
+    if (!this.sessionId) throw new Error("The Ryanlink-Node is either not ready, or not up to date!");
+    return this.request(`/sessions/${this.sessionId}/players`) || [];
+  }
+  async fetchPlayer(guildId) {
+    if (!this.sessionId) throw new Error("The Ryanlink-Node is either not ready, or not up to date!");
+    return this.request(`/sessions/${this.sessionId}/players/${guildId}`);
+  }
+  async updateSession(resuming, timeout) {
+    if (!this.sessionId) throw new Error("the Ryanlink-Node is either not ready, or not up to date!");
+    const data = {};
+    if (typeof resuming === "boolean") data.resuming = resuming;
+    if (typeof timeout === "number" && timeout > 0) data.timeout = timeout;
+    this.resuming = {
+      enabled: typeof resuming === "boolean" ? resuming : false,
+      timeout: typeof resuming === "boolean" && resuming === true ? timeout : null
+    };
+    return this.request(`/sessions/${this.sessionId}`, (r) => {
+      r.method = "PATCH";
+      r.headers = { Authorization: this.options.authorization, "Content-Type": "application/json" };
+      r.body = safeStringify(data);
+    });
+  }
+  decode = {
+    singleTrack: async (encoded, requester) => {
+      if (!encoded) throw new SyntaxError("No encoded (Base64 string) was provided");
+      return this._LManager.utils?.buildTrack(
+        await this.request(`/decodetrack?encodedTrack=${encodeURIComponent(encoded.replace(/\s/g, ""))}`),
+        requester
+      );
+    },
+    multipleTracks: async (encodeds, requester) => {
+      if (!Array.isArray(encodeds) || !encodeds.every((v) => typeof v === "string" && v.length > 1))
+        throw new SyntaxError("You need to provide encodeds, which is an array of base64 strings");
+      return await this.request(`/decodetracks`, (r) => {
+        r.method = "POST";
+        r.body = safeStringify(encodeds);
+        r.headers["Content-Type"] = "application/json";
+      }).then((r) => r.map((track) => this._LManager.utils.buildTrack(track, requester)));
+    }
+  };
+  lyrics = {
+    get: async (track, skipTrackSource = false) => {
+      if (!this.sessionId) throw new Error("the Ryanlink-Node is either not ready, or not up to date!");
+      if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "lavalyrics-plugin"))
+        throw new RangeError(`there is no lavalyrics-plugin available in the ryanlink node (required for lyrics): ${this.id}`);
+      if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "source-engine") && this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "lyrics-engine"))
+        throw new RangeError(
+          `there is no lyrics source (via source-engine / lyrics-engine) available in the ryanlink node (required for lyrics): ${this.id}`
+        );
+      const url = `/lyrics?track=${track.encoded}&skipTrackSource=${skipTrackSource}`;
+      return await this.request(url);
+    },
+    getCurrent: async (guildId, skipTrackSource = false) => {
+      if (!this.sessionId) throw new Error("the Ryanlink-Node is either not ready, or not up to date!");
+      if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "lavalyrics-plugin"))
+        throw new RangeError(`there is no lavalyrics-plugin available in the ryanlink node (required for lyrics): ${this.id}`);
+      if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "source-engine") && this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "lyrics-engine"))
+        throw new RangeError(
+          `there is no lyrics source (via source-engine / lyrics-engine) available in the ryanlink node (required for lyrics): ${this.id}`
+        );
+      const url = `/sessions/${this.sessionId}/players/${guildId}/track/lyrics?skipTrackSource=${skipTrackSource}`;
+      return await this.request(url);
+    },
+    subscribe: async (guildId, skipTrackSource) => {
+      if (!this.sessionId) throw new Error("the Ryanlink-Node is either not ready, or not up to date!");
+      if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "lavalyrics-plugin"))
+        throw new RangeError(`there is no lavalyrics-plugin available in the ryanlink node (required for lyrics): ${this.id}`);
+      return await this.request(
+        `/sessions/${this.sessionId}/players/${guildId}/lyrics/subscribe?skipTrackSource=${skipTrackSource ?? false}`,
+        (options) => {
+          options.method = "POST";
+        }
+      );
+    },
+    unsubscribe: async (guildId) => {
+      if (!this.sessionId) throw new Error("the Ryanlink-Node is either not ready, or not up to date!");
+      if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "lavalyrics-plugin"))
+        throw new RangeError(`there is no lavalyrics-plugin available in the ryanlink node (required for lyrics): ${this.id}`);
+      return await this.request(`/sessions/${this.sessionId}/players/${guildId}/lyrics/subscribe`, (options) => {
+        options.method = "DELETE";
+      });
+    }
+  };
+  async fetchStats() {
+    return await this.request(`/stats`);
+  }
+  async fetchConnectionMetrics() {
+    if (this.info && !this.info.isNodelink)
+      throw new Error("There is no Information about wether you are using NodeLink instead of Lavalink, so this function won't work");
+    return await this.request(`/connection`);
+  }
+  async fetchVersion() {
+    return await this.request(
+      `/version`,
+      (r) => {
+        r.path = "/version";
+      },
+      true
+    );
+  }
+  async fetchInfo() {
+    return await this.request(`/info`);
+  }
+  nodeMetricSummary() {
+    if (!this.connected || !this.isAlive)
+      return {
+        systemLoad: 0,
+        cpuLoad: 0,
+        memoryUsage: 0,
+        players: 0,
+        playingPlayers: 0,
+        uptime: 0,
+        ping: 0,
+        frameDeficit: 0
+      };
+    const _memoryUsed = this.stats.memory.used;
+    const _memoryAllocated = this.stats.memory.allocated;
+    return {
+      systemLoad: this.stats.cpu.systemLoad,
+      cpuLoad: this.stats.cpu.audioLoad,
+      memoryUsage: _memoryAllocated > 0 ? _memoryUsed / _memoryAllocated * 100 : 0,
+      players: this.stats.players,
+      playingPlayers: this.stats.playingPlayers,
+      uptime: this.stats.uptime,
+      ping: this.heartBeatPing,
+      frameDeficit: this.stats.frameStats?.deficit || 0
+    };
+  }
+  getHealthStatus(thresholds) {
+    const cpuThresholds = {
+      excellent: 0.3,
+      good: 0.5,
+      fair: 0.7,
+      poor: 0.85,
+      ...thresholds?.cpu
+    };
+    const memoryThresholds = {
+      excellent: 60,
+      good: 75,
+      fair: 85,
+      poor: 95,
+      ...thresholds?.memory
+    };
+    const pingThresholds = {
+      excellent: 50,
+      good: 100,
+      fair: 200,
+      poor: 300,
+      ...thresholds?.ping
+    };
+    const recommendations = [];
+    const metrics = this.nodeMetricSummary();
+    if (!this.connected || !this.isAlive) {
+      return {
+        status: "offline",
+        performance: "poor",
+        isOverloaded: false,
+        needsRestart: true,
+        penaltyScore: 999999,
+        estimatedRemainingCapacity: 0,
+        recommendations: [RecommendationsStrings.nodeOffline, RecommendationsStrings.checkConnectivity],
+        metrics
+      };
+    }
+    let cpuScore = 0;
+    if (metrics.cpuLoad < cpuThresholds.excellent) cpuScore = 4;
+    else if (metrics.cpuLoad < cpuThresholds.good) cpuScore = 3;
+    else if (metrics.cpuLoad < cpuThresholds.fair) cpuScore = 2;
+    else if (metrics.cpuLoad < cpuThresholds.poor) cpuScore = 1;
+    let memoryScore = 0;
+    if (metrics.memoryUsage < memoryThresholds.excellent) memoryScore = 4;
+    else if (metrics.memoryUsage < memoryThresholds.good) memoryScore = 3;
+    else if (metrics.memoryUsage < memoryThresholds.fair) memoryScore = 2;
+    else if (metrics.memoryUsage < memoryThresholds.poor) memoryScore = 1;
+    let pingScore = 0;
+    if (metrics.ping < pingThresholds.excellent) pingScore = 4;
+    else if (metrics.ping < pingThresholds.good) pingScore = 3;
+    else if (metrics.ping < pingThresholds.fair) pingScore = 2;
+    else if (metrics.ping < pingThresholds.poor) pingScore = 1;
+    const avgScore = (cpuScore + memoryScore + pingScore) / 3;
+    let performance2 = "poor";
+    if (avgScore >= 3.5) performance2 = "excellent";
+    else if (avgScore >= 2.5) performance2 = "good";
+    else if (avgScore >= 1.5) performance2 = "fair";
+    const isOverloaded = metrics.cpuLoad > cpuThresholds.fair || metrics.memoryUsage > memoryThresholds.fair || metrics.frameDeficit > 100;
+    const isCritical = metrics.cpuLoad > cpuThresholds.poor || metrics.memoryUsage > memoryThresholds.poor || metrics.frameDeficit > 500;
+    const status = isCritical ? "critical" : isOverloaded ? "degraded" : "healthy";
+    const needsRestart = status === "critical" || isOverloaded && metrics.memoryUsage > 90 || metrics.frameDeficit > 1e3 || this.reconnectionAttemptCount > 0 && this.reconnectionAttemptCount >= this.options.retryAmount / 2;
+    if (metrics.cpuLoad > cpuThresholds.fair) recommendations.push(RecommendationsStrings.highCPULoad(metrics.cpuLoad));
+    if (metrics.systemLoad > 0.8) recommendations.push(RecommendationsStrings.highSystemLoad(metrics.systemLoad));
+    if (metrics.memoryUsage > memoryThresholds.fair) recommendations.push(RecommendationsStrings.highMemoryUsage(metrics.memoryUsage));
+    if (metrics.frameDeficit > 100) recommendations.push(RecommendationsStrings.frameDeficit(metrics.frameDeficit));
+    if (metrics.ping > pingThresholds.fair) recommendations.push(RecommendationsStrings.highLatency(metrics.ping));
+    if (needsRestart) recommendations.push(RecommendationsStrings.nodeRestart);
+    if (metrics.players > 500) recommendations.push(RecommendationsStrings.highPlayercount(metrics.players));
+    const nullFrames = this.stats.frameStats?.nulled || 0;
+    let penaltyScore = metrics.players + Math.pow(metrics.cpuLoad * 100, 2) + Math.pow(metrics.memoryUsage, 1.5) + metrics.ping * 2 + metrics.frameDeficit * 10 + nullFrames * 5;
+    if (status === "critical") penaltyScore += 1e4;
+    else if (status === "degraded") penaltyScore += 5e3;
+    if (this.reconnectionAttemptCount > 0) penaltyScore += this.reconnectionAttemptCount * 1e3;
+    penaltyScore = Math.round(penaltyScore);
+    let estimatedRemainingCapacity = 0;
+    if (status !== "critical") {
+      const cpuCapacity = metrics.players === 0 ? 200 : metrics.cpuLoad > 0 ? Math.max(0, Math.floor((cpuThresholds.fair - metrics.cpuLoad) / metrics.cpuLoad * metrics.players)) : 200;
+      const memoryCapacity = metrics.players === 0 ? 200 : metrics.memoryUsage > 0 ? Math.max(0, Math.floor((memoryThresholds.fair - metrics.memoryUsage) / metrics.memoryUsage * metrics.players)) : 200;
+      estimatedRemainingCapacity = Math.min(Math.min(cpuCapacity, memoryCapacity), 500);
+      if (isOverloaded) estimatedRemainingCapacity = 0;
+    }
+    return {
+      status,
+      performance: performance2,
+      isOverloaded,
+      needsRestart,
+      penaltyScore,
+      estimatedRemainingCapacity,
+      recommendations,
+      metrics
+    };
+  }
+  routePlannerApi = {
+    getStatus: async () => {
+      if (!this.sessionId) throw new Error("the Ryanlink-Node is either not ready, or not up to date!");
+      return await this.request(`/routeplanner/status`);
+    },
+    unmarkFailedAddress: async (address) => {
+      if (!this.sessionId) throw new Error("the Ryanlink-Node is either not ready, or not up to date!");
+      return await this.request(`/routeplanner/free/address`, (r) => {
+        r.method = "POST";
+        r.headers["Content-Type"] = "application/json";
+        r.body = safeStringify({ address });
+      });
+    },
+    unmarkAllFailedAddresses: async () => {
+      if (!this.sessionId) throw new Error("the Ryanlink-Node is either not ready, or not up to date!");
+      return await this.request(`/routeplanner/free/all`, (r) => {
+        r.method = "POST";
+        r.headers["Content-Type"] = "application/json";
+      });
+    }
+  };
+  validate() {
+    if (!this.options.authorization) throw new SyntaxError("RyanlinkNode requires 'authorization'");
+    if (!this.options.host) throw new SyntaxError("RyanlinkNode requires 'host'");
+    if (!this.options.port) throw new SyntaxError("RyanlinkNode requires 'port'");
+    if (typeof this.options.port !== "number" || this.options.port < 1 || this.options.port > 65535)
+      throw new SyntaxError("RyanlinkNode.port must be a number within 1 and 65535");
+    if (this.options.closeOnError !== void 0 && typeof this.options.closeOnError !== "boolean")
+      throw new SyntaxError("RyanlinkNode.closeOnError must be either false | true aka boolean");
+    if (this.options.retryDelay !== void 0 && typeof this.options.retryDelay !== "number")
+      throw new SyntaxError("NodeConfiguration.retryDelay must be a number");
+    if (this.options.retryAmount !== void 0 && typeof this.options.retryAmount !== "number")
+      throw new SyntaxError("NodeConfiguration.retryAmount must be a number");
+    if (this.options.retryTimespan !== void 0 && typeof this.options.retryTimespan !== "number")
+      throw new SyntaxError("NodeConfiguration.retryTimespan must be a number");
+    if (this.options.requestSignalTimeoutMS !== void 0 && typeof this.options.requestSignalTimeoutMS !== "number")
+      throw new SyntaxError("NodeConfiguration.requestSignalTimeoutMS must be a number");
+    if (this.options.heartBeatInterval !== void 0 && typeof this.options.heartBeatInterval !== "number")
+      throw new SyntaxError("NodeConfiguration.heartBeatInterval must be a number");
+    if (this.options.enablePingOnStatsCheck !== void 0 && typeof this.options.enablePingOnStatsCheck !== "boolean")
+      throw new SyntaxError("NodeConfiguration.enablePingOnStatsCheck must be either false | true aka boolean");
+    if (this.options.autoChecks !== void 0 && typeof this.options.autoChecks !== "object")
+      throw new SyntaxError("RyanlinkNode.autoChecks must be an object");
+    if (this.options?.autoChecks?.sourcesValidations !== void 0 && typeof this.options?.autoChecks?.sourcesValidations !== "boolean")
+      throw new SyntaxError("RyanlinkNode.autoChecks.sourcesValidations must be either false | true aka boolean");
+    if (this.options?.autoChecks?.pluginValidations !== void 0 && typeof this.options?.autoChecks?.pluginValidations !== "boolean")
+      throw new SyntaxError("RyanlinkNode.autoChecks.pluginValidations must be either false | true aka boolean");
+    if (this.options.regions !== void 0 && (!Array.isArray(this.options.regions) || !this.options.regions.every((r) => typeof r === "string")))
+      throw new SyntaxError("RyanlinkNode.regions must be an Array of strings");
+  }
+  isNodeLink() {
+    return this.nodeType === "NodeLink";
+  }
+  isRyanlinkNode() {
+    return this.nodeType === "Core";
+  }
+  syncPlayerData(data, res) {
+    if (typeof data === "object" && typeof data?.guildId === "string" && typeof data.playerOptions === "object" && Object.keys(data.playerOptions).length > 0) {
+      const player = this._LManager.getPlayer(data.guildId);
+      if (!player) return;
+      if (typeof data.playerOptions.paused !== "undefined") {
+        player.paused = data.playerOptions.paused;
+        player.playing = !data.playerOptions.paused;
+      }
+      if (typeof data.playerOptions.position === "number") {
+        player.lastPosition = data.playerOptions.position;
+        player.lastPositionChange = Date.now();
+      }
+      if (typeof data.playerOptions.voice !== "undefined") player.voice = data.playerOptions.voice;
+      if (typeof data.playerOptions.volume !== "undefined") {
+        if (this._LManager.options.playerOptions.volumeDecrementer) {
+          player.volume = Math.round(data.playerOptions.volume / this._LManager.options.playerOptions.volumeDecrementer);
+          player.internalVolume = Math.round(data.playerOptions.volume);
+        } else {
+          player.volume = Math.round(data.playerOptions.volume);
+          player.internalVolume = Math.round(data.playerOptions.volume);
+        }
+      }
+      if (typeof data.playerOptions.filters !== "undefined") {
+        const oldFilterTimescale = { ...player.filterManager.data.timescale };
+        Object.freeze(oldFilterTimescale);
+        if (data.playerOptions.filters.timescale) player.filterManager.data.timescale = data.playerOptions.filters.timescale;
+        if (data.playerOptions.filters.distortion) player.filterManager.data.distortion = data.playerOptions.filters.distortion;
+        if (data.playerOptions.filters.pluginFilters) player.filterManager.data.pluginFilters = data.playerOptions.filters.pluginFilters;
+        if (data.playerOptions.filters.vibrato) player.filterManager.data.vibrato = data.playerOptions.filters.vibrato;
+        if (data.playerOptions.filters.volume) player.filterManager.data.volume = data.playerOptions.filters.volume;
+        if (data.playerOptions.filters.equalizer) player.filterManager.equalizerBands = data.playerOptions.filters.equalizer;
+        if (data.playerOptions.filters.karaoke) player.filterManager.data.karaoke = data.playerOptions.filters.karaoke;
+        if (data.playerOptions.filters.lowPass) player.filterManager.data.lowPass = data.playerOptions.filters.lowPass;
+        if (data.playerOptions.filters.rotation) player.filterManager.data.rotation = data.playerOptions.filters.rotation;
+        if (data.playerOptions.filters.tremolo) player.filterManager.data.tremolo = data.playerOptions.filters.tremolo;
+        player.filterManager.checkFiltersState(oldFilterTimescale);
+      }
+    }
+    if (typeof res?.guildId === "string" && typeof res?.voice !== "undefined") {
+      const player = this._LManager.getPlayer(data.guildId);
+      if (!player) return;
+      if (typeof res?.voice?.connected === "boolean" && res.voice.connected === false) {
+        player.destroy("NodeNoVoice" /* NodeNoVoice */);
+        return;
+      }
+      player.ping.ws = res?.voice?.ping || player?.ping.ws;
+    }
+    return;
+  }
+  get restAddress() {
+    return `http${this.options.secure ? "s" : ""}://${this.options.host}:${this.options.port}`;
+  }
+  get isNodeReconnecting() {
+    return this.reconnectionState !== "IDLE" /* IDLE */;
+  }
+  reconnect(force = false) {
+    if (this.isNodeReconnecting) {
+      return;
+    }
+    this.reconnectionState = "PENDING" /* PENDING */;
+    this.NodeManager.emit("reconnectinprogress", this);
+    if (force) {
+      this.executeReconnect();
+      return;
+    }
+    if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      this.executeReconnect();
+    }, this.options.retryDelay || 1e3);
+  }
+  get reconnectionAttemptCount() {
+    const maxAllowedTimestan = this.options.retryTimespan || -1;
+    if (maxAllowedTimestan <= 0) return this.reconnectAttempts.length;
+    return this.reconnectAttempts.filter((timestamp) => Date.now() - timestamp <= maxAllowedTimestan).length;
+  }
+  executeReconnect() {
+    if (this.reconnectionAttemptCount >= this.options.retryAmount) {
+      const error = new Error(`Unable to connect after ${this.options.retryAmount} attempts.`);
+      this.reconnectionState = "DESTROYING" /* DESTROYING */;
+      this.NodeManager.emit("error", this, error);
+      this.destroy("NodeReconnectFail" /* NodeReconnectFail */);
+      return;
+    }
+    const MAX_RECONNECT_ATTEMPTS = 1e3;
+    this.reconnectAttempts.push(Date.now());
+    if (this.reconnectAttempts.length > MAX_RECONNECT_ATTEMPTS) {
+      this.reconnectAttempts = this.reconnectAttempts.slice(-MAX_RECONNECT_ATTEMPTS);
+    }
+    this.reconnectionState = "RECONNECTING" /* RECONNECTING */;
+    this.NodeManager.emit("reconnecting", this);
+    this.connect();
+  }
+  resetReconnectionAttempts() {
+    this.reconnectionState = "IDLE" /* IDLE */;
+    this.reconnectAttempts = [];
+    clearTimeout(this.reconnectTimeout);
+    this.reconnectTimeout = null;
+    return;
+  }
+  resetAckTimeouts(heartbeat = true, ping = true) {
+    if (ping) {
+      if (this.pingTimeout) clearTimeout(this.pingTimeout);
+      this.pingTimeout = null;
+    }
+    if (heartbeat) {
+      if (this.heartBeatInterval) clearInterval(this.heartBeatInterval);
+      this.heartBeatInterval = null;
+    }
+    return;
+  }
+  async open() {
+    this.isAlive = true;
+    this.resetReconnectionAttempts();
+    if (this.nodeType === "Core") {
+      if (this.options.enablePingOnStatsCheck) this.heartBeat();
+      if (this.heartBeatInterval) clearInterval(this.heartBeatInterval);
+      if (this.options.heartBeatInterval > 0) {
+        this.socket.on("pong", () => {
+          this.heartBeatPongTimestamp = performance.now();
+          this.isAlive = true;
+        });
+        this.heartBeatInterval = setInterval(() => {
+          if (!this.socket) return console.error("Node-Heartbeat-Interval - Socket not available - maybe reconnecting?");
+          if (!this.isAlive) return this.close(500, "Node-Heartbeat-Timeout");
+          this.isAlive = false;
+          this.heartBeatPingTimestamp = performance.now();
+          this.socket?.ping?.();
+        }, this.options.heartBeatInterval || 3e4);
+      }
+    }
+    this.info = await this.fetchInfo().catch((e) => (console.error(e, "ON-OPEN-FETCH"), null));
+    if (!this.info && ["v3", "v4"].includes(this.version)) {
+      const errorString = `Audio Node(${this.restAddress}) does not provide any / ${this.version}/info`;
+      throw new Error(errorString);
+    }
+    this.info.isNodelink = !!this.info.isNodelink;
+    this.NodeManager.emit("connect", this);
+    console.log(`\x1B[32m[Ryanlink]\x1B[0m Node \x1B[36m${this.id}\x1B[0m connected successfully.`);
+  }
+  close(code, reason) {
+    this.resetAckTimeouts(true, true);
+    try {
+      if (this.socket) {
+        this.socket.removeAllListeners();
+        this.socket = null;
+      }
+    } catch (e) {
+      if (this.NodeManager?.RyanlinkManager?.options?.advancedOptions?.enableDebugEvents) {
+        this._LManager.emit("debug", "SocketCleanupError" /* SocketCleanupError */, {
+          state: "warn",
+          message: `An error occurred during socket cleanup in close() (likely a race condition): ${e.message}`,
+          functionLayer: "RyanlinkNode > close()"
+        });
+      }
+    }
+    this.isAlive = false;
+    if (code === 1006 && !reason) reason = "Socket got terminated due to no ping connection";
+    if (code === 1e3 && reason === "Node-Disconnect") return;
+    this.NodeManager.emit("disconnect", this, { code, reason });
+    if (code !== 1e3 || reason !== "Node-Destroy") {
+      if (this.NodeManager.nodes.has(this.id)) {
+        this.reconnect();
+      }
+    }
+    this._LManager.players.filter((p) => p?.node?.options?.id === this?.options?.id).forEach((p) => {
+      if (!this._LManager.options.autoMove) return p.playing = false;
+      if (this._LManager.options.autoMove) {
+        if (this.NodeManager.nodes.filter((n) => n.connected).size === 0) return p.playing = false;
+        p.moveNode();
+      }
+    });
+  }
+  error(error) {
+    if (!error) return;
+    this.NodeManager.emit("error", this, error);
+    this.reconnectionState = "IDLE" /* IDLE */;
+    if (this.options.closeOnError) {
+      if (this.heartBeatInterval) clearInterval(this.heartBeatInterval);
+      if (this.pingTimeout) clearTimeout(this.pingTimeout);
+      this.socket?.close(500, "Node-Error - Force Reconnect");
+      return;
+    }
+    this.reconnect();
+  }
+  async message(d) {
+    if (Array.isArray(d)) d = Buffer.concat(d);
+    else if (d instanceof ArrayBuffer) d = Buffer.from(d);
+    let payload;
+    try {
+      payload = JSON.parse(d.toString());
+    } catch (e) {
+      this.NodeManager.emit("error", this, e);
+      return;
+    }
+    if (!payload.op) return;
+    this.NodeManager.emit("raw", this, payload);
+    switch (payload.op) {
+      case "stats":
+        if (this.options.enablePingOnStatsCheck) this.heartBeat();
+        delete payload.op;
+        this.stats = { ...payload };
+        break;
+      case "playerUpdate":
+        {
+          const player = this._LManager.getPlayer(payload.guildId);
+          if (!player)
+            return this.dispatchDebug("PlayerUpdateNoPlayer" /* PlayerUpdateNoPlayer */, {
+              state: "error",
+              message: `PlayerUpdate Event Triggered, but no player found of payload.guildId: ${payload.guildId}`,
+              functionLayer: "RyanlinkNode > nodeEvent > playerUpdate"
+            });
+          const oldPlayer = player?.toJSON();
+          player.lastPositionChange = Date.now();
+          player.lastPosition = payload.state.position || 0;
+          player.connected = payload.state.connected;
+          player.ping.ws = payload.state.ping >= 0 ? payload.state.ping : player.ping.ws <= 0 && player.connected ? null : player.ping.ws || 0;
+          if (!player.createdTimeStamp && payload.state.time) player.createdTimeStamp = payload.state.time;
+          if (player.filterManager.filterUpdatedState === true && ((player.queue.current?.info?.duration || 0) <= (player.RyanlinkManager.options.advancedOptions.maxFilterFixDuration || 6e5) || player.queue.current?.info?.uri && (0, import_node_path.isAbsolute)(player.queue.current?.info?.uri))) {
+            player.filterManager.filterUpdatedState = false;
+            this.dispatchDebug("PlayerUpdateFilterFixApply" /* PlayerUpdateFilterFixApply */, {
+              state: "log",
+              message: `Fixing FilterState on "${player.guildId}" because player.options.instaUpdateFiltersFix === true`,
+              functionLayer: "RyanlinkNode > nodeEvent > playerUpdate"
+            });
+            await player.seek(player.position);
+          }
+          this._LManager.emit("playerUpdate", oldPlayer, player);
+        }
+        break;
+      case "event":
+        this.handleEvent(payload);
+        break;
+      case "ready":
+        this.resetReconnectionAttempts();
+        this.sessionId = payload.sessionId;
+        this.resuming.enabled = payload.resumed;
+        if (payload.resumed === true) {
+          try {
+            this.NodeManager.emit("resumed", this, payload, await this.fetchAllPlayers());
+          } catch (e) {
+            this.dispatchDebug("ResumingFetchingError" /* ResumingFetchingError */, {
+              state: "error",
+              message: `Failed to fetch players for resumed event, falling back without players array`,
+              error: e,
+              functionLayer: "RyanlinkNode > nodeEvent > resumed"
+            });
+            this.NodeManager.emit("resumed", this, payload, []);
+          }
+        }
+        break;
+      default:
+        this.NodeManager.emit("error", this, new Error(`Unexpected op "${payload.op}" with data`), payload);
+        return;
+    }
+  }
+  async handleEvent(payload) {
+    if (!payload?.guildId) return;
+    const player = this._LManager.getPlayer(payload.guildId);
+    if (!player) return;
+    const NodeLinkEventType = payload.type;
+    if (NodeLinkExclusiveEvents.includes(NodeLinkEventType) && (!this.info || this.info.isNodelink)) {
+      return this.nodeLinkEventHandler(
+        NodeLinkEventType,
+        player,
+        player.queue.current,
+        payload
+      );
+    }
+    switch (payload.type) {
+      case "TrackStartEvent":
+        this.trackStart(player, player.queue.current, payload);
+        break;
+      case "TrackEndEvent":
+        this.trackEnd(player, player.queue.current, payload);
+        break;
+      case "TrackStuckEvent":
+        this.trackStuck(player, player.queue.current, payload);
+        break;
+      case "TrackExceptionEvent":
+        this.trackError(player, player.queue.current, payload);
+        break;
+      case "WebSocketClosedEvent":
+        this.socketClosed(player, payload);
+        break;
+      case "SegmentsLoaded":
+        this.SponsorBlockSegmentLoaded(player, player.queue.current, payload);
+        break;
+      case "SegmentSkipped":
+        this.SponsorBlockSegmentSkipped(player, player.queue.current, payload);
+        break;
+      case "ChaptersLoaded":
+        this.SponsorBlockChaptersLoaded(player, player.queue.current, payload);
+        break;
+      case "ChapterStarted":
+        this.SponsorBlockChapterStarted(player, player.queue.current, payload);
+        break;
+      case "LyricsLineEvent":
+        this.LyricsLine(player, player.queue.current, payload);
+        break;
+      case "LyricsFoundEvent":
+        this.LyricsFound(player, player.queue.current, payload);
+        break;
+      case "LyricsNotFoundEvent":
+        this.LyricsNotFound(player, player.queue.current, payload);
+        break;
+      default:
+        this.NodeManager.emit(
+          "error",
+          this,
+          new Error(`Node#event unknown event '${payload.type}'.`),
+          payload
+        );
+        break;
+    }
+    return;
+  }
+  async nodeLinkEventHandler(eventName, player, track, payload) {
+    this.NodeManager.emit("nodeLinkEvent", this, eventName, player, track, payload);
+  }
+  getTrackOfPayload(payload) {
+    return "track" in payload ? this._LManager.utils.buildTrack(payload.track, void 0) : null;
+  }
+  async trackStart(player, track, payload) {
+    if (!player.getData("internal_nodeChanging")) {
+      player.playing = true;
+      player.paused = false;
+    }
+    if (this._LManager.options?.emitNewSongsOnly === true && player.queue.previous[0]?.info?.identifier === track?.info?.identifier) {
+      return this.dispatchDebug("TrackStartNewSongsOnly" /* TrackStartNewSongsOnly */, {
+        state: "log",
+        message: `TrackStart not Emitting, because playing the previous song again.`,
+        functionLayer: "RyanlinkNode > trackStart()"
+      });
+    }
+    if (!player.queue.current) {
+      player.queue.current = this.getTrackOfPayload(payload);
+      if (player.queue.current) {
+        await player.queue.utils.save();
+      } else {
+        this.dispatchDebug("TrackStartNoTrack" /* TrackStartNoTrack */, {
+          state: "warn",
+          message: `Trackstart emitted but there is no track on player.queue.current, trying to get the track of the payload failed too.`,
+          functionLayer: "RyanlinkNode > trackStart()"
+        });
+      }
+    }
+    this._LManager.emit("trackStart", player, player.queue.current, payload);
+    return;
+  }
+  async trackEnd(player, track, payload) {
+    if (player.getData("internal_nodeChanging") === true) return;
+    const trackToUse = track || this.getTrackOfPayload(payload);
+    if (payload.reason === "replaced") {
+      this.dispatchDebug("TrackEndReplaced" /* TrackEndReplaced */, {
+        state: "warn",
+        message: `TrackEnd Event does not handle any playback, because the track was replaced.`,
+        functionLayer: "RyanlinkNode > trackEnd()"
+      });
+      this._LManager.emit("trackEnd", player, trackToUse, payload);
+      return;
+    }
+    if (!player.queue.tracks.length && (player.repeatMode === "off" || player.getData("internal_stopPlaying")))
+      return this.queueEnd(player, track, payload);
+    if (["loadFailed", "cleanup"].includes(payload.reason)) {
+      if (player.getData("internal_destroystatus") === true) return;
+      await queueTrackEnd(player);
+      if (!player.queue.current) return this.queueEnd(player, trackToUse, payload);
+      this._LManager.emit("trackEnd", player, trackToUse, payload);
+      if (this._LManager.options.autoSkip && player.queue.current) {
+        player.play({ noReplace: true });
+      }
+      return;
+    }
+    if (player.repeatMode !== "track" || player.getData("internal_skipped")) await queueTrackEnd(player);
+    else if (trackToUse && !trackToUse?.pluginInfo?.clientData?.previousTrack) {
+      player.queue.previous.unshift(trackToUse);
+      if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
+        player.queue.previous.splice(player.queue.options.maxPreviousTracks, player.queue.previous.length);
+      await player.queue.utils.save();
+    }
+    if (!player.queue.current) return this.queueEnd(player, trackToUse, payload);
+    player.setData("internal_skipped", false);
+    this._LManager.emit("trackEnd", player, trackToUse, payload);
+    if (this._LManager.options.autoSkip && player.queue.current) {
+      player.play({ noReplace: true });
+    }
+    return;
+  }
+  async trackStuck(player, track, payload) {
+    if (this._LManager.options.playerOptions.maxErrorsPerTime?.threshold > 0 && this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount >= 0) {
+      const oldTimestamps = (player.getData("internal_erroredTracksTimestamps") || []).filter(
+        (v) => Date.now() - v < this._LManager.options.playerOptions.maxErrorsPerTime?.threshold
+      );
+      player.setData("internal_erroredTracksTimestamps", [...oldTimestamps, Date.now()]);
+      if (oldTimestamps.length >= this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount) {
+        this.dispatchDebug("TrackStuckMaxTracksErroredPerTime" /* TrackStuckMaxTracksErroredPerTime */, {
+          state: "log",
+          message: `trackStuck Event was triggered too often within a given threshold (RyanlinkManager.options.playerOptions.maxErrorsPerTime). Threshold: "${this._LManager.options.playerOptions.maxErrorsPerTime?.threshold}ms", maxAmount: "${this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount}"`,
+          functionLayer: "RyanlinkNode > trackStuck()"
+        });
+        player.destroy("TrackStuckMaxTracksErroredPerTime" /* TrackStuckMaxTracksErroredPerTime */);
+        return;
+      }
+    }
+    this._LManager.emit("trackStuck", player, track || this.getTrackOfPayload(payload), payload);
+    if (!player.queue.tracks.length && (player.repeatMode === "off" || player.getData("internal_stopPlaying"))) {
+      try {
+        await player.node.updatePlayer({
+          guildId: player.guildId,
+          playerOptions: { track: { encoded: null } }
+        });
+        return;
+      } catch {
+        return this.queueEnd(player, track || this.getTrackOfPayload(payload), payload);
+      }
+    }
+    await queueTrackEnd(player);
+    if (!player.queue.current) {
+      return this.queueEnd(player, track || this.getTrackOfPayload(payload), payload);
+    }
+    if (this._LManager.options.autoSkip && player.queue.current) {
+      player.play({ track: player.queue.current, noReplace: false });
+    }
+    return;
+  }
+  async trackError(player, track, payload) {
+    if (this._LManager.options.playerOptions.maxErrorsPerTime?.threshold > 0 && this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount >= 0) {
+      const oldTimestamps = (player.getData("internal_erroredTracksTimestamps") || []).filter(
+        (v) => Date.now() - v < this._LManager.options.playerOptions.maxErrorsPerTime?.threshold
+      );
+      player.setData("internal_erroredTracksTimestamps", [...oldTimestamps, Date.now()]);
+      if (oldTimestamps.length >= this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount) {
+        this.dispatchDebug("TrackErrorMaxTracksErroredPerTime" /* TrackErrorMaxTracksErroredPerTime */, {
+          state: "log",
+          message: `TrackError Event was triggered too often within a given threshold (RyanlinkManager.options.playerOptions.maxErrorsPerTime). Threshold: "${this._LManager.options.playerOptions.maxErrorsPerTime?.threshold}ms", maxAmount: "${this._LManager.options.playerOptions.maxErrorsPerTime?.maxAmount}"`,
+          functionLayer: "RyanlinkNode > trackError()"
+        });
+        player.destroy("TrackErrorMaxTracksErroredPerTime" /* TrackErrorMaxTracksErroredPerTime */);
+        return;
+      }
+    }
+    this._LManager.emit("trackError", player, track || this.getTrackOfPayload(payload), payload);
+    return;
+  }
+  socketClosed(player, payload) {
+    this._LManager.emit("playerSocketClosed", player, payload);
+    return;
+  }
+  SponsorBlockSegmentLoaded(player, track, payload) {
+    this._LManager.emit("SegmentsLoaded", player, track || this.getTrackOfPayload(payload), payload);
+    return;
+  }
+  SponsorBlockSegmentSkipped(player, track, payload) {
+    this._LManager.emit("SegmentSkipped", player, track || this.getTrackOfPayload(payload), payload);
+    return;
+  }
+  SponsorBlockChaptersLoaded(player, track, payload) {
+    this._LManager.emit("ChaptersLoaded", player, track || this.getTrackOfPayload(payload), payload);
+    return;
+  }
+  SponsorBlockChapterStarted(player, track, payload) {
+    this._LManager.emit("ChapterStarted", player, track || this.getTrackOfPayload(payload), payload);
+    return;
+  }
+  async getSponsorBlock(player) {
+    if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "sponsorblock-plugin"))
+      throw new RangeError(`there is no sponsorblock-plugin available in the ryanlink node: ${this.id}`);
+    return await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`);
+  }
+  async setSponsorBlock(player, segments = ["sponsor", "selfpromo"]) {
+    if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "sponsorblock-plugin"))
+      throw new RangeError(`there is no sponsorblock-plugin available in the ryanlink node: ${this.id}`);
+    if (!segments.length) throw new RangeError("No Segments provided. Did you ment to use 'deleteSponsorBlock'?");
+    if (segments.some((v) => !validSponsorBlocks.includes(v.toLowerCase())))
+      throw new SyntaxError(`You provided a sponsorblock which isn't valid, valid ones are: ${validSponsorBlocks.map((v) => `'${v}'`).join(", ")}`);
+    await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, (r) => {
+      r.method = "PUT";
+      r.headers = {
+        Authorization: this.options.authorization,
+        "Content-Type": "application/json"
+      };
+      r.body = safeStringify(segments.map((v) => v.toLowerCase()));
+    });
+    player.setData(
+      "internal_sponsorBlockCategories",
+      segments.map((v) => v.toLowerCase())
+    );
+    this.dispatchDebug("SetSponsorBlock" /* SetSponsorBlock */, {
+      state: "log",
+      message: `SponsorBlock was set for Player: ${player.guildId} to: ${segments.map((v) => `'${v.toLowerCase()}'`).join(", ")}`,
+      functionLayer: "RyanlinkNode > setSponsorBlock()"
+    });
+    return;
+  }
+  async deleteSponsorBlock(player) {
+    if (this._checkForPlugins && !this.info?.plugins?.find?.((v) => v.name === "sponsorblock-plugin"))
+      throw new RangeError(`there is no sponsorblock-plugin available in the ryanlink node: ${this.id}`);
+    await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, (r) => {
+      r.method = "DELETE";
+    });
+    player.setData("internal_sponsorBlockCategories", []);
+    this.dispatchDebug("DeleteSponsorBlock" /* DeleteSponsorBlock */, {
+      state: "log",
+      message: `SponsorBlock was deleted for Player: ${player.guildId}`,
+      functionLayer: "RyanlinkNode > deleteSponsorBlock()"
+    });
+    return;
+  }
+  async queueEnd(player, track, payload) {
+    if (player.getData("internal_nodeChanging") === true) return;
+    player.queue.current = null;
+    player.playing = false;
+    player.setData("internal_stopPlaying", void 0);
+    this.dispatchDebug("QueueEnded" /* QueueEnded */, {
+      state: "log",
+      message: `Queue Ended because no more Tracks were in the Queue, due to EventName: "${payload.type}"`,
+      functionLayer: "RyanlinkNode > queueEnd()"
+    });
+    if (typeof this._LManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function" && typeof player.getData("internal_autoplayStopPlaying") === "undefined") {
+      this.dispatchDebug("AutoplayExecution" /* AutoplayExecution */, {
+        state: "log",
+        message: `Now Triggering Autoplay.`,
+        functionLayer: "RyanlinkNode > queueEnd() > autoplayFunction"
+      });
+      const previousAutoplayTime = player.getData("internal_previousautoplay");
+      const duration = previousAutoplayTime ? Date.now() - previousAutoplayTime : 0;
+      if (!duration || duration > this._LManager.options.playerOptions.minAutoPlayMs || !!player.getData("internal_skipped")) {
+        await this._LManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
+        player.setData("internal_previousautoplay", Date.now());
+        if (player.queue.tracks.length > 0) await queueTrackEnd(player);
+        else
+          this.dispatchDebug("AutoplayNoSongsAdded" /* AutoplayNoSongsAdded */, {
+            state: "warn",
+            message: `Autoplay was triggered but no songs were added to the queue.`,
+            functionLayer: "RyanlinkNode > queueEnd() > autoplayFunction"
+          });
+      }
+      if (player.queue.current) {
+        if (payload.type === "TrackEndEvent") this._LManager.emit("trackEnd", player, track, payload);
+        if (this._LManager.options.autoSkip) return player.play({ noReplace: true, paused: false });
+      } else {
+        this.dispatchDebug("AutoplayThresholdSpamLimiter" /* AutoplayThresholdSpamLimiter */, {
+          state: "warn",
+          message: `Autoplay was triggered after the previousautoplay too early. Threshold is: ${this._LManager.options.playerOptions.minAutoPlayMs}ms and the Duration was ${duration}ms`,
+          functionLayer: "RyanlinkNode > queueEnd() > autoplayFunction"
+        });
+      }
+    }
+    player.setData("internal_skipped", false);
+    player.setData("internal_autoplayStopPlaying", void 0);
+    if (track && !track?.pluginInfo?.clientData?.previousTrack) {
+      player.queue.previous.unshift(track);
+      if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
+        player.queue.previous.splice(player.queue.options.maxPreviousTracks, player.queue.previous.length);
+      await player.queue.utils.save();
+    }
+    if (payload?.reason !== "stopped") {
+      await player.queue.utils.save();
+    }
+    if (typeof this._LManager.options.playerOptions?.onEmptyQueue?.destroyAfterMs === "number" && !isNaN(this._LManager.options.playerOptions.onEmptyQueue?.destroyAfterMs) && this._LManager.options.playerOptions.onEmptyQueue?.destroyAfterMs >= 0) {
+      if (this._LManager.options.playerOptions.onEmptyQueue?.destroyAfterMs === 0) {
+        player.destroy("QueueEmpty" /* QueueEmpty */);
+        return;
+      } else {
+        this.dispatchDebug("TriggerQueueEmptyInterval" /* TriggerQueueEmptyInterval */, {
+          state: "log",
+          message: `Trigger Queue Empty Interval was Triggered because playerOptions.onEmptyQueue.destroyAfterMs is set to ${this._LManager.options.playerOptions.onEmptyQueue?.destroyAfterMs}ms`,
+          functionLayer: "RyanlinkNode > queueEnd() > destroyAfterMs"
+        });
+        this._LManager.emit("playerQueueEmptyStart", player, this._LManager.options.playerOptions.onEmptyQueue?.destroyAfterMs);
+        if (player.getData("internal_queueempty")) clearTimeout(player.getData("internal_queueempty"));
+        player.setData(
+          "internal_queueempty",
+          setTimeout(() => {
+            player.setData("internal_queueempty", void 0);
+            if (player.queue.current) {
+              return this._LManager.emit("playerQueueEmptyCancel", player);
+            }
+            this._LManager.emit("playerQueueEmptyEnd", player);
+            player.destroy("QueueEmpty" /* QueueEmpty */);
+          }, this._LManager.options.playerOptions.onEmptyQueue?.destroyAfterMs)
+        );
+      }
+    }
+    this._LManager.emit("queueEnd", player, track, payload);
+    return;
+  }
+  async LyricsLine(player, track, payload) {
+    if (!player.queue.current) {
+      player.queue.current = this.getTrackOfPayload(payload);
+      if (player.queue.current) {
+        await player.queue.utils.save();
+      } else {
+        this.dispatchDebug("TrackStartNoTrack" /* TrackStartNoTrack */, {
+          state: "warn",
+          message: `Trackstart emitted but there is no track on player.queue.current, trying to get the track of the payload failed too.`,
+          functionLayer: "RyanlinkNode > trackStart()"
+        });
+      }
+    }
+    this._LManager.emit("LyricsLine", player, track, payload);
+    return;
+  }
+  async LyricsFound(player, track, payload) {
+    if (!player.queue.current) {
+      player.queue.current = this.getTrackOfPayload(payload);
+      if (player.queue.current) {
+        await player.queue.utils.save();
+      } else {
+        this.dispatchDebug("TrackStartNoTrack" /* TrackStartNoTrack */, {
+          state: "warn",
+          message: `Trackstart emitted but there is no track on player.queue.current, trying to get the track of the payload failed too.`,
+          functionLayer: "RyanlinkNode > trackStart()"
+        });
+      }
+    }
+    this._LManager.emit("LyricsFound", player, track, payload);
+    return;
+  }
+  async LyricsNotFound(player, track, payload) {
+    if (!player.queue.current) {
+      player.queue.current = this.getTrackOfPayload(payload);
+      if (player.queue.current) {
+        await player.queue.utils.save();
+      } else {
+        this.dispatchDebug("TrackStartNoTrack" /* TrackStartNoTrack */, {
+          state: "warn",
+          message: `Trackstart emitted but there is no track on player.queue.current, trying to get the track of the payload failed too.`,
+          functionLayer: "RyanlinkNode > trackStart()"
+        });
+      }
+    }
+    this._LManager.emit("LyricsNotFound", player, track, payload);
+    return;
+  }
+};
+
+// src/node/NodeLink.ts
+var NodeLinkNode = class extends RyanlinkNode {
+  nodeType = "NodeLink";
+  constructor(options, manager) {
+    super(options, manager);
+    if (this.options.nodeType === "Core" && this.constructor.name === "NodeLink") {
+      return new RyanlinkNode(options, manager);
+    }
+    this.nodeType = "NodeLink";
+  }
+  async setNextTrackGapLess(player, track) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    const nextTrack = track || player.queue.tracks[0];
+    if (!nextTrack) throw new Error("No track provided");
+    await this.updatePlayer({
+      guildId: player.guildId,
+      playerOptions: { nextTrack: { encoded: nextTrack.encoded, userData: nextTrack.userData || {} } }
+    });
+    return true;
+  }
+  async removeNextTrackGapLess(player) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    await this.updatePlayer({
+      guildId: player.guildId,
+      playerOptions: { nextTrack: { encoded: null } }
+    });
+    return true;
+  }
+  async getMeaning(track) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    const encodedTrack = track?.encoded;
+    if (!encodedTrack) throw new Error("No track provided");
+    return await this.request(`/meaning?encodedTrack=${encodedTrack}`, (m) => {
+      m.method = "GET";
+    });
+  }
+  async addMixerLayer(player, trackToAdd, volume) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    return await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/mix`, (m) => {
+      m.method = "POST";
+      m.body = safeStringify({
+        track: {
+          encoded: trackToAdd.encoded,
+          userData: trackToAdd.userData
+        },
+        volume: volume / 100
+      });
+    });
+  }
+  async listMixerLayers(player) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    return await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/mix`, (m) => {
+      m.method = "GET";
+    });
+  }
+  async updateMixerLayerVolume(player, mixId, volume) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/mix/${mixId}`, (m) => {
+      m.method = "PATCH";
+      m.body = safeStringify({
+        volume: volume / 100
+      });
+    });
+    return true;
+  }
+  async removeMixerLayer(player, mixId) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/mix/${mixId}`, (m) => {
+      m.method = "DELETE";
+    });
+    return true;
+  }
+  specificFilters = {
+    echo: async (player, options, disableFilter = false) => {
+      if (disableFilter) delete player.filterManager.data.echo;
+      else player.filterManager.data.echo = options;
+      await player.filterManager.applyPlayerFilters();
+      return player.filterManager.filters.nodeLinkEcho;
+    },
+    chorus: async (player, options, disableFilter = false) => {
+      if (disableFilter) delete player.filterManager.data.chorus;
+      else player.filterManager.data.chorus = options;
+      await player.filterManager.applyPlayerFilters();
+      return player.filterManager.filters.nodeLinkChorus;
+    },
+    compressor: async (player, options, disableFilter = false) => {
+      if (disableFilter) delete player.filterManager.data.compressor;
+      else player.filterManager.data.compressor = options;
+      await player.filterManager.applyPlayerFilters();
+      return player.filterManager.filters.nodeLinkCompressor;
+    },
+    highPass: async (player, options, disableFilter = false) => {
+      if (disableFilter) delete player.filterManager.data.highPass;
+      else player.filterManager.data.highPass = options;
+      await player.filterManager.applyPlayerFilters();
+      return player.filterManager.filters.nodeLinkHighPass;
+    },
+    phaser: async (player, options, disableFilter = false) => {
+      if (disableFilter) delete player.filterManager.data.phaser;
+      else player.filterManager.data.phaser = options;
+      await player.filterManager.applyPlayerFilters();
+      return player.filterManager.filters.nodeLinkPhaser;
+    },
+    spatial: async (player, options, disableFilter = false) => {
+      if (disableFilter) delete player.filterManager.data.spatial;
+      else player.filterManager.data.spatial = options;
+      await player.filterManager.applyPlayerFilters();
+      return player.filterManager.filters.nodeLinkSpatial;
+    },
+    resetNodeLinkFilters: async (player) => {
+      delete player.filterManager.data.spatial;
+      delete player.filterManager.data.echo;
+      delete player.filterManager.data.chorus;
+      delete player.filterManager.data.compressor;
+      delete player.filterManager.data.highPass;
+      delete player.filterManager.data.phaser;
+      player.filterManager.checkFiltersState();
+      await player.filterManager.applyPlayerFilters();
+      return true;
+    }
+  };
+  async nodeLinkLyrics(player, track, language = "en") {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    const encodedTrack = track?.encoded || player.queue.current?.encoded;
+    if (!encodedTrack) throw new Error("No track provided");
+    return await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/lyrics?encodedTrack=${encodedTrack}&lang=${language}`, (m) => {
+      m.method = "GET";
+    });
+  }
+  async getChapters(player, track) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    const encodedTrack = track?.encoded || player.queue.current?.encoded;
+    if (!encodedTrack) throw new Error("No track provided");
+    return await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/chapters?encodedTrack=${encodedTrack}`, (m) => {
+      m.method = "GET";
+    });
+  }
+  async getConnectionMetrics() {
+    return await this.request(`/connection`, (m) => {
+      m.method = "GET";
+    });
+  }
+  async getDirectStream(track) {
+    return await this.request(`/trackstream?encodedTrack=${track.encoded}`, (m) => {
+      m.method = "GET";
+    });
+  }
+  async loadDirectStream(track, volume, position, filters) {
+    let requestPath = `/loadstream?encodedTrack=${track.encoded}`;
+    if (volume && volume > 0 && volume <= 100) requestPath += `&volume=${volume / 100}`;
+    if (position && position > 0) requestPath += `&position=${position}`;
+    if (filters) requestPath += `&filters=${typeof filters === "object" ? safeStringify(filters) : filters}`;
+    const res = await this.rawRequest(requestPath, (m) => {
+      m.method = "GET";
+    });
+    return res.response;
+  }
+  async changeAudioTrackLanguage(player, language_audioTrackId) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    const res = await this.request(`/sessions/${this.sessionId}/players/${player.guildId}`, (r) => {
+      r.method = "PATCH";
+      r.headers["Content-Type"] = "application/json";
+      r.body = safeStringify({
+        track: {
+          encoded: player.queue.current?.encoded,
+          position: player.position,
+          audioTrackId: language_audioTrackId
+        }
+      });
+    });
+    return res;
+  }
+  async updateYoutubeConfig(refreshToken, visitorData) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    const res = await this.request(`/youtube/config`, (r) => {
+      r.method = "PATCH";
+      r.headers["Content-Type"] = "application/json";
+      r.body = safeStringify({
+        refreshToken,
+        visitorData
+      });
+    });
+    return res;
+  }
+  async getYoutubeConfig(validate = false) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    const res = await this.request(`/youtube/config${validate ? "?validate=true" : ""}`, (r) => {
+      r.method = "GET";
+    });
+    return res;
+  }
+  async getYoutubeOAUTH(refreshToken) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    return await this.request(`/youtube/oauth?refreshToken=${refreshToken}`, (m) => {
+      m.method = "GET";
+    });
+  }
+  async updateYoutubeOAUTH(refreshToken) {
+    if (!this.sessionId) throw new Error("The Audio Node is either not ready, or not up to date!");
+    return await this.request(`/youtube/oauth`, (m) => {
+      m.method = "POST";
+      m.body = safeStringify({
+        refreshToken
+      });
+    });
+  }
+};
+RyanlinkNode._NodeLinkClass = NodeLinkNode;
+
+// src/node/NodeManager.ts
+var NodeManager = class extends import_node_events.EventEmitter {
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  removeListener(event, listener) {
+    return super.removeListener(event, listener);
+  }
+  RyanlinkManager;
+  nodes = new MiniMap();
+  constructor(RyanlinkManager2) {
+    super();
+    this.RyanlinkManager = RyanlinkManager2;
+    if (this.RyanlinkManager.options.nodes)
+      this.RyanlinkManager.options.nodes.forEach((node) => {
+        this.createNode(node);
+      });
+  }
+  async disconnectAll(deleteAllNodes = false, destroyPlayers = true) {
+    if (!this.nodes.size) throw new Error("There are no nodes to disconnect (no nodes in the nodemanager)");
+    if (!this.nodes.filter((v) => v.connected).size) throw new Error("There are no nodes to disconnect (all nodes disconnected)");
+    let counter = 0;
+    for (const node of this.nodes.values()) {
+      if (!node.connected) continue;
+      if (destroyPlayers) {
+        await node.destroy("DisconnectAllNodes" /* DisconnectAllNodes */, deleteAllNodes);
+      } else {
+        await node.disconnect("DisconnectAllNodes" /* DisconnectAllNodes */);
+      }
+      counter++;
+    }
+    return counter;
+  }
+  async connectAll() {
+    if (!this.nodes.size) throw new Error("There are no nodes to connect (no nodes in the nodemanager)");
+    if (!this.nodes.filter((v) => !v.connected).size) throw new Error("There are no nodes to connect (all nodes connected)");
+    let counter = 0;
+    for (const node of this.nodes.values()) {
+      if (node.connected) continue;
+      await node.connect();
+      counter++;
+    }
+    return counter;
+  }
+  async reconnectAll() {
+    if (!this.nodes.size) throw new Error("There are no nodes to reconnect (no nodes in the nodemanager)");
+    let counter = 0;
+    for (const node of this.nodes.values()) {
+      const sessionId = node.sessionId ? `${node.sessionId}` : void 0;
+      await node.destroy("ReconnectAllNodes" /* ReconnectAllNodes */, false);
+      await node.connect(sessionId);
+      counter++;
+    }
+    return counter;
+  }
+  createNode(options) {
+    if (this.nodes.has(options.id || `${options.host}:${options.port}`)) return this.nodes.get(options.id || `${options.host}:${options.port}`);
+    const newNode = options.nodeType === "NodeLink" ? new NodeLinkNode(options, this) : new RyanlinkNode(options, this);
+    this.nodes.set(newNode.id, newNode);
+    return newNode;
+  }
+  leastUsedNodes(sortType = "players") {
+    const connectedNodes = Array.from(this.nodes.values()).filter((node) => node.connected);
+    switch (sortType) {
+      case "memory":
+        {
+          return connectedNodes.sort((a, b) => (a.stats?.memory?.used || 0) - (b.stats?.memory?.used || 0));
+        }
+        break;
+      case "cpuLavalink":
+        {
+          return connectedNodes.sort((a, b) => (a.stats?.cpu?.audioLoad || 0) - (b.stats?.cpu?.audioLoad || 0));
+        }
+        break;
+      case "cpuSystem":
+        {
+          return connectedNodes.sort((a, b) => (a.stats?.cpu?.systemLoad || 0) - (b.stats?.cpu?.systemLoad || 0));
+        }
+        break;
+      case "calls":
+        {
+          return connectedNodes.sort((a, b) => a.calls - b.calls);
+        }
+        break;
+      case "playingPlayers":
+        {
+          return connectedNodes.sort((a, b) => (a.stats?.playingPlayers || 0) - (b.stats?.playingPlayers || 0));
+        }
+        break;
+      case "players":
+        {
+          return connectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+        }
+        break;
+      default:
+        {
+          return connectedNodes.sort((a, b) => (a.stats?.players || 0) - (b.stats?.players || 0));
+        }
+        break;
+    }
+  }
+  deleteNode(node, movePlayers = false) {
+    const decodeNode = typeof node === "string" ? this.nodes.get(node) : node;
+    if (!(decodeNode instanceof RyanlinkNode)) throw new RangeError("nodeManager.deleteNode: The node you provided is not valid or doesn't exist.");
+    if (typeof movePlayers !== "boolean") throw new TypeError("nodeManager.deleteNode: movePlayers must be a boolean");
+    decodeNode.destroy("NodeDeleted" /* NodeDeleted */, true, movePlayers);
+    this.nodes.delete(decodeNode.id);
+    return;
+  }
+  getNode(node) {
+    const decodeNode = typeof node === "string" ? this.nodes.get(node) : node;
+    if (!decodeNode) return void 0;
+    if (decodeNode.nodeType === "NodeLink") return decodeNode;
+    return decodeNode;
+  }
+};
+
+// src/audio/Filters.ts
+var DEFAULT_FILTER_DATAS = {
+  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
+  },
+  channelMix: audioOutputsData.stereo,
+  echo: {
+    delay: 0,
+    feedback: 0,
+    mix: 0
+  },
+  chorus: {
+    rate: 0,
+    depth: 0,
+    delay: 0,
+    mix: 0,
+    feedback: 0
+  },
+  compressor: {
+    threshold: 0,
+    ratio: 1,
+    attack: 0,
+    release: 0,
+    gain: 0
+  },
+  highPass: {
+    smoothing: 0
+  },
+  phaser: {
+    stages: 0,
+    rate: 0,
+    depth: 0,
+    feedback: 0,
+    mix: 0,
+    minFrequency: 0,
+    maxFrequency: 0
+  },
+  spatial: {
+    depth: 0,
+    rate: 0
+  },
+  pluginFilters: {
+    "filter-engine": {
+      echo: {
+        delay: 0,
+        decay: 0
+      },
+      reverb: {
+        delays: [],
+        gains: []
+      }
+    },
+    "high-pass": {},
+    "low-pass": {},
+    normalization: {},
+    echo: {}
+  }
+};
+var FilterManager = class {
+  static EQList = EQList;
+  equalizerBands = [];
+  filterUpdatedState = false;
+  filters = {
+    volume: false,
+    vaporwave: false,
+    custom: false,
+    nightcore: false,
+    rotation: false,
+    karaoke: false,
+    tremolo: false,
+    vibrato: false,
+    lowPass: false,
+    nodeLinkEcho: false,
+    nodeLinkChorus: false,
+    nodeLinkCompressor: false,
+    nodeLinkHighPass: false,
+    nodeLinkPhaser: false,
+    nodeLinkSpatial: false,
+    coreFilterPlugin: {
+      echo: false,
+      reverb: false
+    },
+    dspxPlugin: {
+      lowPass: false,
+      highPass: false,
+      normalization: false,
+      echo: false
+    },
+    audioOutput: "stereo"
+  };
+  data = structuredClone(DEFAULT_FILTER_DATAS);
+  player;
+  constructor(player) {
+    this.player = player;
+  }
+  async applyPlayerFilters() {
+    const sendData = { ...this.data };
+    this.checkFiltersState();
+    if (!this.filters.volume) delete sendData.volume;
+    if (!this.filters.tremolo) delete sendData.tremolo;
+    if (!this.filters.vibrato) delete sendData.vibrato;
+    if (!this.filters.coreFilterPlugin.echo) delete sendData.pluginFilters?.["filter-engine"]?.echo;
+    if (!this.filters.coreFilterPlugin.reverb) delete sendData.pluginFilters?.["filter-engine"]?.reverb;
+    if (!this.filters.dspxPlugin.echo) delete sendData.pluginFilters?.echo;
+    if (!this.filters.dspxPlugin.normalization) delete sendData.pluginFilters?.normalization;
+    if (!this.filters.dspxPlugin.highPass) delete sendData.pluginFilters?.["high-pass"];
+    if (!this.filters.dspxPlugin.lowPass) delete sendData.pluginFilters?.["low-pass"];
+    if (sendData.pluginFilters?.["filter-engine"] && Object.values(sendData.pluginFilters?.["filter-engine"]).length === 0)
+      delete sendData.pluginFilters["filter-engine"];
+    if (sendData.pluginFilters && Object.values(sendData.pluginFilters).length === 0) delete sendData.pluginFilters;
+    if (!this.filters.lowPass) delete sendData.lowPass;
+    if (!this.filters.karaoke) delete sendData.karaoke;
+    if (!this.filters.rotation) delete sendData.rotation;
+    if (this.filters.audioOutput === "stereo") delete sendData.channelMix;
+    if (!this.filters.nodeLinkEcho) delete sendData.echo;
+    if (!this.filters.nodeLinkChorus) delete sendData.chorus;
+    if (!this.filters.nodeLinkCompressor) delete sendData.compressor;
+    if (!this.filters.nodeLinkHighPass) delete sendData.highPass;
+    if (!this.filters.nodeLinkPhaser) delete sendData.phaser;
+    if (!this.filters.nodeLinkSpatial) delete sendData.spatial;
+    if (Object.values(this.data.timescale ?? {}).every((v) => v === 1)) delete sendData.timescale;
+    if (!this.player.node.sessionId) throw new Error("The Lavalink-Node is either not ready or not up to date");
+    sendData.equalizer = [...this.equalizerBands];
+    if (sendData.equalizer.length === 0) delete sendData.equalizer;
+    for (const key of Object.keys(sendData)) {
+      if (key === "pluginFilters") {
+      } else if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.(key)) delete sendData[key];
+    }
+    const now = performance.now();
+    if (this.player.options.instaFixFilter === true) this.filterUpdatedState = true;
+    this.player.syncState();
+    await this.player.node.updatePlayer({
+      guildId: this.player.guildId,
+      playerOptions: {
+        filters: sendData
+      }
+    });
+    this.player.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    return;
+  }
+  privateNot0(value, numToCheckAgains = 0) {
+    return typeof value === "number" && value !== numToCheckAgains;
+  }
+  getAudioFilters() {
+    return this.data.pluginFilters?.["filter-engine"] || {
+      echo: {
+        decay: this.data.pluginFilters?.echo?.decay && !this.data.pluginFilters?.echo?.echoLength ? this.data.pluginFilters?.echo?.decay : 0,
+        delay: this.data.pluginFilters?.echo?.delay || 0
+      },
+      reverb: {
+        gains: [],
+        delays: [],
+        ...this.data.pluginFilters?.reverb
+      }
+    };
+  }
+  checkFiltersState(oldFilterTimescale) {
+    this.data = this.data ?? {};
+    this.filters.rotation = this.privateNot0(this.data.rotation?.rotationHz);
+    this.filters.vibrato = this.privateNot0(this.data.vibrato?.frequency) || this.privateNot0(this.data.vibrato?.depth);
+    this.filters.tremolo = this.privateNot0(this.data.tremolo?.frequency) || this.privateNot0(this.data.tremolo?.depth);
+    const audioFilterData = this.getAudioFilters();
+    this.filters.coreFilterPlugin = {
+      echo: this.privateNot0(audioFilterData?.echo?.decay) || this.privateNot0(audioFilterData?.echo?.delay),
+      reverb: this.privateNot0(audioFilterData?.reverb?.delays?.length) || this.privateNot0(audioFilterData?.reverb?.gains?.length)
+    };
+    this.filters.dspxPlugin = {
+      lowPass: Object.values(this.data.pluginFilters?.["low-pass"] || {})?.length > 0,
+      highPass: Object.values(this.data.pluginFilters?.["high-pass"] || {})?.length > 0,
+      normalization: Object.values(this.data.pluginFilters?.normalization || {})?.length > 0,
+      echo: Object.values(this.data.pluginFilters?.echo || {})?.length > 0 && typeof this.data.pluginFilters?.echo?.delay === "undefined"
+    };
+    this.filters.lowPass = this.privateNot0(this.data.lowPass?.smoothing);
+    this.filters.nodeLinkEcho = this.privateNot0(this.data.echo?.delay) || this.privateNot0(this.data.echo?.feedback) || this.privateNot0(this.data.echo?.mix);
+    this.filters.nodeLinkChorus = this.privateNot0(this.data.chorus?.rate) || this.privateNot0(this.data.chorus?.depth) || this.privateNot0(this.data.chorus?.delay) || this.privateNot0(this.data.chorus?.mix) || this.privateNot0(this.data.chorus?.feedback);
+    this.filters.nodeLinkCompressor = this.privateNot0(this.data.compressor?.threshold) || this.privateNot0(this.data.compressor?.ratio, 1) || this.privateNot0(this.data.compressor?.attack) || this.privateNot0(this.data.compressor?.release) || this.privateNot0(this.data.compressor?.gain);
+    this.filters.nodeLinkHighPass = this.privateNot0(this.data.highPass?.smoothing);
+    this.filters.nodeLinkPhaser = this.privateNot0(this.data.phaser?.stages) || this.privateNot0(this.data.phaser?.rate) || this.privateNot0(this.data.phaser?.depth) || this.privateNot0(this.data.phaser?.feedback) || this.privateNot0(this.data.phaser?.mix) || this.privateNot0(this.data.phaser?.minFrequency) || this.privateNot0(this.data.phaser?.maxFrequency);
+    this.filters.nodeLinkSpatial = this.privateNot0(this.data.spatial?.depth) || this.privateNot0(this.data.spatial?.rate);
+    this.filters.karaoke = Object.values(this.data.karaoke ?? {}).some((v) => v !== 0);
+    if ((this.filters.nightcore || this.filters.vaporwave) && oldFilterTimescale) {
+      if (oldFilterTimescale.pitch !== this.data.timescale?.pitch || oldFilterTimescale.rate !== this.data.timescale?.rate || oldFilterTimescale.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;
+      }
+    }
+    return true;
+  }
+  async resetFilters() {
+    this.filters.dspxPlugin.echo = false;
+    this.filters.dspxPlugin.normalization = false;
+    this.filters.dspxPlugin.highPass = false;
+    this.filters.dspxPlugin.lowPass = false;
+    this.filters.coreFilterPlugin.echo = false;
+    this.filters.coreFilterPlugin.reverb = false;
+    this.filters.nightcore = false;
+    this.filters.lowPass = false;
+    this.filters.rotation = false;
+    this.filters.tremolo = false;
+    this.filters.vibrato = false;
+    this.filters.karaoke = false;
+    this.filters.vaporwave = false;
+    this.filters.volume = false;
+    this.filters.nodeLinkEcho = false;
+    this.filters.nodeLinkChorus = false;
+    this.filters.nodeLinkCompressor = false;
+    this.filters.nodeLinkHighPass = false;
+    this.filters.nodeLinkPhaser = false;
+    this.filters.nodeLinkSpatial = false;
+    this.filters.audioOutput = "stereo";
+    this.data = structuredClone(DEFAULT_FILTER_DATAS);
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async setVolume(volume) {
+    if (volume < 0 || volume > 5) throw new SyntaxError("Volume-Filter must be between 0 and 5");
+    this.data = this.data ?? {};
+    this.data.volume = volume;
+    this.filters.volume = volume !== 1;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async setAudioOutput(type) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("channelMix"))
+      throw new Error("Node#Info#filters does not include the 'channelMix' Filter (Node has it not enable)");
+    if (!type || !audioOutputsData[type]) throw new Error("Invalid audio type added, must be 'mono' / 'stereo' / 'left' / 'right'");
+    this.data = this.data ?? {};
+    this.data.channelMix = audioOutputsData[type];
+    this.filters.audioOutput = type;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async setSpeed(speed = 1) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("timescale"))
+      throw new Error("Node#Info#filters does not include the 'timescale' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.filters.nightcore = false;
+    this.filters.vaporwave = false;
+    this.data.timescale = { ...DEFAULT_FILTER_DATAS.timescale, ...this.data.timescale, speed };
+    this.isCustomFilterActive();
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async setPitch(pitch = 1) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("timescale"))
+      throw new Error("Node#Info#filters does not include the 'timescale' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.filters.nightcore = false;
+    this.filters.vaporwave = false;
+    this.data.timescale = { ...DEFAULT_FILTER_DATAS.timescale, ...this.data.timescale, pitch };
+    this.isCustomFilterActive();
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async setRate(rate = 1) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("timescale"))
+      throw new Error("Node#Info#filters does not include the 'timescale' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.filters.nightcore = false;
+    this.filters.vaporwave = false;
+    this.data.timescale = { ...DEFAULT_FILTER_DATAS.timescale, ...this.data.timescale, rate };
+    this.isCustomFilterActive();
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async toggleRotation(rotationHz = 0.2) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("rotation"))
+      throw new Error("Node#Info#filters does not include the 'rotation' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.data.rotation = this.filters.rotation ? DEFAULT_FILTER_DATAS.rotation : { rotationHz };
+    this.filters.rotation = !this.filters.rotation;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async toggleVibrato(frequency = 10, depth = 1) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("vibrato"))
+      throw new Error("Node#Info#filters does not include the 'vibrato' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.data.vibrato = this.filters.vibrato ? DEFAULT_FILTER_DATAS.vibrato : { depth, frequency };
+    this.filters.vibrato = !this.filters.vibrato;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async toggleTremolo(frequency = 4, depth = 0.8) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("tremolo"))
+      throw new Error("Node#Info#filters does not include the 'tremolo' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.data.tremolo = this.filters.tremolo ? DEFAULT_FILTER_DATAS.tremolo : { depth, frequency };
+    this.filters.tremolo = !this.filters.tremolo;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async toggleLowPass(smoothing = 20) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("lowPass"))
+      throw new Error("Node#Info#filters does not include the 'lowPass' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.data.lowPass = this.filters.lowPass ? DEFAULT_FILTER_DATAS.lowPass : { smoothing };
+    this.filters.lowPass = !this.filters.lowPass;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  dspxPlugin = {
+    toggleLowPass: async (boostFactor = 1, cutoffFrequency = 80) => {
+      if (this.player.node._checkForPlugins && !this.player?.node?.info?.plugins?.find?.((v) => v.name === "lavadspx-plugin"))
+        throw new Error("Node#Info#plugins does not include the lavadspx plugin");
+      if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("low-pass"))
+        throw new Error("Node#Info#filters does not include the 'low-pass' Filter (Node has it not enable)");
+      this.data = this.data ?? {};
+      this.data.pluginFilters = this.data.pluginFilters ?? {};
+      if (this.filters.dspxPlugin.lowPass) delete this.data.pluginFilters["low-pass"];
+      else this.data.pluginFilters["low-pass"] = { boostFactor, cutoffFrequency };
+      this.filters.dspxPlugin.lowPass = !this.filters.dspxPlugin.lowPass;
+      await this.applyPlayerFilters();
+      return this;
+    },
+    toggleHighPass: async (boostFactor = 1, cutoffFrequency = 80) => {
+      if (this.player.node._checkForPlugins && !this.player?.node?.info?.plugins?.find?.((v) => v.name === "lavadspx-plugin"))
+        throw new Error("Node#Info#plugins does not include the lavadspx plugin");
+      if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("high-pass"))
+        throw new Error("Node#Info#filters does not include the 'high-pass' Filter (Node has it not enable)");
+      this.data = this.data ?? {};
+      this.data.pluginFilters = this.data.pluginFilters ?? {};
+      if (this.filters.dspxPlugin.highPass) delete this.data.pluginFilters["high-pass"];
+      else this.data.pluginFilters["high-pass"] = { boostFactor, cutoffFrequency };
+      this.filters.dspxPlugin.highPass = !this.filters.dspxPlugin.highPass;
+      await this.applyPlayerFilters();
+      return this;
+    },
+    toggleNormalization: async (maxAmplitude = 0.75, adaptive = true) => {
+      if (this.player.node._checkForPlugins && !this.player?.node?.info?.plugins?.find?.((v) => v.name === "lavadspx-plugin"))
+        throw new Error("Node#Info#plugins does not include the lavadspx plugin");
+      if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("normalization"))
+        throw new Error("Node#Info#filters does not include the 'normalization' Filter (Node has it not enable)");
+      this.data = this.data ?? {};
+      this.data.pluginFilters = this.data.pluginFilters ?? {};
+      if (this.filters.dspxPlugin.normalization) delete this.data.pluginFilters.normalization;
+      else this.data.pluginFilters.normalization = { adaptive, maxAmplitude };
+      this.filters.dspxPlugin.normalization = !this.filters.dspxPlugin.normalization;
+      await this.applyPlayerFilters();
+      return this;
+    },
+    toggleEcho: async (decay = 0.5, echoLength = 0.5) => {
+      if (this.player.node._checkForPlugins && !this.player?.node?.info?.plugins?.find?.((v) => v.name === "lavadspx-plugin"))
+        throw new Error("Node#Info#plugins does not include the lavadspx plugin");
+      if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("echo"))
+        throw new Error("Node#Info#filters does not include the 'echo' Filter (Node has it not enable)");
+      this.data = this.data ?? {};
+      this.data.pluginFilters = this.data.pluginFilters ?? {};
+      if (this.filters.dspxPlugin.echo) delete this.data.pluginFilters.echo;
+      else this.data.pluginFilters.echo = { decay, echoLength };
+      this.filters.dspxPlugin.echo = !this.filters.dspxPlugin.echo;
+      await this.applyPlayerFilters();
+      return this;
+    }
+  };
+  coreFilterPlugin = {
+    toggleEcho: async (delay = 4, decay = 0.8) => {
+      if (this.player.node._checkForPlugins && !this.player?.node?.info?.plugins?.find?.((v) => v.name === "filter-engine"))
+        throw new Error("Node#Info#plugins does not include the filter-engine plugin");
+      if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("echo"))
+        throw new Error("Node#Info#filters does not include the 'echo' Filter (Node has it not enable aka not installed!)");
+      this.data = this.data ?? {};
+      const { echo, reverb } = DEFAULT_FILTER_DATAS.pluginFilters["filter-engine"];
+      this.data.pluginFilters = {
+        ...this.data.pluginFilters,
+        ["filter-engine"]: {
+          reverb: this.data.pluginFilters?.["filter-engine"]?.reverb ?? reverb,
+          echo: this.filters.coreFilterPlugin.echo ? echo : { delay, decay }
+        }
+      };
+      this.filters.coreFilterPlugin.echo = !this.filters.coreFilterPlugin.echo;
+      await this.applyPlayerFilters();
+      return this;
+    },
+    toggleReverb: async (delays = [0.037, 0.042, 0.048, 0.053], gains = [0.84, 0.83, 0.82, 0.81]) => {
+      if (this.player.node._checkForPlugins && !this.player?.node?.info?.plugins?.find?.((v) => v.name === "filter-engine"))
+        throw new Error("Node#Info#plugins does not include the filter-engine plugin");
+      if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("reverb"))
+        throw new Error("Node#Info#filters does not include the 'reverb' Filter (Node has it not enable aka not installed!)");
+      this.data = this.data ?? {};
+      const { echo, reverb } = DEFAULT_FILTER_DATAS.pluginFilters["filter-engine"];
+      this.data.pluginFilters = {
+        ...this.data.pluginFilters,
+        ["filter-engine"]: {
+          echo: this.data.pluginFilters?.["filter-engine"]?.echo ?? echo,
+          reverb: this.filters.coreFilterPlugin.reverb ? reverb : { delays, gains }
+        }
+      };
+      this.filters.coreFilterPlugin.reverb = !this.filters.coreFilterPlugin.reverb;
+      await this.applyPlayerFilters();
+      return this;
+    }
+  };
+  async toggleNightcore(speed = 1.289999523162842, pitch = 1.289999523162842, rate = 0.9365999523162842) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("timescale"))
+      throw new Error("Node#Info#filters does not include the 'timescale' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.data.timescale = this.filters.nightcore ? DEFAULT_FILTER_DATAS.timescale : { speed, pitch, rate };
+    this.filters.nightcore = !this.filters.nightcore;
+    this.filters.vaporwave = false;
+    this.filters.custom = false;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async toggleVaporwave(speed = 0.8500000238418579, pitch = 0.800000011920929, rate = 1) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("timescale"))
+      throw new Error("Node#Info#filters does not include the 'timescale' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.data.timescale = this.filters.vaporwave ? DEFAULT_FILTER_DATAS.timescale : { speed, pitch, rate };
+    this.filters.vaporwave = !this.filters.vaporwave;
+    this.filters.nightcore = false;
+    this.filters.custom = false;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  async toggleKaraoke(level = 1, monoLevel = 1, filterBand = 220, filterWidth = 100) {
+    if (this.player.node._checkForSources && !this.player?.node?.info?.filters?.includes?.("karaoke"))
+      throw new Error("Node#Info#filters does not include the 'karaoke' Filter (Node has it not enable)");
+    this.data = this.data ?? {};
+    this.data.karaoke = this.filters.karaoke ? DEFAULT_FILTER_DATAS.karaoke : { level, monoLevel, filterBand, filterWidth };
+    this.filters.karaoke = !this.filters.karaoke;
+    await this.applyPlayerFilters();
+    return this;
+  }
+  isCustomFilterActive() {
+    this.filters.custom = !this.filters.nightcore && !this.filters.vaporwave && Object.values(this.data.timescale).some((d) => d !== 1);
+    return this.filters.custom;
+  }
+  async setEQPreset(preset) {
+    const bands = EQList[preset];
+    return this.setEQ(bands);
+  }
+  async setEQ(bands) {
+    if (!Array.isArray(bands)) bands = [bands];
+    if (!bands.length || !bands.every((band) => safeStringify(Object.keys(band).sort()) === '["band","gain"]'))
+      throw new TypeError("Bands must be a non-empty object array containing 'band' and 'gain' properties.");
+    for (const { band, gain } of bands) this.equalizerBands[band] = { band, gain };
+    if (!this.player.node.sessionId) throw new Error("The Lavalink-Node is either not ready or not up to date");
+    const now = performance.now();
+    if (this.player.options.instaFixFilter === true) this.filterUpdatedState = true;
+    this.player.syncState();
+    await this.player.node.updatePlayer({
+      guildId: this.player.guildId,
+      playerOptions: {
+        filters: { equalizer: this.equalizerBands }
+      }
+    });
+    this.player.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    return this;
+  }
+  async clearEQ() {
+    return this.setEQ(Array.from({ length: 15 }, (_v, i) => ({ band: i, gain: 0 })));
+  }
+};
+
+// src/audio/Queue.ts
+var QueueSaver = class {
+  _;
+  options;
+  constructor(options) {
+    this._ = options?.queueStore || new DefaultQueueStore();
+    this.options = {
+      maxPreviousTracks: options?.maxPreviousTracks || 25
+    };
+  }
+  async get(guildId) {
+    return this._.parse(await this._.get(guildId));
+  }
+  async delete(guildId) {
+    return this._.delete(guildId);
+  }
+  async set(guildId, valueToStringify) {
+    return this._.set(guildId, await this._.stringify(valueToStringify));
+  }
+  async sync(guildId) {
+    return this.get(guildId);
+  }
+};
+var DefaultQueueStore = class {
+  data = new MiniMap();
+  constructor() {
+  }
+  get(guildId) {
+    return this.data.get(guildId);
+  }
+  set(guildId, valueToStringify) {
+    return this.data.set(guildId, valueToStringify) ? true : false;
+  }
+  delete(guildId) {
+    return this.data.delete(guildId);
+  }
+  stringify(value) {
+    return value;
+  }
+  parse(value) {
+    return value;
+  }
+};
+var Queue = class {
+  tracks = [];
+  previous = [];
+  current = null;
+  options = { maxPreviousTracks: 25 };
+  guildId = "";
+  QueueSaver = null;
+  managerUtils = new RyanlinkUtils();
+  queueChanges;
+  constructor(guildId, data = {}, QueueSaver2, queueOptions) {
+    this.queueChanges = queueOptions?.queueChangesWatcher || null;
+    this.guildId = guildId;
+    this.QueueSaver = QueueSaver2;
+    this.options.maxPreviousTracks = this.QueueSaver?.options?.maxPreviousTracks ?? this.options.maxPreviousTracks;
+    this.current = this.managerUtils.isTrack(data.current) ? data.current : null;
+    this.previous = Array.isArray(data.previous) && data.previous.some((track) => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) ? data.previous.filter((track) => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) : [];
+    this.tracks = Array.isArray(data.tracks) && data.tracks.some((track) => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) ? data.tracks.filter((track) => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)) : [];
+    Object.defineProperty(this, AudioQueueSymbol, { configurable: true, value: true });
+  }
+  utils = {
+    save: async () => {
+      if (this.previous.length > this.options.maxPreviousTracks) this.previous.splice(this.options.maxPreviousTracks, this.previous.length);
+      return await this.QueueSaver.set(this.guildId, this.utils.toJSON());
+    },
+    sync: async (override = true, dontSyncCurrent = true) => {
+      const data = await this.QueueSaver.get(this.guildId);
+      if (!data) throw new Error(`No data found to sync for guildId: ${this.guildId}`);
+      if (!dontSyncCurrent && !this.current && this.managerUtils.isTrack(data.current)) this.current = data.current;
+      if (Array.isArray(data.tracks) && data?.tracks.length && data.tracks.some((track) => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)))
+        this.tracks.splice(
+          override ? 0 : this.tracks.length,
+          override ? this.tracks.length : 0,
+          ...data.tracks.filter((track) => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track))
+        );
+      if (Array.isArray(data.previous) && data?.previous.length && data.previous.some((track) => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track)))
+        this.previous.splice(
+          0,
+          override ? this.previous.length : 0,
+          ...data.previous.filter((track) => this.managerUtils.isTrack(track) || this.managerUtils.isUnresolvedTrack(track))
+        );
+      await this.utils.save();
+      return;
+    },
+    destroy: async () => {
+      return await this.QueueSaver.delete(this.guildId);
+    },
+    toJSON: () => {
+      if (this.previous?.length > this.options?.maxPreviousTracks) this.previous?.splice(this.options?.maxPreviousTracks, this.previous.length);
+      return {
+        current: this.current ? { ...this.current } : null,
+        previous: this.previous ? [...this.previous] : [],
+        tracks: this.tracks ? [...this.tracks] : []
+      };
+    },
+    totalDuration: () => {
+      return this.tracks.reduce((acc, cur) => acc + (cur.info.duration || 0), this.current?.info.duration || 0);
+    },
+    filterTracks: (predicate) => {
+      if (typeof predicate === "function") {
+        return this.tracks.map((track, index) => ({ track, index })).filter(({ track, index }) => predicate(track, index));
+      }
+      return this.tracks.map((track, index) => ({ track, index })).filter(({ track }) => {
+        if (predicate.title && !track.info?.title?.toLowerCase().includes(predicate.title.toLowerCase())) {
+          return false;
+        }
+        if (predicate.author && !track.info?.author?.toLowerCase().includes(predicate.author.toLowerCase())) {
+          return false;
+        }
+        if (predicate.duration !== void 0) {
+          const duration = track.info?.duration || 0;
+          if (typeof predicate.duration === "number") {
+            if (duration !== predicate.duration) return false;
+          } else {
+            if (predicate.duration.min !== void 0 && duration < predicate.duration.min) return false;
+            if (predicate.duration.max !== void 0 && duration > predicate.duration.max) return false;
+          }
+        }
+        if (predicate.uri && track.info?.uri !== predicate.uri) {
+          return false;
+        }
+        if (predicate.identifier && track.info?.identifier !== predicate.identifier) {
+          return false;
+        }
+        if (predicate.sourceName && track.info?.sourceName?.toLowerCase() !== predicate.sourceName.toLowerCase()) {
+          return false;
+        }
+        if (predicate.isStream !== void 0 && track.info?.isStream !== predicate.isStream) {
+          return false;
+        }
+        if (predicate.isSeekable !== void 0 && track.info?.isSeekable !== predicate.isSeekable) {
+          return false;
+        }
+        return true;
+      });
+    },
+    findTrack: (predicate) => {
+      const results = this.utils.filterTracks(predicate);
+      return results.length > 0 ? results[0] : null;
+    }
+  };
+  async shuffle() {
+    const oldStored = typeof this.queueChanges?.shuffled === "function" ? this.utils.toJSON() : null;
+    if (this.tracks.length <= 1) return this.tracks.length;
+    if (this.tracks.length === 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]];
+      }
+    }
+    if (typeof this.queueChanges?.shuffled === "function") this.queueChanges.shuffled(this.guildId, oldStored, this.utils.toJSON());
+    await this.utils.save();
+    return this.tracks.length;
+  }
+  async add(TrackOrTracks, index) {
+    if (typeof index === "number" && index >= 0 && index < this.tracks.length) {
+      return await this.splice(
+        index,
+        0,
+        (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).flat(2).filter((v) => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v))
+      );
+    }
+    const oldStored = typeof this.queueChanges?.tracksAdd === "function" ? this.utils.toJSON() : null;
+    this.tracks.push(
+      ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).flat(2).filter((v) => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v))
+    );
+    if (typeof this.queueChanges?.tracksAdd === "function")
+      try {
+        this.queueChanges.tracksAdd(
+          this.guildId,
+          (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).flat(2).filter((v) => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)),
+          this.tracks.length,
+          oldStored,
+          this.utils.toJSON()
+        );
+      } catch {
+      }
+    await this.utils.save();
+    return this.tracks.length;
+  }
+  async splice(index, amount, TrackOrTracks) {
+    const oldStored = typeof this.queueChanges?.tracksAdd === "function" || typeof this.queueChanges?.tracksRemoved === "function" ? this.utils.toJSON() : null;
+    if (!this.tracks.length) {
+      if (TrackOrTracks) return await this.add(TrackOrTracks);
+      return null;
+    }
+    if (TrackOrTracks && typeof this.queueChanges?.tracksAdd === "function")
+      try {
+        this.queueChanges.tracksAdd(
+          this.guildId,
+          (Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).flat(2).filter((v) => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v)),
+          index,
+          oldStored,
+          this.utils.toJSON()
+        );
+      } catch {
+      }
+    const spliced = TrackOrTracks ? this.tracks.splice(
+      index,
+      amount,
+      ...(Array.isArray(TrackOrTracks) ? TrackOrTracks : [TrackOrTracks]).flat(2).filter((v) => this.managerUtils.isTrack(v) || this.managerUtils.isUnresolvedTrack(v))
+    ) : this.tracks.splice(index, amount);
+    if (typeof this.queueChanges?.tracksRemoved === "function")
+      try {
+        this.queueChanges.tracksRemoved(this.guildId, spliced, index, oldStored, this.utils.toJSON());
+      } catch {
+      }
+    await this.utils.save();
+    return spliced.length === 1 ? spliced[0] : spliced;
+  }
+  async remove(removeQueryTrack) {
+    if (removeQueryTrack === null || removeQueryTrack === void 0 || Array.isArray(removeQueryTrack) && removeQueryTrack.length === 0) {
+      return null;
+    }
+    const oldStored = typeof this.queueChanges?.tracksRemoved === "function" ? this.utils.toJSON() : null;
+    if (typeof removeQueryTrack === "number") {
+      const toRemove2 = this.tracks[removeQueryTrack];
+      if (!toRemove2) return null;
+      const removed2 = this.tracks.splice(removeQueryTrack, 1);
+      if (typeof this.queueChanges?.tracksRemoved === "function")
+        try {
+          this.queueChanges.tracksRemoved(this.guildId, removed2, removeQueryTrack, oldStored, this.utils.toJSON());
+        } catch {
+        }
+      await this.utils.save();
+      return { removed: removed2 };
+    }
+    if (Array.isArray(removeQueryTrack)) {
+      if (removeQueryTrack.every((v) => typeof v === "number")) {
+        const removed3 = [];
+        const sortedIndexes = removeQueryTrack.sort((a, b) => b - a);
+        for (const i of sortedIndexes) {
+          if (this.tracks[i]) {
+            removed3.unshift(...this.tracks.splice(i, 1));
+          }
+        }
+        if (!removed3.length) return null;
+        if (typeof this.queueChanges?.tracksRemoved === "function")
+          try {
+            this.queueChanges.tracksRemoved(this.guildId, removed3, removeQueryTrack, oldStored, this.utils.toJSON());
+          } catch {
+          }
+        await this.utils.save();
+        return { removed: removed3 };
+      }
+      const tracksToRemove = this.tracks.map((v, i) => ({ v, i })).filter(
+        ({ v, i }) => removeQueryTrack.find(
+          (t) => typeof t === "number" && t === i || typeof t === "object" && (t.encoded && t.encoded === v.encoded || t.info?.identifier && t.info.identifier === v.info?.identifier || t.info?.uri && t.info.uri === v.info?.uri || t.info?.title && t.info.title === v.info?.title || t.info?.isrc && t.info.isrc === v.info?.isrc || t.info?.artworkUrl && t.info.artworkUrl === v.info?.artworkUrl)
+        )
+      );
+      if (!tracksToRemove.length) return null;
+      const removed2 = [];
+      tracksToRemove.sort((a, b) => b.i - a.i);
+      for (const { i } of tracksToRemove) {
+        if (this.tracks[i]) {
+          removed2.unshift(...this.tracks.splice(i, 1));
+        }
+      }
+      if (typeof this.queueChanges?.tracksRemoved === "function")
+        try {
+          this.queueChanges.tracksRemoved(
+            this.guildId,
+            removed2,
+            tracksToRemove.map((v) => v.i),
+            oldStored,
+            this.utils.toJSON()
+          );
+        } catch {
+        }
+      await this.utils.save();
+      return { removed: removed2 };
+    }
+    const toRemove = this.tracks.findIndex(
+      (v) => removeQueryTrack.encoded && removeQueryTrack.encoded === v.encoded || removeQueryTrack.info?.identifier && removeQueryTrack.info.identifier === v.info?.identifier || removeQueryTrack.info?.uri && removeQueryTrack.info.uri === v.info?.uri || removeQueryTrack.info?.title && removeQueryTrack.info.title === v.info?.title || removeQueryTrack.info?.isrc && removeQueryTrack.info.isrc === v.info?.isrc || removeQueryTrack.info?.artworkUrl && removeQueryTrack.info.artworkUrl === v.info?.artworkUrl
+    );
+    if (toRemove < 0) return null;
+    const removed = this.tracks.splice(toRemove, 1);
+    if (typeof this.queueChanges?.tracksRemoved === "function")
+      try {
+        this.queueChanges.tracksRemoved(this.guildId, removed, toRemove, oldStored, this.utils.toJSON());
+      } catch {
+      }
+    await this.utils.save();
+    return { removed };
+  }
+  async shiftPrevious() {
+    const removed = this.previous.shift();
+    if (removed) await this.utils.save();
+    return removed ?? null;
+  }
+  filter(predicate) {
+    return this.utils.filterTracks(predicate);
+  }
+  find(predicate) {
+    return this.utils.findTrack(predicate);
+  }
+  async sortBy(sortBy, order = "asc") {
+    if (typeof sortBy === "function") {
+      this.tracks.sort(sortBy);
+    } else {
+      this.tracks.sort((a, b) => {
+        let comparison = 0;
+        switch (sortBy) {
+          case "duration":
+            comparison = (a.info?.duration || 0) - (b.info?.duration || 0);
+            break;
+          case "title":
+            comparison = (a.info?.title || "").localeCompare(b.info?.title || "");
+            break;
+          case "author":
+            comparison = (a.info?.author || "").localeCompare(b.info?.author || "");
+            break;
+          default:
+            return 0;
+        }
+        return order === "desc" ? -comparison : comparison;
+      });
+    }
+    await this.utils.save();
+    return this;
+  }
+  toSortedBy(sortBy, order = "asc") {
+    const tracksCopy = [...this.tracks];
+    if (typeof sortBy === "function") {
+      return tracksCopy.sort(sortBy);
+    }
+    return tracksCopy.sort((a, b) => {
+      let comparison = 0;
+      switch (sortBy) {
+        case "duration":
+          comparison = (a.info?.duration || 0) - (b.info?.duration || 0);
+          break;
+        case "title":
+          comparison = (a.info?.title || "").localeCompare(b.info?.title || "");
+          break;
+        case "author":
+          comparison = (a.info?.author || "").localeCompare(b.info?.author || "");
+          break;
+        default:
+          return 0;
+      }
+      return order === "desc" ? -comparison : comparison;
+    });
+  }
+  getTracks(start, end) {
+    return this.tracks.slice(start, end);
+  }
+};
+
+// src/audio/Player.ts
+var Player = class {
+  filterManager;
+  RyanlinkManager;
+  options;
+  node;
+  queue;
+  guildId;
+  voiceChannelId = null;
+  textChannelId = null;
+  playing = false;
+  paused = false;
+  repeatMode = "off";
+  ping = {
+    node: 0,
+    ws: 0
+  };
+  volume = 100;
+  internalVolume = 100;
+  get position() {
+    return this.lastPosition + (this.lastPositionChange ? Date.now() - this.lastPositionChange : 0);
+  }
+  lastPositionChange = null;
+  lastPosition = 0;
+  lastSavedPosition = 0;
+  createdTimeStamp;
+  connected = false;
+  voice = {
+    endpoint: null,
+    sessionId: null,
+    token: null,
+    channelId: void 0
+  };
+  voiceState = {
+    selfDeaf: false,
+    selfMute: false,
+    serverDeaf: false,
+    serverMute: false,
+    suppress: false
+  };
+  data = {};
+  dispatchDebug(name, eventData) {
+    if (!this.RyanlinkManager.options?.advancedOptions?.enableDebugEvents) return;
+    this.RyanlinkManager.emit("debug", name, eventData);
+  }
+  constructor(options, RyanlinkManager2, dontEmitPlayerCreateEvent) {
+    if (typeof options?.customData === "object") for (const [key, value] of Object.entries(options.customData)) this.setData(key, value);
+    this.options = options;
+    this.filterManager = new FilterManager(this);
+    this.RyanlinkManager = RyanlinkManager2;
+    this.guildId = this.options.guildId;
+    this.voiceChannelId = this.options.voiceChannelId;
+    this.textChannelId = this.options.textChannelId || null;
+    this.node = typeof this.options.node === "string" ? this.RyanlinkManager.nodeManager.nodes.get(this.options.node) : this.options.node;
+    if (!this.node || typeof this.node.request !== "function") {
+      if (typeof this.options.node === "string") {
+        this.dispatchDebug("PlayerCreateNodeNotFound" /* PlayerCreateNodeNotFound */, {
+          state: "warn",
+          message: `Player was created with provided node Id: ${this.options.node}, but no node with that Id was found.`,
+          functionLayer: "Player > constructor()"
+        });
+      }
+      const least = this.RyanlinkManager.nodeManager.leastUsedNodes();
+      this.node = least.filter((v) => options.vcRegion ? v.options?.regions?.includes(options.vcRegion) : true)[0] || least[0] || null;
+    }
+    if (!this.node) throw new Error("No available Node was found, please add a RyanlinkNode to the Manager via Manager.NodeManager#createNode");
+    if (typeof options.volume === "number" && !isNaN(options.volume)) this.volume = Number(options.volume);
+    this.volume = Math.round(Math.max(Math.min(this.volume, 1e3), 0));
+    this.internalVolume = Math.round(
+      Math.max(
+        Math.min(
+          Math.round(
+            this.RyanlinkManager.options.playerOptions.volumeDecrementer ? this.volume * this.RyanlinkManager.options.playerOptions.volumeDecrementer : this.volume
+          ),
+          1e3
+        ),
+        0
+      )
+    );
+    if (!dontEmitPlayerCreateEvent) this.RyanlinkManager.emit("playerCreate", this);
+    this.queue = new Queue(this.guildId, {}, new QueueSaver(this.RyanlinkManager.options.queueOptions), this.RyanlinkManager.options.queueOptions);
+  }
+  set(key, value) {
+    this.data[key] = value;
+    return this;
+  }
+  get(key) {
+    return this.data[key];
+  }
+  setData(key, value) {
+    this.data[key] = value;
+    return this;
+  }
+  getData(key) {
+    return this.data[key];
+  }
+  deleteData(key) {
+    if (key.startsWith("internal_")) return this;
+    delete this.data[key];
+    return this;
+  }
+  clearData() {
+    const toKeep = Object.keys(this.data).filter((v) => v.startsWith("internal_"));
+    for (const key in this.data) {
+      if (toKeep.includes(key)) continue;
+      delete this.data[key];
+    }
+    return this;
+  }
+  getAllData() {
+    return Object.fromEntries(Object.entries(this.data).filter((v) => !v[0].startsWith("internal_")));
+  }
+  async play(options = {}) {
+    if (this.getData("internal_queueempty")) {
+      this.dispatchDebug("PlayerPlayQueueEmptyTimeoutClear" /* PlayerPlayQueueEmptyTimeoutClear */, {
+        state: "log",
+        message: `Player was called to play something, while there was a queueEmpty Timeout set, clearing the timeout.`,
+        functionLayer: "Player > play()"
+      });
+      this.RyanlinkManager.emit("playerQueueEmptyCancel", this);
+      clearTimeout(this.getData("internal_queueempty"));
+      this.setData("internal_queueempty", void 0);
+    }
+    if (options?.clientTrack && (this.RyanlinkManager.utils.isTrack(options?.clientTrack) || this.RyanlinkManager.utils.isUnresolvedTrack(options.clientTrack))) {
+      if (this.RyanlinkManager.utils.isUnresolvedTrack(options.clientTrack)) {
+        try {
+          await options.clientTrack.resolve(this);
+        } catch (error) {
+          this.dispatchDebug("PlayerPlayUnresolvedTrackFailed" /* PlayerPlayUnresolvedTrackFailed */, {
+            state: "error",
+            error,
+            message: `Player Play was called with clientTrack, Song is unresolved, but couldn't resolve it`,
+            functionLayer: "Player > play() > resolve currentTrack"
+          });
+          this.RyanlinkManager.emit("trackError", this, this.queue.current, error);
+          if (options && "clientTrack" in options) delete options.clientTrack;
+          if (options && "track" in options) delete options.track;
+          if (this.RyanlinkManager.options?.autoSkipOnResolveError === true && this.queue.tracks[0]) return this.play(options);
+          return this;
+        }
+      }
+      if ((typeof options.track?.userData === "object" || typeof options.clientTrack?.userData === "object") && options.clientTrack)
+        options.clientTrack.userData = {
+          ...typeof options?.clientTrack?.requester === "object" ? {
+            requester: this.RyanlinkManager.utils.getTransformedRequester(options?.clientTrack?.requester || {})
+          } : {},
+          ...options?.clientTrack.userData,
+          ...options.track?.userData
+        };
+      options.track = {
+        encoded: options.clientTrack?.encoded,
+        requester: options.clientTrack?.requester,
+        userData: options.clientTrack?.userData,
+        audioTrackId: options.track?.audioTrackId ?? options.clientTrack?.audioTrackId
+      };
+      if (options.track.audioTrackId && !this.node.isNodeLink()) {
+        delete options.track.audioTrackId;
+      }
+    }
+    if (options?.track?.encoded || options?.track?.identifier) {
+      this.queue.current = options.clientTrack || null;
+      this.queue.utils.save();
+      if (typeof options?.volume === "number" && !isNaN(options?.volume)) {
+        this.volume = Math.max(Math.min(options?.volume, 1e3), 0);
+        let vol = Number(this.volume);
+        if (this.RyanlinkManager.options.playerOptions.volumeDecrementer) vol *= this.RyanlinkManager.options.playerOptions.volumeDecrementer;
+        this.internalVolume = Math.round(vol);
+        options.volume = this.internalVolume;
+      }
+      const track = Object.fromEntries(
+        Object.entries({
+          encoded: options.track.encoded,
+          identifier: options.track.identifier,
+          userData: {
+            ...typeof options?.track?.requester === "object" ? {
+              requester: this.RyanlinkManager.utils.getTransformedRequester(options?.track?.requester || {})
+            } : {},
+            ...options.track.userData
+          },
+          audioTrackId: options.track.audioTrackId
+        }).filter((v) => typeof v[1] !== "undefined")
+      );
+      this.dispatchDebug("PlayerPlayWithTrackReplace" /* PlayerPlayWithTrackReplace */, {
+        state: "log",
+        message: `Player was called to play something, with a specific track provided. Replacing the current Track and resolving the track on trackStart Event.`,
+        functionLayer: "Player > play()"
+      });
+      if (track.audioTrackId && !this.node.isNodeLink()) {
+        delete track.audioTrackId;
+      }
+      return this.node.updatePlayer({
+        guildId: this.guildId,
+        noReplace: false,
+        playerOptions: Object.fromEntries(
+          Object.entries({
+            track,
+            position: options.position ?? void 0,
+            paused: options.paused ?? void 0,
+            endTime: options?.endTime ?? void 0,
+            filters: options?.filters ?? void 0,
+            volume: options.volume ?? this.internalVolume ?? void 0,
+            voice: options.voice ?? void 0
+          }).filter((v) => typeof v[1] !== "undefined")
+        )
+      });
+    }
+    if (!this.queue.current && this.queue.tracks.length) await queueTrackEnd(this);
+    if (this.queue.current && this.RyanlinkManager.utils.isUnresolvedTrack(this.queue.current)) {
+      this.dispatchDebug("PlayerPlayUnresolvedTrack" /* PlayerPlayUnresolvedTrack */, {
+        state: "log",
+        message: `Player Play was called, current Queue Song is unresolved, resolving the track.`,
+        functionLayer: "Player > play()"
+      });
+      try {
+        await this.queue.current.resolve(this);
+        if (typeof options.track?.userData === "object" && this.queue.current)
+          this.queue.current.userData = {
+            ...typeof this.queue.current?.requester === "object" ? {
+              requester: this.RyanlinkManager.utils.getTransformedRequester(this.queue.current?.requester || {})
+            } : {},
+            ...this.queue.current?.userData,
+            ...options.track?.userData
+          };
+      } catch (error) {
+        this.dispatchDebug("PlayerPlayUnresolvedTrackFailed" /* PlayerPlayUnresolvedTrackFailed */, {
+          state: "error",
+          error,
+          message: `Player Play was called, current Queue Song is unresolved, but couldn't resolve it`,
+          functionLayer: "Player > play() > resolve currentTrack"
+        });
+        this.RyanlinkManager.emit("trackError", this, this.queue.current, error);
+        if (options && "clientTrack" in options) delete options.clientTrack;
+        if (options && "track" in options) delete options.track;
+        await queueTrackEnd(this, true);
+        if (this.RyanlinkManager.options?.autoSkipOnResolveError === true && this.queue.tracks[0]) return this.play(options);
+        return this;
+      }
+    }
+    if (!this.queue.current) throw new Error(`There is no Track in the Queue, nor provided in the PlayOptions`);
+    if (typeof options?.volume === "number" && !isNaN(options?.volume)) {
+      this.volume = Math.max(Math.min(options?.volume, 1e3), 0);
+      let vol = Number(this.volume);
+      if (this.RyanlinkManager.options.playerOptions.volumeDecrementer) vol *= this.RyanlinkManager.options.playerOptions.volumeDecrementer;
+      this.internalVolume = Math.round(vol);
+      options.volume = this.internalVolume;
+    }
+    const finalOptions = Object.fromEntries(
+      Object.entries({
+        track: {
+          encoded: this.queue.current?.encoded || null,
+          userData: {
+            ...typeof this.queue.current?.requester === "object" ? {
+              requester: this.RyanlinkManager.utils.getTransformedRequester(this.queue.current?.requester || {})
+            } : {},
+            ...options?.track?.userData,
+            ...this.queue.current?.userData
+          },
+          audioTrackId: options?.track?.audioTrackId
+        },
+        volume: this.internalVolume,
+        position: options?.position ?? 0,
+        endTime: options?.endTime ?? void 0,
+        filters: options?.filters ?? void 0,
+        paused: options?.paused ?? void 0,
+        voice: options?.voice ?? void 0
+      }).filter((v) => typeof v[1] !== "undefined")
+    );
+    if (finalOptions.track.audioTrackId && !this.node.isNodeLink()) {
+      delete finalOptions.track.audioTrackId;
+    }
+    if (typeof finalOptions.position !== "undefined" && isNaN(finalOptions.position) || typeof finalOptions.position === "number" && finalOptions.position < 0 || typeof finalOptions.position === "number" && this.queue.current.info.duration > 0 && finalOptions.position >= this.queue.current.info.duration)
+      throw new Error("PlayerOption#position must be a positive number, less than track's duration");
+    if (typeof finalOptions.volume !== "undefined" && isNaN(finalOptions.volume) || typeof finalOptions.volume === "number" && finalOptions.volume < 0)
+      throw new Error("PlayerOption#volume must be a positive number");
+    if (typeof finalOptions.endTime !== "undefined" && isNaN(finalOptions.endTime) || typeof finalOptions.endTime === "number" && finalOptions.endTime < 0 || typeof finalOptions.endTime === "number" && this.queue.current.info.duration > 0 && finalOptions.endTime >= this.queue.current.info.duration)
+      throw new Error("PlayerOption#endTime must be a positive number, less than track's duration");
+    if (typeof finalOptions.position === "number" && typeof finalOptions.endTime === "number" && finalOptions.endTime < finalOptions.position)
+      throw new Error("PlayerOption#endTime must be bigger than PlayerOption#position");
+    const now = performance.now();
+    await this.node.updatePlayer({
+      guildId: this.guildId,
+      noReplace: options?.noReplace ?? false,
+      playerOptions: finalOptions
+    });
+    this.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    return this;
+  }
+  oldJSON = this.toJSON();
+  syncState() {
+    this.RyanlinkManager.emit("playerClientUpdate", this.oldJSON, this);
+    this.oldJSON = this.toJSON();
+    if (this.filterManager.filterUpdatedState) {
+      this.filterManager.filterUpdatedState = false;
+      if (this.queue.current && this.queue.current.info.duration < (this.RyanlinkManager.options.advancedOptions?.maxFilterFixDuration || 6e5)) {
+        this.seek(this.position);
+      }
+    }
+  }
+  async setVolume(volume, ignoreVolumeDecrementer = false) {
+    volume = Number(volume);
+    if (isNaN(volume)) throw new TypeError("Volume must be a number.");
+    this.volume = Math.round(Math.max(Math.min(volume, 1e3), 0));
+    this.internalVolume = Math.round(
+      Math.max(
+        Math.min(
+          Math.round(
+            this.RyanlinkManager.options.playerOptions.volumeDecrementer && !ignoreVolumeDecrementer ? this.volume * this.RyanlinkManager.options.playerOptions.volumeDecrementer : this.volume
+          ),
+          1e3
+        ),
+        0
+      )
+    );
+    this.syncState();
+    const now = performance.now();
+    if (this.RyanlinkManager.options.playerOptions.applyVolumeAsFilter) {
+      this.dispatchDebug("PlayerVolumeAsFilter" /* PlayerVolumeAsFilter */, {
+        state: "log",
+        message: `Player Volume was set as a Filter, because RyanlinkManager option "playerOptions.applyVolumeAsFilter" is true`,
+        functionLayer: "Player > setVolume()"
+      });
+      await this.node.updatePlayer({
+        guildId: this.guildId,
+        playerOptions: { filters: { volume: this.internalVolume / 100 } }
+      });
+    } else {
+      await this.node.updatePlayer({
+        guildId: this.guildId,
+        playerOptions: { volume: this.internalVolume }
+      });
+    }
+    this.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    return this;
+  }
+  async audioSearch(query, requestUser, throwOnEmpty = false) {
+    return this.node.audioSearch(query, requestUser, throwOnEmpty);
+  }
+  async setSponsorBlock(segments = ["sponsor", "selfpromo"]) {
+    return this.node.setSponsorBlock(this, segments);
+  }
+  async getSponsorBlock() {
+    return this.node.getSponsorBlock(this);
+  }
+  async deleteSponsorBlock() {
+    return this.node.deleteSponsorBlock(this);
+  }
+  async search(query, requestUser, throwOnEmpty = false) {
+    const Query = this.RyanlinkManager.utils.transformQuery(query);
+    if (["bcsearch", "bandcamp"].includes(Query.source) && !this.node.info?.sourceManagers.includes("bandcamp")) {
+      this.dispatchDebug("BandcampSearchLokalEngine" /* BandcampSearchLokalEngine */, {
+        state: "log",
+        message: `Player.search was called with a Bandcamp Query, but no bandcamp search was enabled on the audio node, searching with the custom Search Engine.`,
+        functionLayer: "Player > search()"
+      });
+      return await this._bandCampSearch(Query.query, requestUser);
+    }
+    return this.node.search(Query, requestUser, throwOnEmpty);
+  }
+  async _bandCampSearch(query, requestUser) {
+    let error = null;
+    let tracks = [];
+    if (this.RyanlinkManager.options.advancedOptions.debugOptions.logCustomSearches) console.log(`Audio-Debug | SEARCHING | - ${query} on ryanlink`);
+    this.RyanlinkManager.utils.validateQueryString(this.node, query);
+    try {
+      const requestUrl = new URL("https://bandcamp.com/api/nusearch/2/autocomplete");
+      requestUrl.searchParams.append("q", query);
+      const data = await fetch(requestUrl.toString(), {
+        headers: {
+          "User-Agent": "android-async-http/1.4.1 (http://loopj.com/android-async-http)",
+          Cookie: "$Version=1"
+        }
+      });
+      if (!data.ok) throw new Error(`Bandcamp Error: ${data.statusText}`);
+      let json = null;
+      try {
+        json = await data.json();
+      } catch {
+        throw new Error("Invalid JSON response from Bandcamp");
+      }
+      tracks = json?.results?.filter((x) => !!x && typeof x === "object" && "type" in x && x.type === "t").map?.(
+        (item) => this.RyanlinkManager.utils.buildUnresolvedTrack(
+          {
+            uri: item.url || item.uri,
+            artworkUrl: item.img,
+            author: item.band_name,
+            title: item.name,
+            identifier: item.id ? `${item.id}` : item.url?.split("/")?.reverse()[0]
+          },
+          requestUser
+        )
+      ) || [];
+    } catch (e) {
+      error = e;
+    }
+    return {
+      loadType: "search",
+      exception: error,
+      pluginInfo: {},
+      playlist: null,
+      tracks
+    };
+  }
+  async pause() {
+    this.paused = true;
+    this.lastPositionChange = null;
+    const now = performance.now();
+    this.syncState();
+    await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { paused: true } });
+    this.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    this.RyanlinkManager.emit("playerPaused", this, this.queue.current);
+    return this;
+  }
+  async resume() {
+    if (!this.paused) throw new Error("Player isn't paused - not able to resume.");
+    this.paused = false;
+    const now = performance.now();
+    this.syncState();
+    await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { paused: false } });
+    this.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    this.RyanlinkManager.emit("playerResumed", this, this.queue.current);
+    return this;
+  }
+  async seek(position) {
+    if (!this.queue.current) return void 0;
+    position = Number(position);
+    if (isNaN(position)) throw new RangeError("Position must be a number.");
+    if (!this.queue.current.info.isSeekable || this.queue.current.info.isStream) throw new RangeError("Current Track is not seekable / a stream");
+    if (position < 0 || position > this.queue.current.info.duration) position = Math.max(Math.min(position, this.queue.current.info.duration), 0);
+    this.lastPositionChange = Date.now();
+    this.lastPosition = position;
+    const now = performance.now();
+    this.syncState();
+    await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { position } });
+    this.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    return this;
+  }
+  async setRepeatMode(repeatMode) {
+    if (!["off", "track", "queue"].includes(repeatMode)) throw new RangeError("Repeatmode must be either 'off', 'track', or 'queue'");
+    this.repeatMode = repeatMode;
+    this.syncState();
+    return this;
+  }
+  async skip(skipTo = 0, throwError = true) {
+    if (!this.queue.tracks.length && (throwError || typeof skipTo === "boolean" && skipTo === true))
+      throw new RangeError("Can't skip more than the queue size");
+    if (typeof skipTo === "number" && skipTo > 1) {
+      if (skipTo > this.queue.tracks.length) throw new RangeError("Can't skip more than the queue size");
+      await this.queue.splice(0, skipTo - 1);
+    }
+    if (!this.playing && !this.queue.current) return this.play(), this;
+    const now = performance.now();
+    this.setData("internal_skipped", true);
+    await this.node.updatePlayer({
+      guildId: this.guildId,
+      playerOptions: { track: { encoded: null }, paused: false }
+    });
+    this.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    return this;
+  }
+  async stopPlaying(clearQueue = true, executeAutoplay = false) {
+    this.setData("internal_stopPlaying", true);
+    if (this.queue.tracks.length && clearQueue === true) await this.queue.splice(0, this.queue.tracks.length);
+    if (executeAutoplay === false) this.setData("internal_autoplayStopPlaying", true);
+    else this.setData("internal_autoplayStopPlaying", void 0);
+    const now = performance.now();
+    await this.node.updatePlayer({
+      guildId: this.guildId,
+      playerOptions: this.node.isNodeLink() ? {
+        track: { encoded: null },
+        nextTrack: { encoded: null }
+      } : {
+        track: { encoded: null }
+      }
+    });
+    this.paused = false;
+    this.ping.node = Math.round((performance.now() - now) / 10) / 100;
+    return this;
+  }
+  async connect() {
+    if (!this.options.voiceChannelId) throw new RangeError("No Voice Channel id has been set. (player.options.voiceChannelId)");
+    await this.RyanlinkManager.options.sendToShard(this.guildId, {
+      op: 4,
+      d: {
+        guild_id: this.guildId,
+        channel_id: this.options.voiceChannelId,
+        self_mute: this.options.selfMute ?? false,
+        self_deaf: this.options.selfDeaf ?? true
+      }
+    });
+    this.voiceChannelId = this.options.voiceChannelId;
+    return this;
+  }
+  async changeVoiceState(data) {
+    if (this.options.voiceChannelId === data.voiceChannelId) throw new RangeError("New Channel can't be equal to the old Channel.");
+    await this.RyanlinkManager.options.sendToShard(this.guildId, {
+      op: 4,
+      d: {
+        guild_id: this.guildId,
+        channel_id: data.voiceChannelId,
+        self_mute: data.selfMute ?? this.options.selfMute ?? false,
+        self_deaf: data.selfDeaf ?? this.options.selfDeaf ?? true
+      }
+    });
+    this.options.voiceChannelId = data.voiceChannelId;
+    this.options.selfMute = data.selfMute;
+    this.options.selfDeaf = data.selfDeaf;
+    this.voiceChannelId = data.voiceChannelId;
+    return this;
+  }
+  async disconnect(force = false) {
+    if (!force && !this.options.voiceChannelId) throw new RangeError("No Voice Channel id has been set. (player.options.voiceChannelId)");
+    await this.RyanlinkManager.options.sendToShard(this.guildId, {
+      op: 4,
+      d: {
+        guild_id: this.guildId,
+        channel_id: null,
+        self_mute: false,
+        self_deaf: false
+      }
+    });
+    this.voiceChannelId = null;
+    return this;
+  }
+  async destroy(reason, disconnect = true) {
+    if (this.RyanlinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
+      console.log(`Audio-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Destroy-Reason: ${String(reason)}`);
+    if (this.getData("internal_queueempty")) {
+      clearTimeout(this.getData("internal_queueempty"));
+      this.setData("internal_queueempty", void 0);
+    }
+    if (this.getData("internal_destroystatus") === true) {
+      this.dispatchDebug("PlayerDestroyingSomewhereElse" /* PlayerDestroyingSomewhereElse */, {
+        state: "warn",
+        message: `Player is already destroying somewhere else..`,
+        functionLayer: "Player > destroy()"
+      });
+      if (this.RyanlinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
+        console.log(`Audio-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Already destroying somewhere else..`);
+      return;
+    }
+    this.setData("internal_destroystatus", true);
+    if (disconnect) await this.disconnect(true);
+    else this.setData("internal_destroywithoutdisconnect", true);
+    await this.queue.utils.destroy();
+    this.RyanlinkManager.deletePlayer(this.guildId);
+    await this.node.destroyPlayer(this.guildId);
+    if (this.RyanlinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
+      console.log(`Audio-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Player got destroyed successfully`);
+    this.RyanlinkManager.emit("playerDestroy", this, reason);
+    return this;
+  }
+  async getCurrentLyrics(skipTrackSource) {
+    return await this.node.lyrics.getCurrent(this.guildId, skipTrackSource);
+  }
+  async getLyrics(track, skipTrackSource) {
+    return await this.node.lyrics.get(track, skipTrackSource);
+  }
+  subscribeLyrics(skipTrackSource) {
+    return this.node.lyrics.subscribe(this.guildId, skipTrackSource);
+  }
+  unsubscribeLyrics() {
+    return this.node.lyrics.unsubscribe(this.guildId);
+  }
+  async changeNode(newNode, checkSources = true) {
+    const updateNode = typeof newNode === "string" ? this.RyanlinkManager.nodeManager.nodes.get(newNode) : newNode;
+    if (!updateNode) throw new Error("Could not find the new Node");
+    if (!updateNode.connected) throw new Error("The provided Node is not active or disconnected");
+    if (this.node.id === updateNode.id) throw new Error("Player is already on the provided Node");
+    if (this.getData("internal_nodeChanging") === true) throw new Error("Player is already changing the node please wait");
+    if (checkSources) {
+      const isDefaultSource = () => {
+        try {
+          this.RyanlinkManager.utils.validateSourceString(updateNode, this.RyanlinkManager.options.playerOptions.defaultSearchPlatform);
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      if (!isDefaultSource())
+        throw new RangeError(
+          `defaultSearchPlatform "${this.RyanlinkManager.options.playerOptions.defaultSearchPlatform}" is not supported by the newNode`
+        );
+      if (this.queue.current || this.queue.tracks.length) {
+        const trackSources = new Set([this.queue.current, ...this.queue.tracks].map((track) => track.info.sourceName));
+        const missingSources = [...trackSources].filter((source) => !updateNode.info?.sourceManagers.includes(source));
+        if (updateNode._checkForSources && missingSources.length)
+          throw new RangeError(`Sources missing for Node ${updateNode.id}: ${missingSources.join(", ")}`);
+      }
+    }
+    this.dispatchDebug("PlayerChangeNode" /* PlayerChangeNode */, {
+      state: "log",
+      message: `Player.changeNode() was executed, trying to change from "${this.node.id}" to "${updateNode.id}"`,
+      functionLayer: "Player > changeNode()"
+    });
+    const data = this.toJSON();
+    const currentTrack = this.queue.current;
+    if (!this.voice.endpoint || !this.voice.sessionId || !this.voice.token) throw new Error("Voice Data is missing, can't change the node");
+    this.setData("internal_nodeChanging", true);
+    if (this.node.connected) await this.node.destroyPlayer(this.guildId);
+    this.node = updateNode;
+    const now = performance.now();
+    try {
+      await this.connect();
+      const hasSponsorBlock = !this.node._checkForPlugins || this.node.info?.plugins?.find((v) => v.name === "sponsorblock-plugin");
+      if (hasSponsorBlock) {
+        const sponsorBlockCategories = this.getData("internal_sponsorBlockCategories");
+        if (Array.isArray(sponsorBlockCategories) && sponsorBlockCategories.length) {
+          await this.setSponsorBlock(sponsorBlockCategories).catch((error) => {
+            this.dispatchDebug("PlayerChangeNode" /* PlayerChangeNode */, {
+              state: "error",
+              error,
+              message: `Player > changeNode() Unable to set SponsorBlock Segments`,
+              functionLayer: "Player > changeNode()"
+            });
+          });
+        } else if (this.RyanlinkManager.options?.playerOptions?.enforceSponsorBlockRequestForEventEnablement !== false) {
+          await this.setSponsorBlock().catch((error) => {
+            this.dispatchDebug("PlayerChangeNode" /* PlayerChangeNode */, {
+              state: "error",
+              error,
+              message: `Player > changeNode() Unable to set SponsorBlock Segments`,
+              functionLayer: "Player > changeNode()"
+            });
+          });
+        }
+      }
+      await this.node.updatePlayer({
+        guildId: this.guildId,
+        noReplace: false,
+        playerOptions: {
+          ...currentTrack && {
+            track: currentTrack,
+            position: data.lastPosition || 0,
+            volume: this.internalVolume,
+            paused: this.paused
+          },
+          voice: {
+            token: this.voice.token,
+            endpoint: this.voice.endpoint,
+            sessionId: this.voice.sessionId,
+            channelId: this.voice.channelId
+          }
+        }
+      });
+      this.filterManager.applyPlayerFilters();
+      this.ping.node = Math.round((performance.now() - now) / 10) / 100;
+      return this.node.id;
+    } catch (error) {
+      this.dispatchDebug("PlayerChangeNode" /* PlayerChangeNode */, {
+        state: "error",
+        error,
+        message: `Player.changeNode() execution failed`,
+        functionLayer: "Player > changeNode()"
+      });
+      throw new Error(`Failed to change the node: ${error}`);
+    } finally {
+      this.setData("internal_nodeChanging", void 0);
+    }
+  }
+  async moveNode(node) {
+    try {
+      if (!node)
+        node = Array.from(this.RyanlinkManager.nodeManager.leastUsedNodes("playingPlayers")).find(
+          (n) => n.connected && n.options.id !== this.node.options.id
+        ).id;
+      if (!node || !this.RyanlinkManager.nodeManager.nodes.get(node)) throw new RangeError("No nodes are available.");
+      if (this.node.options.id === node) return this;
+      this.RyanlinkManager.emit("debug", "PlayerChangeNode" /* PlayerChangeNode */, {
+        state: "log",
+        message: `Player.moveNode() was executed, trying to move from "${this.node.id}" to "${node}"`,
+        functionLayer: "Player > moveNode()"
+      });
+      const updateNode = this.RyanlinkManager.nodeManager.nodes.get(node);
+      if (!updateNode) throw new RangeError("No nodes are available.");
+      return await this.changeNode(updateNode);
+    } catch (error) {
+      throw new Error(`Failed to move the node: ${error}`);
+    }
+  }
+  toJSON() {
+    return {
+      guildId: this.guildId,
+      options: this.options,
+      voiceChannelId: this.voiceChannelId,
+      textChannelId: this.textChannelId,
+      position: this.position,
+      lastPosition: this.lastPosition,
+      lastPositionChange: this.lastPositionChange,
+      volume: this.volume,
+      internalVolume: this.internalVolume,
+      repeatMode: this.repeatMode,
+      paused: this.paused,
+      playing: this.playing,
+      createdTimeStamp: this.createdTimeStamp,
+      filters: this.filterManager?.data || {},
+      equalizer: this.filterManager?.equalizerBands || [],
+      nodeId: this.node?.id,
+      nodeSessionId: this.node?.sessionId,
+      ping: this.ping,
+      queue: this.queue?.utils?.toJSON?.()
+    };
+  }
+};
+var Autoplay = class {
+  static adding = /* @__PURE__ */ new Set();
+  static async defaultAutoplay(player, lastTrack) {
+    if (!lastTrack) return;
+    const config = player.RyanlinkManager.options.playerOptions.autoplayConfig;
+    if (config.enabled === false) return;
+    if (this.adding.has(player.guildId)) return;
+    this.adding.add(player.guildId);
+    try {
+      const playedData = this.buildPlayedData(player);
+      const relatedTracks = await this.fetchRelatedTracks(player, lastTrack, config, playedData);
+      if (relatedTracks.length > 0) {
+        for (const track of relatedTracks) {
+          player.queue.add(track);
+        }
+        if (!player.playing && !player.paused && player.queue.tracks.length > 0) {
+          await player.play();
+        }
+      }
+    } catch (error) {
+      player.RyanlinkManager.emit("debug", "AutoplayError", {
+        state: "error",
+        message: `Autoplay failed: ${error.message}`,
+        error,
+        functionLayer: "Autoplay > defaultAutoplay()"
+      });
+    } finally {
+      this.adding.delete(player.guildId);
+    }
+  }
+  static buildPlayedData(player) {
+    const playedIds = /* @__PURE__ */ new Set();
+    const playedTracks = /* @__PURE__ */ new Set();
+    const addTrack = (track) => {
+      if (!track) return;
+      if (track.info.identifier) playedIds.add(track.info.identifier);
+      if (track.info.isrc) playedIds.add(track.info.isrc);
+      if (track.info.title && track.info.author) {
+        const key = `${track.info.title.toLowerCase()}|${track.info.author.toLowerCase()}`;
+        playedTracks.add(key);
+      }
+    };
+    if (player.queue.current) addTrack(player.queue.current);
+    player.queue.previous.forEach(addTrack);
+    player.queue.tracks.forEach(addTrack);
+    return { playedIds, playedTracks };
+  }
+  static async fetchRelatedTracks(player, lastTrack, config, playedData) {
+    const tracks = [];
+    const source = lastTrack.info.sourceName?.toLowerCase();
+    if (source?.includes("spotify")) {
+      const spotifyTracks = await this.getSpotifyRecommendations(player, lastTrack);
+      tracks.push(...spotifyTracks);
+    }
+    if (tracks.length < (config.limit || 5) && (source?.includes("youtube") || source?.includes("yt"))) {
+      const youtubeTracks = await this.getYouTubeSimilar(player, lastTrack);
+      tracks.push(...youtubeTracks);
+    }
+    if (tracks.length === 0) {
+      const searchTracks = await this.getArtistSearch(player, lastTrack, config.defaultSource || "ytsearch");
+      tracks.push(...searchTracks);
+    }
+    return this.filterTracks(tracks, playedData, config);
+  }
+  static filterTracks(tracks, playedData, config) {
+    const excludeKeywords = config.excludeKeywords?.map((k) => k.toLowerCase()) || [];
+    return tracks.filter((track) => {
+      if (playedData.playedIds.has(track.info.identifier)) return false;
+      if (track.info.isrc && playedData.playedIds.has(track.info.isrc)) return false;
+      const key = `${track.info.title.toLowerCase()}|${track.info.author.toLowerCase()}`;
+      if (playedData.playedTracks.has(key)) return false;
+      if (track.info.duration < (config.minDuration || 2e4) || track.info.duration > (config.maxDuration || 9e5)) {
+        return false;
+      }
+      const title = track.info.title.toLowerCase();
+      if (excludeKeywords.some((keyword) => title.includes(keyword))) return false;
+      return true;
+    }).sort(() => Math.random() - 0.5).slice(0, config.limit || 5);
+  }
+  static async getSpotifyRecommendations(player, track) {
+    try {
+      const res = await player.search({ query: `sprec:seed_tracks=${track.info.identifier}` }, "Autoplay");
+      if (res.loadType === "search" || res.loadType === "track") return res.tracks;
+      if (res.loadType === "playlist") return res.tracks;
+    } catch {
+    }
+    return [];
+  }
+  static async getYouTubeSimilar(player, track) {
+    try {
+      const res = await player.search({ query: `https://www.youtube.com/watch?v=${track.info.identifier}` }, "Autoplay");
+      if (res.loadType === "playlist") return res.tracks;
+    } catch {
+    }
+    return [];
+  }
+  static async getArtistSearch(player, track, source) {
+    try {
+      const res = await player.search({ query: track.info.author, source }, "Autoplay");
+      if (res.loadType === "search" || res.loadType === "track") return res.tracks;
+    } catch {
+    }
+    return [];
+  }
+};
+
+// src/core/Manager.ts
+var RyanlinkManager = class _RyanlinkManager extends import_node_events2.EventEmitter {
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  removeListener(event, listener) {
+    return super.removeListener(event, listener);
+  }
+  options;
+  nodeManager;
+  utils;
+  initiated = false;
+  players = new MiniMap();
+  applyOptions(options) {
+    const optionsToAssign = {
+      ...options,
+      client: {
+        ...options?.client,
+        id: options?.client?.id,
+        username: options?.client?.username ?? "ryanlink"
+      },
+      sendToShard: options?.sendToShard,
+      autoMove: options?.autoMove ?? false,
+      nodes: options?.nodes,
+      playerClass: options?.playerClass ?? Player,
+      playerOptions: {
+        applyVolumeAsFilter: options?.playerOptions?.applyVolumeAsFilter ?? false,
+        clientBasedPositionUpdateInterval: options?.playerOptions?.clientBasedPositionUpdateInterval ?? 100,
+        defaultSearchPlatform: options?.playerOptions?.defaultSearchPlatform ?? "ytsearch",
+        allowCustomSources: options?.playerOptions?.allowCustomSources ?? false,
+        onDisconnect: {
+          destroyPlayer: options?.playerOptions?.onDisconnect?.destroyPlayer ?? true,
+          autoReconnect: options?.playerOptions?.onDisconnect?.autoReconnect ?? false,
+          autoReconnectOnlyWithTracks: options?.playerOptions?.onDisconnect?.autoReconnectOnlyWithTracks ?? false
+        },
+        onEmptyQueue: {
+          autoPlayFunction: options?.playerOptions?.onEmptyQueue?.autoPlayFunction ?? Autoplay.defaultAutoplay,
+          destroyAfterMs: options?.playerOptions?.onEmptyQueue?.destroyAfterMs ?? void 0
+        },
+        autoplayConfig: {
+          enabled: options?.playerOptions?.autoplayConfig?.enabled ?? true,
+          defaultSource: options?.playerOptions?.autoplayConfig?.defaultSource ?? "ytsearch",
+          limit: options?.playerOptions?.autoplayConfig?.limit ?? 5,
+          minDuration: options?.playerOptions?.autoplayConfig?.minDuration ?? 2e4,
+          maxDuration: options?.playerOptions?.autoplayConfig?.maxDuration ?? 9e5,
+          excludeKeywords: options?.playerOptions?.autoplayConfig?.excludeKeywords ?? ["nightcore", "bass boosted", "8d audio", "slowed", "reverb"]
+        },
+        volumeDecrementer: options?.playerOptions?.volumeDecrementer ?? 1,
+        requesterTransformer: options?.playerOptions?.requesterTransformer ?? null,
+        useUnresolvedData: options?.playerOptions?.useUnresolvedData ?? false,
+        minAutoPlayMs: options?.playerOptions?.minAutoPlayMs ?? 1e4,
+        maxErrorsPerTime: {
+          threshold: options?.playerOptions?.maxErrorsPerTime?.threshold ?? 35e3,
+          maxAmount: options?.playerOptions?.maxErrorsPerTime?.maxAmount ?? 3
+        },
+        enforceSponsorBlockRequestForEventEnablement: options?.playerOptions?.enforceSponsorBlockRequestForEventEnablement ?? true
+      },
+      linksWhitelist: options?.linksWhitelist ?? [],
+      linksBlacklist: options?.linksBlacklist ?? [],
+      linksAllowed: options?.linksAllowed ?? true,
+      autoSkip: options?.autoSkip ?? true,
+      autoSkipOnResolveError: options?.autoSkipOnResolveError ?? true,
+      emitNewSongsOnly: options?.emitNewSongsOnly ?? false,
+      queueOptions: {
+        maxPreviousTracks: options?.queueOptions?.maxPreviousTracks ?? 25,
+        queueChangesWatcher: options?.queueOptions?.queueChangesWatcher ?? null,
+        queueStore: options?.queueOptions?.queueStore ?? new DefaultQueueStore()
+      },
+      advancedOptions: {
+        enableDebugEvents: options?.advancedOptions?.enableDebugEvents ?? false,
+        maxFilterFixDuration: options?.advancedOptions?.maxFilterFixDuration ?? 6e5,
+        debugOptions: {
+          logCustomSearches: options?.advancedOptions?.debugOptions?.logCustomSearches ?? false,
+          noAudio: options?.advancedOptions?.debugOptions?.noAudio ?? false,
+          playerDestroy: {
+            dontThrowError: options?.advancedOptions?.debugOptions?.playerDestroy?.dontThrowError ?? false,
+            debugLog: options?.advancedOptions?.debugOptions?.playerDestroy?.debugLog ?? false
+          }
+        }
+      }
+    };
+    this.options = optionsToAssign;
+    return;
+  }
+  validateOptions(options) {
+    if (typeof options?.sendToShard !== "function") throw new SyntaxError("ManagerOption.sendToShard was not provided, which is required!");
+    if (options?.autoSkip && typeof options?.autoSkip !== "boolean")
+      throw new SyntaxError("ManagerOption.autoSkip must be either false | true aka boolean");
+    if (options?.autoSkipOnResolveError && typeof options?.autoSkipOnResolveError !== "boolean")
+      throw new SyntaxError("ManagerOption.autoSkipOnResolveError must be either false | true aka boolean");
+    if (options?.emitNewSongsOnly && typeof options?.emitNewSongsOnly !== "boolean")
+      throw new SyntaxError("ManagerOption.emitNewSongsOnly must be either false | true aka boolean");
+    if (!options?.nodes || !Array.isArray(options?.nodes) || !options?.nodes.every((node) => this.utils.isNodeOptions(node)))
+      throw new SyntaxError("ManagerOption.nodes must be an Array of NodeOptions and is required of at least 1 Node");
+    if (options?.queueOptions?.queueStore) {
+      const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(options?.queueOptions?.queueStore));
+      const requiredKeys = ["get", "set", "stringify", "parse", "delete"];
+      if (!requiredKeys.every((v) => keys.includes(v)) || !requiredKeys.every((v) => typeof options?.queueOptions?.queueStore[v] === "function"))
+        throw new SyntaxError(`The provided ManagerOption.QueueStore, does not have all required functions: ${requiredKeys.join(", ")}`);
+    }
+    if (options?.queueOptions?.queueChangesWatcher) {
+      const keys = Object.getOwnPropertyNames(Object.getPrototypeOf(options?.queueOptions?.queueChangesWatcher));
+      const requiredKeys = ["tracksAdd", "tracksRemoved", "shuffled"];
+      if (!requiredKeys.every((v) => keys.includes(v)) || !requiredKeys.every((v) => typeof options?.queueOptions?.queueChangesWatcher[v] === "function"))
+        throw new SyntaxError(
+          `The provided ManagerOption.DefaultQueueChangesWatcher, does not have all required functions: ${requiredKeys.join(", ")}`
+        );
+    }
+    if (typeof options?.queueOptions?.maxPreviousTracks !== "number" || options?.queueOptions?.maxPreviousTracks < 0)
+      options.queueOptions.maxPreviousTracks = 25;
+  }
+  dispatchDebug(name, eventData) {
+    if (!this.options?.advancedOptions?.enableDebugEvents) return;
+    this.emit("debug", name, eventData);
+  }
+  static _noAudioDebugPrefix = "Audio-Debug | NO-AUDIO [::] provideVoiceUpdate function, ";
+  _debugNoAudio(state, functionLayer, messages, ...consoleArgs) {
+    this.dispatchDebug("NoAudioDebug" /* NoAudioDebug */, { state, functionLayer, message: messages.message });
+    if (this.options?.advancedOptions?.debugOptions?.noAudio === true) {
+      const consoleMsg = messages.consoleMessage ?? messages.message;
+      console.debug(_RyanlinkManager._noAudioDebugPrefix + consoleMsg, ...consoleArgs);
+    }
+  }
+  constructor(options) {
+    super();
+    if (!options) throw new SyntaxError("No Manager Options Provided");
+    this.utils = new RyanlinkUtils(this);
+    this.applyOptions(options);
+    this.validateOptions(this.options);
+    this.nodeManager = new NodeManager(this);
+  }
+  getPlayer(guildId) {
+    return this.players.get(guildId);
+  }
+  createPlayer(options) {
+    const oldPlayer = this.getPlayer(options?.guildId);
+    if (oldPlayer) return oldPlayer;
+    const newPlayer = new this.options.playerClass(options, this, true);
+    this.players.set(newPlayer.guildId, newPlayer);
+    this.emit("playerCreate", newPlayer);
+    return newPlayer;
+  }
+  destroyPlayer(guildId, destroyReason) {
+    const oldPlayer = this.getPlayer(guildId);
+    if (!oldPlayer) return;
+    return oldPlayer.destroy(destroyReason);
+  }
+  deletePlayer(guildId) {
+    const oldPlayer = this.getPlayer(guildId);
+    if (!oldPlayer) return;
+    if (typeof oldPlayer.voiceChannelId === "string" && oldPlayer.connected && !oldPlayer.getData("internal_destroywithoutdisconnect")) {
+      if (!this.options?.advancedOptions?.debugOptions?.playerDestroy?.dontThrowError)
+        throw new Error(`Use Player#destroy() not RyanlinkManager#deletePlayer() to stop the Player ${safeStringify(oldPlayer.toJSON?.())}`);
+      this.dispatchDebug("PlayerDeleteInsteadOfDestroy" /* PlayerDeleteInsteadOfDestroy */, {
+        state: "warn",
+        message: "Use Player#destroy() not RyanlinkManager#deletePlayer() to stop the Player",
+        functionLayer: "RyanlinkManager > deletePlayer()"
+      });
+    }
+    return this.players.delete(guildId);
+  }
+  get useable() {
+    return this.nodeManager.nodes.filter((v) => v.connected).size > 0;
+  }
+  async init(clientData) {
+    if (this.initiated) return this;
+    clientData = clientData ?? {};
+    this.options.client = { ...this.options?.client, ...clientData };
+    if (!this.options?.client.id) throw new Error('"client.id" is not set. Pass it in Manager#init() or as a option in the constructor.');
+    if (typeof this.options?.client.id !== "string") throw new Error('"client.id" set is not type of "string"');
+    let success = 0;
+    for (const node of this.nodeManager.nodes.values()) {
+      try {
+        await node.connect();
+        success++;
+      } catch (err) {
+        console.error(err);
+        this.nodeManager.emit("error", node, err);
+      }
+    }
+    if (success > 0) this.initiated = true;
+    else
+      this.dispatchDebug("FailedToConnectToNodes" /* FailedToConnectToNodes */, {
+        state: "error",
+        message: "Failed to connect to at least 1 Node",
+        functionLayer: "RyanlinkManager > init()"
+      });
+    return this;
+  }
+  async provideVoiceUpdate(data) {
+    if (!this.initiated) {
+      this._debugNoAudio("log", "RyanlinkManager > provideVoiceUpdate()", {
+        message: "Manager is not initated yet",
+        consoleMessage: "manager is not initated yet"
+      });
+      return;
+    }
+    if (!("t" in data)) {
+      this._debugNoAudio(
+        "error",
+        "RyanlinkManager > provideVoiceUpdate()",
+        {
+          message: "No 't' in payload-data of the raw event:",
+          consoleMessage: "no 't' in payload-data of the raw event:"
+        },
+        data
+      );
+      return;
+    }
+    if ("CHANNEL_DELETE" === data.t) {
+      const update = "d" in data ? data.d : data;
+      if (!update.guild_id) return;
+      const player = this.getPlayer(update.guild_id);
+      if (player && player.voiceChannelId === update.id) return void player.destroy("ChannelDeleted" /* ChannelDeleted */);
+    }
+    if (["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(data.t)) {
+      const update = "d" in data ? data.d : data;
+      if (!update) {
+        this._debugNoAudio(
+          "warn",
+          "RyanlinkManager > provideVoiceUpdate()",
+          {
+            message: `No Update data found in payload :: ${safeStringify(data, 2)}`,
+            consoleMessage: "no update data found in payload:"
+          },
+          data
+        );
+        return;
+      }
+      if (!("token" in update) && !("session_id" in update)) {
+        this._debugNoAudio(
+          "error",
+          "RyanlinkManager > provideVoiceUpdate()",
+          {
+            message: `No 'token' nor 'session_id' found in payload :: ${safeStringify(data, 2)}`,
+            consoleMessage: "no 'token' nor 'session_id' found in payload:"
+          },
+          data
+        );
+        return;
+      }
+      const player = this.getPlayer(update.guild_id);
+      if (!player) {
+        this._debugNoAudio(
+          "warn",
+          "RyanlinkManager > provideVoiceUpdate()",
+          {
+            message: `No Audio Player found via key: 'guild_id' of update-data :: ${safeStringify(update, 2)}`,
+            consoleMessage: "No Audio Player found via key: 'guild_id' of update-data:"
+          },
+          update
+        );
+        return;
+      }
+      if (player.getData("internal_destroystatus") === true) {
+        this._debugNoAudio("warn", "RyanlinkManager > provideVoiceUpdate()", {
+          message: "Player is in a destroying state. can't signal the voice states"
+        });
+        return;
+      }
+      if ("token" in update) {
+        if (!player.node?.sessionId) throw new Error("Audio Node is either not ready or not up to date");
+        const sessionId2Use = player.voice?.sessionId || ("sessionId" in update ? update.sessionId : void 0);
+        const channelId2Use = player.voice?.channelId || ("channel_id" in update ? update.channel_id : void 0);
+        const voiceData = {
+          token: update.token,
+          endpoint: update.endpoint,
+          sessionId: sessionId2Use,
+          channelId: channelId2Use
+        };
+        if (!sessionId2Use) {
+          this._debugNoAudio(
+            "error",
+            "RyanlinkManager > provideVoiceUpdate()",
+            {
+              message: `Can't send updatePlayer for voice token session - Missing sessionId :: ${safeStringify({ voice: voiceData, update, playerVoice: player.voice }, 2)}`,
+              consoleMessage: "Can't send updatePlayer for voice token session - Missing sessionId"
+            },
+            { voice: voiceData, update, playerVoice: player.voice }
+          );
+        } else if (!channelId2Use) {
+          this._debugNoAudio(
+            "error",
+            "RyanlinkManager > provideVoiceUpdate()",
+            {
+              message: `Can't send updatePlayer for voice token session - Missing channelId :: ${safeStringify({ voice: voiceData, update, playerVoice: player.voice }, 2)}`,
+              consoleMessage: "Can't send updatePlayer for voice token session - Missing channelId"
+            },
+            { voice: voiceData, update, playerVoice: player.voice }
+          );
+        } else {
+          await player.node.updatePlayer({
+            guildId: player.guildId,
+            playerOptions: {
+              voice: voiceData
+            }
+          });
+          this._debugNoAudio(
+            "log",
+            "RyanlinkManager > provideVoiceUpdate()",
+            {
+              message: `Sent updatePlayer for voice token session :: ${safeStringify({ voice: voiceData, update, playerVoice: player.voice }, 2)}`,
+              consoleMessage: "Sent updatePlayer for voice token session"
+            },
+            { voice: voiceData, playerVoice: player.voice, update }
+          );
+        }
+        return;
+      }
+      if (update.user_id !== this.options?.client.id) {
+        if (update.user_id && player.voiceChannelId) {
+          this.emit(update.channel_id === player.voiceChannelId ? "playerVoiceJoin" : "playerVoiceLeave", player, update.user_id);
+        }
+        this._debugNoAudio(
+          "warn",
+          "RyanlinkManager > provideVoiceUpdate()",
+          {
+            message: `voice update user is not equal to provided client id of the RyanlinkManager.options.client.id :: user: "${update.user_id}" manager client id: "${this.options?.client.id}"`,
+            consoleMessage: "voice update user is not equal to provided client id of the manageroptions#client#id"
+          },
+          "user:",
+          update.user_id,
+          "manager client id:",
+          this.options?.client.id
+        );
+        return;
+      }
+      if (update.channel_id) {
+        if (player.voiceChannelId !== update.channel_id) this.emit("playerMove", player, player.voiceChannelId, update.channel_id);
+        player.voice.sessionId = update.session_id || player.voice.sessionId;
+        player.voice.channelId = update.channel_id || player.voice.channelId;
+        if (!player.voice.sessionId) {
+          this._debugNoAudio("warn", "RyanlinkManager > provideVoiceUpdate()", {
+            message: `Function to assing sessionId provided, but no found in Payload: ${safeStringify({ update, playerVoice: player.voice }, 2)}`,
+            consoleMessage: `Function to assing sessionId provided, but no found in Payload: ${safeStringify(update, 2)}`
+          });
+        }
+        player.voiceChannelId = update.channel_id;
+        player.options.voiceChannelId = update.channel_id;
+        const selfMuteChanged = typeof update.self_mute === "boolean" && player.voiceState.selfMute !== update.self_mute;
+        const serverMuteChanged = typeof update.mute === "boolean" && player.voiceState.serverMute !== update.mute;
+        const selfDeafChanged = typeof update.self_deaf === "boolean" && player.voiceState.selfDeaf !== update.self_deaf;
+        const serverDeafChanged = typeof update.deaf === "boolean" && player.voiceState.serverDeaf !== update.deaf;
+        const suppressChange = typeof update.suppress === "boolean" && player.voiceState.suppress !== update.suppress;
+        player.voiceState.selfDeaf = update.self_deaf ?? player.voiceState?.selfDeaf;
+        player.voiceState.selfMute = update.self_mute ?? player.voiceState?.selfMute;
+        player.voiceState.serverDeaf = update.deaf ?? player.voiceState?.serverDeaf;
+        player.voiceState.serverMute = update.mute ?? player.voiceState?.serverMute;
+        player.voiceState.suppress = update.suppress ?? player.voiceState?.suppress;
+        if (selfMuteChanged || serverMuteChanged) {
+          this.emit("playerMuteChange", player, player.voiceState.selfMute, player.voiceState.serverMute);
+          if (player.options.autoPauseOnMute === true) {
+            if (player.voiceState.selfMute || player.voiceState.serverMute) await player.pause();
+            else await player.resume();
+          }
+        }
+        if (selfDeafChanged || serverDeafChanged) this.emit("playerDeafChange", player, player.voiceState.selfDeaf, player.voiceState.serverDeaf);
+        if (suppressChange) this.emit("playerSuppressChange", player, player.voiceState.suppress);
+      } else {
+        const { autoReconnectOnlyWithTracks, destroyPlayer, autoReconnect } = this.options?.playerOptions?.onDisconnect ?? {};
+        if (destroyPlayer === true) {
+          return void await player.destroy("Disconnected" /* Disconnected */);
+        }
+        if (autoReconnect === true) {
+          try {
+            const previousPosition = player.position;
+            const previousPaused = player.paused;
+            this.dispatchDebug("PlayerAutoReconnect" /* PlayerAutoReconnect */, {
+              state: "log",
+              message: `Auto reconnecting player because RyanlinkManager.options.playerOptions.onDisconnect.autoReconnect is true`,
+              functionLayer: "RyanlinkManager > provideVoiceUpdate()"
+            });
+            if (!autoReconnectOnlyWithTracks || autoReconnectOnlyWithTracks && (player.queue.current || player.queue.tracks.length)) {
+              await player.connect();
+              this.emit("playerReconnect", player, player.voiceChannelId);
+            }
+            if (player.queue.current) {
+              return void await player.play({
+                position: previousPosition,
+                paused: previousPaused,
+                clientTrack: player.queue.current
+              });
+            }
+            if (player.queue.tracks.length) {
+              return void await player.play({ paused: previousPaused });
+            }
+            this.dispatchDebug("PlayerAutoReconnect" /* PlayerAutoReconnect */, {
+              state: "log",
+              message: `Auto reconnected, but nothing to play`,
+              functionLayer: "RyanlinkManager > provideVoiceUpdate()"
+            });
+            return;
+          } catch (e) {
+            console.error(e);
+            return void await player.destroy("PlayerReconnectFail" /* PlayerReconnectFail */);
+          }
+        }
+        this.emit("playerDisconnect", player, player.voiceChannelId);
+        player.voiceChannelId = null;
+        player.voice = Object.assign({});
+        return;
+      }
+    }
+  }
+};
+
+// src/index.ts
+var version = "2.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioNodeSymbol,
+  AudioQueueSymbol,
+  AudioTrackSymbol,
+  Autoplay,
+  BuiltinSources,
+  DebugEvents,
+  DefaultQueueStore,
+  DestroyReasons,
+  DisconnectReasons,
+  EQList,
+  FilterManager,
+  LinkMatchers,
+  MiniMap,
+  NodeLinkExclusiveEvents,
+  NodeLinkNode,
+  NodeManager,
+  Player,
+  Queue,
+  QueueSaver,
+  RecommendationsStrings,
+  ReconnectionState,
+  RyanlinkManager,
+  RyanlinkNode,
+  RyanlinkUtils,
+  SourceMappings,
+  UnresolvedAudioTrackSymbol,
+  audioOutputsData,
+  parseConnectionUrl,
+  queueTrackEnd,
+  safeStringify,
+  validSponsorBlocks,
+  version
+});