discord-sb.js 1.0.5 → 1.0.7

package/README.md

@@ -1,21 +1,21 @@
-> [!IMPORTANT]
-> **This project is a fork of the [discord.js-selfbot-v13](https://github.com/aiko-chan-ai/discord.js-selfbot-v13) an archived project.**
+[!IMPORTANT]
+**This project is a fork of the [discord.js-selfbot-v13](https://github.com/aiko-chan-ai/discord.js-selfbot-v13) archived project.**
 
 # discord.js-selfbot-v13 (fork)
 
 Small additions focused on profile data and account integrations.
 
-## Nouveautés
-- Les fetchs de users remontent désormais la bio/pronoms quand disponible (via `/users/{id}/profile`).
-- `client.user.fetchConnections({ includeMetadata })` pour récupérer vos connexions (Spotify, Steam, etc.) avec métadonnées quand l’API les expose.
+## What's New
+- User fetches now include bio and pronouns when available (via `/users/{id}/profile`).
+- `client.user.fetchConnections({ includeMetadata })` returns your connections (Spotify, Steam, etc.) with metadata when the API exposes it.
 
-## Exemples rapides
+## Quick Examples
 ```js
-// Récupérer la bio d'un user
+// Fetch a user's bio and pronouns
 const user = await client.users.fetch('123456789012345678');
 console.log(user.bio, user.pronouns);
 
-// Lister vos connexions avec métadonnées
+// List your connections with metadata
 const connections = await client.user.fetchConnections();
 console.log(connections);
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-sb.js",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",
@@ -29,7 +29,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/sqlu/discord-selfbot.js.git"
+    "url": "git+https://github.com/sqlu/discord-sb.js.git"
   },
   "keywords": [
     "discord.js",
@@ -47,9 +47,9 @@
   "author": "Snayz",
   "license": "GNU General Public License v3.0",
   "bugs": {
-    "url": "https://github.com/sqlu/discord-selfbot.js/issues"
+    "url": "https://github.com/sqlu/discord-sb.js/issues"
   },
-  "homepage": "https://github.com/sqlu/discord-selfbot.js#readme",
+  "homepage": "https://github.com/sqlu/discord-sb.js#readme",
   "dependencies": {
     "@discordjs/builders": "^1.6.3",
     "@discordjs/collection": "^2.1.1",

package/src/client/Client.js

@@ -40,6 +40,7 @@ const DataResolver = require('../util/DataResolver');
 const Intents = require('../util/Intents');
 const DiscordAuthWebsocket = require('../util/RemoteAuth');
 const Sweepers = require('../util/Sweepers');
+const TOKEN_PREFIX_REGEX = /^(Bot|Bearer)\s*/i;
 
 /**
  * The main hub for interacting with the Discord API, and the starting point for any bot.
@@ -184,6 +185,19 @@ class Client extends BaseClient {
      */
     this.settings = new ClientUserSettingManager(this);
 
+    this._emojiCacheDirty = true;
+    this._emojiManager = null;
+    this._invalidateEmojiCache = () => {
+      this._emojiCacheDirty = true;
+    };
+    this.on(Events.GUILD_CREATE, this._invalidateEmojiCache);
+    this.on(Events.GUILD_DELETE, this._invalidateEmojiCache);
+    this.on(Events.GUILD_EMOJI_CREATE, this._invalidateEmojiCache);
+    this.on(Events.GUILD_EMOJI_DELETE, this._invalidateEmojiCache);
+    this.on(Events.GUILD_EMOJI_UPDATE, this._invalidateEmojiCache);
+    this.on(Events.GUILD_EMOJIS_UPDATE, this._invalidateEmojiCache);
+    this.on(Events.GUILD_UNAVAILABLE, this._invalidateEmojiCache);
+
     Object.defineProperty(this, 'token', { writable: true });
     if (!this.token && 'DISCORD_TOKEN' in process.env) {
       /**
@@ -240,9 +254,20 @@ class Client extends BaseClient {
    * @readonly
    */
   get emojis() {
+    if (this._emojiCacheDirty || !this._emojiManager) {
+      this._emojiManager = this._buildEmojiCache();
+      this._emojiCacheDirty = false;
+    }
+    return this._emojiManager;
+  }
+
+  _buildEmojiCache() {
     const emojis = new BaseGuildEmojiManager(this);
     for (const guild of this.guilds.cache.values()) {
-      if (guild.available) for (const emoji of guild.emojis.cache.values()) emojis.cache.set(emoji.id, emoji);
+      if (!guild.available) continue;
+      for (const emoji of guild.emojis.cache.values()) {
+        emojis.cache.set(emoji.id, emoji);
+      }
     }
     return emojis;
   }
@@ -274,7 +299,7 @@ class Client extends BaseClient {
    */
   async login(token = this.token) {
     if (!token || typeof token !== 'string') throw new Error('TOKEN_INVALID');
-    this.token = token = token.replace(/^(Bot|Bearer)\s*/i, '');
+    this.token = token = token.replace(TOKEN_PREFIX_REGEX, '');
     this.emit(
       Events.DEBUG,
       `
@@ -363,6 +388,16 @@ class Client extends BaseClient {
   destroy() {
     super.destroy();
 
+    if (this._invalidateEmojiCache) {
+      this.off(Events.GUILD_CREATE, this._invalidateEmojiCache);
+      this.off(Events.GUILD_DELETE, this._invalidateEmojiCache);
+      this.off(Events.GUILD_EMOJI_CREATE, this._invalidateEmojiCache);
+      this.off(Events.GUILD_EMOJI_DELETE, this._invalidateEmojiCache);
+      this.off(Events.GUILD_EMOJI_UPDATE, this._invalidateEmojiCache);
+      this.off(Events.GUILD_EMOJIS_UPDATE, this._invalidateEmojiCache);
+      this.off(Events.GUILD_UNAVAILABLE, this._invalidateEmojiCache);
+    }
+
     for (const fn of this._cleanups) fn();
     this._cleanups.clear();
 
@@ -370,6 +405,8 @@ class Client extends BaseClient {
 
     this.sweepers.destroy();
     this.ws.destroy();
+    this._emojiManager = null;
+    this._emojiCacheDirty = true;
     this.token = null;
   }
 
@@ -841,7 +878,7 @@ class Client extends BaseClient {
    * @returns {Promise<boolean>}
    */
   async installUserApps(applicationId, scopes = ['applications.commands']) {
-    const scope = Array.isArray(scopes) ? scopes.join(' ') : scopes;
+    const scope = typeof scopes === 'string' ? scopes : scopes.join(' ');
     await this.api.oauth2.authorize.post({
       query: {
         client_id: applicationId,

package/src/client/websocket/WebSocketManager.js

@@ -79,6 +79,7 @@ class WebSocketManager extends EventEmitter {
      * @name WebSocketManager#packetQueue
      */
     Object.defineProperty(this, 'packetQueue', { value: [] });
+    this._processingQueue = false;
 
     /**
      * The current status of this WebSocketManager
@@ -107,8 +108,11 @@ class WebSocketManager extends EventEmitter {
    * @readonly
    */
   get ping() {
-    const sum = this.shards.reduce((a, b) => a + b.ping, 0);
-    return sum / this.shards.size;
+    let total = 0;
+    for (const shard of this.shards.values()) {
+      total += shard.ping;
+    }
+    return this.shards.size ? total / this.shards.size : 0;
   }
 
   /**
@@ -315,8 +319,37 @@ class WebSocketManager extends EventEmitter {
     if (this.destroyed) return;
     this.debug(`Manager was destroyed. Called by:\n${new Error('MANAGER_DESTROYED').stack}`);
     this.destroyed = true;
-    this.shardQueue.clear();
-    for (const shard of this.shards.values()) shard.destroy({ closeCode: 1_000, reset: true, emit: false, log: false });
+   this.shardQueue.clear();
+   for (const shard of this.shards.values()) shard.destroy({ closeCode: 1_000, reset: true, emit: false, log: false });
+  }
+
+  _dispatchPacket(packet, shard) {
+    if (packet && PacketHandlers[packet.t]) {
+      PacketHandlers[packet.t](this.client, packet, shard);
+    } else if (packet) {
+      /**
+       * Emitted whenever a packet isn't handled.
+       * @event Client#unhandledPacket
+       * @param {Object} packet The packet (t: EVENT_NAME, d: any)
+       * @param {Number} shard The shard that received the packet (Shard 0)
+       */
+      this.client.emit(Events.UNHANDLED_PACKET, packet, shard);
+    }
+  }
+
+  _schedulePacketQueue() {
+    if (this._processingQueue || this.status !== Status.READY || !this.packetQueue.length) return;
+    this._processingQueue = true;
+    setImmediate(() => {
+      while (this.packetQueue.length && this.status === Status.READY) {
+        const { packet, shard } = this.packetQueue.shift();
+        this._dispatchPacket(packet, shard);
+      }
+      this._processingQueue = false;
+      if (this.packetQueue.length && this.status === Status.READY) {
+        this._schedulePacketQueue();
+      }
+    }).unref();
   }
 
   /**
@@ -327,30 +360,17 @@ class WebSocketManager extends EventEmitter {
    * @private
    */
   handlePacket(packet, shard) {
-    if (packet && this.status !== Status.READY) {
-      if (!BeforeReadyWhitelist.includes(packet.t)) {
-        this.packetQueue.push({ packet, shard });
-        return false;
-      }
+    if (packet && this.status !== Status.READY && !BeforeReadyWhitelist.includes(packet.t)) {
+      this.packetQueue.push({ packet, shard });
+      return false;
     }
 
-    if (this.packetQueue.length) {
-      const item = this.packetQueue.shift();
-      setImmediate(() => {
-        this.handlePacket(item.packet, item.shard);
-      }).unref();
+    if (packet) {
+      this._dispatchPacket(packet, shard);
     }
 
-    if (packet && PacketHandlers[packet.t]) {
-      PacketHandlers[packet.t](this.client, packet, shard);
-    } else if (packet) {
-      /**
-       * Emitted whenever a packet isn't handled.
-       * @event Client#unhandledPacket
-       * @param {Object} packet The packet (t: EVENT_NAME, d: any)
-       * @param {Number} shard The shard that received the packet (Shard 0)
-       */
-      this.client.emit(Events.UNHANDLED_PACKET, packet, shard);
+    if (this.status === Status.READY && this.packetQueue.length) {
+      this._schedulePacketQueue();
     }
 
     return true;

package/src/managers/CachedManager.js

@@ -51,19 +51,19 @@ class CachedManager extends DataManager {
   }
 
   _add(data, cache = true, { id, extras = [] } = {}) {
-    const existing = this.cache.get(id ?? data.id);
+    const entryId = id ?? data.id;
+    const existing = this.cache.get(entryId);
     if (existing) {
-      if (cache) {
+      if (typeof existing._patch === 'function') {
         existing._patch(data);
-        return existing;
       }
-      const clone = existing._clone();
-      clone._patch(data);
-      return clone;
+      if (cache) this.cache.set(entryId, existing);
+      return existing;
     }
 
     const entry = this.holds ? new this.holds(this.client, data, ...extras) : data;
-    if (cache) this.cache.set(id ?? entry.id, entry);
+    const cacheId = entryId ?? entry.id;
+    if (cache) this.cache.set(cacheId, entry);
     return entry;
   }
 }

package/src/managers/QuestManager.js

@@ -131,7 +131,11 @@ class QuestManager extends BaseManager {
    * @returns {Quest[]}
    */
   getExpired(date = new Date()) {
-    return this.list().filter(quest => quest.isExpired(date));
+    const expired = [];
+    for (const quest of this.cache.values()) {
+      if (quest.isExpired(date)) expired.push(quest);
+    }
+    return expired;
   }
 
   /**
@@ -139,7 +143,11 @@ class QuestManager extends BaseManager {
    * @returns {Quest[]}
    */
   getCompleted() {
-    return this.list().filter(quest => quest.isCompleted());
+    const completed = [];
+    for (const quest of this.cache.values()) {
+      if (quest.isCompleted()) completed.push(quest);
+    }
+    return completed;
   }
 
   /**
@@ -147,7 +155,13 @@ class QuestManager extends BaseManager {
    * @returns {Quest[]}
    */
   getClaimable() {
-    return this.list().filter(quest => quest.isCompleted() && !quest.hasClaimedRewards());
+    const claimable = [];
+    for (const quest of this.cache.values()) {
+      if (quest.isCompleted() && !quest.hasClaimedRewards()) {
+        claimable.push(quest);
+      }
+    }
+    return claimable;
   }
 
   /**
@@ -155,9 +169,13 @@ class QuestManager extends BaseManager {
    * @returns {Quest[]}
    */
   filterQuestsValid() {
-    return this.list().filter(
-      quest => quest.id !== '1412491570820812933' && !quest.isCompleted() && !quest.isExpired(),
-    );
+    const valid = [];
+    for (const quest of this.cache.values()) {
+      if (quest.id !== '1412491570820812933' && !quest.isCompleted() && !quest.isExpired()) {
+        valid.push(quest);
+      }
+    }
+    return valid;
   }
 
   /**

package/src/rest/RequestHandler.js

@@ -75,13 +75,38 @@ class RequestHandler {
   }
 
   get limited() {
-    return this.globalLimited || this.localLimited;
+    return this._getActiveRateLimit() !== null;
   }
 
   get _inactive() {
     return this.queue.remaining === 0 && !this.limited;
   }
 
+  _getActiveRateLimit(now = Date.now()) {
+    if (this.manager.globalRemaining <= 0 && now < this.manager.globalReset) {
+      const timeout = this.manager.globalReset + this.manager.client.options.restTimeOffset - now;
+      return { isGlobal: true, limit: this.manager.globalLimit, timeout };
+    }
+
+    if (this.remaining <= 0 && now < this.reset) {
+      const timeout = this.reset + this.manager.client.options.restTimeOffset - now;
+      return { isGlobal: false, limit: this.limit, timeout };
+    }
+
+    return null;
+  }
+
+  _getDelayPromise(isGlobal, timeout) {
+    const delay = Math.max(timeout, 0);
+    if (isGlobal) {
+      if (!this.manager.globalDelay) {
+        this.manager.globalDelay = this.globalDelayFor(delay);
+      }
+      return this.manager.globalDelay;
+    }
+    return sleep(delay);
+  }
+
   globalDelayFor(ms) {
     return new Promise(resolve => {
       setTimeout(() => {
@@ -116,32 +141,29 @@ class RequestHandler {
   }
 
   async execute(request, captchaKey, captchaToken) {
+    const hasRateLimitListener = this.manager.client.listenerCount(RATE_LIMIT) > 0;
+    const hasApiRequestListener = this.manager.client.listenerCount(API_REQUEST) > 0;
+    const hasApiResponseListener = this.manager.client.listenerCount(API_RESPONSE) > 0;
+    const invalidRequestInterval = this.manager.client.options.invalidRequestWarningInterval;
+    const hasInvalidRequestListener =
+      this.manager.client.listenerCount(INVALID_REQUEST_WARNING) > 0 && invalidRequestInterval > 0;
+
     /*
      * After calculations have been done, pre-emptively stop further requests
      * Potentially loop until this task can run if e.g. the global rate limit is hit twice
      */
-    while (this.limited) {
-      const isGlobal = this.globalLimited;
-      let limit, timeout, delayPromise;
-
-      if (isGlobal) {
-        // Set the variables based on the global rate limit
-        limit = this.manager.globalLimit;
-        timeout = this.manager.globalReset + this.manager.client.options.restTimeOffset - Date.now();
-      } else {
-        // Set the variables based on the route-specific rate limit
-        limit = this.limit;
-        timeout = this.reset + this.manager.client.options.restTimeOffset - Date.now();
-      }
+    for (let rateLimitState = this._getActiveRateLimit(); rateLimitState; rateLimitState = this._getActiveRateLimit()) {
+      const { isGlobal, limit, timeout } = rateLimitState;
+      const safeTimeout = Math.max(timeout, 0);
 
-      if (this.manager.client.listenerCount(RATE_LIMIT)) {
+      if (hasRateLimitListener) {
         /**
          * Emitted when the client hits a rate limit while making a request
          * @event BaseClient#rateLimit
          * @param {RateLimitData} rateLimitData Object containing the rate limit info
          */
         this.manager.client.emit(RATE_LIMIT, {
-          timeout,
+          timeout: safeTimeout,
           limit,
           method: request.method,
           path: request.path,
@@ -150,27 +172,19 @@ class RequestHandler {
         });
       }
 
-      if (isGlobal) {
-        // If this is the first task to reach the global timeout, set the global delay
-        if (!this.manager.globalDelay) {
-          // The global delay function should clear the global delay state when it is resolved
-          this.manager.globalDelay = this.globalDelayFor(timeout);
-        }
-        delayPromise = this.manager.globalDelay;
-      } else {
-        delayPromise = sleep(timeout);
-      }
+      const delayPromise = this._getDelayPromise(isGlobal, safeTimeout);
 
       // Determine whether a RateLimitError should be thrown
-      await this.onRateLimit(request, limit, timeout, isGlobal); // eslint-disable-line no-await-in-loop
+      await this.onRateLimit(request, limit, safeTimeout, isGlobal); // eslint-disable-line no-await-in-loop
 
       // Wait for the timeout to expire in order to avoid an actual 429
       await delayPromise; // eslint-disable-line no-await-in-loop
     }
 
     // As the request goes out, update the global usage information
-    if (!this.manager.globalReset || this.manager.globalReset < Date.now()) {
-      this.manager.globalReset = Date.now() + 1_000;
+    const now = Date.now();
+    if (!this.manager.globalReset || this.manager.globalReset < now) {
+      this.manager.globalReset = now + 1_000;
       this.manager.globalRemaining = this.manager.globalLimit;
     }
     this.manager.globalRemaining--;
@@ -185,7 +199,7 @@ class RequestHandler {
      * @property {number} retries The number of times this request has been attempted
      */
 
-    if (this.manager.client.listenerCount(API_REQUEST)) {
+    if (hasApiRequestListener) {
       /**
        * Emitted before every API request.
        * This event can emit several times for the same request, e.g. when hitting a rate limit.
@@ -217,7 +231,7 @@ class RequestHandler {
       return this.execute(request);
     }
 
-    if (this.manager.client.listenerCount(API_RESPONSE)) {
+    if (hasApiResponseListener) {
       /**
        * Emitted after every API request has received a response.
        * This event does not necessarily correlate to completion of the request, e.g. when hitting a rate limit.
@@ -278,16 +292,14 @@ class RequestHandler {
 
     // Count the invalid requests
     if (res.status === 401 || res.status === 403 || res.status === 429) {
-      if (!invalidCountResetTime || invalidCountResetTime < Date.now()) {
-        invalidCountResetTime = Date.now() + 1_000 * 60 * 10;
+      const invalidNow = Date.now();
+      if (!invalidCountResetTime || invalidCountResetTime < invalidNow) {
+        invalidCountResetTime = invalidNow + 1_000 * 60 * 10;
         invalidCount = 0;
       }
       invalidCount++;
 
-      const emitInvalid =
-        this.manager.client.listenerCount(INVALID_REQUEST_WARNING) &&
-        this.manager.client.options.invalidRequestWarningInterval > 0 &&
-        invalidCount % this.manager.client.options.invalidRequestWarningInterval === 0;
+      const emitInvalid = hasInvalidRequestListener && invalidCount % invalidRequestInterval === 0;
       if (emitInvalid) {
         /**
          * @typedef {Object} InvalidRequestWarningData
@@ -303,7 +315,7 @@ class RequestHandler {
          */
         this.manager.client.emit(INVALID_REQUEST_WARNING, {
           count: invalidCount,
-          remainingTime: invalidCountResetTime - Date.now(),
+          remainingTime: invalidCountResetTime - invalidNow,
         });
       }
     }
@@ -318,17 +330,16 @@ class RequestHandler {
     if (res.status >= 400 && res.status < 500) {
       // Handle ratelimited requests
       if (res.status === 429) {
-        const isGlobal = this.globalLimited;
-        let limit, timeout;
-        if (isGlobal) {
-          // Set the variables based on the global rate limit
-          limit = this.manager.globalLimit;
-          timeout = this.manager.globalReset + this.manager.client.options.restTimeOffset - Date.now();
-        } else {
-          // Set the variables based on the route-specific rate limit
-          limit = this.limit;
-          timeout = this.reset + this.manager.client.options.restTimeOffset - Date.now();
-        }
+        const rateLimitNow = Date.now();
+        const rateLimitState = this._getActiveRateLimit(rateLimitNow);
+        const isGlobal = rateLimitState?.isGlobal ?? this.globalLimited;
+        const limit = rateLimitState?.limit ?? (isGlobal ? this.manager.globalLimit : this.limit);
+        const computedTimeout =
+          rateLimitState?.timeout ??
+          (isGlobal
+            ? this.manager.globalReset + this.manager.client.options.restTimeOffset - rateLimitNow
+            : this.reset + this.manager.client.options.restTimeOffset - rateLimitNow);
+        const safeTimeout = Math.max(computedTimeout, 0);
 
         this.manager.client.emit(
           DEBUG,
@@ -338,11 +349,11 @@ class RequestHandler {
     Path    : ${request.path}
     Route   : ${request.route}
     Limit   : ${limit}
-    Timeout : ${timeout}ms
+    Timeout : ${safeTimeout}ms
     Sublimit: ${sublimitTimeout ? `${sublimitTimeout}ms` : 'None'}`,
         );
 
-        await this.onRateLimit(request, limit, timeout, isGlobal);
+        await this.onRateLimit(request, limit, safeTimeout, isGlobal);
 
         // If caused by a sublimit, wait it out here so other requests on the route can be handled
         if (sublimitTimeout) {

package/src/structures/Guild.js

@@ -1670,16 +1670,19 @@ class Guild extends AnonymousGuild {
    * guild.markRead([
    *   { channel_id: '123456789012345678', message_id: '987654321098765432' }
    * ]);
-   */
+  */
   async markRead(readStates = []) {
     // If no readStates provided, get all channels in guild
     if (readStates.length === 0) {
-      const channels = this.channels.cache.filter(c => c.isTextBased());
-      readStates = channels.map(channel => ({
-        channel_id: channel.id,
-        message_id: channel.lastMessageId || '0',
-        read_state_type: 0,
-      }));
+      readStates = [];
+      for (const channel of this.channels.cache.values()) {
+        if (!channel.isTextBased()) continue;
+        readStates.push({
+          channel_id: channel.id,
+          message_id: channel.lastMessageId || '0',
+          read_state_type: 0,
+        });
+      }
     }
 
     const data = await this.client.api['read-states']['ack-bulk'].post({

package/src/structures/Presence.js

@@ -142,7 +142,15 @@ class Presence extends Base {
 
   _clone() {
     const clone = Object.assign(Object.create(this), this);
-    clone.activities = this.activities.map(activity => activity._clone());
+    if (!this.activities.length) {
+      clone.activities = this.activities;
+      return clone;
+    }
+    const clonedActivities = [];
+    for (const activity of this.activities) {
+      clonedActivities.push(typeof activity._clone === 'function' ? activity._clone() : activity);
+    }
+    clone.activities = clonedActivities;
     return clone;
   }
 

package/src/util/Sweepers.js

@@ -33,29 +33,22 @@ class Sweepers {
      * A record of interval timeout that is used to sweep the indicated items, or null if not being swept
      * @type {Object<SweeperKey, ?Timeout>}
      */
-    this.intervals = Object.fromEntries(SweeperKeys.map(key => [key, null]));
+    this.intervals = {};
+    for (const key of SweeperKeys) {
+      this.intervals[key] = null;
+    }
+
+    /**
+     * Cached validated options to avoid recalculating filters
+     * @type {Map<string, Object>}
+     * @private
+     */
+    this._validatedOptions = new Map();
 
     for (const key of SweeperKeys) {
       if (!(key in options)) continue;
 
-      this._validateProperties(key);
-
-      const clonedOptions = { ...this.options[key] };
-
-      // Handle cases that have a "lifetime"
-      if (!('filter' in clonedOptions)) {
-        switch (key) {
-          case 'invites':
-            clonedOptions.filter = this.constructor.expiredInviteSweepFilter(clonedOptions.lifetime);
-            break;
-          case 'messages':
-            clonedOptions.filter = this.constructor.outdatedMessageSweepFilter(clonedOptions.lifetime);
-            break;
-          case 'threads':
-            clonedOptions.filter = this.constructor.archivedThreadSweepFilter(clonedOptions.lifetime);
-        }
-      }
-
+      const clonedOptions = this._getValidatedOptions(key);
       this._initInterval(key, `sweep${key[0].toUpperCase()}${key.slice(1)}`, clonedOptions);
     }
   }
@@ -124,6 +117,14 @@ class Sweepers {
     return this._sweepGuildDirectProp('members', filter, { outputName: 'guild members' }).items;
   }
 
+  _getTextChannels() {
+    const textChannels = [];
+    for (const channel of this.client.channels.cache.values()) {
+      if (channel.isText()) textChannels.push(channel);
+    }
+    return textChannels;
+  }
+
   /**
    * Sweeps all text-based channels' messages and removes the ones which are indicated by the filter.
    * @param {Function} filter The function used to determine which messages will be removed from the caches.
@@ -142,15 +143,13 @@ class Sweepers {
     if (typeof filter !== 'function') {
       throw new TypeError('INVALID_TYPE', 'filter', 'function');
     }
-    let channels = 0;
+    const textChannels = this._getTextChannels();
     let messages = 0;
 
-    for (const channel of this.client.channels.cache.values()) {
-      if (!channel.isText()) continue;
-
-      channels++;
+    for (const channel of textChannels) {
       messages += channel.messages.cache.sweep(filter);
     }
+    const channels = textChannels.length;
     this.client.emit(Events.CACHE_SWEEP, `Swept ${messages} messages in ${channels} text-based channels.`);
     return messages;
   }
@@ -173,19 +172,19 @@ class Sweepers {
     if (typeof filter !== 'function') {
       throw new TypeError('INVALID_TYPE', 'filter', 'function');
     }
-    let channels = 0;
+    const textChannels = this._getTextChannels();
     let messages = 0;
     let reactions = 0;
 
-    for (const channel of this.client.channels.cache.values()) {
-      if (!channel.isText()) continue;
-      channels++;
-
+    for (const channel of textChannels) {
       for (const message of channel.messages.cache.values()) {
+        const reactionCache = message.reactions?.cache;
+        if (!reactionCache?.size) continue;
         messages++;
-        reactions += message.reactions.cache.sweep(filter);
+        reactions += reactionCache.sweep(filter);
       }
     }
+    const channels = textChannels.length;
     this.client.emit(
       Events.CACHE_SWEEP,
       `Swept ${reactions} reactions on ${messages} messages in ${channels} text-based channels.`,
@@ -390,6 +389,34 @@ class Sweepers {
    * @private
    */
 
+  _getValidatedOptions(key) {
+    if (this._validatedOptions.has(key)) {
+      return this._validatedOptions.get(key);
+    }
+
+    this._validateProperties(key);
+    const clonedOptions = { ...this.options[key] };
+
+    if (!('filter' in clonedOptions)) {
+      switch (key) {
+        case 'invites':
+          clonedOptions.filter = this.constructor.expiredInviteSweepFilter(clonedOptions.lifetime);
+          break;
+        case 'messages':
+          clonedOptions.filter = this.constructor.outdatedMessageSweepFilter(clonedOptions.lifetime);
+          break;
+        case 'threads':
+          clonedOptions.filter = this.constructor.archivedThreadSweepFilter(clonedOptions.lifetime);
+          break;
+        default:
+          break;
+      }
+    }
+
+    this._validatedOptions.set(key, clonedOptions);
+    return clonedOptions;
+  }
+
   /**
    * Sweep a direct sub property of all guilds
    * @param {string} key The name of the property

package/typings/enums.d.ts

@@ -436,7 +436,7 @@ export const enum ApplicationType {
   CREATOR_MONETIZATION = 4,
 }
 
-export enum ClientEvents {
+export const enum ClientEvents {
   RateLimit = 'rateLimit',
   InvalidRequestWarning = 'invalidRequestWarning',
   ApiResponse = 'apiResponse',