aqualink 2.11.8 → 2.11.9

package/build/structures/Aqua.js

@@ -19,6 +19,17 @@ const EMPTY_TRACKS_RESPONSE = Object.freeze({
   tracks: EMPTY_ARRAY
 })
 
+const CLEANUP_INTERVAL = 180000
+const MAX_CONCURRENT_OPS = 10
+const BROKEN_PLAYER_TTL = 300000
+const FAILOVER_CLEANUP_TTL = 600000
+const PLAYER_BATCH_SIZE = 20
+const SEEK_DELAY = 120
+const RECONNECT_DELAY = 400
+const CACHE_VALID_TIME = 12000
+const NODE_TIMEOUT = 30000
+
+const URL_PATTERN = /^https?:\/\//i
 const DEFAULT_OPTIONS = Object.freeze({
   shouldDeleteMessage: false,
   defaultSearchPlatform: 'ytsearch',
@@ -27,10 +38,7 @@ const DEFAULT_OPTIONS = Object.freeze({
   plugins: [],
   autoResume: true,
   infiniteReconnects: true,
-  urlFilteringEnabled: false,
-  restrictedDomains: [],
-  allowedDomains: [],
-  loadBancer: 'leastLoad', // cpu, memory, rest: leastLoad, only rest: leastRest, no check: random
+  loadBalancer: 'leastLoad',
   failoverOptions: Object.freeze({
     enabled: true,
     maxRetries: 3,
@@ -42,34 +50,20 @@ const DEFAULT_OPTIONS = Object.freeze({
   })
 })
 
-const CLEANUP_INTERVAL = 180000
-const MAX_CONCURRENT_OPS = 10
-const BROKEN_PLAYER_TTL = 300000
-const FAILOVER_CLEANUP_TTL = 600000
-const PLAYER_BATCH_SIZE = 20
-const SEEK_DELAY = 120
-const RECONNECT_DELAY = 400
-const CACHE_VALID_TIME = 12000
-const NODE_TIMEOUT = 30000
-const URL_PATTERN = /^https?:\/\//i
 
-const _normalizeHost = (h) => {
-  if (!h) return ''
-  h = h.toLowerCase()
-  if (h.startsWith('www.')) h = h.slice(4)
-  return h.endsWith('.') ? h.slice(0, -1) : h
+const _isProbablyUrl = (s) => typeof s === 'string' && s.length > 8 && URL_PATTERN.test(s)
+const _delay = (ms) => new Promise(r => setTimeout(r, ms))
+const _range = (start, end, step = 1) => {
+  const result = []
+  for (let i = start; i < end; i += step) result.push(i)
+  return result
 }
 
-const _hostMatchesSuffix = (host, suffix) => {
-  host = _normalizeHost(host)
-  suffix = _normalizeHost(suffix)
-  return host === suffix || host.endsWith('.' + suffix)
+const _unref = (timer) => {
+  if (timer && typeof timer.unref === 'function') timer.unref()
+  return timer
 }
 
-const _isProbablyUrl = (s) => typeof s === 'string' && s.length > 8 && URL_PATTERN.test(s)
-
-const _delay = (ms) => new Promise(resolve => setTimeout(resolve, ms))
-
 class Aqua extends EventEmitter {
   constructor(client, nodes, options = {}) {
     super()
@@ -84,20 +78,22 @@ class Aqua extends EventEmitter {
     this.initiated = false
     this.version = pkgVersion
 
-    this.options = Object.assign({}, DEFAULT_OPTIONS, options)
-    this.failoverOptions = Object.assign({}, DEFAULT_OPTIONS.failoverOptions, options.failoverOptions)
-    this.shouldDeleteMessage = this.options.shouldDeleteMessage
-    this.defaultSearchPlatform = this.options.defaultSearchPlatform
-    this.leaveOnEnd = this.options.leaveOnEnd
-    this.restVersion = this.options.restVersion || 'v4'
-    this.plugins = this.options.plugins
-    this.autoResume = this.options.autoResume
-    this.infiniteReconnects = this.options.infiniteReconnects
-    this.urlFilteringEnabled = this.options.urlFilteringEnabled
-    this.restrictedDomains = this.options.restrictedDomains || []
-    this.allowedDomains = this.options.allowedDomains || []
-    this.loadBalancer = this.options.loadBalancer
-    this.send = this.options.send || this._createDefaultSend()
+    this.options = { ...DEFAULT_OPTIONS, ...options }
+    this.failoverOptions = { ...DEFAULT_OPTIONS.failoverOptions, ...options.failoverOptions }
+
+    const opts = this.options
+    this.shouldDeleteMessage = opts.shouldDeleteMessage
+    this.defaultSearchPlatform = opts.defaultSearchPlatform
+    this.leaveOnEnd = opts.leaveOnEnd
+    this.restVersion = opts.restVersion || 'v4'
+    this.plugins = opts.plugins
+    this.autoResume = opts.autoResume
+    this.infiniteReconnects = opts.infiniteReconnects
+    this.urlFilteringEnabled = opts.urlFilteringEnabled
+    this.restrictedDomains = opts.restrictedDomains || []
+    this.allowedDomains = opts.allowedDomains || []
+    this.loadBalancer = opts.loadBalancer
+    this.send = opts.send || this._createDefaultSend()
 
     this._nodeStates = new Map()
     this._failoverQueue = new Map()
@@ -109,97 +105,70 @@ class Aqua extends EventEmitter {
     this._nodeLoadCache = new Map()
     this._nodeLoadCacheTime = new Map()
 
-    this.on('nodeReady', (node, { resumed }) => {
-      for (const player of this.players.values()) {
-        if (player.nodes === node && player.connection) {
-          player.connection.resendVoiceUpdate({ resume: !!resumed })
-        }
-      }
-    })
-
+    this.on('nodeReady', this._onNodeReady.bind(this))
     this._bindEventHandlers()
     this._startCleanupTimer()
   }
 
-  _getDomainLists() {
-    if (this._domainLists) return this._domainLists
-
-    const allowedHostSuffixes = []
-    const allowedRegexes = []
-    for (const d of this.allowedDomains) {
-      if (!d) continue
-      if (d instanceof RegExp) allowedRegexes.push(d)
-      else allowedHostSuffixes.push(_normalizeHost(String(d)))
+  _onNodeReady(node, { resumed }) {
+    if (!resumed) return
+    const playersToUpdate = []
+    for (const player of this.players.values()) {
+      if (player.nodes === node && player.connection) playersToUpdate.push(player)
     }
-
-    const restrictedHostSuffixes = []
-    const restrictedRegexes = []
-    for (const d of this.restrictedDomains) {
-      if (!d) continue
-      if (d instanceof RegExp) restrictedRegexes.push(d)
-      else restrictedHostSuffixes.push(_normalizeHost(String(d)))
+    if (playersToUpdate.length) {
+      queueMicrotask(() => {
+        for (const player of playersToUpdate) {
+          player.connection.resendVoiceUpdate({ resume: true })
+        }
+      })
     }
-
-    this._domainLists = { allowedHostSuffixes, allowedRegexes, restrictedHostSuffixes, restrictedRegexes }
-    return this._domainLists
   }
 
   _createDefaultSend() {
     return packet => {
       const guildId = packet?.d?.guild_id
       if (!guildId) return
-      const guild = this.client.cache?.guilds?.get?.(guildId) ?? this.client.guilds?.cache?.get?.(guildId)
+      const guild = this.client.guilds?.cache?.get?.(guildId) || this.client.cache?.guilds?.get?.(guildId)
       if (!guild) return
       const gateway = this.client.gateway
-      if (gateway?.send) {
-        gateway.send(gateway.calculateShardId(guildId), packet)
-      } else if (guild.shard?.send) {
-        guild.shard.send(packet)
-      }
+      if (gateway?.send) gateway.send(gateway.calculateShardId(guildId), packet)
+      else if (guild.shard?.send) guild.shard.send(packet)
     }
   }
 
   _bindEventHandlers() {
     if (!this.autoResume) return
-    this._onNodeConnect = node => queueMicrotask(() => {
+    this._onNodeConnect = node => {
       this._invalidateCache()
-      this._rebuildBrokenPlayers(node)
-    })
-    this._onNodeDisconnect = node => queueMicrotask(() => {
+      queueMicrotask(() => this._rebuildBrokenPlayers(node))
+    }
+    this._onNodeDisconnect = node => {
       this._invalidateCache()
-      this._storeBrokenPlayers(node)
-    })
+      queueMicrotask(() => this._storeBrokenPlayers(node))
+    }
     this.on('nodeConnect', this._onNodeConnect)
     this.on('nodeDisconnect', this._onNodeDisconnect)
   }
 
   _startCleanupTimer() {
-    this._cleanupTimer = setInterval(() => this._performCleanup(), CLEANUP_INTERVAL)
-    if (this._cleanupTimer.unref) this._cleanupTimer.unref()
+    this._cleanupTimer = _unref(setInterval(() => this._performCleanup(), CLEANUP_INTERVAL))
   }
 
   get leastUsedNodes() {
     const now = Date.now()
-    if (this._leastUsedNodesCache && (now - this._leastUsedNodesCacheTime) < CACHE_VALID_TIME) { return this._leastUsedNodesCache }
+    if (this._leastUsedNodesCache && (now - this._leastUsedNodesCacheTime) < CACHE_VALID_TIME) {
+      return this._leastUsedNodesCache
+    }
     const connected = []
-    for (const node of this.nodeMap.values()) { if (node.connected) connected.push(node) }
-    let sorted
-    switch (this.options.loadBancer) {
-      case 'leastRest':
-        sorted = connected.slice().sort((a, b) => {
-          const restA = a?.rest?.calls || 0
-          const restB = b?.rest?.calls || 0
-          return restA - restB
-        })
-        break
-      case 'random':
-        sorted = Array.from(connected)
-        break
-      case 'leastLoad':
-      default:
-        sorted = connected.slice().sort((a, b) => this._getCachedNodeLoad(a) - this._getCachedNodeLoad(b))
-        break
+    for (const node of this.nodeMap.values()) {
+      if (node.connected) connected.push(node)
     }
+    const sorted = this.loadBalancer === 'leastRest'
+      ? connected.sort((a, b) => (a.rest?.calls || 0) - (b.rest?.calls || 0))
+      : this.loadBalancer === 'random'
+        ? connected.slice()
+        : connected.sort((a, b) => this._getCachedNodeLoad(a) - this._getCachedNodeLoad(b))
     this._leastUsedNodesCache = Object.freeze(sorted)
     this._leastUsedNodesCacheTime = now
     return this._leastUsedNodesCache
@@ -214,9 +183,7 @@ class Aqua extends EventEmitter {
     const nodeId = node.name || node.host
     const now = Date.now()
     const cacheTime = this._nodeLoadCacheTime.get(nodeId)
-    if (cacheTime && (now - cacheTime) < 5000) {
-      return this._nodeLoadCache.get(nodeId) || 0
-    }
+    if (cacheTime && (now - cacheTime) < 5000) return this._nodeLoadCache.get(nodeId) || 0
     const load = this._calculateNodeLoad(node)
     this._nodeLoadCache.set(nodeId, load)
     this._nodeLoadCacheTime.set(nodeId, now)
@@ -227,27 +194,23 @@ class Aqua extends EventEmitter {
     const stats = node?.stats
     if (!stats) return 0
     const cpu = stats.cpu
-    const cores = Math.max(1, cpu?.cores || 1)
-    const cpuLoad = cpu ? (cpu.systemLoad / cores) : 0
+    const cpuLoad = cpu ? (cpu.systemLoad / Math.max(1, cpu.cores || 1)) : 0
     const playing = stats.playingPlayers || 0
     const memory = stats.memory
-    const memoryUsage = memory ? (memory.used / Math.max(1, memory.reservable)) : 0
-    const restCalls = node?.rest?.calls || 0
-    return (cpuLoad * 100) + (playing * 0.75) + (memoryUsage * 40) + (restCalls * 0.001)
+    const memUsage = memory ? (memory.used / Math.max(1, memory.reservable)) : 0
+    const restCalls = node.rest?.calls || 0
+    return (cpuLoad * 100) + (playing * 0.75) + (memUsage * 40) + (restCalls * 0.001)
   }
 
   async init(clientId) {
     if (this.initiated) return this
     this.clientId = clientId
     if (!this.clientId) return
-    const results = await Promise.allSettled(
-      this.nodes.map(n =>
-        Promise.race([
-          this._createNode(n),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Node timeout')), NODE_TIMEOUT))
-        ])
-      )
-    )
+    const nodePromises = this.nodes.map(n => Promise.race([
+      this._createNode(n),
+      new Promise((_, reject) => setTimeout(() => reject(new Error('Node timeout')), NODE_TIMEOUT))
+    ]))
+    const results = await Promise.allSettled(nodePromises)
     const successCount = results.filter(r => r.status === 'fulfilled').length
     if (!successCount) throw new Error('No nodes connected')
     await this._loadPlugins()
@@ -257,15 +220,13 @@ class Aqua extends EventEmitter {
 
   async _loadPlugins() {
     if (!this.plugins?.length) return
-    await Promise.allSettled(
-      this.plugins.map(async plugin => {
-        try {
-          await plugin.load(this)
-        } catch (err) {
-          this.emit('error', null, new Error(`Plugin error: ${err?.message || String(err)}`))
-        }
-      })
-    )
+    await Promise.allSettled(this.plugins.map(async plugin => {
+      try {
+        await plugin.load(this)
+      } catch (err) {
+        this.emit('error', null, new Error(`Plugin error: ${err?.message || String(err)}`))
+      }
+    }))
   }
 
   async _createNode(options) {
@@ -290,7 +251,7 @@ class Aqua extends EventEmitter {
   _destroyNode(identifier) {
     const node = this.nodeMap.get(identifier)
     if (node) {
-      try { node.destroy?.() } catch { }
+      try { node.destroy?.() } catch {}
       this._cleanupNode(identifier)
       this.emit('nodeDestroy', node)
     }
@@ -340,18 +301,14 @@ class Aqua extends EventEmitter {
     const successes = []
     for (const i of _range(0, rebuilds.length, batchSize)) {
       const batch = rebuilds.slice(i, i + batchSize)
-      const results = await Promise.allSettled(
-        batch.map(({ guildId, brokenState }) =>
-          this._rebuildPlayer(brokenState, node).then(() => guildId)
-        )
-      )
+      const results = await Promise.allSettled(batch.map(({ guildId, brokenState }) =>
+        this._rebuildPlayer(brokenState, node).then(() => guildId)
+      ))
       for (const r of results) {
         if (r.status === 'fulfilled') successes.push(r.value)
       }
     }
-    for (const guildId of successes) {
-      this._brokenPlayers.delete(guildId)
-    }
+    for (const guildId of successes) this._brokenPlayers.delete(guildId)
     if (successes.length) this.emit('playersRebuilt', node, successes.length)
   }
 
@@ -370,12 +327,8 @@ class Aqua extends EventEmitter {
       if (current && player?.queue?.add) {
         player.queue.add(current)
         await player.play()
-        if (brokenState.position > 0) {
-          setTimeout(() => player.seek?.(brokenState.position), SEEK_DELAY)
-        }
-        if (brokenState.paused) {
-          await player.pause(true)
-        }
+        if (brokenState.position > 0) setTimeout(() => player.seek?.(brokenState.position), SEEK_DELAY)
+        if (brokenState.paused) await player.pause(true)
       }
       return player
     } finally {
@@ -407,9 +360,7 @@ class Aqua extends EventEmitter {
       if (!availableNodes.length) throw new Error('No failover nodes available')
       const results = await this._migratePlayersOptimized(affectedPlayers, availableNodes)
       const successful = results.filter(r => r.success).length
-      if (successful) {
-        this.emit('nodeFailoverComplete', failedNode, successful, results.length - successful)
-      }
+      if (successful) this.emit('nodeFailoverComplete', failedNode, successful, results.length - successful)
     } catch (error) {
       this.emit('error', null, new Error(`Failover failed: ${error?.message || String(error)}`))
     } finally {
@@ -489,27 +440,16 @@ class Aqua extends EventEmitter {
   async _restorePlayerState(newPlayer, playerState) {
     const operations = []
     if (typeof playerState.volume === 'number') {
-      if (typeof newPlayer.setVolume === 'function') {
-        operations.push(newPlayer.setVolume(playerState.volume))
-      } else {
-        newPlayer.volume = playerState.volume
-      }
-    }
-    if (playerState.queue?.length && newPlayer.queue?.add) {
-      newPlayer.queue.add(...playerState.queue)
+      if (typeof newPlayer.setVolume === 'function') operations.push(newPlayer.setVolume(playerState.volume))
+      else newPlayer.volume = playerState.volume
     }
+    if (playerState.queue?.length && newPlayer.queue?.add) newPlayer.queue.add(...playerState.queue)
     if (playerState.current && this.failoverOptions.preservePosition) {
-      if (newPlayer.queue?.add) {
-        newPlayer.queue.add(playerState.current, { toFront: true })
-      }
+      if (newPlayer.queue?.add) newPlayer.queue.add(playerState.current, { toFront: true })
       if (this.failoverOptions.resumePlayback) {
         operations.push(newPlayer.play())
-        if (playerState.position > 0) {
-          setTimeout(() => newPlayer.seek?.(playerState.position), SEEK_DELAY)
-        }
-        if (playerState.paused) {
-          operations.push(newPlayer.pause(true))
-        }
+        if (playerState.position > 0) setTimeout(() => newPlayer.seek?.(playerState.position), SEEK_DELAY)
+        if (playerState.paused) operations.push(newPlayer.pause(true))
       }
     }
     Object.assign(newPlayer, { repeat: playerState.repeat, shuffle: playerState.shuffle })
@@ -550,7 +490,7 @@ class Aqua extends EventEmitter {
     const existing = this.players.get(options.guildId)
     if (existing) {
       if (options.voiceChannel && existing.voiceChannel !== options.voiceChannel) {
-        try { existing.connect(options) } catch { }
+        try { existing.connect(options) } catch {}
       }
       return existing
     }
@@ -563,9 +503,7 @@ class Aqua extends EventEmitter {
 
   createPlayer(node, options) {
     const existing = this.players.get(options.guildId)
-    if (existing) {
-      try { existing.destroy?.() } catch { }
-    }
+    if (existing) try { existing.destroy?.() } catch {}
     const player = new Player(this, node, options)
     this.players.set(options.guildId, player)
     node?.players?.add?.(player)
@@ -578,9 +516,7 @@ class Aqua extends EventEmitter {
   _handlePlayerDestroy(player) {
     const node = player.nodes
     node?.players?.delete?.(player)
-    if (this.players.get(player.guildId) === player) {
-      this.players.delete(player.guildId)
-    }
+    if (this.players.get(player.guildId) === player) this.players.delete(player.guildId)
     this.emit('playerDestroy', player)
   }
 
@@ -591,89 +527,18 @@ class Aqua extends EventEmitter {
       this.players.delete(guildId)
       player.removeAllListeners?.()
       await player.destroy?.()
-    } finally { }
-  }
-
-  _isUrlAllowed(url) {
-    if (!this.urlFilteringEnabled || !_isProbablyUrl(url)) return true
-    const hostname = _safeGetHostname(url)
-    if (!hostname) return false
-    const { allowedHostSuffixes, allowedRegexes, restrictedHostSuffixes, restrictedRegexes } = this._getDomainLists()
-    if (allowedHostSuffixes.length || allowedRegexes.length) {
-      for (const rx of allowedRegexes) {
-        if (rx.test(hostname)) return true
-      }
-      for (const suffix of allowedHostSuffixes) {
-        if (_hostMatchesSuffix(hostname, suffix)) return true
-      }
-      return false
-    }
-    if (restrictedHostSuffixes.length || restrictedRegexes.length) {
-      for (const rx of restrictedRegexes) {
-        if (rx.test(hostname)) return false
-      }
-      for (const suffix of restrictedHostSuffixes) {
-        if (_hostMatchesSuffix(hostname, suffix)) return false
-      }
-    }
-    return true
-  }
-
-  _resolveSearchPlatform(source) {
-    if (!source) return this.defaultSearchPlatform
-    const normalized = source.toLowerCase().trim()
-    return SearchPlatforms.SEARCH_PLATFORMS[normalized] || source
-  }
-
-  _validateSourceRegex(urlStr) {
-    if (!_isProbablyUrl(urlStr)) return null
-    const parsed = _safeParseUrl(urlStr)
-    if (!parsed) return null
-    const { host, path } = parsed
-    if (/\.(mp3|m3u8?|mp4|m4a|wav|aacp)(?:$|\?)/i.test(path)) return 'http'
-    const hostMapping = {
-      'music.youtube.com': 'ytmsearch',
-      'youtu.be': 'ytsearch',
-      'youtube.com': 'ytsearch',
-      'soundcloud.com': 'scsearch',
-      'soundcloud.app.goo.gl': 'scsearch',
-      'open.spotify.com': 'spsearch',
-      'deezer.com': 'dzsearch',
-      'deezer.page.link': 'dzsearch',
-      'music.apple.com': 'amsearch',
-      'tidal.com': 'tdsearch',
-      'listen.tidal.com': 'tdsearch',
-      'jiosaavn.com': 'jssearch',
-      'music.yandex.ru': 'ymsearch',
-      'bandcamp.com': 'bcsearch'
-    }
-    for (const [hostSuffix, platform] of Object.entries(hostMapping)) {
-      if (host === hostSuffix || _hostMatchesSuffix(host, hostSuffix)) return platform
-    }
-    const linkHosts = ['twitch.tv', 'vimeo.com', 'tiktok.com', 'mixcloud.com', 'radiohost.de']
-    for (const linkHost of linkHosts) {
-      if (_hostMatchesSuffix(host, linkHost)) return 'link'
-    }
-    return null
+    } finally {}
   }
 
   async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
     if (!this.initiated) throw new Error('Aqua not initialized')
     const requestNode = this._getRequestNode(nodes)
     if (!requestNode) throw new Error('No nodes available')
-    if (this.restrictedDomains.length > 0) {
-      if (_isProbablyUrl(query) && !this._isUrlAllowed(query)) {
-        this.emit('debug', `Blocked URL by domain restrictions: ${query}`)
-        return EMPTY_TRACKS_RESPONSE
-      }
-    }
     const formattedQuery = _isProbablyUrl(query) ? query : `${source}${SEARCH_PREFIX}${query}`
     try {
       const endpoint = `/${this.restVersion}/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`
       const response = await requestNode.rest.makeRequest('GET', endpoint)
-      if (!response || response.loadType === 'empty' || response.loadType === 'NO_MATCHES') {
-        return EMPTY_TRACKS_RESPONSE
-      }
+      if (!response || response.loadType === 'empty' || response.loadType === 'NO_MATCHES') return EMPTY_TRACKS_RESPONSE
       return this._constructResponse(response, requester, requestNode)
     } catch (error) {
       throw new Error(error?.name === 'AbortError' ? 'Request timeout' : `Resolve failed: ${error?.message || String(error)}`)
@@ -714,42 +579,31 @@ class Aqua extends EventEmitter {
 
   _constructResponse(response, requester, requestNode) {
     const { loadType, data, pluginInfo: rootPluginInfo } = response || {}
-    const baseResponse = {
-      loadType,
-      exception: null,
-      playlistInfo: null,
-      pluginInfo: rootPluginInfo ?? {},
-      tracks: []
-    }
+    const baseResponse = { loadType, exception: null, playlistInfo: null, pluginInfo: rootPluginInfo || {}, tracks: [] }
     if (loadType === 'error' || loadType === 'LOAD_FAILED') {
-      baseResponse.exception = data ?? response.exception ?? null
+      baseResponse.exception = data || response.exception || null
       return baseResponse
     }
     const makeTrack = t => new Track(t, requester, requestNode)
     switch (loadType) {
-      case 'track': {
+      case 'track':
         if (data) {
-          baseResponse.pluginInfo = data.info?.pluginInfo ?? data.pluginInfo ?? baseResponse.pluginInfo
+          baseResponse.pluginInfo = data.info?.pluginInfo || data.pluginInfo || baseResponse.pluginInfo
           baseResponse.tracks.push(makeTrack(data))
         }
         break
-      }
-      case 'playlist': {
+      case 'playlist':
         if (data) {
-          const info = data.info ?? null
+          const info = data.info || null
           const thumbnail = data.pluginInfo?.artworkUrl || data.tracks?.[0]?.info?.artworkUrl || null
-          if (info) {
-            baseResponse.playlistInfo = { name: info.name || info.title, thumbnail, ...info }
-          }
-          baseResponse.pluginInfo = data.pluginInfo ?? baseResponse.pluginInfo
+          if (info) baseResponse.playlistInfo = { name: info.name || info.title, thumbnail, ...info }
+          baseResponse.pluginInfo = data.pluginInfo || baseResponse.pluginInfo
           baseResponse.tracks = Array.isArray(data.tracks) ? data.tracks.map(makeTrack) : []
         }
         break
-      }
-      case 'search': {
+      case 'search':
         baseResponse.tracks = Array.isArray(data) ? data.map(makeTrack) : []
         break
-      }
     }
     return baseResponse
   }
@@ -788,14 +642,12 @@ class Aqua extends EventEmitter {
           batch.length = 0
         }
       }
-      if (batch.length) {
-        await Promise.allSettled(batch.map(p => this._restorePlayer(p)))
-      }
+      if (batch.length) await Promise.allSettled(batch.map(p => this._restorePlayer(p)))
       await fs.promises.writeFile(filePath, '')
     } catch (error) {
       this.emit('debug', 'Aqua', `Load players error: ${error?.message || String(error)}`)
     } finally {
-      await fs.promises.unlink(lockFile).catch(() => { })
+      await fs.promises.unlink(lockFile).catch(() => {})
     }
   }
 
@@ -834,7 +686,7 @@ class Aqua extends EventEmitter {
     } catch (error) {
       this.emit('error', null, new Error(`Save players failed: ${error?.message || String(error)}`))
     } finally {
-      await fs.promises.unlink(lockFile).catch(() => { })
+      await fs.promises.unlink(lockFile).catch(() => {})
     }
   }
 
@@ -857,11 +709,8 @@ class Aqua extends EventEmitter {
       }
       if (p.u && validTracks[0]) {
         if (p.vol != null) {
-          if (typeof player.setVolume === 'function') {
-            await player.setVolume(p.vol)
-          } else {
-            player.volume = p.vol
-          }
+          if (typeof player.setVolume === 'function') await player.setVolume(p.vol)
+          else player.volume = p.vol
         }
         await player.play()
         if (p.p > 0) setTimeout(() => player.seek?.(p.p), SEEK_DELAY)
@@ -870,9 +719,7 @@ class Aqua extends EventEmitter {
       if (p.nw && p.t) {
         const channel = this.client.channels?.cache?.get(p.t)
         if (channel?.messages) {
-          try {
-            player.nowPlayingMessage = await channel.messages.fetch(p.nw).catch(() => null)
-          } catch { }
+          try { player.nowPlayingMessage = await channel.messages.fetch(p.nw).catch(() => null) } catch {}
         }
       }
     } catch (error) {
@@ -915,18 +762,18 @@ class Aqua extends EventEmitter {
 
   _performCleanup() {
     const now = Date.now()
-    const expiredGuilds = []
+    const expiredPlayers = []
     for (const [guildId, state] of this._brokenPlayers) {
-      if (now - state.brokenAt > BROKEN_PLAYER_TTL) expiredGuilds.push(guildId)
+      if (now - state.brokenAt > BROKEN_PLAYER_TTL) expiredPlayers.push(guildId)
     }
-    for (const g of expiredGuilds) this._brokenPlayers.delete(g)
+    for (const guildId of expiredPlayers) this._brokenPlayers.delete(guildId)
     const expiredNodes = []
     for (const [nodeId, ts] of this._lastFailoverAttempt) {
       if (now - ts > FAILOVER_CLEANUP_TTL) expiredNodes.push(nodeId)
     }
-    for (const n of expiredNodes) {
-      this._lastFailoverAttempt.delete(n)
-      this._failoverQueue.delete(n)
+    for (const nodeId of expiredNodes) {
+      this._lastFailoverAttempt.delete(nodeId)
+      this._failoverQueue.delete(nodeId)
     }
     if (this._nodeLoadCache.size > 50) {
       this._nodeLoadCache.clear()
@@ -947,13 +794,13 @@ class Aqua extends EventEmitter {
       this.off('nodeConnect', this._onNodeConnect)
       this.off('nodeDisconnect', this._onNodeDisconnect)
     }
-    const tasks = []
+    const destroyTasks = []
     for (const player of this.players.values()) {
       player.removeAllListeners?.()
-      tasks.push(Promise.resolve(player.destroy?.()).catch(() => { }))
+      if (player.destroy) destroyTasks.push(Promise.resolve(player.destroy()).catch(() => {}))
     }
     for (const node of this.nodeMap.values()) {
-      tasks.push(Promise.resolve(node.destroy?.()).catch(() => { }))
+      if (node.destroy) destroyTasks.push(Promise.resolve(node.destroy()).catch(() => {}))
     }
     this.players.clear()
     this.nodeMap.clear()
@@ -965,30 +812,7 @@ class Aqua extends EventEmitter {
     this._nodeLoadCacheTime.clear()
     this._leastUsedNodesCache = null
     this.removeAllListeners()
-    return Promise.all(tasks)
-  }
-}
-
-const _range = function* (start, end, step = 1) {
-  for (let i = start; i < end; i += step) {
-    yield i
-  }
-}
-
-const _safeGetHostname = (url) => {
-  try {
-    return _normalizeHost(new URL(url).hostname)
-  } catch {
-    return null
-  }
-}
-
-const _safeParseUrl = (url) => {
-  try {
-    const u = new URL(url)
-    return { host: _normalizeHost(u.hostname), path: u.pathname.toLowerCase() }
-  } catch {
-    return null
+    return Promise.all(destroyTasks)
   }
 }