cognova 0.2.6 → 0.2.7

package/.output/server/node_modules/discord.js/src/managers/MessageManager.js

@@ -1,368 +0,0 @@
-'use strict';
-
-const process = require('node:process');
-const { Collection } = require('@discordjs/collection');
-const { makeURLSearchParams } = require('@discordjs/rest');
-const { Routes } = require('discord-api-types/v10');
-const CachedManager = require('./CachedManager');
-const { DiscordjsTypeError, ErrorCodes } = require('../errors');
-const { Message } = require('../structures/Message');
-const MessagePayload = require('../structures/MessagePayload');
-const { MakeCacheOverrideSymbol } = require('../util/Symbols');
-const { resolvePartialEmoji } = require('../util/Util');
-
-let deprecationEmittedForFetchPinned = false;
-
-/**
- * Manages API methods for Messages and holds their cache.
- * @extends {CachedManager}
- * @abstract
- */
-class MessageManager extends CachedManager {
-  static [MakeCacheOverrideSymbol] = MessageManager;
-
-  constructor(channel, iterable) {
-    super(channel.client, Message, iterable);
-
-    /**
-     * The channel that the messages belong to
-     * @type {TextBasedChannels}
-     */
-    this.channel = channel;
-  }
-
-  /**
-   * The cache of Messages
-   * @type {Collection<Snowflake, Message>}
-   * @name MessageManager#cache
-   */
-
-  _add(data, cache) {
-    return super._add(data, cache);
-  }
-
-  /**
-   * Data that can be resolved to a Message object. This can be:
-   * * A Message
-   * * A Snowflake
-   * @typedef {Message|Snowflake} MessageResolvable
-   */
-
-  /**
-   * Options used to fetch a message.
-   * @typedef {BaseFetchOptions} FetchMessageOptions
-   * @property {MessageResolvable} message The message to fetch
-   */
-
-  /**
-   * Options used to fetch multiple messages.
-   * <info>The `before`, `after`, and `around` parameters are mutually exclusive.</info>
-   * @typedef {Object} FetchMessagesOptions
-   * @property {number} [limit] The maximum number of messages to return
-   * @property {Snowflake} [before] Consider only messages before this id
-   * @property {Snowflake} [after] Consider only messages after this id
-   * @property {Snowflake} [around] Consider only messages around this id
-   * @property {boolean} [cache] Whether to cache the fetched messages
-   */
-
-  /**
-   * Fetches message(s) from a channel.
-   * <info>The returned Collection does not contain reaction users of the messages if they were not cached.
-   * Those need to be fetched separately in such a case.</info>
-   * @param {MessageResolvable|FetchMessageOptions|FetchMessagesOptions} [options] Options for fetching message(s)
-   * @returns {Promise<Message|Collection<Snowflake, Message>>}
-   * @example
-   * // Fetch a message
-   * channel.messages.fetch('99539446449315840')
-   *   .then(message => console.log(message.content))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a maximum of 10 messages without caching
-   * channel.messages.fetch({ limit: 10, cache: false })
-   *   .then(messages => console.log(`Received ${messages.size} messages`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a maximum of 10 messages without caching around a message id
-   * channel.messages.fetch({ limit: 10, cache: false, around: '99539446449315840' })
-   *   .then(messages => console.log(`Received ${messages.size} messages`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch messages and filter by a user id
-   * channel.messages.fetch()
-   *   .then(messages => console.log(`${messages.filter(message =>
-   *          message.author.id === '84484653687267328').size} messages`))
-   *   .catch(console.error);
-   */
-  fetch(options) {
-    if (!options) return this._fetchMany();
-    const { message, cache, force } = options;
-    const resolvedMessage = this.resolveId(message ?? options);
-    if (resolvedMessage) return this._fetchSingle({ message: resolvedMessage, cache, force });
-    return this._fetchMany(options);
-  }
-
-  async _fetchSingle({ message, cache, force = false }) {
-    if (!force) {
-      const existing = this.cache.get(message);
-      if (existing && !existing.partial) return existing;
-    }
-
-    const data = await this.client.rest.get(Routes.channelMessage(this.channel.id, message));
-    return this._add(data, cache);
-  }
-
-  async _fetchMany({ cache, ...apiOptions } = {}) {
-    const data = await this.client.rest.get(Routes.channelMessages(this.channel.id), {
-      query: makeURLSearchParams(apiOptions),
-    });
-
-    return data.reduce((_data, message) => _data.set(message.id, this._add(message, cache)), new Collection());
-  }
-
-  /**
-   * Options used to fetch pinned messages.
-   *
-   * @typedef {Object} FetchPinnedMessagesOptions
-   * @property {DateResolvable} [before] Consider only pinned messages before this time
-   * @property {number} [limit] The maximum number of pinned messages to return
-   * @property {boolean} [cache] Whether to cache the pinned messages
-   */
-
-  /**
-   * Data returned from fetching pinned messages.
-   *
-   * @typedef {Object} FetchPinnedMessagesResponse
-   * @property {MessagePin[]} items The pinned messages
-   * @property {boolean} hasMore Whether there are additional pinned messages that require a subsequent call
-   */
-
-  /**
-   * Pinned message data returned from fetching pinned messages.
-   *
-   * @typedef {Object} MessagePin
-   * @property {Date} pinnedAt The time the message was pinned at
-   * @property {number} pinnedTimestamp The timestamp the message was pinned at
-   * @property {Message} message The pinned message
-   */
-
-  /**
-   * Fetches the pinned messages of this channel, returning a paginated result.
-   * <info>The returned messages do not contain any reaction data.
-   * Those need to be fetched separately.</info>
-   *
-   * @param {FetchPinnedMessagesOptions} [options={}] Options for fetching pinned messages
-   * @returns {Promise<FetchPinnedMessagesResponse>}
-   * @example
-   * // Get pinned messages
-   * channel.messages.fetchPins()
-   *   .then(messages => console.log(`Received ${messages.items.length} messages`))
-   *   .catch(console.error);
-   */
-  async fetchPins({ cache, ...apiOptions } = {}) {
-    const data = await this.client.rest.get(Routes.channelMessagesPins(this.channel.id), {
-      query: makeURLSearchParams({
-        ...apiOptions,
-        before: apiOptions.before && new Date(apiOptions.before).toISOString(),
-      }),
-    });
-
-    return {
-      items: data.items.map(item => ({
-        pinnedTimestamp: Date.parse(item.pinned_at),
-        get pinnedAt() {
-          return new Date(this.pinnedTimestamp);
-        },
-        message: this._add(item.message, cache),
-      })),
-      hasMore: data.has_more,
-    };
-  }
-
-  /**
-   * Fetches the pinned messages of this channel and returns a collection of them.
-   * <info>The returned Collection does not contain any reaction data of the messages.
-   * Those need to be fetched separately.</info>
-   * @param {boolean} [cache=true] Whether to cache the message(s)
-   * @deprecated Use {@link MessageManager#fetchPins} instead.
-   * @returns {Promise<Collection<Snowflake, Message>>}
-   */
-  async fetchPinned(cache = true) {
-    if (!deprecationEmittedForFetchPinned) {
-      process.emitWarning(
-        'The MessageManager#fetchPinned() method is deprecated. Use MessageManager#fetchPins() instead.',
-        'DeprecationWarning',
-      );
-
-      deprecationEmittedForFetchPinned = true;
-    }
-
-    const data = await this.client.rest.get(Routes.channelPins(this.channel.id));
-    const messages = new Collection();
-    for (const message of data) messages.set(message.id, this._add(message, cache));
-    return messages;
-  }
-
-  /**
-   * Resolves a {@link MessageResolvable} to a {@link Message} object.
-   * @method resolve
-   * @memberof MessageManager
-   * @instance
-   * @param {MessageResolvable} message The message resolvable to resolve
-   * @returns {?Message}
-   */
-
-  /**
-   * Resolves a {@link MessageResolvable} to a {@link Message} id.
-   * @method resolveId
-   * @memberof MessageManager
-   * @instance
-   * @param {MessageResolvable} message The message resolvable to resolve
-   * @returns {?Snowflake}
-   */
-
-  /**
-   * Data used to reference an attachment.
-   * @typedef {Object} MessageEditAttachmentData
-   * @property {Snowflake} id The id of the attachment
-   */
-
-  /**
-   * Options that can be passed to edit a message.
-   * @typedef {BaseMessageOptions} MessageEditOptions
-   * @property {Array<Attachment|MessageEditAttachmentData>} [attachments] An array of attachments to keep.
-   * All attachments will be kept if omitted
-   * @property {MessageFlags} [flags] Which flags to set for the message
-   * <info>Only the {@link MessageFlags.SuppressEmbeds} flag can be modified.</info>
-   */
-
-  /**
-   * Edits a message, even if it's not cached.
-   * @param {MessageResolvable} message The message to edit
-   * @param {string|MessageEditOptions|MessagePayload} options The options to edit the message
-   * @returns {Promise<Message>}
-   */
-  async edit(message, options) {
-    const messageId = this.resolveId(message);
-    if (!messageId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
-
-    const { body, files } = await (
-      options instanceof MessagePayload
-        ? options
-        : MessagePayload.create(message instanceof Message ? message : this, options)
-    )
-      .resolveBody()
-      .resolveFiles();
-    const d = await this.client.rest.patch(Routes.channelMessage(this.channel.id, messageId), { body, files });
-
-    const existing = this.cache.get(messageId);
-    if (existing) {
-      const clone = existing._clone();
-      clone._patch(d);
-      return clone;
-    }
-    return this._add(d);
-  }
-
-  /**
-   * Publishes a message in an announcement channel to all channels following it, even if it's not cached.
-   * @param {MessageResolvable} message The message to publish
-   * @returns {Promise<Message>}
-   */
-  async crosspost(message) {
-    message = this.resolveId(message);
-    if (!message) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
-
-    const data = await this.client.rest.post(Routes.channelMessageCrosspost(this.channel.id, message));
-    return this.cache.get(data.id) ?? this._add(data);
-  }
-
-  /**
-   * Pins a message to the channel's pinned messages, even if it's not cached.
-   * @param {MessageResolvable} message The message to pin
-   * @param {string} [reason] Reason for pinning
-   * @returns {Promise<void>}
-   */
-  async pin(message, reason) {
-    message = this.resolveId(message);
-    if (!message) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
-
-    await this.client.rest.put(Routes.channelMessagesPin(this.channel.id, message), { reason });
-  }
-
-  /**
-   * Unpins a message from the channel's pinned messages, even if it's not cached.
-   * @param {MessageResolvable} message The message to unpin
-   * @param {string} [reason] Reason for unpinning
-   * @returns {Promise<void>}
-   */
-  async unpin(message, reason) {
-    message = this.resolveId(message);
-    if (!message) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
-
-    await this.client.rest.delete(Routes.channelMessagesPin(this.channel.id, message), { reason });
-  }
-
-  /**
-   * Adds a reaction to a message, even if it's not cached.
-   * @param {MessageResolvable} message The message to react to
-   * @param {EmojiIdentifierResolvable} emoji The emoji to react with
-   * @returns {Promise<void>}
-   */
-  async react(message, emoji) {
-    message = this.resolveId(message);
-    if (!message) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
-
-    emoji = resolvePartialEmoji(emoji);
-    if (!emoji) throw new DiscordjsTypeError(ErrorCodes.EmojiType, 'emoji', 'EmojiIdentifierResolvable');
-
-    const emojiId = emoji.id
-      ? `${emoji.animated ? 'a:' : ''}${emoji.name}:${emoji.id}`
-      : encodeURIComponent(emoji.name);
-
-    await this.client.rest.put(Routes.channelMessageOwnReaction(this.channel.id, message, emojiId));
-  }
-
-  /**
-   * Deletes a message, even if it's not cached.
-   * @param {MessageResolvable} message The message to delete
-   * @returns {Promise<void>}
-   */
-  async delete(message) {
-    message = this.resolveId(message);
-    if (!message) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
-
-    await this.client.rest.delete(Routes.channelMessage(this.channel.id, message));
-  }
-
-  /**
-   * Ends a poll.
-   * @param {Snowflake} messageId The id of the message
-   * @returns {Promise<Message>}
-   */
-  async endPoll(messageId) {
-    const message = await this.client.rest.post(Routes.expirePoll(this.channel.id, messageId));
-    return this._add(message, false);
-  }
-
-  /**
-   * Options used for fetching voters of an answer in a poll.
-   * @typedef {BaseFetchPollAnswerVotersOptions} FetchPollAnswerVotersOptions
-   * @param {Snowflake} messageId The id of the message
-   * @param {number} answerId The id of the answer
-   */
-
-  /**
-   * Fetches the users that voted for a poll answer.
-   * @param {FetchPollAnswerVotersOptions} options The options for fetching the poll answer voters
-   * @returns {Promise<Collection<Snowflake, User>>}
-   */
-  async fetchPollAnswerVoters({ messageId, answerId, after, limit }) {
-    const voters = await this.client.rest.get(Routes.pollAnswerVoters(this.channel.id, messageId, answerId), {
-      query: makeURLSearchParams({ limit, after }),
-    });
-
-    return voters.users.reduce((acc, user) => acc.set(user.id, this.client.users._add(user, false)), new Collection());
-  }
-}
-
-module.exports = MessageManager;

package/.output/server/node_modules/discord.js/src/managers/PartialGroupDMMessageManager.js

@@ -1,17 +0,0 @@
-'use strict';
-
-const MessageManager = require('./MessageManager');
-
-/**
- * Manages API methods for messages in group direct message channels and holds their cache.
- * @extends {MessageManager}
- */
-class PartialGroupDMMessageManager extends MessageManager {
-  /**
-   * The channel that the messages belong to
-   * @name PartialGroupDMMessageManager#channel
-   * @type {PartialGroupDMChannel}
-   */
-}
-
-module.exports = PartialGroupDMMessageManager;

package/.output/server/node_modules/discord.js/src/managers/PermissionOverwriteManager.js

@@ -1,166 +0,0 @@
-'use strict';
-
-const process = require('node:process');
-const { Collection } = require('@discordjs/collection');
-const { OverwriteType, Routes } = require('discord-api-types/v10');
-const CachedManager = require('./CachedManager');
-const { DiscordjsTypeError, ErrorCodes } = require('../errors');
-const PermissionOverwrites = require('../structures/PermissionOverwrites');
-const { Role } = require('../structures/Role');
-
-let cacheWarningEmitted = false;
-
-/**
- * Manages API methods for guild channel permission overwrites and stores their cache.
- * @extends {CachedManager}
- */
-class PermissionOverwriteManager extends CachedManager {
-  constructor(channel, iterable) {
-    super(channel.client, PermissionOverwrites);
-    if (!cacheWarningEmitted && this._cache.constructor.name !== 'Collection') {
-      cacheWarningEmitted = true;
-      process.emitWarning(
-        `Overriding the cache handling for ${this.constructor.name} is unsupported and breaks functionality.`,
-        'UnsupportedCacheOverwriteWarning',
-      );
-    }
-
-    /**
-     * The channel of the permission overwrite this manager belongs to
-     * @type {GuildChannel}
-     */
-    this.channel = channel;
-
-    if (iterable) {
-      for (const item of iterable) {
-        this._add(item);
-      }
-    }
-  }
-
-  /**
-   * The cache of this Manager
-   * @type {Collection<Snowflake, PermissionOverwrites>}
-   * @name PermissionOverwriteManager#cache
-   */
-
-  _add(data, cache) {
-    return super._add(data, cache, { extras: [this.channel] });
-  }
-
-  /**
-   * Replaces the permission overwrites in this channel.
-   * @param {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} overwrites
-   * Permission overwrites the channel gets updated with
-   * @param {string} [reason] Reason for updating the channel overwrites
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * message.channel.permissionOverwrites.set([
-   *   {
-   *      id: message.author.id,
-   *      deny: [PermissionFlagsBits.ViewChannel],
-   *   },
-   * ], 'Needed to change permissions');
-   */
-  async set(overwrites, reason) {
-    if (!Array.isArray(overwrites) && !(overwrites instanceof Collection)) {
-      throw new DiscordjsTypeError(
-        ErrorCodes.InvalidType,
-        'overwrites',
-        'Array or Collection of Permission Overwrites',
-        true,
-      );
-    }
-    return this.channel.edit({ permissionOverwrites: overwrites, reason });
-  }
-
-  /**
-   * Extra information about the overwrite.
-   * @typedef {Object} GuildChannelOverwriteOptions
-   * @property {string} [reason] The reason for creating/editing this overwrite
-   * @property {OverwriteType} [type] The type of overwrite. Use this to bypass automatic resolution of `type`
-   * that results in an error for an uncached structure
-   */
-
-  /**
-   * Creates or edits permission overwrites for a user or role in this channel.
-   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
-   * @param {PermissionOverwriteOptions} options The options for the update
-   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
-   * @param {PermissionOverwrites} [existing] The existing overwrites to merge with this update
-   * @returns {Promise<GuildChannel>}
-   * @private
-   */
-  async upsert(userOrRole, options, overwriteOptions = {}, existing) {
-    let userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
-    let { type, reason } = overwriteOptions;
-    if (typeof type !== 'number') {
-      userOrRole = this.channel.guild.roles.resolve(userOrRole) ?? this.client.users.resolve(userOrRole);
-      if (!userOrRole) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'parameter', 'User nor a Role');
-      type = userOrRole instanceof Role ? OverwriteType.Role : OverwriteType.Member;
-    }
-
-    const { allow, deny } = PermissionOverwrites.resolveOverwriteOptions(options, existing);
-
-    await this.client.rest.put(Routes.channelPermission(this.channel.id, userOrRoleId), {
-      body: { id: userOrRoleId, type, allow, deny },
-      reason,
-    });
-    return this.channel;
-  }
-
-  /**
-   * Creates permission overwrites for a user or role in this channel, or replaces them if already present.
-   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
-   * @param {PermissionOverwriteOptions} options The options for the update
-   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * // Create or Replace permission overwrites for a message author
-   * message.channel.permissionOverwrites.create(message.author, {
-   *   SendMessages: false
-   * })
-   *   .then(channel => console.log(channel.permissionOverwrites.cache.get(message.author.id)))
-   *   .catch(console.error);
-   */
-  create(userOrRole, options, overwriteOptions) {
-    return this.upsert(userOrRole, options, overwriteOptions);
-  }
-
-  /**
-   * Edits permission overwrites for a user or role in this channel, or creates an entry if not already present.
-   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
-   * @param {PermissionOverwriteOptions} options The options for the update
-   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
-   * @returns {Promise<GuildChannel>}
-   * @example
-   * // Edit or Create permission overwrites for a message author
-   * message.channel.permissionOverwrites.edit(message.author, {
-   *   SendMessages: false
-   * })
-   *   .then(channel => console.log(channel.permissionOverwrites.cache.get(message.author.id)))
-   *   .catch(console.error);
-   */
-  edit(userOrRole, options, overwriteOptions) {
-    const existing = this.cache.get(
-      this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole),
-    );
-    return this.upsert(userOrRole, options, overwriteOptions, existing);
-  }
-
-  /**
-   * Deletes permission overwrites for a user or role in this channel.
-   * @param {UserResolvable|RoleResolvable} userOrRole The user or role to delete
-   * @param {string} [reason] The reason for deleting the overwrite
-   * @returns {Promise<GuildChannel>}
-   */
-  async delete(userOrRole, reason) {
-    const userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
-    if (!userOrRoleId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'parameter', 'User nor a Role');
-
-    await this.client.rest.delete(Routes.channelPermission(this.channel.id, userOrRoleId), { reason });
-    return this.channel;
-  }
-}
-
-module.exports = PermissionOverwriteManager;

