ryanlink 1.0.1

package/dist/index.mjs

@@ -0,0 +1,4604 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { URL } from 'url';
+import { EventEmitter, once } from 'events';
+import { clearTimeout as clearTimeout$1, setTimeout as setTimeout$1 } from 'timers';
+import { WebSocket } from 'ws';
+import { setTimeout as setTimeout$2 } from 'timers/promises';
+
+/* Ryanlink v1.0.0 - Modern Lavalink Client | Apache-2.0 License | https://github.com/ryanwtf7/ryanlink */
+
+var packageInfo = null;
+function loadPackageInfo() {
+  if (packageInfo) {
+    return packageInfo;
+  }
+  try {
+    const possiblePaths = [
+      join(__dirname, "..", "..", "package.json"),
+      join(__dirname, "..", "package.json"),
+      join(process.cwd(), "package.json")
+    ];
+    for (const path of possiblePaths) {
+      try {
+        const content = readFileSync(path, "utf-8");
+        packageInfo = JSON.parse(content);
+        return packageInfo;
+      } catch {
+        continue;
+      }
+    }
+    console.warn("Could not load package.json, using fallback values");
+    return {
+      name: "ryanlink",
+      version: "1.0.0",
+      repository: {
+        type: "git",
+        url: "https://github.com/ryanwtf7/ryanlink.git"
+      }
+    };
+  } catch (error) {
+    return {
+      name: "ryanlink",
+      version: "1.0.0",
+      repository: {
+        type: "git",
+        url: "https://github.com/ryanwtf7/ryanlink.git"
+      }
+    };
+  }
+}
+var pkg = loadPackageInfo();
+var CLIENT_NAME = pkg.name;
+var CLIENT_VERSION = pkg.version;
+var CLIENT_REPOSITORY = pkg.repository?.url.replace(/\.git$/, "") ?? "https://github.com/ryanwtf7/ryanlink";
+var PACKAGE_INFO = Object.freeze({
+  name: CLIENT_NAME,
+  version: CLIENT_VERSION,
+  repository: CLIENT_REPOSITORY,
+  description: pkg.description
+});
+
+// src/config/defaults.ts
+var DefaultRestOptions = Object.seal({
+  /**
+   * Lavalink API version
+   */
+  version: 4,
+  /**
+   * User agent string sent with requests
+   */
+  userAgent: `${CLIENT_NAME}/${CLIENT_VERSION} (${CLIENT_REPOSITORY})`,
+  /**
+   * Whether to include stack traces in error responses
+   */
+  stackTrace: false,
+  /**
+   * Request timeout in milliseconds
+   */
+  requestTimeout: 1e4
+});
+var DefaultNodeOptions = Object.seal({
+  /**
+   * Interval for stats updates in milliseconds
+   */
+  statsInterval: 6e4,
+  /**
+   * Highest acceptable latency in milliseconds
+   */
+  highestLatency: 2e3,
+  /**
+   * Delay before reconnection attempts in milliseconds
+   */
+  reconnectDelay: 1e4,
+  /**
+   * Maximum number of reconnection attempts (-1 = infinite)
+   */
+  reconnectLimit: 3,
+  /**
+   * WebSocket handshake timeout in milliseconds
+   */
+  handshakeTimeout: 5e3
+});
+var DefaultPlayerOptions = Object.seal({
+  /**
+   * Automatically initialize player on construction
+   */
+  autoInit: true,
+  /**
+   * Automatically sync queue state with Lavalink
+   */
+  autoSync: true,
+  /**
+   * Default search prefix (ytsearch, ytmsearch, scsearch, etc.)
+   */
+  queryPrefix: "ytsearch",
+  /**
+   * Automatically relocate queues when nodes disconnect
+   */
+  relocateQueues: true,
+  /**
+   * Default function to fetch related tracks for autoplay
+   * Returns empty array by default (no autoplay)
+   */
+  async fetchRelatedTracks() {
+    return await Promise.resolve([]);
+  }
+});
+var DefaultQueueOptions = Object.seal({
+  /**
+   * Default volume (0-1000)
+   */
+  volume: 100,
+  /**
+   * Default repeat mode
+   */
+  repeatMode: "none",
+  /**
+   * Default autoplay state
+   */
+  autoplay: false,
+  /**
+   * Default paused state
+   */
+  paused: false
+});
+var DefaultFilterOptions = Object.seal({
+  /**
+   * Volume multiplier (0.0 - 5.0)
+   */
+  volume: 1,
+  /**
+   * Equalizer bands (15 bands, -0.25 to 1.0 each)
+   */
+  equalizer: [],
+  /**
+   * Karaoke filter
+   */
+  karaoke: null,
+  /**
+   * Timescale filter (speed, pitch, rate)
+   */
+  timescale: null,
+  /**
+   * Tremolo filter (frequency, depth)
+   */
+  tremolo: null,
+  /**
+   * Vibrato filter (frequency, depth)
+   */
+  vibrato: null,
+  /**
+   * Rotation filter (rotationHz)
+   */
+  rotation: null,
+  /**
+   * Distortion filter
+   */
+  distortion: null,
+  /**
+   * Channel mix filter
+   */
+  channelMix: null,
+  /**
+   * Low pass filter
+   */
+  lowPass: null
+});
+var HttpStatusCodes = Object.freeze({
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+});
+var WebSocketCloseCodes = Object.freeze({
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  PROTOCOL_ERROR: 1002,
+  UNSUPPORTED_DATA: 1003,
+  NO_STATUS_RECEIVED: 1005,
+  ABNORMAL_CLOSURE: 1006,
+  INVALID_FRAME_PAYLOAD_DATA: 1007,
+  POLICY_VIOLATION: 1008,
+  MESSAGE_TOO_BIG: 1009,
+  INTERNAL_ERROR: 1011
+});
+
+// src/config/presets.ts
+var EQPresets = {
+  /** A Bassboost Equalizer, so high it distorts the audio */
+  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 }
+  ],
+  /** A High and decent Bassboost Equalizer */
+  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 }
+  ],
+  /** A decent Bassboost Equalizer */
+  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 }
+  ],
+  /** A slight Bassboost Equalizer */
+  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 }
+  ],
+  /** Professional high-fidelity audio preset for clear vocals and deep bass */
+  HighQuality: [
+    { band: 0, gain: 0.15 },
+    { band: 1, gain: 0.1 },
+    { band: 2, gain: 0.05 },
+    { band: 3, gain: 0 },
+    { band: 4, gain: 0 },
+    { band: 5, gain: 0 },
+    { band: 6, gain: 0 },
+    { band: 7, gain: 0 },
+    { band: 8, gain: 0 },
+    { band: 9, gain: 0 },
+    { band: 10, gain: 0.05 },
+    { band: 11, gain: 0.1 },
+    { band: 12, gain: 0.15 },
+    { band: 13, gain: 0.15 },
+    { band: 14, gain: 0.15 }
+  ],
+  /** Makes the Music slightly "better" */
+  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 }
+  ],
+  /** Makes the Music sound like rock music / sound rock music better */
+  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 }
+  ],
+  /** Makes the Music sound like Classic music / sound Classic music better */
+  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 }
+  ],
+  /** Makes the Music sound like Pop music / sound Pop music better */
+  Pop: [
+    { band: 0, gain: 0.26 },
+    { band: 1, gain: 0.22 },
+    { band: 2, gain: 0.18 },
+    { band: 3, gain: 0.12 },
+    { band: 4, gain: 0.1 },
+    { band: 5, gain: 0.03 },
+    { band: 6, gain: -5e-3 },
+    { band: 7, gain: -0.01 },
+    { band: 8, gain: -0.015 },
+    { band: 9, gain: -0.015 },
+    { band: 10, gain: -0.01 },
+    { band: 11, gain: -5e-3 },
+    { band: 12, gain: 0.08 },
+    { band: 13, gain: 0.15 },
+    { band: 14, gain: 0.2 }
+  ],
+  /** Makes the Music sound like Electronic music / sound Electronic music better */
+  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 }
+  ],
+  /** Boosts all Bands slightly for louder and fuller sound */
+  FullSound: [
+    { band: 0, gain: 0.25 },
+    { band: 1, gain: 0.25 },
+    { band: 2, gain: 0.25 },
+    { band: 3, gain: 0.25 },
+    { band: 4, gain: 0.25 },
+    { band: 5, gain: 0.25 },
+    { band: 6, gain: 0.25 },
+    { band: 7, gain: 0.25 },
+    { band: 8, gain: 0.25 },
+    { band: 9, gain: 0.25 },
+    { band: 10, gain: 0.25 },
+    { band: 11, gain: 0.25 },
+    { band: 12, gain: 0.25 },
+    { band: 13, gain: 0.25 },
+    { band: 14, gain: 0.25 }
+  ],
+  /** Makes the Music sound like being in a Gaming environment / sound Gaming music better */
+  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.075 },
+    { band: 7, gain: 0 },
+    { band: 8, gain: -0.05 },
+    { band: 9, gain: 0.05 },
+    { band: 10, gain: 0.1 },
+    { band: 11, gain: 0.15 },
+    { band: 12, gain: 0.25 },
+    { band: 13, gain: 0.3 },
+    { band: 14, gain: 0.35 }
+  ],
+  /** Nightcore preset with speed and pitch adjustments */
+  Nightcore: [
+    { band: 0, gain: 0.2 },
+    { band: 1, gain: 0.15 },
+    { band: 2, gain: 0.1 },
+    { band: 3, gain: 0.05 },
+    { band: 4, gain: 0 },
+    { band: 5, gain: -0.05 },
+    { band: 6, gain: -0.1 },
+    { band: 7, gain: -0.05 },
+    { band: 8, gain: 0 },
+    { band: 9, gain: 0.05 },
+    { band: 10, gain: 0.1 },
+    { band: 11, gain: 0.15 },
+    { band: 12, gain: 0.2 },
+    { band: 13, gain: 0.25 },
+    { band: 14, gain: 0.3 }
+  ],
+  /** Vaporwave preset */
+  Vaporwave: [
+    { band: 0, gain: 0.35 },
+    { band: 1, gain: 0.3 },
+    { band: 2, gain: 0.2 },
+    { band: 3, gain: 0.1 },
+    { band: 4, gain: 0 },
+    { band: 5, gain: -0.05 },
+    { band: 6, gain: -0.1 },
+    { band: 7, gain: -0.15 },
+    { band: 8, gain: -0.1 },
+    { band: 9, gain: 0 },
+    { band: 10, gain: 0.1 },
+    { band: 11, gain: 0.15 },
+    { band: 12, gain: 0.2 },
+    { band: 13, gain: 0.25 },
+    { band: 14, gain: 0.3 }
+  ],
+  /** Treble and Bass boost */
+  TrebleBass: [
+    { band: 0, gain: 0.3 },
+    { band: 1, gain: 0.25 },
+    { band: 2, gain: 0.2 },
+    { band: 3, gain: 0.1 },
+    { band: 4, gain: 0 },
+    { band: 5, gain: -0.05 },
+    { band: 6, gain: -0.1 },
+    { band: 7, gain: -0.05 },
+    { band: 8, gain: 0 },
+    { band: 9, gain: 0.05 },
+    { band: 10, gain: 0.1 },
+    { band: 11, gain: 0.15 },
+    { band: 12, gain: 0.2 },
+    { band: 13, gain: 0.25 },
+    { band: 14, gain: 0.3 }
+  ],
+  /** Soft preset */
+  Soft: [
+    { band: 0, gain: 0.1 },
+    { band: 1, gain: 0.08 },
+    { band: 2, gain: 0.06 },
+    { band: 3, gain: 0.04 },
+    { band: 4, gain: 0.02 },
+    { band: 5, gain: 0 },
+    { band: 6, gain: 0 },
+    { band: 7, gain: 0 },
+    { band: 8, gain: 0 },
+    { band: 9, gain: 0 },
+    { band: 10, gain: 0.02 },
+    { band: 11, gain: 0.04 },
+    { band: 12, gain: 0.06 },
+    { band: 13, gain: 0.08 },
+    { band: 14, gain: 0.1 }
+  ],
+  /** TV preset */
+  TV: [
+    { band: 0, gain: 0.2 },
+    { band: 1, gain: 0.25 },
+    { band: 2, gain: 0.3 },
+    { band: 3, gain: 0.25 },
+    { band: 4, gain: 0.2 },
+    { band: 5, gain: 0.1 },
+    { band: 6, gain: 0 },
+    { band: 7, gain: 0 },
+    { band: 8, gain: 0.1 },
+    { band: 9, gain: 0.15 },
+    { band: 10, gain: 0.2 },
+    { band: 11, gain: 0.15 },
+    { band: 12, gain: 0.1 },
+    { band: 13, gain: 0.05 },
+    { band: 14, gain: 0 }
+  ],
+  /** Radio preset */
+  Radio: [
+    { band: 0, gain: 0.15 },
+    { band: 1, gain: 0.2 },
+    { band: 2, gain: 0.25 },
+    { band: 3, gain: 0.2 },
+    { band: 4, gain: 0.15 },
+    { band: 5, gain: 0.1 },
+    { band: 6, gain: 0 },
+    { band: 7, gain: 0 },
+    { band: 8, gain: 0 },
+    { band: 9, gain: 0.1 },
+    { band: 10, gain: 0.15 },
+    { band: 11, gain: 0.2 },
+    { band: 12, gain: 0.15 },
+    { band: 13, gain: 0.1 },
+    { band: 14, gain: 0.05 }
+  ],
+  /** Normalization preset (all bands at 0) */
+  Normalization: [
+    { band: 0, gain: 0 },
+    { band: 1, gain: 0 },
+    { band: 2, gain: 0 },
+    { band: 3, gain: 0 },
+    { band: 4, gain: 0 },
+    { band: 5, gain: 0 },
+    { band: 6, gain: 0 },
+    { band: 7, gain: 0 },
+    { band: 8, gain: 0 },
+    { band: 9, gain: 0 },
+    { band: 10, gain: 0 },
+    { band: 11, gain: 0 },
+    { band: 12, gain: 0 },
+    { band: 13, gain: 0 },
+    { band: 14, gain: 0 }
+  ]
+};
+function getEQPreset(name) {
+  return EQPresets[name];
+}
+function getEQPresetNames() {
+  return Object.keys(EQPresets);
+}
+function isValidEQPreset(name) {
+  return name in EQPresets;
+}
+
+// src/config/patterns.ts
+var SnowflakeRegex = /^\d{17,20}$/;
+var VoiceRegionIdRegex = /^([-a-z]{2,20})(?=[-a-z\d]*\.discord\.media:\d+$)/;
+var UrlRegex = /^https?:\/\/.+/i;
+var YoutubeRegex = /^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.be)\/.+/i;
+var SpotifyRegex = /^https?:\/\/open\.spotify\.com\/(track|album|playlist|artist)\/.+/i;
+var SoundCloudRegex = /^https?:\/\/(www\.)?soundcloud\.com\/.+/i;
+var BandcampRegex = /^https?:\/\/.+\.bandcamp\.com\/(track|album)\/.+/i;
+var TwitchRegex = /^https?:\/\/(www\.)?twitch\.tv\/.+/i;
+var AppleMusicRegex = /^https?:\/\/music\.apple\.com\/.+/i;
+var DeezerRegex = /^https?:\/\/(www\.)?deezer\.com\/(track|album|playlist)\/.+/i;
+var AudioFileRegex = /^https?:\/\/.+\.(mp3|wav|ogg|flac|m4a|aac|opus|webm)(\?.*)?$/i;
+var TidalRegex = /^https?:\/\/(?:(?:listen|www)\.)?tidal\.com\/(?:browse\/)?(?:album|track|playlist|mix)\/[a-zA-Z0-9-]+(?:\/.*)?(?:\?.*)?$/i;
+var YandexMusicRegex = /^(?:https?:\/\/)?music\.yandex\.(?:ru|com|kz|by)\/(?:artist|album|track|users\/[0-9A-Za-z@.-]+\/playlists|playlists)\/[0-9A-Za-z-.]+(?:\/track\/[0-9]+)?(?:\/)?$/i;
+var AmazonMusicRegex = /^https?:\/\/music\.amazon\.[^/]+\/(?:albums|tracks|artists|playlists|user-playlists|community-playlists)\/[A-Za-z0-9]+(?:\/[^/?#]+)?(?:[/?].*)?$/i;
+var JioSaavnRegex = /^(?:https?:\/\/)?(?:www\.)?jiosaavn\.com\/(?:song|album|featured|artist|s\/playlist)\/[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)?$/i;
+var PandoraRegex = /^@?(?:https?:\/\/)?(?:www\.)?pandora\.com\/(?:playlist\/PL:[\d:]+|artist\/[\w-]+(?:\/[\w-]+)*\/(?:TR|AL|AR)[A-Za-z0-9]+)(?:[?#].*)?$/i;
+var QobuzRegex = /^https?:\/\/(?:www\.|play\.|open\.)?qobuz\.com\/(?:(?:[a-z]{2}-[a-z]{2}\/)?(?:album|playlist|track|artist)\/(?:.+?\/)?[a-zA-Z0-9]+|playlist\/\d+)$/i;
+var AudiomackRegex = /^https?:\/\/audiomack\.com\/(?:(?:[^/]+\/(?:song|album|playlist)|(?:song|album|playlist))\/[^/?#]+)$/i;
+var MixcloudRegex = /^https?:\/\/(?:(?:www|beta|m)\.)?mixcloud\.com\/[^/]+\/(?:playlists\/[^/]+|(?!stream|uploads|favorites|listens|playlists)[^/]+|(?:uploads|favorites|listens|stream))(?:\/)?$/i;
+var AnghamiRegex = /^https?:\/\/(?:play\.)?anghami\.com\/(?:song|album|playlist|artist)\/[0-9]+$/i;
+var AudiusRegex = /^https?:\/\/(?:www\.)?audius\.co\/[^/]+\/[^/]+$/i;
+var GaanaRegex = /^https?:\/\/(?:www\.)?gaana\.com\/(?:song|album|playlist)\/[^/]+$/i;
+var InstagramRegex = /^https?:\/\/(?:www\.)?instagram\.com\/(?:p|reel|tv)\/[A-Za-z0-9_-]+(?:\/)?$/i;
+var ShazamRegex = /^https?:\/\/(?:www\.)?shazam\.com\/track\/[0-9]+$/i;
+
+// src/config/endpoints.ts
+var Routes = {
+  /**
+   * WebSocket endpoint
+   * @returns `/websocket`
+   */
+  websocket() {
+    return "/websocket";
+  },
+  /**
+   * Track loading endpoint
+   * @returns `/loadtracks`
+   */
+  trackLoading() {
+    return "/loadtracks";
+  },
+  /**
+   * Track decoding endpoint
+   * @param multiple Whether to decode multiple tracks
+   * @returns `/decodetrack` or `/decodetracks`
+   */
+  trackDecoding(multiple) {
+    if (multiple) {
+      return "/decodetracks";
+    }
+    return "/decodetrack";
+  },
+  /**
+   * Player endpoint
+   * @param sessionId Lavalink session ID
+   * @param guildId Optional guild ID for specific player
+   * @returns `/sessions/{sessionId}/players` or `/sessions/{sessionId}/players/{guildId}`
+   */
+  player(sessionId, guildId) {
+    if (guildId) {
+      return `/sessions/${sessionId}/players/${guildId}`;
+    }
+    return `/sessions/${sessionId}/players`;
+  },
+  /**
+   * Session endpoint
+   * @param sessionId Lavalink session ID
+   * @returns `/sessions/{sessionId}`
+   */
+  session(sessionId) {
+    return `/sessions/${sessionId}`;
+  },
+  /**
+   * Info endpoint
+   * @returns `/info`
+   */
+  info() {
+    return "/info";
+  },
+  /**
+   * Stats endpoint
+   * @returns `/stats`
+   */
+  stats() {
+    return "/stats";
+  },
+  /**
+   * Route planner endpoint
+   * @param free Optional action: `address` or `all`
+   * @returns `/routeplanner/status` or `/routeplanner/free/{action}`
+   */
+  routePlanner(free) {
+    if (free) {
+      return `/routeplanner/free/${free}`;
+    }
+    return "/routeplanner/status";
+  },
+  /**
+   * Version endpoint
+   * @returns `/version`
+   */
+  version() {
+    return "/version";
+  }
+};
+
+// src/config/symbols.ts
+var LookupSymbol = /* @__PURE__ */ Symbol.for("lookup");
+var UpdateSymbol = /* @__PURE__ */ Symbol.for("update");
+var OnPingUpdateSymbol = /* @__PURE__ */ Symbol("onPingUpdate");
+var OnVoiceCloseSymbol = /* @__PURE__ */ Symbol("onVoiceClose");
+var OnStateUpdateSymbol = /* @__PURE__ */ Symbol("onStateUpdate");
+var OnEventUpdateSymbol = /* @__PURE__ */ Symbol("onEventUpdate");
+
+// src/utils/helpers.ts
+var noop = () => {
+};
+var formatDuration = (ms) => {
+  if (!Number.isSafeInteger(ms) || ms <= 0) {
+    return "00:00";
+  }
+  const s = Math.floor(ms / 1e3);
+  const ss = `${s % 60}`.padStart(2, "0");
+  const mm = `${Math.floor(s / 60) % 60}`.padStart(2, "0");
+  if (s < 3600) {
+    return `${(s === 3600 ? "01:" : "") + mm}:${ss}`;
+  }
+  return `${`${Math.floor(s / 3600)}`.padStart(2, "0")}:${mm}:${ss}`;
+};
+var parseDuration = (duration) => {
+  const parts = duration.split(":").map(Number);
+  if (parts.length === 1) {
+    return (parts[0] ?? 0) * 1e3;
+  }
+  if (parts.length === 2) {
+    return ((parts[0] ?? 0) * 60 + (parts[1] ?? 0)) * 1e3;
+  }
+  if (parts.length === 3) {
+    return ((parts[0] ?? 0) * 3600 + (parts[1] ?? 0) * 60 + (parts[2] ?? 0)) * 1e3;
+  }
+  return 0;
+};
+var clamp = (value, min, max) => {
+  return Math.min(Math.max(value, min), max);
+};
+var sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+var retry = async (fn, maxAttempts = 3, baseDelay = 1e3) => {
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxAttempts - 1) {
+        const delay = baseDelay * Math.pow(2, attempt);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError ?? new Error("Retry failed");
+};
+var shuffle = (array) => {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+};
+var randomElement = (array) => {
+  if (array.length === 0) {
+    return void 0;
+  }
+  return array[Math.floor(Math.random() * array.length)];
+};
+var chunk = (array, size) => {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+};
+var unique = (array, key) => {
+  if (!key) {
+    return [...new Set(array)];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return array.filter((item) => {
+    const k = key(item);
+    if (seen.has(k)) {
+      return false;
+    }
+    seen.add(k);
+    return true;
+  });
+};
+var isNumber = (input, check) => {
+  if (check === void 0) {
+    return Number.isFinite(input);
+  }
+  if (check === "integer" || check === "safe-int") {
+    return Number.isSafeInteger(input);
+  }
+  if (check === "natural" || check === "positive") {
+    return Number.isSafeInteger(input) && input > 0;
+  }
+  if (check === "whole") {
+    return Number.isSafeInteger(input) && input >= 0;
+  }
+  return false;
+};
+var isString = (input, check) => {
+  if (typeof input !== "string") {
+    return false;
+  }
+  if (check === void 0) {
+    return true;
+  }
+  if (check === "url") {
+    return URL.canParse(input);
+  }
+  if (check === "non-empty") {
+    return input.trim().length > 0;
+  }
+  if (check instanceof RegExp) {
+    return check.test(input);
+  }
+  return false;
+};
+var isRecord = (input, check) => {
+  if (!input || input.constructor !== Object) {
+    return false;
+  }
+  if (check === void 0) {
+    return true;
+  }
+  if (check === "non-empty") {
+    return Object.keys(input).length > 0;
+  }
+  return false;
+};
+var isArray = (input, check) => {
+  if (!Array.isArray(input)) {
+    return false;
+  }
+  if (check === void 0) {
+    return true;
+  }
+  if (check === "non-empty") {
+    return input.length !== 0;
+  }
+  if (typeof check === "function") {
+    return input.every(check);
+  }
+  return false;
+};
+var isBoolean = (input) => {
+  return typeof input === "boolean";
+};
+var isFunction = (input) => {
+  return typeof input === "function";
+};
+var isNullish = (input) => {
+  return input === null || input === void 0;
+};
+var isSnowflake = (input) => {
+  return isString(input) && /^\d{17,20}$/.test(input);
+};
+var isUrl = (input) => {
+  return isString(input, "url");
+};
+var isError = (error) => {
+  return error instanceof Error;
+};
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+function validateNodeOptions(options) {
+  assert(isString(options.name, "non-empty"), "Node name must be a non-empty string");
+  assert(isString(options.host, "non-empty"), "Node host must be a non-empty string");
+  assert(isNumber(options.port, "natural"), "Node port must be a positive number");
+  assert(isString(options.password, "non-empty"), "Node password must be a non-empty string");
+}
+function validatePlayerOptions(options) {
+  assert(isArray(options.nodes, "non-empty"), "At least one node is required");
+  assert(isFunction(options.forwardVoiceUpdate), "forwardVoiceUpdate must be a function");
+  if (options.queryPrefix !== void 0) {
+    assert(isString(options.queryPrefix, "non-empty"), "queryPrefix must be a non-empty string");
+  }
+}
+
+// src/lavalink/HttpClient.ts
+var REST = class {
+  #origin;
+  #headers;
+  #sessionId = null;
+  #requestTimeout;
+  userAgent;
+  constructor(options) {
+    if (options.origin) {
+      if (!options.origin.startsWith("http://") && !options.origin.startsWith("https://")) {
+        throw new Error("Origin must start with http:// or https://");
+      }
+      this.#origin = options.origin;
+    } else {
+      const protocol = options.secure ? "https" : "http";
+      const port = options.port ?? 2333;
+      const host = options.host ?? "localhost";
+      this.#origin = `${protocol}://${host}:${port}`;
+    }
+    if (options.version !== void 0 && options.version <= 0) {
+      throw new Error("Version must be a positive number");
+    }
+    if (options.password.includes("\n") || options.password.includes("\r")) {
+      throw new Error("Password cannot contain newline characters");
+    }
+    const userAgent = options.userAgent ?? `${CLIENT_NAME}/${CLIENT_VERSION} (${CLIENT_REPOSITORY})`;
+    if (userAgent.includes("\n") || userAgent.includes("\r")) {
+      throw new Error("User agent cannot contain newline characters");
+    }
+    this.userAgent = userAgent;
+    const requestTimeout = options.requestTimeout ?? 1e4;
+    if (requestTimeout <= 0) {
+      throw new Error("Request timeout must be a positive number");
+    }
+    this.#requestTimeout = requestTimeout;
+    this.#headers = {
+      Authorization: options.password,
+      "User-Agent": this.userAgent,
+      "Content-Type": "application/json"
+    };
+    if (options.sessionId) {
+      this.#sessionId = options.sessionId;
+    }
+  }
+  get origin() {
+    return this.#origin;
+  }
+  get sessionId() {
+    return this.#sessionId;
+  }
+  set sessionId(value) {
+    if (value !== null && (typeof value !== "string" || value.trim() === "")) {
+      return;
+    }
+    this.#sessionId = value;
+  }
+  /**
+   * Make a request to the Lavalink REST API
+   */
+  async #request(path, options = {}, timeout) {
+    const url = `${this.#origin}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout ?? this.#requestTimeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...this.#headers,
+          ...options.headers
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await this.#parseError(response);
+        throw error;
+      }
+      if (response.status === 204) {
+        return void 0;
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${timeout ?? this.#requestTimeout}ms`);
+      }
+      throw error;
+    }
+  }
+  async #parseError(response) {
+    let message = `HTTP ${response.status}: ${response.statusText}`;
+    try {
+      const data = await response.json();
+      if (data.error) {
+        message = data.error;
+      } else if (data.message) {
+        message = data.message;
+      }
+    } catch {
+    }
+    const error = new Error(message);
+    error.name = "LavalinkRestError";
+    return error;
+  }
+  /**
+   * Load tracks from a query or URL
+   */
+  async loadTracks(identifier) {
+    const path = `${Routes.trackLoading()}?identifier=${encodeURIComponent(identifier)}`;
+    return this.#request(path, { method: "GET" });
+  }
+  /**
+   * Decode a single track
+   */
+  async decodeTrack(encoded) {
+    const path = `${Routes.trackDecoding()}?encodedTrack=${encodeURIComponent(encoded)}`;
+    return this.#request(path, { method: "GET" });
+  }
+  /**
+   * Decode multiple tracks
+   */
+  async decodeTracks(encoded) {
+    return this.#request(Routes.trackDecoding(true), {
+      method: "POST",
+      body: JSON.stringify(encoded)
+    });
+  }
+  /**
+   * Fetch all players for a session
+   */
+  async fetchPlayers() {
+    if (!this.#sessionId) {
+      throw new Error("No session ID available");
+    }
+    return this.#request(Routes.player(this.#sessionId), { method: "GET" });
+  }
+  /**
+   * Fetch a specific player
+   */
+  async fetchPlayer(guildId) {
+    if (!this.#sessionId) {
+      throw new Error("No session ID available");
+    }
+    return this.#request(Routes.player(this.#sessionId, guildId), { method: "GET" });
+  }
+  /**
+   * Update a player
+   */
+  async updatePlayer(guildId, data, params) {
+    if (!this.#sessionId) {
+      throw new Error("No session ID available");
+    }
+    let path = Routes.player(this.#sessionId, guildId);
+    if (params?.noReplace) {
+      path += "?noReplace=true";
+    }
+    return this.#request(path, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Destroy a player
+   */
+  async destroyPlayer(guildId) {
+    if (!this.#sessionId) {
+      throw new Error("No session ID available");
+    }
+    return this.#request(Routes.player(this.#sessionId, guildId), { method: "DELETE" });
+  }
+  /**
+   * Update session configuration
+   */
+  async updateSession(data) {
+    if (!this.#sessionId) {
+      throw new Error("No session ID available");
+    }
+    return this.#request(Routes.session(this.#sessionId), {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Fetch Lavalink server info
+   */
+  async fetchInfo() {
+    return this.#request(Routes.info(), { method: "GET" });
+  }
+  /**
+   * Fetch node statistics
+   */
+  async fetchStats() {
+    return this.#request(Routes.stats(), { method: "GET" });
+  }
+  /**
+   * Fetch Lavalink version
+   */
+  async fetchVersion() {
+    return this.#request("/version", { method: "GET" });
+  }
+  /**
+   * Fetch route planner status
+   */
+  async fetchRoutePlannerStatus() {
+    return this.#request(Routes.routePlanner(), { method: "GET" });
+  }
+  /**
+   * Free a specific address from the route planner
+   */
+  async freeRoutePlannerAddress(address) {
+    return this.#request(Routes.routePlanner("address"), {
+      method: "POST",
+      body: JSON.stringify({ address })
+    });
+  }
+  /**
+   * Free all addresses from the route planner
+   */
+  async freeAllRoutePlannerAddresses() {
+    return this.#request(Routes.routePlanner("all"), { method: "POST" });
+  }
+  /**
+   * Set SponsorBlock segments for a player
+   */
+  async setSponsorBlock(guildId, segments) {
+    if (!this.#sessionId) {
+      throw new Error("No session ID available");
+    }
+    return this.#request(`${Routes.player(this.#sessionId, guildId)}/sponsorblock`, {
+      method: "PATCH",
+      body: JSON.stringify(segments)
+    });
+  }
+  /**
+   * Get current SponsorBlock segments for a player
+   */
+  async getSponsorBlock(guildId) {
+    if (!this.#sessionId) {
+      throw new Error("No session ID available");
+    }
+    return this.#request(`${Routes.player(this.#sessionId, guildId)}/sponsorblock`, { method: "GET" });
+  }
+  /**
+   * Delete SponsorBlock configuration for a player
+   */
+  async deleteSponsorBlock(guildId) {
+    if (!this.#sessionId) {
+      throw new Error("No session ID available");
+    }
+    return this.#request(`${Routes.player(this.#sessionId, guildId)}/sponsorblock`, { method: "DELETE" });
+  }
+};
+var CloseCodes = /* @__PURE__ */ ((CloseCodes2) => {
+  CloseCodes2[CloseCodes2["Normal"] = 1e3] = "Normal";
+  CloseCodes2[CloseCodes2["GoingAway"] = 1001] = "GoingAway";
+  CloseCodes2[CloseCodes2["ProtocolError"] = 1002] = "ProtocolError";
+  CloseCodes2[CloseCodes2["UnsupportedData"] = 1003] = "UnsupportedData";
+  CloseCodes2[CloseCodes2["NoStatusReceived"] = 1005] = "NoStatusReceived";
+  CloseCodes2[CloseCodes2["AbnormalClosure"] = 1006] = "AbnormalClosure";
+  CloseCodes2[CloseCodes2["InvalidFramePayloadData"] = 1007] = "InvalidFramePayloadData";
+  CloseCodes2[CloseCodes2["PolicyViolation"] = 1008] = "PolicyViolation";
+  CloseCodes2[CloseCodes2["MessageTooBig"] = 1009] = "MessageTooBig";
+  CloseCodes2[CloseCodes2["InternalError"] = 1011] = "InternalError";
+  return CloseCodes2;
+})(CloseCodes || {});
+var LavalinkNode = class extends EventEmitter {
+  #socketConfig;
+  #connectPromise = null;
+  #disconnectPromise = null;
+  #pingTimer = null;
+  #reconnectTimer = null;
+  #ping = null;
+  #lastPingTime = null;
+  #reconnectCycle = true;
+  #reconnectAttempts = 0;
+  #manualDisconnect = false;
+  #socket = null;
+  #stats = null;
+  #socketUrl;
+  #pingTimeout;
+  #reconnectDelay;
+  #reconnectLimit;
+  name;
+  rest;
+  constructor(options) {
+    super({ captureRejections: false });
+    if (!options.name || typeof options.name !== "string") {
+      throw new Error("Node name must be a non-empty string");
+    }
+    if (!options.clientId || typeof options.clientId !== "string") {
+      throw new Error("Client ID must be a non-empty string");
+    }
+    this.rest = new REST(options);
+    this.#socketConfig = {
+      headers: {
+        "Client-Name": `${CLIENT_NAME}/${CLIENT_VERSION}`,
+        "User-Id": options.clientId,
+        "User-Agent": this.rest.userAgent,
+        Authorization: options.password
+      },
+      perMessageDeflate: false,
+      handshakeTimeout: options.handshakeTimeout ?? 3e4
+    };
+    if (this.rest.sessionId) {
+      this.#socketConfig.headers["Session-Id"] = this.rest.sessionId;
+    }
+    const protocol = options.secure ? "wss" : "ws";
+    this.#socketUrl = `${protocol}://${options.host}:${options.port}/v4/websocket`;
+    this.#pingTimeout = (options.statsInterval ?? 6e4) + (options.highestLatency ?? 5e3);
+    this.#reconnectDelay = options.reconnectDelay ?? 5e3;
+    this.#reconnectLimit = options.reconnectLimit ?? -1;
+    this.name = options.name;
+    Object.defineProperty(this.rest, "sessionId", {
+      configurable: false,
+      get: () => this.sessionId,
+      set: () => {
+      }
+    });
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      name: immutable,
+      rest: immutable
+    });
+  }
+  get clientId() {
+    return this.#socketConfig.headers["User-Id"];
+  }
+  get sessionId() {
+    return this.#socketConfig.headers["Session-Id"] ?? null;
+  }
+  get ping() {
+    return this.#ping;
+  }
+  get stats() {
+    return this.#stats;
+  }
+  get state() {
+    if (this.connecting) {
+      return "connecting";
+    }
+    if (this.connected) {
+      return this.ready ? "ready" : "connected";
+    }
+    return this.reconnecting ? "reconnecting" : "disconnected";
+  }
+  get connecting() {
+    return this.#socket?.readyState === WebSocket.CONNECTING;
+  }
+  get connected() {
+    return this.#socket?.readyState === WebSocket.OPEN;
+  }
+  get ready() {
+    return this.connected && this.sessionId !== null;
+  }
+  get reconnecting() {
+    return this.#socket === null && this.#reconnectTimer !== null;
+  }
+  get disconnected() {
+    return this.#socket === null && !this.reconnecting;
+  }
+  get reconnectLimit() {
+    return this.#reconnectLimit;
+  }
+  get reconnectAttempts() {
+    return this.#reconnectAttempts;
+  }
+  #error(err) {
+    const data = "errors" in err && Array.isArray(err.errors) ? err.errors[err.errors.length - 1] : err;
+    const error = data instanceof Error ? data : new Error(String(data));
+    error.name = `Error [${this.constructor.name}]`;
+    return error;
+  }
+  #cleanup() {
+    this.#socket?.removeAllListeners();
+    if (this.#pingTimer !== null) {
+      clearTimeout$1(this.#pingTimer);
+    }
+    this.#socket = this.#pingTimer = this.#stats = null;
+    this.#lastPingTime = this.#ping = null;
+  }
+  #reconnect() {
+    this.#reconnectCycle = false;
+    this.#reconnectTimer?.refresh();
+    this.#reconnectTimer ??= setTimeout$1(() => {
+      this.#reconnectCycle = true;
+      void this.connect();
+    }, this.#reconnectDelay).unref();
+  }
+  #stopReconnecting(resetCount = true, reconnectCycle = false) {
+    this.#reconnectCycle = reconnectCycle;
+    if (resetCount) {
+      this.#reconnectAttempts = 0;
+    }
+    if (this.#reconnectTimer !== null) {
+      clearTimeout$1(this.#reconnectTimer);
+    }
+    this.#reconnectTimer = null;
+  }
+  #keepAliveAndPing() {
+    this.#pingTimer?.refresh();
+    this.#pingTimer ??= setTimeout$1(() => {
+      this.#socket?.terminate();
+      this.#cleanup();
+      this.#reconnect();
+    }, this.#pingTimeout).unref();
+    this.#lastPingTime = Date.now();
+    this.#socket?.ping();
+  }
+  #parseMessageData(data) {
+    try {
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Connect to the Lavalink node
+   * Handles reconnection attempts and session resumption
+   */
+  async connect() {
+    if (this.#socket !== null) {
+      return this.#connectPromise ?? this.connected;
+    }
+    if (this.reconnecting) {
+      this.#reconnectAttempts++;
+      if (!this.#reconnectCycle) {
+        this.#stopReconnecting(false, true);
+      }
+    }
+    this.#socket = new WebSocket(this.#socketUrl, this.#socketConfig);
+    this.#socket.once("open", () => {
+      this.emit("connect", this.#reconnectAttempts, this.name);
+    });
+    this.#socket.on("message", (data) => {
+      void this.#onMessage(data.toString("utf8"));
+    });
+    this.#socket.on("error", (err) => {
+      this.emit("error", this.#error(err), this.name);
+    });
+    this.#socket.on("close", (code, reason) => {
+      this.#onClose(code, reason.toString("utf8"));
+    });
+    this.#socket.on("pong", () => {
+      if (this.#lastPingTime === null) {
+        return;
+      }
+      this.#ping = Math.max(0, Date.now() - this.#lastPingTime);
+    });
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const resolver = { promise, resolve, reject };
+    this.#connectPromise = resolver.promise;
+    const controller = new AbortController();
+    try {
+      await Promise.race([
+        once(this.#socket, "open", { signal: controller.signal }),
+        once(this.#socket, "close", { signal: controller.signal })
+      ]);
+    } catch {
+      this.#cleanup();
+    } finally {
+      controller.abort();
+      const connected = this.connected;
+      resolver.resolve(connected);
+      this.#connectPromise = null;
+    }
+    return this.connected;
+  }
+  /**
+   * Disconnect from the Lavalink node
+   * @param code - WebSocket close code
+   * @param reason - Disconnect reason
+   */
+  async disconnect(code = 1e3 /* Normal */, reason = "disconnected") {
+    if (this.#disconnectPromise !== null) {
+      return this.#disconnectPromise;
+    }
+    this.#stopReconnecting();
+    if (this.#socket === null) {
+      return;
+    }
+    if (this.connecting) {
+      this.#manualDisconnect = true;
+      this.#socket.terminate();
+      return;
+    }
+    if (!this.connected) {
+      return;
+    }
+    this.#manualDisconnect = true;
+    this.#disconnectPromise = once(this.#socket, "close").then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.#socket.close(code, reason);
+    await this.#disconnectPromise;
+    this.#disconnectPromise = null;
+  }
+  async #onMessage(data) {
+    const payload = this.#parseMessageData(data);
+    if (payload === null) {
+      return this.disconnect(1003 /* UnsupportedData */, "expected json payload");
+    }
+    if (payload.op === "stats" /* Stats */) {
+      this.#stats = payload;
+      this.#keepAliveAndPing();
+    } else if (payload.op === "ready" /* Ready */) {
+      this.#stopReconnecting();
+      this.#socketConfig.headers["Session-Id"] = payload.sessionId;
+      this.emit("ready", payload.resumed, payload.sessionId, this.name);
+    }
+    this.emit("dispatch", payload, this.name);
+  }
+  #onClose(code, reason) {
+    this.#cleanup();
+    const shouldStop = this.#manualDisconnect || this.#reconnectLimit >= 0 && this.#reconnectAttempts >= this.#reconnectLimit;
+    if (shouldStop) {
+      this.#stopReconnecting();
+      delete this.#socketConfig.headers["Session-Id"];
+      const byLocal = this.#manualDisconnect;
+      this.#manualDisconnect = false;
+      this.emit("disconnect", code, reason, byLocal, this.name);
+      return;
+    }
+    if (this.#reconnectCycle) {
+      this.#reconnect();
+      this.emit("close", code, reason, this.name);
+      return;
+    }
+    setTimeout$1(() => {
+      this.#reconnectCycle = true;
+      void this.connect();
+    }, 0);
+  }
+  /**
+   * Set SponsorBlock segments for a player
+   */
+  async setSponsorBlock(player, segments) {
+    return this.rest.setSponsorBlock(player.guildId, segments);
+  }
+  /**
+   * Get current SponsorBlock segments for a player
+   */
+  async getSponsorBlock(player) {
+    return this.rest.getSponsorBlock(player.guildId);
+  }
+  /**
+   * Delete SponsorBlock configuration for a player
+   */
+  async deleteSponsorBlock(player) {
+    return this.rest.deleteSponsorBlock(player.guildId);
+  }
+  toString() {
+    return this.name;
+  }
+};
+var NodeManager = class extends EventEmitter {
+  #player;
+  #nodes = /* @__PURE__ */ new Map();
+  info = /* @__PURE__ */ new Map();
+  // LavalinkInfo cache
+  constructor(player) {
+    super({ captureRejections: false });
+    this.#player = player;
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      info: immutable
+    });
+  }
+  /**
+   * Get a node by name
+   */
+  get(name) {
+    return this.#nodes.get(name);
+  }
+  /**
+   * Check if a node exists
+   */
+  has(name) {
+    return this.#nodes.has(name);
+  }
+  /**
+   * Get all nodes
+   */
+  get all() {
+    return Array.from(this.#nodes.values());
+  }
+  /**
+   * Get number of nodes
+   */
+  get size() {
+    return this.#nodes.size;
+  }
+  /**
+   * Create a new node
+   */
+  create(options) {
+    if (this.#nodes.has(options.name)) {
+      throw new Error(`Node '${options.name}' already exists`);
+    }
+    const node = new LavalinkNode({
+      ...options,
+      clientId: this.#player.clientId ?? ""
+    });
+    node.on("connect", (_attempts, _name) => {
+      this.emit("connect", node);
+    });
+    node.on("ready", (resumed, sessionId, _name) => {
+      this.emit("ready", node, resumed, sessionId);
+      if (!this.info.has(node.name)) {
+        this.fetchInfo(node.name).catch(() => {
+        });
+      }
+      if (resumed) {
+        void this.#handleResumed(node);
+      }
+    });
+    node.on("disconnect", (code, reason, _byLocal, _name) => {
+      this.emit("disconnect", node, { code, reason });
+    });
+    node.on("close", (_code, _reason, _name) => {
+      this.emit("reconnecting", node);
+    });
+    node.on("error", (error, _name) => {
+      this.emit("error", node, error);
+    });
+    node.on("dispatch", (payload, _name) => {
+      this.emit("raw", node, payload);
+    });
+    this.#nodes.set(options.name, node);
+    this.emit("create", node);
+    return node;
+  }
+  /**
+   * Delete a node
+   */
+  async delete(name) {
+    const node = this.#nodes.get(name);
+    if (!node) {
+      return false;
+    }
+    const activeQueues = this.#player.queues.all.filter((q) => q.node?.name === name);
+    if (activeQueues.length > 0) {
+      throw new Error(`Cannot delete node '${name}' with ${activeQueues.length} active queue(s)`);
+    }
+    await node.disconnect();
+    this.#nodes.delete(name);
+    this.info.delete(name);
+    this.emit("destroy", node);
+    return true;
+  }
+  /**
+   * Connect all nodes
+   */
+  async connect() {
+    const promises = Array.from(this.#nodes.values()).map((node) => node.connect());
+    await Promise.allSettled(promises);
+  }
+  /**
+   * Disconnect all nodes
+   */
+  async disconnect() {
+    const promises = Array.from(this.#nodes.values()).map((node) => node.disconnect());
+    await Promise.allSettled(promises);
+  }
+  /**
+   * Get relevant nodes sorted by load and availability
+   * Returns nodes that are ready and have lowest load
+   */
+  relevant() {
+    const readyNodes = Array.from(this.#nodes.values()).filter((node) => node.ready);
+    if (readyNodes.length === 0) {
+      return [];
+    }
+    return readyNodes.sort((a, b) => {
+      const aStats = a.stats;
+      const bStats = b.stats;
+      if (!aStats) {
+        return 1;
+      }
+      if (!bStats) {
+        return -1;
+      }
+      const aLoad = aStats.playingPlayers / (aStats.players || 1);
+      const bLoad = bStats.playingPlayers / (bStats.players || 1);
+      if (aLoad !== bLoad) {
+        return aLoad - bLoad;
+      }
+      const aCpu = aStats.cpu.lavalinkLoad;
+      const bCpu = bStats.cpu.lavalinkLoad;
+      if (aCpu !== bCpu) {
+        return aCpu - bCpu;
+      }
+      const aMemory = aStats.memory.used / aStats.memory.allocated;
+      const bMemory = bStats.memory.used / bStats.memory.allocated;
+      return aMemory - bMemory;
+    });
+  }
+  /**
+   * Get node metrics
+   */
+  get metrics() {
+    const nodes = Array.from(this.#nodes.values());
+    return {
+      total: nodes.length,
+      connected: nodes.filter((n) => n.connected).length,
+      ready: nodes.filter((n) => n.ready).length,
+      reconnecting: nodes.filter((n) => n.reconnecting).length,
+      players: nodes.reduce((sum, n) => sum + (n.stats?.players ?? 0), 0),
+      playingPlayers: nodes.reduce((sum, n) => sum + (n.stats?.playingPlayers ?? 0), 0)
+    };
+  }
+  /**
+   * Get all node names
+   */
+  keys() {
+    return this.#nodes.keys();
+  }
+  /**
+   * Get all nodes
+   */
+  values() {
+    return this.#nodes.values();
+  }
+  /**
+   * Get all entries
+   */
+  entries() {
+    return this.#nodes.entries();
+  }
+  /**
+   * Fetch and cache node info
+   * @param name Node name
+   */
+  async fetchInfo(name) {
+    if (this.info.has(name)) {
+      return this.info.get(name);
+    }
+    const node = this.#nodes.get(name);
+    if (!node) {
+      throw new Error(`Node '${name}' not found`);
+    }
+    const info = await node.rest.fetchInfo();
+    this.info.set(name, info);
+    return info;
+  }
+  /**
+   * Check if a feature is supported by a node
+   * @param type Feature type (filter, source, plugin)
+   * @param value Feature value (name)
+   * @param nodeName Optional node name (checks all if not specified)
+   */
+  supports(type, value, nodeName) {
+    if (nodeName) {
+      const node = this.#nodes.get(nodeName);
+      if (!node) {
+        return false;
+      }
+      return this.#checkNodeSupport(node.name, type, value);
+    }
+    return Array.from(this.#nodes.values()).some((node) => this.#checkNodeSupport(node.name, type, value));
+  }
+  /**
+   * Check if a specific node supports a feature
+   */
+  #checkNodeSupport(nodeName, type, value) {
+    const info = this.info.get(nodeName);
+    if (!info) {
+      return false;
+    }
+    switch (type) {
+      case "filter":
+        return info.filters?.includes(value) ?? false;
+      case "source":
+        return info.sourceManagers?.includes(value) ?? false;
+      case "plugin":
+        return info.plugins?.some((p) => p.name === value) ?? false;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Handle node resumption
+   * Sync all queues when a node resumes
+   */
+  async #handleResumed(node) {
+    try {
+      if (this.#player.options.autoSync) {
+        await this.#player.queues.syncAll();
+      }
+    } catch (error) {
+      this.emit("error", node, error);
+    }
+  }
+};
+
+// src/voice/VoiceSession.ts
+var VoiceState = class {
+  #changePromise = null;
+  #node;
+  #state;
+  #player;
+  guildId;
+  player;
+  constructor(player, node, guildId) {
+    if (player.voices.has(guildId)) {
+      throw new Error("An identical voice state already exists");
+    }
+    const _node = player.nodes.get(node);
+    if (!_node) {
+      throw new Error(`Node '${node}' not found`);
+    }
+    if (!_node.ready) {
+      throw new Error(`Node '${node}' not ready`);
+    }
+    const state = player.voices[LookupSymbol](guildId);
+    if (!state) {
+      throw new Error(`No connection found for guild '${guildId}'`);
+    }
+    const _player = player.queues[LookupSymbol](guildId);
+    if (!_player) {
+      throw new Error(`No player found for guild '${guildId}'`);
+    }
+    this.#node = _node;
+    this.#state = state;
+    this.#player = _player;
+    this.guildId = guildId;
+    this.player = player;
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      guildId: immutable,
+      player: { ...immutable, enumerable: false }
+    });
+  }
+  /**
+   * Current node for this voice connection
+   */
+  get node() {
+    return this.#node;
+  }
+  /**
+   * Ping to the voice server in milliseconds
+   */
+  get ping() {
+    return this.#player.state.ping;
+  }
+  /**
+   * Voice region ID (e.g., "us-west", "eu-central")
+   */
+  get regionId() {
+    return this.#state.region_id;
+  }
+  /**
+   * Voice channel ID
+   */
+  get channelId() {
+    return this.#state.channel_id;
+  }
+  /**
+   * Whether the bot is self-deafened
+   */
+  get selfDeaf() {
+    return this.#state.self_deaf;
+  }
+  /**
+   * Whether the bot is self-muted
+   */
+  get selfMute() {
+    return this.#state.self_mute;
+  }
+  /**
+   * Whether the bot is server-deafened
+   */
+  get serverDeaf() {
+    return this.#state.deaf;
+  }
+  /**
+   * Whether the bot is server-muted
+   */
+  get serverMute() {
+    return this.#state.mute;
+  }
+  /**
+   * Whether the bot is suppressed (priority speaker)
+   */
+  get suppressed() {
+    return this.#state.suppress;
+  }
+  /**
+   * Whether this voice state has been destroyed
+   */
+  get destroyed() {
+    return this.player.voices.get(this.guildId) !== this;
+  }
+  /**
+   * Whether the voice connection is fully connected
+   */
+  get connected() {
+    if (!this.#player.state.connected) {
+      return false;
+    }
+    return this.#state.connected && this.#state.node_session_id === this.#node.sessionId;
+  }
+  /**
+   * Whether the voice connection is reconnecting
+   */
+  get reconnecting() {
+    return this.#state.reconnecting;
+  }
+  /**
+   * Whether the voice connection is disconnected
+   */
+  get disconnected() {
+    return !this.connected && !this.reconnecting;
+  }
+  /**
+   * Whether the voice connection is changing nodes
+   */
+  get changingNode() {
+    return this.#changePromise !== null;
+  }
+  /**
+   * Session ID for the voice connection
+   */
+  get sessionId() {
+    return this.#state.session_id;
+  }
+  /**
+   * Voice server token
+   */
+  get token() {
+    return this.#state.token;
+  }
+  /**
+   * Voice server endpoint
+   */
+  get endpoint() {
+    return this.#state.endpoint;
+  }
+  /**
+   * Node session ID this voice state is connected to
+   */
+  get nodeSessionId() {
+    return this.#state.node_session_id;
+  }
+  /**
+   * Destroy this voice connection
+   * @param reason Optional reason for destruction
+   */
+  async destroy(reason) {
+    return this.player.voices.destroy(this.guildId, reason);
+  }
+  /**
+   * Connect to a voice channel
+   * @param channelId Voice channel ID (defaults to current channel)
+   */
+  async connect(channelId = this.#state.channel_id) {
+    await this.player.voices.connect(this.guildId, channelId);
+  }
+  /**
+   * Disconnect from the voice channel
+   */
+  async disconnect() {
+    return this.player.voices.disconnect(this.guildId);
+  }
+  /**
+   * Change to a different Lavalink node
+   * Preserves playback state and filters
+   * @param name Name of the node to change to
+   */
+  async changeNode(name) {
+    const node = this.player.nodes.get(name);
+    if (!node) {
+      throw new Error(`Node '${name}' not found`);
+    }
+    if (!node.ready) {
+      throw new Error(`Node '${name}' not ready`);
+    }
+    if (this.#changePromise !== null) {
+      return this.#changePromise;
+    }
+    if (name === this.#node.name) {
+      throw new Error(`Already on node '${name}'`);
+    }
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const resolver = { promise, resolve, reject };
+    this.#changePromise = resolver.promise;
+    const request = {
+      voice: {
+        channelId: this.#state.channel_id,
+        endpoint: this.#state.endpoint,
+        sessionId: this.#state.session_id,
+        token: this.#state.token
+      },
+      filters: this.#player.filters,
+      paused: this.#player.paused,
+      volume: this.#player.volume
+    };
+    const track = this.#player.track;
+    const wasPlaying = !this.#player.paused && track !== null;
+    if (wasPlaying && this.player.nodes.supports("source", track.info.sourceName, node.name)) {
+      request.track = { encoded: track.encoded, userData: track.userData };
+      request.position = this.#player.state.position;
+    }
+    await this.#node.rest.destroyPlayer(this.guildId).catch(noop);
+    const previousNode = this.#node;
+    this.#node = node;
+    try {
+      const player = await node.rest.updatePlayer(this.guildId, request);
+      this.#state.node_session_id = node.sessionId ?? "";
+      Object.assign(this.#player, player);
+      this.player.emit("voiceChange", this, previousNode, wasPlaying);
+      resolver.resolve();
+    } catch (err) {
+      resolver.reject(err);
+      throw err;
+    } finally {
+      this.#changePromise = null;
+    }
+  }
+  /**
+   * String representation of the voice state
+   */
+  toString() {
+    return `VoiceState<${this.guildId}>`;
+  }
+};
+
+// src/voice/RegionSelector.ts
+var VoiceRegion = class {
+  #pings = /* @__PURE__ */ new Map();
+  id;
+  player;
+  constructor(player, regionId) {
+    if (player.voices.regions.has(regionId)) {
+      throw new Error("An identical voice region already exists");
+    }
+    this.id = regionId;
+    this.player = player;
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      id: immutable,
+      player: { ...immutable, enumerable: false }
+    });
+  }
+  /**
+   * Check if all ready nodes have ping data for this region
+   * @returns `true` if all nodes are synced, `false` otherwise
+   */
+  inSync() {
+    return !Array.from(this.player.nodes.values()).some((n) => n.ready && !this.#pings.has(n.name));
+  }
+  /**
+   * Remove ping data for a node
+   * @param name Node name
+   * @returns `true` if data was removed, `false` if it didn't exist
+   */
+  forgetNode(name) {
+    return this.#pings.delete(name);
+  }
+  /**
+   * Get the average ping for a node in this region
+   * @param name Node name
+   * @returns Average ping in milliseconds, or `null` if no data
+   */
+  getAveragePing(name) {
+    const pings = this.#pings.get(name)?.history;
+    if (!pings?.length) {
+      return null;
+    }
+    return Math.round(pings.reduce((total, current) => total + current, 0) / pings.length);
+  }
+  /**
+   * Get all nodes with their average pings
+   * @returns Array of [nodeName, averagePing] tuples
+   */
+  getAllPings() {
+    return Array.from(this.player.nodes.values()).map((node) => [node.name, this.getAveragePing(node.name)]);
+  }
+  /**
+   * Get the most relevant node for this region
+   * Selects based on lowest average ping
+   * @returns The node with lowest ping, or first relevant node if no ping data
+   */
+  getRelevantNode() {
+    return this.player.nodes.relevant().sort((a, b) => {
+      const pingA = this.getAveragePing(a.name) ?? Number.MAX_SAFE_INTEGER;
+      const pingB = this.getAveragePing(b.name) ?? Number.MAX_SAFE_INTEGER;
+      return pingA - pingB;
+    })[0];
+  }
+  /**
+   * Internal method to update ping statistics
+   * Called by the voice manager when player state updates
+   * @param name Node name
+   * @param state Player state with ping information
+   * @internal
+   */
+  [OnPingUpdateSymbol](name, state) {
+    if (!state.connected) {
+      return;
+    }
+    if (state.ping <= 0 || state.time <= 0) {
+      return;
+    }
+    const pings = this.#pings.get(name);
+    if (!pings) {
+      this.#pings.set(name, {
+        history: [state.ping],
+        lastPingTime: state.time
+      });
+      return;
+    }
+    if (state.time - pings.lastPingTime < 12e3) {
+      return;
+    }
+    pings.lastPingTime = state.time;
+    pings.history.push(state.ping);
+    if (pings.history.length > 5) {
+      pings.history.shift();
+    }
+  }
+  /**
+   * Clear all ping data for this region
+   */
+  clear() {
+    this.#pings.clear();
+  }
+  /**
+   * Get the number of nodes with ping data
+   */
+  get nodeCount() {
+    return this.#pings.size;
+  }
+  /**
+   * String representation of the voice region
+   */
+  toString() {
+    return `VoiceRegion<${this.id}>`;
+  }
+  /**
+   * JSON representation of the voice region
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      inSync: this.inSync(),
+      nodeCount: this.nodeCount,
+      pings: Array.from(this.#pings.entries()).map(([node, stats]) => ({
+        node,
+        averagePing: this.getAveragePing(node),
+        samples: stats.history.length
+      }))
+    };
+  }
+};
+
+// src/voice/VoiceConnection.ts
+var VoiceManager = class {
+  #cache = /* @__PURE__ */ new Map();
+  #voices = /* @__PURE__ */ new Map();
+  #joins = /* @__PURE__ */ new Map();
+  #destroys = /* @__PURE__ */ new Map();
+  regions = /* @__PURE__ */ new Map();
+  player;
+  constructor(player) {
+    if (player.voices === void 0) {
+      this.player = player;
+    } else {
+      throw new Error("Manager already exists for this Player");
+    }
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      regions: immutable,
+      player: { ...immutable, enumerable: false }
+    });
+  }
+  /**
+   * Number of voice connections
+   */
+  get size() {
+    return this.#voices.size;
+  }
+  /**
+   * Get voice state for a guild
+   */
+  get(guildId) {
+    return this.#voices.get(guildId);
+  }
+  /**
+   * Check if voice state exists
+   */
+  has(guildId) {
+    return this.#voices.has(guildId);
+  }
+  /**
+   * Get all connected guild IDs
+   */
+  keys() {
+    return this.#voices.keys();
+  }
+  /**
+   * Get all voice connections
+   */
+  values() {
+    return this.#voices.values();
+  }
+  /**
+   * Get all voice connections as entries
+   */
+  entries() {
+    return this.#voices.entries();
+  }
+  /**
+   * Destroy a voice connection
+   * @param guildId Guild ID
+   * @param reason Reason for destruction
+   */
+  async destroy(guildId, reason = "destroyed") {
+    if (this.player.queues.has(guildId)) {
+      return this.player.queues.destroy(guildId, reason);
+    }
+    if (this.#destroys.has(guildId)) {
+      return this.#destroys.get(guildId) ?? Promise.resolve();
+    }
+    const voice = this.#voices.get(guildId);
+    if (!voice) {
+      return;
+    }
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const resolver = { promise, resolve, reject };
+    this.#destroys.set(guildId, resolver.promise);
+    if (this[LookupSymbol](guildId)?.connected) {
+      await voice.disconnect().catch(noop);
+    }
+    this.#cache.delete(guildId);
+    this.#voices.delete(guildId);
+    this.player.emit("voiceDestroy", voice, reason);
+    resolver.resolve();
+    this.#destroys.delete(guildId);
+  }
+  /**
+   * Connect to a voice channel
+   * @param guildId Guild ID
+   * @param voiceId Voice channel ID
+   * @param options Connection options
+   */
+  async connect(guildId, voiceId, options) {
+    if (!isString(guildId, SnowflakeRegex)) {
+      throw new Error("Guild Id is not a valid Discord Id");
+    }
+    if (!isString(voiceId, SnowflakeRegex)) {
+      throw new Error("Voice Id is not a valid Discord Id");
+    }
+    const currentRequest = this.#joins.get(guildId);
+    if (currentRequest) {
+      if (currentRequest.voiceId === voiceId) {
+        return currentRequest.promise;
+      }
+      currentRequest.reject(new Error("Connection request was replaced"));
+    }
+    this.#joins.delete(guildId);
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const request = {
+      promise,
+      resolve,
+      reject,
+      voiceId,
+      node: options?.node,
+      context: options?.context,
+      config: options ? { filters: options.filters, volume: options.volume } : void 0
+    };
+    this.#joins.set(guildId, request);
+    await this.player.options.forwardVoiceUpdate(guildId, {
+      op: 4,
+      d: {
+        guild_id: guildId,
+        channel_id: voiceId,
+        self_deaf: false,
+        self_mute: false
+      }
+    });
+    const timeout = setTimeout$2(15e3, void 0, { ref: false });
+    const result = await Promise.race([request.promise, timeout]);
+    if (result === void 0) {
+      this.#joins.delete(guildId);
+      throw new Error("Voice connection timed out");
+    }
+    return result;
+  }
+  /**
+   * Disconnect from voice channel
+   * @param guildId Guild ID
+   */
+  async disconnect(guildId) {
+    const state = this.#cache.get(guildId);
+    if (!state) {
+      return;
+    }
+    await this.player.options.forwardVoiceUpdate(guildId, {
+      op: 4,
+      d: {
+        guild_id: guildId,
+        channel_id: null,
+        self_deaf: false,
+        self_mute: false
+      }
+    });
+    state.channel_id = "";
+    state.connected = false;
+  }
+  /**
+   * Handle Discord dispatch events
+   * @param payload Discord gateway payload
+   */
+  handleDispatch(payload) {
+    if (payload.t === "READY") {
+      this.#handleReady(payload);
+    } else if (payload.t === "VOICE_STATE_UPDATE") {
+      this.#handleVoiceStateUpdate(payload);
+    } else if (payload.t === "VOICE_SERVER_UPDATE") {
+      this.#handleVoiceServerUpdate(payload);
+    }
+  }
+  /**
+   * Internal lookup for voice state
+   * @internal
+   */
+  [LookupSymbol](guildId) {
+    return this.#cache.get(guildId);
+  }
+  /**
+   * Internal update for voice state
+   * @internal
+   */
+  [UpdateSymbol](guildId, partial) {
+    const state = this.#cache.get(guildId);
+    if (state) {
+      Object.assign(state, partial);
+    }
+  }
+  /**
+   * Internal voice close handler
+   * @internal
+   */
+  [OnVoiceCloseSymbol](guildId, code, reason, byRemote) {
+    const voice = this.#voices.get(guildId);
+    if (!voice) {
+      return;
+    }
+    this.player.emit("voiceClose", voice, code, reason, byRemote);
+    const shouldDestroy = code === 4014 /* Disconnected */ || code === 4021 /* DisconnectedRateLimited */ || code === 4022 /* DisconnectedCallTerminated */;
+    if (shouldDestroy) {
+      this.destroy(guildId, `Voice closed: ${reason} (${code})`).catch(noop);
+    }
+  }
+  /**
+   * Handle READY event
+   */
+  #handleReady(_payload) {
+    this.#cache.clear();
+    this.#voices.clear();
+    this.#joins.clear();
+  }
+  /**
+   * Handle VOICE_STATE_UPDATE event
+   */
+  #handleVoiceStateUpdate(payload) {
+    const { d: data } = payload;
+    const guildId = data.guild_id;
+    if (!guildId || data.user_id !== this.player.clientId) {
+      return;
+    }
+    let state = this.#cache.get(guildId);
+    if (data.channel_id === null) {
+      if (state) {
+        state.channel_id = "";
+        state.connected = false;
+      }
+      return;
+    }
+    if (!state) {
+      state = {
+        channel_id: data.channel_id,
+        session_id: data.session_id,
+        deaf: data.deaf,
+        mute: data.mute,
+        self_deaf: data.self_deaf,
+        self_mute: data.self_mute,
+        suppress: data.suppress,
+        token: "",
+        endpoint: "",
+        connected: false,
+        node_session_id: "",
+        reconnecting: false,
+        region_id: ""
+      };
+      this.#cache.set(guildId, state);
+    } else {
+      state.channel_id = data.channel_id;
+      state.session_id = data.session_id;
+      state.deaf = data.deaf;
+      state.mute = data.mute;
+      state.self_deaf = data.self_deaf;
+      state.self_mute = data.self_mute;
+      state.suppress = data.suppress;
+    }
+    void this.#tryConnect(guildId);
+  }
+  /**
+   * Handle VOICE_SERVER_UPDATE event
+   */
+  #handleVoiceServerUpdate(payload) {
+    const { d: data } = payload;
+    const guildId = data.guild_id;
+    let state = this.#cache.get(guildId);
+    if (!state) {
+      state = {
+        channel_id: "",
+        session_id: "",
+        deaf: false,
+        mute: false,
+        self_deaf: false,
+        self_mute: false,
+        suppress: false,
+        token: data.token,
+        endpoint: data.endpoint ?? "",
+        connected: false,
+        node_session_id: "",
+        reconnecting: false,
+        region_id: ""
+      };
+      this.#cache.set(guildId, state);
+    } else {
+      state.token = data.token;
+      state.endpoint = data.endpoint ?? "";
+    }
+    if (state.endpoint) {
+      const match = state.endpoint.match(VoiceRegionIdRegex);
+      if (match?.[1]) {
+        state.region_id = match[1];
+        if (!this.regions.has(state.region_id)) {
+          this.regions.set(state.region_id, new VoiceRegion(this.player, state.region_id));
+        }
+      }
+    }
+    void this.#tryConnect(guildId);
+  }
+  /**
+   * Try to establish voice connection
+   */
+  async #tryConnect(guildId) {
+    const state = this.#cache.get(guildId);
+    const request = this.#joins.get(guildId);
+    if (!state || !request) {
+      return;
+    }
+    if (!state.channel_id || !state.session_id || !state.token || !state.endpoint) {
+      return;
+    }
+    this.#joins.delete(guildId);
+    try {
+      const nodeName = request.node ?? (state.region_id && this.regions.get(state.region_id)?.getRelevantNode()?.name) ?? this.player.nodes.relevant()[0]?.name;
+      if (!nodeName) {
+        throw new Error("No nodes available");
+      }
+      let queue = this.player.queues.get(guildId);
+      if (!queue) {
+        queue = await this.player.queues.create({
+          guildId,
+          voiceId: state.channel_id,
+          node: nodeName,
+          context: request.context,
+          ...request.config
+        });
+      }
+      const voice = new VoiceState(this.player, nodeName, guildId);
+      this.#voices.set(guildId, voice);
+      state.connected = true;
+      state.node_session_id = voice.node.sessionId ?? "";
+      this.player.emit("voiceConnect", voice);
+      request.resolve(voice);
+    } catch (error) {
+      request.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+};
+
+// src/audio/AudioTrack.ts
+var Track = class _Track {
+  /**
+   * Unique identifier of the track
+   */
+  id;
+  /**
+   * Title of the track
+   */
+  title = "Unknown Track";
+  /**
+   * Author/artist of the track
+   */
+  author = "Unknown Author";
+  /**
+   * Whether the track is a live stream
+   */
+  isLive = false;
+  /**
+   * Whether the track is seekable
+   */
+  isSeekable = false;
+  /**
+   * Duration of the track in milliseconds
+   */
+  duration = 0;
+  /**
+   * Formatted duration string (hh:mm:ss or mm:ss)
+   */
+  formattedDuration = "00:00";
+  /**
+   * Uniform Resource Identifier of the track
+   */
+  uri = null;
+  /**
+   * International Standard Recording Code
+   */
+  isrc = null;
+  /**
+   * URL of the track (validated URI)
+   */
+  url = null;
+  /**
+   * Artwork/thumbnail URL
+   */
+  artworkUrl = null;
+  /**
+   * Custom user data attached to the track
+   */
+  userData = {};
+  /**
+   * Additional info from plugins
+   */
+  pluginInfo = {};
+  /**
+   * Encoded string representation (Lavalink format)
+   */
+  encoded;
+  /**
+   * Source name (youtube, spotify, soundcloud, etc.)
+   */
+  sourceName = "unknown";
+  get identifier() {
+    return this.id;
+  }
+  get stream() {
+    return this.isLive;
+  }
+  get seekable() {
+    return this.isSeekable;
+  }
+  get durationFormatted() {
+    return this.formattedDuration;
+  }
+  get source() {
+    return this.sourceName;
+  }
+  get thumbnail() {
+    return this.artworkUrl;
+  }
+  get info() {
+    return {
+      identifier: this.id,
+      position: 0,
+      title: this.title,
+      author: this.author,
+      length: this.duration,
+      isStream: this.isLive,
+      isSeekable: this.isSeekable,
+      uri: this.uri,
+      isrc: this.isrc,
+      artworkUrl: this.artworkUrl,
+      sourceName: this.sourceName
+    };
+  }
+  constructor(data) {
+    if (!isRecord(data)) {
+      throw new Error("Track data must be an object");
+    }
+    if (!isRecord(data.info)) {
+      throw new Error("Track info is not an object");
+    }
+    if (isString(data.info.identifier, "non-empty")) {
+      this.id = data.info.identifier;
+    } else {
+      throw new Error("Track does not have an identifier");
+    }
+    if (isString(data.encoded, "non-empty")) {
+      this.encoded = data.encoded;
+    } else {
+      throw new Error("Track does not have an encoded data string");
+    }
+    if (isString(data.info.title, "non-empty")) {
+      this.title = data.info.title;
+    }
+    if (isString(data.info.author, "non-empty")) {
+      this.author = data.info.author;
+    }
+    if (data.info.isStream) {
+      this.isLive = true;
+    }
+    if (data.info.isSeekable) {
+      this.isSeekable = true;
+    }
+    if (this.isLive) {
+      this.duration = Number.POSITIVE_INFINITY;
+      this.formattedDuration = "Live";
+    } else if (isNumber(data.info.length, "whole")) {
+      this.duration = data.info.length;
+      this.formattedDuration = formatDuration(this.duration);
+    }
+    if (isString(data.info.uri, "non-empty")) {
+      this.uri = data.info.uri;
+    }
+    if (isString(data.info.isrc, "non-empty")) {
+      this.isrc = data.info.isrc;
+    }
+    if (isString(this.uri, "url")) {
+      this.url = this.uri;
+    }
+    if (isString(data.info.artworkUrl, "url")) {
+      this.artworkUrl = data.info.artworkUrl;
+    }
+    if (isRecord(data.userData, "non-empty")) {
+      this.userData = data.userData;
+    }
+    if (isRecord(data.pluginInfo, "non-empty")) {
+      this.pluginInfo = data.pluginInfo;
+    }
+    if (isString(data.info.sourceName, "non-empty")) {
+      this.sourceName = data.info.sourceName;
+    }
+  }
+  /**
+   * String representation of the track
+   */
+  toString() {
+    return this.title;
+  }
+  /**
+   * JSON representation of the track
+   */
+  toJSON() {
+    return {
+      identifier: this.id,
+      title: this.title,
+      author: this.author,
+      duration: this.duration,
+      uri: this.uri,
+      thumbnail: this.artworkUrl,
+      source: this.sourceName,
+      isSeekable: this.isSeekable,
+      isStream: this.isLive,
+      encoded: this.encoded,
+      userData: this.userData,
+      pluginInfo: this.pluginInfo
+    };
+  }
+  /**
+   * Create a clone of the track
+   */
+  clone() {
+    return new _Track({
+      encoded: this.encoded,
+      info: {
+        ...this.info,
+        length: this.duration,
+        isStream: this.isLive
+      },
+      userData: this.userData,
+      pluginInfo: this.pluginInfo
+    });
+  }
+};
+
+// src/audio/TrackCollection.ts
+var Playlist = class {
+  /**
+   * Name of the playlist
+   */
+  name = "Unknown Playlist";
+  /**
+   * Index of the track that was selected (from URL)
+   */
+  selectedTrack = -1;
+  /**
+   * List of tracks in the playlist
+   */
+  tracks = [];
+  /**
+   * Additional info from plugins
+   */
+  pluginInfo = {};
+  /**
+   * Total duration of all tracks in milliseconds
+   */
+  duration = 0;
+  /**
+   * Formatted total duration string
+   */
+  formattedDuration = "00:00";
+  constructor(data) {
+    if (!isRecord(data)) {
+      throw new Error("Playlist data must be an object");
+    }
+    if (!isRecord(data.info)) {
+      throw new Error("Playlist info is not an object");
+    }
+    if (!isArray(data.tracks)) {
+      throw new Error("Playlist tracks must be an array");
+    }
+    for (let i = 0; i < data.tracks.length; i++) {
+      const track = new Track(data.tracks[i]);
+      if (!track.isLive) {
+        this.duration += track.duration;
+      }
+      this.tracks.push(track);
+    }
+    if (isString(data.info.name, "non-empty")) {
+      this.name = data.info.name;
+    } else if (data.info.name === "") {
+      this.name = "";
+    }
+    if (isNumber(data.info.selectedTrack, "whole")) {
+      this.selectedTrack = data.info.selectedTrack;
+    }
+    if (isRecord(data.pluginInfo, "non-empty")) {
+      this.pluginInfo = data.pluginInfo;
+    }
+    if (this.duration > 0) {
+      this.formattedDuration = formatDuration(this.duration);
+    }
+  }
+  get selected() {
+    if (this.selectedTrack < 0 || this.selectedTrack >= this.tracks.length) {
+      return null;
+    }
+    return this.tracks[this.selectedTrack] ?? null;
+  }
+  /**
+   * Get the selected track (if any)
+   * @returns The selected track or undefined if none/invalid
+   */
+  getSelectedTrack() {
+    return this.selected ?? void 0;
+  }
+  /**
+   * Get the number of tracks
+   */
+  get length() {
+    return this.tracks.length;
+  }
+  /**
+   * Get the number of tracks (alias for length)
+   */
+  get trackCount() {
+    return this.tracks.length;
+  }
+  /**
+   * Formatted total duration (alias for formattedDuration)
+   */
+  get durationFormatted() {
+    return this.formattedDuration;
+  }
+  /**
+   * String representation of the playlist
+   */
+  toString() {
+    return this.name;
+  }
+  /**
+   * JSON representation of the playlist
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      selectedTrack: this.selectedTrack,
+      tracks: this.tracks.map((t) => t.toJSON()),
+      duration: this.duration,
+      formattedDuration: this.formattedDuration,
+      pluginInfo: this.pluginInfo
+    };
+  }
+};
+
+// src/audio/AudioFilters.ts
+var FilterManager = class {
+  #player;
+  #guildId;
+  constructor(player, guildId) {
+    this.#player = player;
+    this.#guildId = guildId;
+  }
+  /**
+   * Get current filter data
+   */
+  get data() {
+    const queue = this.#player.queues?.get(this.#guildId);
+    if (!queue) {
+      return {};
+    }
+    return queue["#player"]?.filters || {};
+  }
+  /**
+   * Get a specific filter
+   */
+  get(key) {
+    if (key === "pluginFilters") {
+      return void 0;
+    }
+    return this.data[key];
+  }
+  /**
+   * Set a filter
+   */
+  async set(key, value) {
+    const queue = this.#player.queues?.get(this.#guildId);
+    if (!queue) {
+      throw new Error("Queue not found");
+    }
+    const filters = { ...this.data, [key]: value };
+    await queue["#update"]({ filters });
+  }
+  /**
+   * Set volume
+   */
+  async setVolume(volume) {
+    const clamped = Math.max(0, Math.min(1, volume));
+    await this.set("volume", clamped);
+  }
+  /**
+   * Get volume
+   */
+  get volume() {
+    return this.get("volume") ?? 1;
+  }
+  /**
+   * Set equalizer bands
+   */
+  async setEqualizer(bands) {
+    await this.set("equalizer", bands);
+  }
+  /**
+   * Get equalizer bands
+   */
+  get equalizer() {
+    return this.get("equalizer") ?? [];
+  }
+  /**
+   * Set karaoke filter
+   */
+  async setKaraoke(karaoke) {
+    await this.set("karaoke", karaoke);
+  }
+  /**
+   * Get karaoke filter
+   */
+  get karaoke() {
+    return this.get("karaoke");
+  }
+  /**
+   * Set timescale filter
+   */
+  async setTimescale(timescale) {
+    await this.set("timescale", timescale);
+  }
+  /**
+   * Get timescale filter
+   */
+  get timescale() {
+    return this.get("timescale");
+  }
+  /**
+   * Set tremolo filter
+   */
+  async setTremolo(tremolo) {
+    await this.set("tremolo", tremolo);
+  }
+  /**
+   * Get tremolo filter
+   */
+  get tremolo() {
+    return this.get("tremolo");
+  }
+  /**
+   * Set vibrato filter
+   */
+  async setVibrato(vibrato) {
+    await this.set("vibrato", vibrato);
+  }
+  /**
+   * Get vibrato filter
+   */
+  get vibrato() {
+    return this.get("vibrato");
+  }
+  /**
+   * Set rotation filter
+   */
+  async setRotation(rotation) {
+    await this.set("rotation", rotation);
+  }
+  /**
+   * Get rotation filter
+   */
+  get rotation() {
+    return this.get("rotation");
+  }
+  /**
+   * Clear specific equalizer filter
+   */
+  async clearEqualizer() {
+    await this.delete("equalizer");
+  }
+  /**
+   * Clear specific karaoke filter
+   */
+  async clearKaraoke() {
+    await this.delete("karaoke");
+  }
+  /**
+   * Clear specific timescale filter
+   */
+  async clearTimescale() {
+    await this.delete("timescale");
+  }
+  /**
+   * Clear specific tremolo filter
+   */
+  async clearTremolo() {
+    await this.delete("tremolo");
+  }
+  /**
+   * Clear specific vibrato filter
+   */
+  async clearVibrato() {
+    await this.delete("vibrato");
+  }
+  /**
+   * Clear specific rotation filter
+   */
+  async clearRotation() {
+    await this.delete("rotation");
+  }
+  /**
+   * Clear all filters
+   */
+  async clearAll() {
+    await this.clear();
+  }
+  /**
+   * Check if a filter is set
+   */
+  has(key) {
+    const value = this.data[key];
+    return value !== void 0 && value !== null;
+  }
+  /**
+   * Delete a specific filter
+   */
+  async delete(key) {
+    if (!this.has(key)) {
+      return false;
+    }
+    const queue = this.#player.queues?.get(this.#guildId);
+    if (!queue) {
+      throw new Error("Queue not found");
+    }
+    const filters = { ...this.data };
+    delete filters[key];
+    await queue["#update"]({ filters });
+    return true;
+  }
+  /**
+   * Clear filters
+   * @param type - "native" to clear only native filters, "plugin" to clear only plugin filters, undefined to clear all
+   */
+  async clear(type) {
+    const queue = this.#player.queues?.get(this.#guildId);
+    if (!queue) {
+      throw new Error("Queue not found");
+    }
+    let filters = {};
+    if (type === "native") {
+      if (this.data.pluginFilters) {
+        filters.pluginFilters = this.data.pluginFilters;
+      }
+    } else if (type === "plugin") {
+      const { pluginFilters: _, ...nativeFilters } = this.data;
+      filters = nativeFilters;
+    }
+    await queue["#update"]({ filters });
+  }
+  /**
+   * Apply multiple filters at once
+   */
+  async apply(filters) {
+    const queue = this.#player.queues?.get(this.#guildId);
+    if (!queue) {
+      throw new Error("Queue not found");
+    }
+    const newFilters = { ...this.data, ...filters };
+    await queue["#update"]({ filters: newFilters });
+  }
+  /**
+   * Set an EQ preset by name
+   * @param preset The preset name
+   * @returns Promise that resolves when the preset is applied
+   */
+  async setEQPreset(preset) {
+    const bands = EQPresets[preset];
+    if (!bands) {
+      throw new Error(`Invalid EQ preset: ${preset}`);
+    }
+    await this.set("equalizer", bands);
+  }
+  /**
+   * Get all available EQ preset names
+   * @returns Array of preset names
+   */
+  getEQPresetNames() {
+    return Object.keys(EQPresets);
+  }
+  /**
+   * Check if a preset name is valid
+   * @param name The preset name to check
+   * @returns True if the preset exists
+   */
+  isValidEQPreset(name) {
+    return name in EQPresets;
+  }
+};
+
+// src/audio/AudioQueue.ts
+var Queue = class {
+  #player;
+  #autoplay = false;
+  #repeatMode = "none";
+  #tracks = [];
+  #previousTracks = [];
+  context = {};
+  voice;
+  filters;
+  player;
+  constructor(player, guildId, context) {
+    if (player.queues.has(guildId)) {
+      throw new Error("An identical queue already exists");
+    }
+    const _player = player.queues[LookupSymbol](guildId);
+    if (!_player) {
+      throw new Error(`No player found for guild '${guildId}'`);
+    }
+    const voice = player.voices.get(guildId);
+    if (!voice) {
+      throw new Error(`No connection found for guild '${guildId}'`);
+    }
+    this.#player = _player;
+    if (context !== void 0) {
+      this.context = context;
+    }
+    this.voice = voice;
+    this.filters = new FilterManager(player, guildId);
+    this.player = player;
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      voice: immutable,
+      filters: immutable,
+      player: { ...immutable, enumerable: false }
+    });
+  }
+  get node() {
+    return this.voice.nodeSessionId ? this.player.nodes.all.find((n) => n.sessionId === this.voice.nodeSessionId) : this.player.nodes.relevant()[0];
+  }
+  get rest() {
+    return this.node?.rest;
+  }
+  get guildId() {
+    return this.voice.guildId;
+  }
+  get volume() {
+    return this.#player.volume;
+  }
+  get paused() {
+    return this.#player.paused;
+  }
+  get stopped() {
+    return this.track !== null && this.#player.track === null;
+  }
+  get empty() {
+    return this.finished && !this.hasPrevious;
+  }
+  get playing() {
+    return !this.paused && this.track !== null && this.#player.track !== null;
+  }
+  get autoplay() {
+    return this.#autoplay;
+  }
+  get finished() {
+    return this.#tracks.length === 0;
+  }
+  get destroyed() {
+    return this.player.queues.get(this.guildId) !== this;
+  }
+  get repeatMode() {
+    return this.#repeatMode;
+  }
+  get hasNext() {
+    return this.#tracks.length > 1;
+  }
+  get hasPrevious() {
+    return this.#previousTracks.length !== 0;
+  }
+  get track() {
+    return this.#tracks[0] ?? null;
+  }
+  get previousTrack() {
+    return this.#previousTracks[this.#previousTracks.length - 1] ?? null;
+  }
+  get tracks() {
+    return this.#tracks;
+  }
+  get previousTracks() {
+    return this.#previousTracks;
+  }
+  get length() {
+    return this.#tracks.length;
+  }
+  get totalLength() {
+    return this.length + this.#previousTracks.length;
+  }
+  get duration() {
+    return this.#tracks.reduce((time, track) => time + (track.isLive ? 0 : track.duration), 0);
+  }
+  get formattedDuration() {
+    return this.#formatDuration(this.duration);
+  }
+  get currentTime() {
+    if (this.#player.paused || !this.#player.state.connected) {
+      return this.#player.state.position;
+    }
+    if (this.#player.state.position === 0) {
+      return 0;
+    }
+    return this.#player.state.position + (Date.now() - this.#player.state.time);
+  }
+  get formattedCurrentTime() {
+    return this.#formatDuration(this.currentTime);
+  }
+  #formatDuration(ms) {
+    const seconds = Math.floor(ms / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+      return `${hours}:${(minutes % 60).toString().padStart(2, "0")}:${(seconds % 60).toString().padStart(2, "0")}`;
+    }
+    return `${minutes}:${(seconds % 60).toString().padStart(2, "0")}`;
+  }
+  #error(data) {
+    const explicit = typeof data === "string";
+    const message = explicit ? data : data.message ?? data.cause ?? "Unknown error";
+    const error = new Error(message);
+    error.name = `Error [${this.constructor.name}]`;
+    if (!explicit && data.severity) {
+      error.severity = data.severity;
+    }
+    return error;
+  }
+  async #update(data, params) {
+    const node = this.node;
+    if (!node) {
+      throw this.#error("No node available");
+    }
+    const player = await node.rest.updatePlayer(this.guildId, data, params);
+    Object.assign(this.#player, player);
+  }
+  /**
+   * Sync queue state with Lavalink
+   * @param target - "local" to pull from Lavalink, "remote" to push to Lavalink
+   */
+  async sync(target = "local") {
+    const node = this.node;
+    if (!node) {
+      throw this.#error("No node available");
+    }
+    if (target === "local") {
+      const player = await node.rest.fetchPlayer(this.guildId);
+      Object.assign(this.#player, player);
+      return;
+    }
+    if (target !== "remote") {
+      throw this.#error("Target must be 'local' or 'remote'");
+    }
+    const voice = this.player.voices[LookupSymbol](this.guildId);
+    if (!voice) {
+      return;
+    }
+    const request = {
+      voice: {
+        token: voice.token,
+        endpoint: voice.endpoint,
+        sessionId: voice.session_id,
+        channelId: voice.channel_id
+      },
+      filters: this.#player.filters,
+      paused: this.#player.paused,
+      volume: this.#player.volume
+    };
+    if (this.#player.track !== null) {
+      request.track = {
+        encoded: this.#player.track.encoded,
+        userData: this.#player.track.userData
+      };
+      request.position = this.#player.state.position;
+    }
+    await this.#update(request);
+    const nodeSessionId = this.node?.sessionId ?? "";
+    this.player.voices[UpdateSymbol](this.guildId, {
+      node_session_id: nodeSessionId
+    });
+  }
+  /**
+   * Search for tracks
+   */
+  async search(query, prefix = this.player.options.queryPrefix) {
+    return this.player.search(query, { prefix, node: this.node?.name });
+  }
+  /**
+   * Add tracks to the queue
+   */
+  add(source, userData) {
+    const added = [];
+    if (source instanceof Track) {
+      Object.assign(source.userData, userData);
+      this.#tracks.push(source);
+      added.push(source);
+    } else if (source instanceof Playlist) {
+      for (const track of source.tracks) {
+        Object.assign(track.userData, userData);
+        this.#tracks.push(track);
+        added.push(track);
+      }
+    } else if (Array.isArray(source)) {
+      for (const track of source) {
+        if (track instanceof Track) {
+          Object.assign(track.userData, userData);
+          this.#tracks.push(track);
+          added.push(track);
+        }
+      }
+    } else {
+      throw this.#error("Source must be a track, playlist, or array of tracks");
+    }
+    this.player.emit("trackAdd", this.player, this.guildId, added);
+    return this;
+  }
+  /**
+   * Add related tracks (for autoplay)
+   */
+  async addRelated(refTrack) {
+    refTrack ??= this.track ?? this.previousTrack ?? void 0;
+    if (!refTrack) {
+      throw this.#error("The queue is empty and there is no track to refer");
+    }
+    if (!this.node) {
+      return [];
+    }
+    const relatedTracks = await this.player.options.fetchRelatedTracks?.(this, refTrack);
+    this.add(relatedTracks);
+    return relatedTracks;
+  }
+  remove(input) {
+    if (typeof input === "number") {
+      if (input === 0 && !this.stopped) {
+        return;
+      }
+      if (input < 0) {
+        return this.#previousTracks.splice(input, 1)[0];
+      }
+      return this.#tracks.splice(input, 1)[0];
+    }
+    if (Array.isArray(input)) {
+      if (input.length === 0) {
+        return [];
+      }
+      const tracks = [];
+      const indices = input.toSorted((a, b) => a - b);
+      for (let i = 0; i < indices.length; i++) {
+        const index = indices[i] - i;
+        if (index === 0 && !this.stopped) {
+          continue;
+        }
+        if (index < 0) {
+          tracks.push(...this.#previousTracks.splice(index, 1));
+        } else if (index < this.#tracks.length) {
+          tracks.push(...this.#tracks.splice(index, 1));
+        }
+      }
+      return tracks;
+    }
+    throw this.#error("Input must be an index or array of indices");
+  }
+  /**
+   * Clear tracks from the queue
+   */
+  clear(type) {
+    switch (type) {
+      case "current":
+        if (!this.finished) {
+          this.#tracks.length = this.stopped ? 0 : 1;
+        }
+        break;
+      case "previous":
+        this.#previousTracks.length = 0;
+        break;
+      default:
+        if (!this.finished) {
+          this.#tracks.length = this.stopped ? 0 : 1;
+        }
+        this.#previousTracks.length = 0;
+    }
+  }
+  /**
+   * Jump to a specific track
+   */
+  async jump(index) {
+    if (this.empty) {
+      throw this.#error("The queue is empty at the moment");
+    }
+    if (!Number.isInteger(index)) {
+      throw this.#error("Index must be an integer");
+    }
+    const track = index < 0 ? this.#previousTracks[this.#previousTracks.length + index] : this.#tracks[index];
+    if (!track) {
+      throw this.#error("Specified index is out of range");
+    }
+    if (index < 0) {
+      this.#tracks.unshift(...this.#previousTracks.splice(index));
+    } else {
+      this.#previousTracks.push(...this.#tracks.splice(0, index));
+    }
+    await this.#update({
+      paused: false,
+      track: { encoded: track.encoded, userData: track.userData }
+    });
+    return track;
+  }
+  /**
+   * Pause playback
+   */
+  async pause() {
+    await this.#update({ paused: true });
+    return this.#player.paused;
+  }
+  /**
+   * Resume playback
+   */
+  async resume() {
+    if (this.stopped) {
+      await this.jump(0);
+    } else {
+      await this.#update({ paused: false });
+    }
+    return !this.#player.paused;
+  }
+  /**
+   * Seek to a position
+   */
+  async seek(ms) {
+    if (this.track === null) {
+      throw this.#error("No track is playing at the moment");
+    }
+    if (!this.track.isSeekable) {
+      throw this.#error("Current track is not seekable");
+    }
+    if (!Number.isInteger(ms) || ms < 0) {
+      throw this.#error("Seek time must be a positive integer");
+    }
+    if (ms > this.track.duration) {
+      throw this.#error("Specified time to seek is out of range");
+    }
+    const body = { paused: false, position: ms };
+    if (this.#player.track?.info.identifier !== this.track.id) {
+      body.track = { encoded: this.track.encoded, userData: this.track.userData };
+    }
+    await this.#update(body);
+    return this.#player.state.position;
+  }
+  /**
+   * Play next track
+   */
+  async next() {
+    if (this.hasNext) {
+      return this.jump(1);
+    }
+    if (this.hasPrevious && this.#repeatMode === "queue") {
+      const track = this.#previousTracks.shift();
+      if (track) {
+        this.#tracks.push(track);
+      }
+      return this.jump(this.hasNext ? 1 : 0);
+    }
+    if (!this.empty && this.#autoplay) {
+      const related = await this.addRelated();
+      if (related.length > 0) {
+        return this.jump(this.length - related.length);
+      }
+    }
+    if (!this.finished) {
+      const track = this.#tracks.shift();
+      if (track) {
+        this.#previousTracks.push(track);
+      }
+      await this.stop();
+    }
+    return null;
+  }
+  /**
+   * Play previous track
+   */
+  async previous() {
+    if (this.hasPrevious) {
+      return this.jump(-1);
+    }
+    return null;
+  }
+  /**
+   * Shuffle tracks
+   */
+  shuffle(includePrevious = false) {
+    if (includePrevious === true) {
+      this.#tracks.push(...this.#previousTracks.splice(0));
+    }
+    if (this.#tracks.length < 3) {
+      return this;
+    }
+    for (let i = this.#tracks.length - 1; i > 1; --i) {
+      const j = Math.floor(Math.random() * i) + 1;
+      [this.#tracks[i], this.#tracks[j]] = [this.#tracks[j], this.#tracks[i]];
+    }
+    return this;
+  }
+  /**
+   * Set volume
+   */
+  async setVolume(volume) {
+    if (!Number.isInteger(volume) || volume < 0) {
+      throw this.#error("Volume must be a positive integer");
+    }
+    if (volume > 1e3) {
+      throw this.#error("Volume cannot be more than 1000");
+    }
+    await this.#update({ volume });
+    return this.#player.volume;
+  }
+  /**
+   * Set autoplay
+   */
+  setAutoplay(autoplay = false) {
+    if (typeof autoplay !== "boolean") {
+      throw this.#error("Autoplay must be a boolean value");
+    }
+    this.#autoplay = autoplay;
+    return this.#autoplay;
+  }
+  /**
+   * Set repeat mode
+   */
+  setRepeatMode(repeatMode = "none") {
+    if (repeatMode !== "track" && repeatMode !== "queue" && repeatMode !== "none") {
+      throw this.#error("Repeat mode can only be set to track, queue, or none");
+    }
+    this.#repeatMode = repeatMode;
+    return this.#repeatMode;
+  }
+  /**
+   * Stop playback
+   */
+  async stop() {
+    return this.#update({ track: { encoded: null } });
+  }
+  /**
+   * Destroy the queue
+   */
+  async destroy(reason) {
+    return this.player.queues.destroy(this.guildId, reason);
+  }
+  /**
+   * Move a track from one position to another
+   * @param from - Current position of the track
+   * @param to - New position for the track
+   */
+  move(from, to) {
+    if (from < 0 || from >= this.#tracks.length || to < 0 || to >= this.#tracks.length || from === to) {
+      return null;
+    }
+    const track = this.#tracks[from];
+    if (!track) {
+      return null;
+    }
+    this.#tracks.splice(from, 1);
+    this.#tracks.splice(to, 0, track);
+    return track;
+  }
+  /**
+   * Splice tracks - remove and/or add tracks at a specific position
+   * @param index - Position to start
+   * @param amount - Number of tracks to remove
+   * @param tracks - Tracks to add at the position
+   */
+  splice(index, amount, tracks) {
+    if (!this.#tracks.length && tracks) {
+      void this.add(tracks);
+      return [];
+    }
+    const removed = tracks ? this.#tracks.splice(index, amount, ...Array.isArray(tracks) ? tracks : [tracks]) : this.#tracks.splice(index, amount);
+    return removed;
+  }
+  /**
+   * Sort tracks by a property or custom function
+   * @param sortBy - Property name or comparator function
+   * @param order - Sort order (asc/desc)
+   */
+  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.duration - b.duration;
+            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;
+      });
+    }
+    return this;
+  }
+  /**
+   * Get a sorted copy without modifying the original queue
+   */
+  toSortedBy(sortBy, order = "asc") {
+    const copy = [...this.#tracks];
+    if (typeof sortBy === "function") {
+      return copy.sort(sortBy);
+    }
+    return copy.sort((a, b) => {
+      let comparison = 0;
+      switch (sortBy) {
+        case "duration":
+          comparison = a.duration - b.duration;
+          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;
+    });
+  }
+  /**
+   * Filter tracks by predicate or criteria
+   */
+  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) {
+        if (typeof predicate.duration === "number") {
+          if (track.duration !== predicate.duration) {
+            return false;
+          }
+        } else {
+          if (predicate.duration.min && track.duration < predicate.duration.min) {
+            return false;
+          }
+          if (predicate.duration.max && track.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 !== predicate.sourceName) {
+        return false;
+      }
+      if (predicate.isStream !== void 0 && track.isLive !== predicate.isStream) {
+        return false;
+      }
+      if (predicate.isSeekable !== void 0 && track.isSeekable !== predicate.isSeekable) {
+        return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * Find a track by predicate or criteria
+   */
+  findTrack(predicate) {
+    const results = this.filterTracks(predicate);
+    return results[0] ?? null;
+  }
+  /**
+   * Get a range of tracks
+   */
+  getTracks(start, end) {
+    return this.#tracks.slice(start, end);
+  }
+  /**
+   * Shift from previous tracks
+   */
+  shiftPrevious() {
+    return this.#previousTracks.shift() ?? null;
+  }
+};
+var QueueManager = class extends EventEmitter {
+  #player;
+  #queues = /* @__PURE__ */ new Map();
+  #players = /* @__PURE__ */ new Map();
+  constructor(player) {
+    super({ captureRejections: false });
+    this.#player = player;
+  }
+  get(guildId) {
+    return this.#queues.get(guildId);
+  }
+  has(guildId) {
+    return this.#queues.has(guildId);
+  }
+  get all() {
+    return Array.from(this.#queues.values());
+  }
+  get size() {
+    return this.#queues.size;
+  }
+  keys() {
+    return this.#queues.keys();
+  }
+  values() {
+    return this.#queues.values();
+  }
+  entries() {
+    return this.#queues.entries();
+  }
+  async create(options) {
+    if (this.#queues.has(options.guildId)) {
+      throw new Error(`Queue already exists for guild '${options.guildId}'`);
+    }
+    let voice = this.#player.voices.get(options.guildId);
+    if (!voice) {
+      voice = await this.#player.voices.connect(options.guildId, options.voiceId, {
+        node: options.node,
+        context: options.context,
+        filters: options.filters,
+        volume: options.volume
+      });
+    }
+    const playerState = {
+      guildId: options.guildId,
+      track: null,
+      volume: options.volume ?? 100,
+      paused: false,
+      state: {
+        time: Date.now(),
+        position: 0,
+        connected: false,
+        ping: -1
+      },
+      voice: {
+        token: "",
+        endpoint: "",
+        sessionId: "",
+        channelId: options.voiceId
+      },
+      filters: options.filters ?? {}
+    };
+    this.#players.set(options.guildId, playerState);
+    const queue = new Queue(this.#player, options.guildId, options.context);
+    this.#queues.set(options.guildId, queue);
+    this.#player.emit("queueCreate", queue);
+    return queue;
+  }
+  async destroy(guildId, reason = "destroyed") {
+    const queue = this.#queues.get(guildId);
+    if (!queue) {
+      return;
+    }
+    const voice = this.#player.voices.get(guildId);
+    if (voice?.node) {
+      await voice.node.rest.destroyPlayer(guildId).catch(noop);
+    }
+    await this.#player.voices.destroy(guildId, reason);
+    this.#queues.delete(guildId);
+    this.#players.delete(guildId);
+    this.#player.emit("queueDestroy", queue, reason);
+  }
+  async relocate(guildId, nodeName) {
+    const queue = this.#queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    const voice = this.#player.voices.get(guildId);
+    if (!voice) {
+      throw new Error(`No voice connection found for guild '${guildId}'`);
+    }
+    await voice.changeNode(nodeName);
+  }
+  async syncAll() {
+    const promises = [];
+    for (const queue of this.#queues.values()) {
+      promises.push(queue.sync("remote").catch(noop));
+    }
+    await Promise.all(promises);
+  }
+  [LookupSymbol](guildId) {
+    return this.#players.get(guildId);
+  }
+  [OnStateUpdateSymbol](guildId, state) {
+    const player = this.#players.get(guildId);
+    if (!player) {
+      return;
+    }
+    player.state = state;
+    const queue = this.#queues.get(guildId);
+    if (queue) {
+      this.#player.emit("queueUpdate", queue, state);
+    }
+    const voice = this.#player.voices.get(guildId);
+    if (voice?.regionId) {
+      const region = this.#player.voices.regions.get(voice.regionId);
+      if (region) {
+        region[OnPingUpdateSymbol]?.(voice.node.name, state);
+      }
+    }
+  }
+  [OnEventUpdateSymbol](guildId, event) {
+    const queue = this.#queues.get(guildId);
+    if (!queue) {
+      return;
+    }
+    switch (event.type) {
+      case "TrackStartEvent" /* TrackStart */:
+        this.#handleTrackStart(queue, event);
+        break;
+      case "TrackEndEvent" /* TrackEnd */:
+        void this.#handleTrackEnd(queue, event);
+        break;
+      case "TrackExceptionEvent" /* TrackException */:
+        this.#handleTrackException(queue, event);
+        break;
+      case "TrackStuckEvent" /* TrackStuck */:
+        this.#handleTrackStuck(queue, event);
+        break;
+      case "WebSocketClosedEvent" /* WebSocketClosed */:
+        this.#handleWebSocketClosed(queue, event);
+        break;
+    }
+  }
+  #handleTrackStart(queue, event) {
+    const track = new Track(event.track);
+    this.#player.emit("trackStart", queue, track);
+  }
+  async #handleTrackEnd(queue, event) {
+    const track = new Track(event.track);
+    const reason = event.reason;
+    this.#player.emit("trackFinish", queue, track, reason);
+    const shouldAdvance = reason === "finished" /* Finished */ || reason === "loadFailed" /* LoadFailed */;
+    if (shouldAdvance) {
+      const nextTrack = await queue.next().catch(noop);
+      if (!nextTrack && queue.finished) {
+        this.#player.emit("queueFinish", queue);
+      }
+    }
+  }
+  #handleTrackException(queue, event) {
+    const track = new Track(event.track);
+    this.#player.emit("trackError", queue, track, event.exception);
+  }
+  #handleTrackStuck(queue, event) {
+    const track = new Track(event.track);
+    this.#player.emit("trackStuck", queue, track, event.thresholdMs);
+  }
+  #handleWebSocketClosed(queue, event) {
+    const voice = this.#player.voices.get(queue.guildId);
+    if (voice) {
+      this.#player.voices[OnVoiceCloseSymbol]?.(queue.guildId, event.code, event.reason, event.byRemote);
+    }
+  }
+};
+
+// src/core/PluginSystem.ts
+var PlayerPlugin = class {
+};
+
+// src/extensions/AutoplayExtension.ts
+var AutoplayPlugin = class extends PlayerPlugin {
+  name = "autoplay";
+  #player;
+  #adding = /* @__PURE__ */ new Set();
+  // Track which guilds are currently adding
+  init(player) {
+    this.#player = player;
+    player.on("queueFinish", (queue) => {
+      void this.#handleQueueFinish(queue);
+    });
+  }
+  async #handleQueueFinish(queue) {
+    const lastTrack = queue.previousTrack;
+    if (!lastTrack) {
+      return;
+    }
+    const config = queue.player.get?.(`autoplay_config_${queue.guildId}`) ?? {
+      enabled: true,
+      minPlayTime: 1e4,
+      sources: {
+        spotify: true,
+        youtube: true,
+        youtubemusic: true,
+        soundcloud: false
+      },
+      limit: 5,
+      minDuration: 2e4,
+      maxDuration: 9e5,
+      excludeKeywords: ["nightcore", "bass boosted", "8d audio", "slowed", "reverb"]
+    };
+    if (!config.enabled) {
+      return;
+    }
+    if (this.#adding.has(queue.guildId)) {
+      return;
+    }
+    this.#adding.add(queue.guildId);
+    try {
+      const playedData = this.#buildPlayedData(queue);
+      const relatedTracks = await this.#fetchRelatedTracks(queue, lastTrack, config, playedData);
+      if (relatedTracks.length > 0) {
+        for (const relatedTrack of relatedTracks) {
+          if (!relatedTrack.pluginInfo) {
+            relatedTrack.pluginInfo = {};
+          }
+          relatedTrack.pluginInfo.fromAutoplay = true;
+          relatedTrack.userData.requester = {
+            id: this.#player.clientId ?? "autoplay",
+            username: "Autoplay"
+          };
+          queue.add(relatedTrack);
+        }
+        if (queue.stopped && queue.tracks.length > 0) {
+          await queue.resume();
+        }
+      }
+    } catch (error) {
+      this.#player.emit("debug", "autoplay", {
+        message: `Autoplay failed: ${error.message}`,
+        state: "error",
+        error,
+        functionLayer: "AutoplayPlugin"
+      });
+    } finally {
+      this.#adding.delete(queue.guildId);
+    }
+  }
+  #buildPlayedData(queue) {
+    const playedIds = /* @__PURE__ */ new Set();
+    const playedTracks = /* @__PURE__ */ new Set();
+    const addTrack = (track) => {
+      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 (queue.track) {
+      addTrack(queue.track);
+    }
+    queue.previousTracks.forEach(addTrack);
+    queue.tracks.forEach(addTrack);
+    return { playedIds, playedTracks };
+  }
+  async #fetchRelatedTracks(queue, lastTrack, config, playedData) {
+    const tracks = [];
+    const source = lastTrack.info.sourceName?.toLowerCase();
+    if (config.sources.spotify && source?.includes("spotify")) {
+      const spotifyTracks = await this.#getSpotifyRecommendations(queue, lastTrack);
+      tracks.push(...spotifyTracks);
+      if (tracks.length < config.limit) {
+        const artistTracks = await this.#getSpotifyArtistSearch(queue, lastTrack);
+        tracks.push(...artistTracks);
+      }
+    }
+    if (tracks.length < config.limit && config.sources.youtube && source?.includes("youtube")) {
+      const youtubeTracks = await this.#getYouTubeSimilar(queue, lastTrack);
+      tracks.push(...youtubeTracks);
+      if (tracks.length < config.limit) {
+        const artistTracks = await this.#getYouTubeArtist(queue, lastTrack);
+        tracks.push(...artistTracks);
+      }
+    }
+    if (tracks.length === 0 && config.sources.youtube) {
+      const youtubeTracks = await this.#getYouTubeSimilar(queue, lastTrack);
+      tracks.push(...youtubeTracks);
+    }
+    return this.#filterAutoplayTracks(tracks, playedData, config);
+  }
+  #filterAutoplayTracks(tracks, playedData, config) {
+    return tracks.filter((track) => {
+      if (!track.info) {
+        return false;
+      }
+      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.length) {
+        if (track.info.length < config.minDuration) {
+          return false;
+        }
+        if (track.info.length > config.maxDuration) {
+          return false;
+        }
+      }
+      const title = track.info.title.toLowerCase();
+      for (const keyword of config.excludeKeywords) {
+        if (title.includes(keyword.toLowerCase())) {
+          return false;
+        }
+      }
+      return true;
+    }).sort(() => Math.random() - 0.5).slice(0, config.limit);
+  }
+  async #getSpotifyRecommendations(queue, track) {
+    try {
+      const query = `sprec:seed_tracks=${track.info.identifier}`;
+      const result = await queue.search(query);
+      if (result.loadType === "track" /* Track */ || result.loadType === "playlist" /* Playlist */) {
+        if (result.loadType === "track" /* Track */) {
+          return [result.data];
+        }
+        return result.data.tracks;
+      }
+    } catch (error) {
+    }
+    return [];
+  }
+  async #getSpotifyArtistSearch(queue, track) {
+    try {
+      const query = `spsearch:${track.info.author}`;
+      const result = await queue.search(query);
+      if (result.loadType === "search" /* Search */ && Array.isArray(result.data)) {
+        return result.data.slice(0, 5);
+      }
+    } catch (error) {
+    }
+    return [];
+  }
+  async #getYouTubeSimilar(queue, track) {
+    try {
+      const query = `https://www.youtube.com/watch?v=${track.info.identifier}&list=RD${track.info.identifier}`;
+      const result = await queue.search(query);
+      if (result.loadType === "playlist" /* Playlist */ && result.data && "tracks" in result.data) {
+        return result.data.tracks.slice(0, 10);
+      }
+    } catch (error) {
+    }
+    return [];
+  }
+  async #getYouTubeArtist(queue, track) {
+    try {
+      const query = `ytsearch:${track.info.author}`;
+      const result = await queue.search(query);
+      if (result.loadType === "search" /* Search */ && Array.isArray(result.data)) {
+        return result.data.slice(0, 5);
+      }
+    } catch (error) {
+    }
+    return [];
+  }
+};
+
+// src/extensions/LyricsExtension.ts
+var LyricsPlugin = class extends PlayerPlugin {
+  name = "lyrics";
+  #player;
+  init(player) {
+    this.#player = player;
+  }
+  /**
+   * Fetch lyrics for a track
+   * @param track - The track to fetch lyrics for
+   * @param config - Configuration for lyrics sources
+   */
+  async getLyrics(track, config) {
+    const defaultConfig = {
+      sources: {
+        lavalink: true,
+        lrclib: true,
+        musixmatch: false,
+        genius: false
+      },
+      ...config
+    };
+    const title = track.info.title;
+    const artist = track.info.author;
+    if (defaultConfig.sources.lavalink) {
+      const lavalinkLyrics = await this.#fetchFromLavalink(track);
+      if (lavalinkLyrics) {
+        this.#player.emit("lyricsFound", this.#player, track, lavalinkLyrics);
+        return lavalinkLyrics;
+      }
+    }
+    if (defaultConfig.sources.lrclib) {
+      const lrclibLyrics = await this.#fetchFromLRCLib(title, artist);
+      if (lrclibLyrics) {
+        this.#player.emit("lyricsFound", this.#player, track, lrclibLyrics);
+        return lrclibLyrics;
+      }
+    }
+    if (defaultConfig.sources.musixmatch && defaultConfig.apiKeys?.musixmatch) {
+      const musixmatchLyrics = await this.#fetchFromMusixmatch(title, artist, defaultConfig.apiKeys.musixmatch);
+      if (musixmatchLyrics) {
+        this.#player.emit("lyricsFound", this.#player, track, musixmatchLyrics);
+        return musixmatchLyrics;
+      }
+    }
+    if (defaultConfig.sources.genius && defaultConfig.apiKeys?.genius) {
+      const geniusLyrics = await this.#fetchFromGenius(title, artist, defaultConfig.apiKeys.genius);
+      if (geniusLyrics) {
+        this.#player.emit("lyricsFound", this.#player, track, geniusLyrics);
+        return geniusLyrics;
+      }
+    }
+    this.#player.emit("lyricsNotFound", this.#player, track);
+    return null;
+  }
+  /**
+   * Get the current lyric line based on playback position
+   */
+  getCurrentLine(lyrics, position) {
+    if (!lyrics.lines || lyrics.lines.length === 0) {
+      return null;
+    }
+    for (let i = lyrics.lines.length - 1; i >= 0; i--) {
+      if (lyrics.lines[i].timestamp <= position) {
+        return lyrics.lines[i];
+      }
+    }
+    return null;
+  }
+  /**
+   * Format lyrics for display
+   */
+  formatLyrics(lyrics, maxLength = 2e3) {
+    if (lyrics.text) {
+      return lyrics.text.slice(0, maxLength);
+    }
+    if (lyrics.lines && lyrics.lines.length > 0) {
+      let formatted = "";
+      for (const line of lyrics.lines) {
+        const timestamp = this.#formatTimestamp(line.timestamp);
+        formatted += `[${timestamp}] ${line.line}
+`;
+        if (formatted.length > maxLength) {
+          return `${formatted.slice(0, maxLength)}...`;
+        }
+      }
+      return formatted;
+    }
+    return "No lyrics available";
+  }
+  #formatTimestamp(ms) {
+    const minutes = Math.floor(ms / 6e4);
+    const seconds = Math.floor(ms % 6e4 / 1e3);
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+  async #fetchFromLavalink(_track) {
+    return await Promise.resolve(null);
+  }
+  async #fetchFromLRCLib(_title, _artist) {
+    return await Promise.resolve(null);
+  }
+  async #fetchFromMusixmatch(_title, _artist, _apiKey) {
+    return await Promise.resolve(null);
+  }
+  async #fetchFromGenius(_title, _artist, _apiToken) {
+    return await Promise.resolve(null);
+  }
+};
+
+// src/extensions/SponsorBlockExtension.ts
+var SponsorBlockPlugin = class extends PlayerPlugin {
+  name = "sponsorblock";
+  #player;
+  init(player) {
+    this.#player = player;
+    player.on("segmentsLoaded", this.#handleSegmentsLoaded.bind(this));
+    player.on("segmentSkipped", this.#handleSegmentSkipped.bind(this));
+  }
+  /**
+   * Set which segments to skip for a player
+   */
+  async setSegments(queue, segments = ["sponsor", "selfpromo"]) {
+    const node = queue.node;
+    if (!node) {
+      throw new Error("No node available");
+    }
+    await node.setSponsorBlock(queue, segments);
+  }
+  /**
+   * Get current SponsorBlock segments for a player
+   */
+  async getSegments(queue) {
+    const node = queue.node;
+    if (!node) {
+      throw new Error("No node available");
+    }
+    return await node.getSponsorBlock(queue);
+  }
+  /**
+   * Delete SponsorBlock configuration for a player
+   */
+  async deleteSegments(queue) {
+    const node = queue.node;
+    if (!node) {
+      throw new Error("No node available");
+    }
+    await node.deleteSponsorBlock(queue);
+  }
+  #handleSegmentsLoaded(queue, track, segments) {
+    const _segments = segments || [];
+    this.#player.emit("segmentsLoaded", queue, track, _segments);
+  }
+  #handleSegmentSkipped(queue, track, segment) {
+    const _segment = segment;
+    this.#player.emit("segmentSkipped", queue, track, _segment);
+  }
+};
+
+// src/extensions/FairPlayExtension.ts
+var FairPlayPlugin = class extends PlayerPlugin {
+  name = "fairplay";
+  #player;
+  config = {
+    enabled: true,
+    minTracks: 5,
+    maxConsecutive: 3
+  };
+  init(player) {
+    this.#player = player;
+    const config = player.get?.("fairplay_config");
+    if (config) {
+      this.config = { ...this.config, ...config };
+    }
+    player.on("trackAdd", (p, g, t) => {
+      void this.#handleTrackAdd(p, g, t);
+    });
+  }
+  #handleTrackAdd(_player, guildId, _tracks) {
+    if (!this.config.enabled) {
+      return;
+    }
+    const queue = this.#player.queues.get(guildId);
+    if (!queue || queue.length < this.config.minTracks) {
+      return;
+    }
+    this.applyFairPlay(queue.guildId);
+  }
+  /**
+   * Apply fair play algorithm to a queue
+   */
+  applyFairPlay(guildId) {
+    const queue = this.#player.queues.get(guildId);
+    if (!queue) {
+      return;
+    }
+    const playerConfig = this.#player.get?.("fairplay_config");
+    const config = playerConfig ? { ...this.config, ...playerConfig } : this.config;
+    if (queue.length < config.minTracks) {
+      return;
+    }
+    const tracks = queue.tracks;
+    const fairQueue = [];
+    const requesterQueues = /* @__PURE__ */ new Map();
+    for (const track of tracks) {
+      const requesterId = this.#getRequesterId(track);
+      let requesterQueue = requesterQueues.get(requesterId);
+      if (!requesterQueue) {
+        requesterQueue = [];
+        requesterQueues.set(requesterId, requesterQueue);
+      }
+      requesterQueue.push(track);
+    }
+    let hasMore = true;
+    let consecutiveCount = 0;
+    let lastRequesterId = null;
+    while (hasMore) {
+      hasMore = false;
+      for (const [requesterId, requesterTracks] of requesterQueues) {
+        if (requesterTracks.length === 0) {
+          continue;
+        }
+        hasMore = true;
+        if (lastRequesterId === requesterId) {
+          consecutiveCount++;
+          if (consecutiveCount >= config.maxConsecutive) {
+            continue;
+          }
+        } else {
+          consecutiveCount = 1;
+          lastRequesterId = requesterId;
+        }
+        const track = requesterTracks.shift();
+        if (track) {
+          fairQueue.push(track);
+        }
+      }
+      if (!hasMore) {
+        lastRequesterId = null;
+        consecutiveCount = 0;
+        hasMore = Array.from(requesterQueues.values()).some((q) => q.length > 0);
+      }
+    }
+    if (fairQueue.length > 0) {
+      queue.clear("current");
+      queue.add(fairQueue);
+      this.#player.emit("fairPlayApplied", this.#player, guildId, fairQueue.length);
+    }
+  }
+  #getRequesterId(track) {
+    const requester = track.userData.requester;
+    if (requester && typeof requester === "object") {
+      return requester.id || "unknown";
+    }
+    return "unknown";
+  }
+};
+
+// src/extensions/PersistenceExtension.ts
+var MemoryQueueStore = class {
+  #data = /* @__PURE__ */ new Map();
+  get(guildId) {
+    return this.#data.get(guildId) ?? null;
+  }
+  set(guildId, data) {
+    this.#data.set(guildId, data);
+  }
+  delete(guildId) {
+    this.#data.delete(guildId);
+  }
+};
+var QueuePersistencePlugin = class extends PlayerPlugin {
+  name = "queue-persistence";
+  #player;
+  #store;
+  #autoSave;
+  constructor(store, autoSave = true) {
+    super();
+    this.#store = store ?? new MemoryQueueStore();
+    this.#autoSave = autoSave;
+  }
+  init(player) {
+    this.#player = player;
+    if (this.#autoSave) {
+      player.on("trackStart", (queue, _track) => {
+        this.saveQueue(queue.guildId).catch(() => {
+        });
+      });
+      player.on("trackFinish", (queue, _track, _reason) => {
+        this.saveQueue(queue.guildId).catch(() => {
+        });
+      });
+      player.on("queueDestroy", (queue) => {
+        this.deleteQueue(queue.guildId).catch(() => {
+        });
+      });
+    }
+  }
+  /**
+   * Save queue state
+   */
+  async saveQueue(guildId) {
+    const queue = this.#player.queues.get(guildId);
+    if (!queue) {
+      return;
+    }
+    const data = {
+      guildId,
+      tracks: queue.tracks.map((track) => ({
+        encoded: track.encoded,
+        info: track.info,
+        pluginInfo: track.pluginInfo,
+        userData: track.userData
+      })),
+      previousTracks: queue.previousTracks.map((t) => ({
+        encoded: t.encoded,
+        info: t.info,
+        pluginInfo: t.pluginInfo,
+        userData: t.userData
+      })),
+      currentTrack: queue.track ? {
+        encoded: queue.track.encoded,
+        info: queue.track.info,
+        position: queue.currentTime
+      } : void 0,
+      volume: queue.volume,
+      repeatMode: queue.repeatMode,
+      autoplay: queue.autoplay,
+      paused: queue.paused,
+      timestamp: Date.now()
+    };
+    await this.#store.set(guildId, data);
+    this.#player.emit("queueSaved", guildId);
+  }
+  /**
+   * Load queue state
+   */
+  async loadQueue(guildId) {
+    const data = await this.#store.get(guildId);
+    if (!data) {
+      return null;
+    }
+    const queue = this.#player.queues.get(guildId);
+    if (!queue) {
+      return null;
+    }
+    this.#player.emit("queueLoaded", guildId, data.tracks.length);
+    return data;
+  }
+  /**
+   * Delete saved queue
+   */
+  async deleteQueue(guildId) {
+    await this.#store.delete(guildId);
+  }
+  /**
+   * Get all saved queues
+   */
+  async getAllQueues() {
+    return await Promise.resolve([]);
+  }
+};
+var Player = class extends EventEmitter {
+  #initialized = false;
+  #initPromise = null;
+  #clientId = null;
+  #nodes = null;
+  options;
+  plugins;
+  nodes;
+  voices;
+  queues;
+  constructor(options) {
+    super({ captureRejections: false });
+    const _options = { ...DefaultPlayerOptions, ...options };
+    if (_options.nodes.length === 0) {
+      throw new Error("Missing node create options");
+    }
+    if (typeof _options.forwardVoiceUpdate !== "function") {
+      throw new Error("Missing voice update function");
+    }
+    this.#nodes = _options.nodes;
+    delete _options.nodes;
+    this.options = _options;
+    this.plugins = {};
+    if (_options.plugins !== void 0) {
+      for (const plugin of _options.plugins) {
+        if (!(plugin instanceof PlayerPlugin)) {
+          throw new Error("Invalid plugin(s)");
+        }
+        this.plugins[plugin.name] = plugin;
+      }
+      delete _options.plugins;
+    }
+    this.nodes = new NodeManager(this);
+    this.voices = new VoiceManager(this);
+    this.queues = new QueueManager(this);
+    const immutable = {
+      writable: false,
+      configurable: false
+    };
+    Object.defineProperties(this, {
+      options: immutable,
+      plugins: immutable,
+      nodes: immutable,
+      voices: immutable,
+      queues: immutable
+    });
+  }
+  /**
+   * Whether the player is initialized and ready
+   */
+  get ready() {
+    return this.#initialized;
+  }
+  /**
+   * The bot's client ID
+   */
+  get clientId() {
+    return this.#clientId;
+  }
+  /**
+   * Initialize the player
+   * @param clientId Bot client ID
+   */
+  async init(clientId) {
+    if (this.#initialized) {
+      return;
+    }
+    if (this.#initPromise !== null) {
+      return this.#initPromise;
+    }
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this.#initPromise = promise;
+    this.#clientId = clientId;
+    try {
+      const nodes = this.#nodes ?? [];
+      for (const node of nodes) {
+        this.nodes.create({ ...node, clientId });
+      }
+      for (const name in this.plugins) {
+        this.plugins[name].init(this);
+      }
+      await this.nodes.connect();
+      this.#initialized = true;
+      this.#nodes = null;
+      this.emit("init");
+      resolve();
+    } catch (err) {
+      reject(err);
+      throw err;
+    } finally {
+      this.#initPromise = null;
+    }
+  }
+  /**
+   * Returns the queue of a guild
+   * @param guildId Id of the guild
+   */
+  getQueue(guildId) {
+    return this.queues.get(guildId);
+  }
+  /**
+   * Creates a queue from options
+   * @param options Options to create from
+   */
+  async createQueue(options) {
+    return this.queues.create(options);
+  }
+  /**
+   * Destroys the queue of a guild
+   * @param guildId Id of the guild
+   * @param reason Reason for destroying
+   */
+  async destroyQueue(guildId, reason) {
+    return this.queues.destroy(guildId, reason);
+  }
+  /**
+   * Searches for results based on query and options
+   * @param query Query (or URL as well)
+   * @param options Options for customization
+   */
+  async search(query, options) {
+    if (!isString(query, "non-empty")) {
+      throw new Error("Query must be a non-empty string");
+    }
+    const node = options?.node !== void 0 ? this.nodes.get(options.node) : this.nodes.relevant()[0];
+    if (!node) {
+      if (options?.node === void 0) {
+        throw new Error("No nodes available");
+      }
+      throw new Error(`Node '${options.node}' not found`);
+    }
+    const prefix = options?.prefix ?? this.options.queryPrefix;
+    query = isString(query, "url") ? query : `${String(prefix)}:${String(query)} `;
+    const result = await node.rest.loadTracks(query);
+    switch (result.loadType) {
+      case "empty" /* Empty */:
+        return { type: "empty", data: [] };
+      case "error" /* Error */:
+        return { type: "error", data: result.data };
+      case "playlist" /* Playlist */:
+        return { type: "playlist", data: new Playlist(result.data) };
+      case "search" /* Search */:
+        return { type: "query", data: result.data.map((t) => new Track(t)) };
+      case "track" /* Track */:
+        return { type: "track", data: new Track(result.data) };
+      default:
+        throw new Error(`Unexpected load result type from node '${node.name}'`);
+    }
+  }
+  /**
+   * Adds or searches if source is query and resumes the queue if stopped
+   * @param source Source to play from
+   * @param options Options for customization
+   */
+  async play(source, options) {
+    let queue = this.queues.get(options.guildId);
+    if (typeof source === "string") {
+      let result;
+      if (!queue) {
+        result = await this.search(source, options);
+      } else {
+        result = await queue.search(source, options.prefix);
+      }
+      if (result.type === "empty") {
+        throw new Error(`No results found for '${source}'`);
+      }
+      if (result.type === "error") {
+        throw new Error(result.data.message ?? result.data.cause, { cause: result.data });
+      }
+      source = result.type === "query" ? result.data[0] : result.data;
+    }
+    queue ??= await this.queues.create(options);
+    if (options.context !== void 0) {
+      Object.assign(queue.context, options.context);
+    }
+    queue.add(source, options.userData);
+    if (queue.stopped) {
+      await queue.resume();
+    }
+    return queue;
+  }
+  /**
+   * Jumps to the specified index in queue of a guild
+   * @param guildId Id of the guild
+   * @param index Index to jump to
+   */
+  async jump(guildId, index) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.jump(index);
+  }
+  /**
+   * Pauses the queue of a guild
+   * @param guildId Id of the guild
+   */
+  async pause(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.pause();
+  }
+  /**
+   * Plays the previous track in queue of a guild
+   * @param guildId Id of the guild
+   */
+  async previous(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.previous();
+  }
+  /**
+   * Resumes the queue of a guild
+   * @param guildId Id of the guild
+   */
+  async resume(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.resume();
+  }
+  /**
+   * Seeks to a position in the current track of a guild
+   * @param guildId Id of the guild
+   * @param ms Position in milliseconds
+   */
+  async seek(guildId, ms) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.seek(ms);
+  }
+  /**
+   * Enables or disables autoplay for the queue of a guild
+   * @param guildId Id of the guild
+   * @param autoplay Whether to enable autoplay
+   */
+  setAutoplay(guildId, autoplay) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.setAutoplay(autoplay);
+  }
+  /**
+   * Sets the repeat mode for the queue of a guild
+   * @param guildId Id of the guild
+   * @param repeatMode The repeat mode
+   */
+  setRepeatMode(guildId, repeatMode) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.setRepeatMode(repeatMode);
+  }
+  /**
+   * Sets the volume of the queue of a guild
+   * @param guildId Id of the guild
+   * @param volume The volume to set
+   */
+  async setVolume(guildId, volume) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.setVolume(volume);
+  }
+  /**
+   * Shuffles tracks for the queue of a guild
+   * @param guildId Id of the guild
+   * @param includePrevious Whether to pull previous tracks to current
+   */
+  shuffle(guildId, includePrevious) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.shuffle(includePrevious);
+  }
+  /**
+   * Plays the next track in queue of a guild
+   * @param guildId Id of the guild
+   */
+  async next(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.next();
+  }
+  /**
+   * Stops the queue of a guild
+   * @param guildId Id of the guild
+   */
+  async stop(guildId) {
+    const queue = this.queues.get(guildId);
+    if (!queue) {
+      throw new Error(`No queue found for guild '${guildId}'`);
+    }
+    return queue.stop();
+  }
+};
+
+export { AmazonMusicRegex, AnghamiRegex, AppleMusicRegex, AudioFileRegex, AudiomackRegex, AudiusRegex, AutoplayPlugin, BandcampRegex, CloseCodes, DeezerRegex, DefaultFilterOptions, DefaultNodeOptions, DefaultPlayerOptions, DefaultQueueOptions, DefaultRestOptions, EQPresets, FairPlayPlugin, FilterManager, GaanaRegex, HttpStatusCodes, InstagramRegex, JioSaavnRegex, LavalinkNode, LookupSymbol, LyricsPlugin, MemoryQueueStore, MixcloudRegex, LavalinkNode as Node, NodeManager, OnEventUpdateSymbol, OnPingUpdateSymbol, OnStateUpdateSymbol, OnVoiceCloseSymbol, PACKAGE_INFO, PandoraRegex, Player, PlayerPlugin, Playlist, QobuzRegex, Queue, QueueManager, QueuePersistencePlugin, REST, Routes, ShazamRegex, SnowflakeRegex, SoundCloudRegex, SponsorBlockPlugin, SpotifyRegex, TidalRegex, Track, TwitchRegex, UpdateSymbol, UrlRegex, VoiceManager, VoiceRegion, VoiceRegionIdRegex, VoiceState, WebSocketCloseCodes, YandexMusicRegex, YoutubeRegex, assert, chunk, clamp, formatDuration, getEQPreset, getEQPresetNames, isArray, isBoolean, isError, isFunction, isNullish, isNumber, isRecord, isSnowflake, isString, isUrl, isValidEQPreset, CLIENT_NAME as name, noop, parseDuration, randomElement, retry, shuffle, sleep, unique, validateNodeOptions, validatePlayerOptions, CLIENT_VERSION as version };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map