package/.output/server/node_modules/discord.js/src/managers/PollAnswerVoterManager.js

@@ -1,50 +0,0 @@
-'use strict';
-
-const { Collection } = require('@discordjs/collection');
-const { makeURLSearchParams } = require('@discordjs/rest');
-const { Routes } = require('discord-api-types/v10');
-const CachedManager = require('./CachedManager.js');
-const User = require('../structures/User.js');
-
-/**
- * Manages API methods for users who voted on a poll and stores their cache.
- * @extends {CachedManager}
- */
-class PollAnswerVoterManager extends CachedManager {
-  constructor(answer) {
-    super(answer.client, User);
-
-    /**
-     * The poll answer that this manager belongs to
-     * @type {PollAnswer}
-     */
-    this.answer = answer;
-  }
-
-  /**
-   * The cache of this manager
-   * @type {Collection<Snowflake, User>}
-   * @name PollAnswerVoterManager#cache
-   */
-
-  /**
-   * Fetches the users that voted on this poll answer. Resolves with a collection of users, mapped by their ids.
-   * @param {BaseFetchPollAnswerVotersOptions} [options={}] Options for fetching the users
-   * @returns {Promise<Collection<Snowflake, User>>}
-   */
-  async fetch({ after, limit } = {}) {
-    const poll = this.answer.poll;
-    const query = makeURLSearchParams({ limit, after });
-    const data = await this.client.rest.get(Routes.pollAnswerVoters(poll.channelId, poll.messageId, this.answer.id), {
-      query,
-    });
-
-    return data.users.reduce((coll, rawUser) => {
-      const user = this.client.users._add(rawUser);
-      this.cache.set(user.id, user);
-      return coll.set(user.id, user);
-    }, new Collection());
-  }
-}
-
-exports.PollAnswerVoterManager = PollAnswerVoterManager;

package/.output/server/node_modules/discord.js/src/managers/PresenceManager.js

@@ -1,58 +0,0 @@
-'use strict';
-
-const CachedManager = require('./CachedManager');
-const { Presence } = require('../structures/Presence');
-
-/**
- * Manages API methods for Presences and holds their cache.
- * @extends {CachedManager}
- */
-class PresenceManager extends CachedManager {
-  constructor(client, iterable) {
-    super(client, Presence, iterable);
-  }
-
-  /**
-   * The cache of Presences
-   * @type {Collection<Snowflake, Presence>}
-   * @name PresenceManager#cache
-   */
-
-  _add(data, cache) {
-    return super._add(data, cache, { id: data.user.id });
-  }
-
-  /**
-   * Data that can be resolved to a Presence object. This can be:
-   * * A Presence
-   * * A UserResolvable
-   * * A Snowflake
-   * @typedef {Presence|UserResolvable|Snowflake} PresenceResolvable
-   */
-
-  /**
-   * Resolves a {@link PresenceResolvable} to a {@link Presence} object.
-   * @param {PresenceResolvable} presence The presence resolvable to resolve
-   * @returns {?Presence}
-   */
-  resolve(presence) {
-    const presenceResolvable = super.resolve(presence);
-    if (presenceResolvable) return presenceResolvable;
-    const userId = this.client.users.resolveId(presence);
-    return super.cache.get(userId) ?? null;
-  }
-
-  /**
-   * Resolves a {@link PresenceResolvable} to a {@link Presence} id.
-   * @param {PresenceResolvable} presence The presence resolvable to resolve
-   * @returns {?Snowflake}
-   */
-  resolveId(presence) {
-    const presenceResolvable = super.resolveId(presence);
-    if (presenceResolvable) return presenceResolvable;
-    const userId = this.client.users.resolveId(presence);
-    return this.cache.has(userId) ? userId : null;
-  }
-}
-
-module.exports = PresenceManager;