bakit 3.0.0 → 3.1.0

package/dist/index.cjs

@@ -1,672 +1,1135 @@
-'use strict';
-
-var gateway = require('@bakit/gateway');
-var rest = require('@bakit/rest');
-var service = require('@bakit/service');
-var utils = require('@bakit/utils');
-var EventEmitter = require('events');
-var collection = require('@discordjs/collection');
-var v10 = require('discord-api-types/v10');
-var tinyMixin = require('tiny-mixin');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
-var v10__namespace = /*#__PURE__*/_interopNamespace(v10);
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/modules/gateway.ts
+//#endregion
+let _bakit_gateway = require("@bakit/gateway");
+let _bakit_rest = require("@bakit/rest");
+let _bakit_service = require("@bakit/service");
+let _bakit_utils = require("@bakit/utils");
+let node_events = require("node:events");
+node_events = __toESM(node_events);
+let discord_api_types_v10 = require("discord-api-types/v10");
+discord_api_types_v10 = __toESM(discord_api_types_v10);
+let _discordjs_collection = require("@discordjs/collection");
+let tiny_mixin = require("tiny-mixin");
 
-// src/lib/structures/BaseStructure.ts
+//#region src/lib/structures/BaseStructure.ts
 var BaseStructure = class {
-  constructor(client) {
-    Object.defineProperty(this, "client", {
-      value: client,
-      enumerable: false,
-      writable: false
-    });
-  }
-  toJSON() {
-    return {};
-  }
-};
-var User = class extends BaseStructure {
-  constructor(client, data) {
-    super(client);
-    this.data = data;
-  }
-  get id() {
-    return this.data.id;
-  }
-  get username() {
-    return this.data.username;
-  }
-  get discriminator() {
-    return this.data.discriminator;
-  }
-  get globalName() {
-    return this.data.global_name;
-  }
-  get tag() {
-    return this.discriminator !== "0" && this.discriminator !== "0000" ? `${this.username}#${this.discriminator}` : this.username;
-  }
-  get displayName() {
-    return this.globalName ?? this.tag;
-  }
-  get avatar() {
-    return this.data.avatar ?? void 0;
-  }
-  get bot() {
-    return !!this.data.bot;
-  }
-  get system() {
-    return !!this.data.system;
-  }
-  get mfaEnabled() {
-    return this.data.mfa_enabled;
-  }
-  get locale() {
-    return this.data.locale;
-  }
-  get verified() {
-    return this.data.verified;
-  }
-  get email() {
-    return this.data.email;
-  }
-  get flags() {
-    return this.data.flags;
-  }
-  get premiumType() {
-    return this.data.premium_type;
-  }
-  get publicFlags() {
-    return this.data.public_flags;
-  }
-  get banner() {
-    return this.data.banner;
-  }
-  get accentColor() {
-    return this.data.accent_color ?? void 0;
-  }
-  get createdAt() {
-    return utils.getSnowflakeDate(this.id);
-  }
-  get createdTimestamp() {
-    return this.createdAt.getTime();
-  }
-  get hexAccentColor() {
-    return this.accentColor !== void 0 ? `#${this.accentColor.toString(16).padStart(6, "0")}` : void 0;
-  }
-  get defaultAvatarURL() {
-    return `https://cdn.discordapp.com/embed/avatars/${this.discriminator !== "0" && this.discriminator !== "0000" ? BigInt(this.discriminator) % 5n : (BigInt(this.id) >> 22n) % 6n}.png`;
-  }
-  getAvatarURL(options) {
-    if (!this.avatar)
-      return;
-    let isAnimated = this.avatar.startsWith("a_"), ext = options?.extension ?? (isAnimated ? "gif" : "png"), size = options?.size ? `?size=${options.size}` : "";
-    return `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.${ext}${size}`;
-  }
-  getDisplayAvatarURL(options) {
-    return this.getAvatarURL(options) ?? this.defaultAvatarURL;
-  }
-  equals(other) {
-    return typeof other == "string" ? other === this.id : other.id === this.id && other.username === this.username && other.discriminator === this.discriminator && other.bot === this.bot && other.createdTimestamp === this.createdTimestamp;
-  }
-  toJSON() {
-    return this.data;
-  }
-  toString() {
-    return `<@${this.id}>`;
-  }
+	constructor(client) {
+		Object.defineProperty(this, "client", {
+			value: client,
+			enumerable: false,
+			writable: false
+		});
+	}
+	toJSON() {
+		return {};
+	}
 };
 
-// src/lib/structures/Message.ts
-var Message = class extends BaseStructure {
-  constructor(client, data) {
-    super(client);
-    this.data = data;
-  }
-  cachedAuthor;
-  get partial() {
-    return typeof this.data.content != "string" || typeof this.data.author != "object";
-  }
-  get content() {
-    return this.data.content;
-  }
-  get id() {
-    return this.data.id;
-  }
-  get channelId() {
-    return this.data.channel_id;
-  }
-  get channel() {
-    return this.guild.channels.get(this.channelId);
-  }
-  get guildId() {
-    return "guild_id" in this.data ? this.data.guild_id : void 0;
-  }
-  get guild() {
-    return this.guildId ? this.client.guilds.get(this.guildId) : void 0;
-  }
-  get author() {
-    return this.cachedAuthor ??= new User(this.client, this.data.author), this.cachedAuthor;
-  }
-  get createdAt() {
-    return new Date(this.data.timestamp);
-  }
-  get editedAt() {
-    return this.data.edited_timestamp ? new Date(this.data.edited_timestamp) : void 0;
-  }
-  get createdTimestamp() {
-    return this.createdAt.getTime();
-  }
-  get editedTimestamp() {
-    return this.editedAt?.getTime();
-  }
-  get url() {
-    return `https://discord.com/channels/${this.guildId ?? "@me"}/${this.channelId}/${this.id}`;
-  }
-  async fetch() {
-    let message = await this.client.helper.fetchMessage(this.channelId, this.id);
-    return this.data = message.data, this.cachedAuthor = message.cachedAuthor, this;
-  }
-  async reply(options) {
-    return this.client.helper.replyMessage(this.channelId, this.id, options);
-  }
-  async sendToChannel(options) {
-    return this.client.helper.createMessage(this.channelId, options);
-  }
-  toJSON() {
-    return this.data;
-  }
-  toString() {
-    return this.data.content;
-  }
+//#endregion
+//#region src/lib/structures/User.ts
+var User = class extends BaseStructure {
+	constructor(client, data) {
+		super(client);
+		this.data = data;
+	}
+	get id() {
+		return this.data.id;
+	}
+	get username() {
+		return this.data.username;
+	}
+	get discriminator() {
+		return this.data.discriminator;
+	}
+	get globalName() {
+		return this.data.global_name;
+	}
+	get tag() {
+		return this.discriminator !== "0" && this.discriminator !== "0000" ? `${this.username}#${this.discriminator}` : this.username;
+	}
+	get displayName() {
+		return this.globalName ?? this.tag;
+	}
+	get avatar() {
+		return this.data.avatar ?? void 0;
+	}
+	get bot() {
+		return !!this.data.bot;
+	}
+	get system() {
+		return !!this.data.system;
+	}
+	get mfaEnabled() {
+		return this.data.mfa_enabled;
+	}
+	get locale() {
+		return this.data.locale;
+	}
+	get verified() {
+		return this.data.verified;
+	}
+	get email() {
+		return this.data.email;
+	}
+	get flags() {
+		return this.data.flags;
+	}
+	get premiumType() {
+		return this.data.premium_type;
+	}
+	get publicFlags() {
+		return this.data.public_flags;
+	}
+	get banner() {
+		return this.data.banner;
+	}
+	get accentColor() {
+		return this.data.accent_color ?? void 0;
+	}
+	get createdAt() {
+		return (0, _bakit_utils.getSnowflakeDate)(this.id);
+	}
+	get createdTimestamp() {
+		return this.createdAt.getTime();
+	}
+	get hexAccentColor() {
+		return this.accentColor !== void 0 ? `#${this.accentColor.toString(16).padStart(6, "0")}` : void 0;
+	}
+	get defaultAvatarURL() {
+		return `https://cdn.discordapp.com/embed/avatars/${this.discriminator !== "0" && this.discriminator !== "0000" ? BigInt(this.discriminator) % 5n : (BigInt(this.id) >> 22n) % 6n}.png`;
+	}
+	getAvatarURL(options) {
+		if (!this.avatar) return;
+		const isAnimated = this.avatar.startsWith("a_");
+		const ext = options?.extension ?? (isAnimated ? "gif" : "png");
+		const size = options?.size ? `?size=${options.size}` : "";
+		return `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.${ext}${size}`;
+	}
+	getDisplayAvatarURL(options) {
+		return this.getAvatarURL(options) ?? this.defaultAvatarURL;
+	}
+	equals(other) {
+		if (typeof other === "string") return other === this.id;
+		return other.id === this.id && other.username === this.username && other.discriminator === this.discriminator && other.bot === this.bot && other.createdTimestamp === this.createdTimestamp;
+	}
+	async createDM(force = false) {
+		return this.client.helper.createDM(this.id, force);
+	}
+	async send(options) {
+		return await (await this.createDM()).send(options);
+	}
+	_patch(data) {
+		this.data = {
+			...this.data,
+			...data
+		};
+	}
+	toJSON() {
+		return this.data;
+	}
+	toString() {
+		return `<@${this.id}>`;
+	}
 };
 
-// src/lib/structures/channel/BaseChannel.ts
+//#endregion
+//#region src/lib/structures/channel/BaseChannel.ts
 var BaseChannel = class extends BaseStructure {
-  constructor(client, data) {
-    super(client);
-    this.data = data;
-  }
-  get id() {
-    return this.data.id;
-  }
-  get type() {
-    return this.data.type;
-  }
-  toString() {
-    return `<#${this.id}>`;
-  }
-  toJSON() {
-    return this.data;
-  }
-  isTextBased() {
-    return "send" in this;
-  }
-  isVoiceBased() {
-    return "join" in this;
-  }
-  inGuild() {
-    return "guild_id" in this.data;
-  }
-  _patch(data) {
-    this.data = { ...this.data, ...data };
-  }
+	constructor(client, data) {
+		super(client);
+		this.data = data;
+	}
+	get id() {
+		return this.data.id;
+	}
+	get type() {
+		return this.data.type;
+	}
+	toString() {
+		return `<#${this.id}>`;
+	}
+	toJSON() {
+		return this.data;
+	}
+	isTextBased() {
+		return "send" in this;
+	}
+	isVoiceBased() {
+		return "join" in this;
+	}
+	isDM() {
+		return this.type === discord_api_types_v10.ChannelType.DM;
+	}
+	inGuild() {
+		return "guild_id" in this.data;
+	}
+	fetch() {
+		return this.client.helper.fetchChannel(this.id, true);
+	}
+	_patch(data) {
+		this.data = {
+			...this.data,
+			...data
+		};
+	}
 };
-var TextBasedChannelMixin = tinyMixin.createMixin((base) => {
-  class TextBasedChannel extends base {
-    send(options) {
-      return this.client.helper.createMessage(this.id, options);
-    }
-  }
-  return TextBasedChannel;
-}), VoiceBasedChannelMixin = tinyMixin.createMixin((base) => {
-  class VoiceBasedChannel extends base {
-  }
-  return VoiceBasedChannel;
-}), GuildChannelMixin = tinyMixin.createMixin((base) => {
-  class GuildChannel extends base {
-    get guildId() {
-      if (!this.data.guild_id)
-        throw new Error("This channel is not a guild channel");
-      return this.data.guild_id;
-    }
-    get guild() {
-      return this.client.guilds.get(this.guildId);
-    }
-  }
-  return GuildChannel;
+
+//#endregion
+//#region src/lib/mixins/ChannelMixin.ts
+const TextBasedChannelMixin = (0, tiny_mixin.createMixin)((base) => {
+	class TextBasedChannel extends base {
+		send(options) {
+			return this.client.helper.createMessage(this.id, options);
+		}
+	}
+	return TextBasedChannel;
+});
+const VoiceBasedChannelMixin = (0, tiny_mixin.createMixin)((base) => {
+	class VoiceBasedChannel extends base {}
+	return VoiceBasedChannel;
 });
-var GuildTextChannel = class extends tinyMixin.applyMixins(BaseChannel, [
-  GuildChannelMixin,
-  TextBasedChannelMixin
-]) {
+const GuildChannelMixin = (0, tiny_mixin.createMixin)((base) => {
+	class GuildChannel extends base {
+		get guildId() {
+			if (!this.data.guild_id) throw new Error("This channel is not a guild channel");
+			return this.data.guild_id;
+		}
+		get guild() {
+			return this.client.cache.guilds.get(this.guildId);
+		}
+	}
+	return GuildChannel;
+});
+
+//#endregion
+//#region src/lib/structures/channel/DMChannel.ts
+var DMChannel = class extends (0, tiny_mixin.applyMixins)(BaseChannel, [TextBasedChannelMixin]) {
+	#cachedRecipients;
+	constructor(client, data) {
+		super(client, data);
+	}
+	get recipients() {
+		if (!this.#cachedRecipients) {
+			this.#cachedRecipients = new _discordjs_collection.Collection();
+			for (const recipient of this.data.recipients ?? []) {
+				let user;
+				if (this.client.cache.isModuleEnabled("users")) user = this.client.cache.resolveLocal(this.client.cache.users.local, recipient.id, () => new User(this.client, recipient), (user) => user._patch(recipient));
+				else user = new User(this.client, recipient);
+				this.#cachedRecipients.set(recipient.id, user);
+			}
+		}
+		return this.#cachedRecipients;
+	}
+	get recipientId() {
+		const id = (this.data.recipients ?? []).find((user) => user.id !== this.client.user.id)?.id;
+		if (!id) throw new Error("No recipients found");
+		return id;
+	}
+	get recipient() {
+		const user = this.recipients.get(this.recipientId);
+		if (!user) throw new Error("Recipient not found");
+		return user;
+	}
+	async fetch() {
+		const data = await this.client.rest.post(discord_api_types_v10.Routes.userChannels(), { body: { recipient_id: this.recipientId } });
+		this._patch(data);
+		await this.#initRecipientsCache();
+		return this;
+	}
+	send(options) {
+		return super.send(options);
+	}
+	async fetchRecipients(force = false) {
+		if (!force && this.data.recipients?.length) {
+			await this.#initRecipientsCache();
+			return this.#cachedRecipients;
+		}
+		await this.fetch();
+		return this.#cachedRecipients;
+	}
+	async #initRecipientsCache() {
+		this.#cachedRecipients = new _discordjs_collection.Collection();
+		for (const recipient of this.data.recipients ?? []) {
+			let user;
+			if (this.client.cache.isModuleEnabled("users")) user = await this.client.cache.resolve(this.client.cache.users, recipient.id, () => new User(this.client, recipient), (user) => user._patch(recipient));
+			else user = new User(this.client, recipient);
+			this.#cachedRecipients.set(recipient.id, user);
+		}
+	}
+	_patch(data) {
+		super._patch(data);
+		this.#cachedRecipients = void 0;
+	}
 };
-var GuildVoiceChannel = class extends tinyMixin.applyMixins(BaseChannel, [
-  GuildChannelMixin,
-  TextBasedChannelMixin,
-  VoiceBasedChannelMixin
-]) {
+
+//#endregion
+//#region src/lib/structures/Message.ts
+var Message = class extends BaseStructure {
+	#cachedAuthor;
+	constructor(client, data) {
+		super(client);
+		this.data = data;
+		this.#ensureChannelCache();
+	}
+	get partial() {
+		return typeof this.data.content !== "string" || typeof this.data.author !== "object";
+	}
+	get content() {
+		return this.data.content;
+	}
+	get id() {
+		return this.data.id;
+	}
+	get channelId() {
+		return this.data.channel_id;
+	}
+	get channel() {
+		return this.#ensureChannelCache();
+	}
+	get guildId() {
+		return "guild_id" in this.data ? this.data.guild_id : void 0;
+	}
+	get guild() {
+		return this.guildId ? this.client.cache.guilds.get(this.guildId) : void 0;
+	}
+	/**
+	* The author of this message.
+	*
+	* **Note:** This property returns the cached `User` synchronously.
+	* It may be stale if the users cache has short lifetime or uses an asynchronous remote store.
+	* To ensure the author is up-to-date, use the `fetchAuthor()` method instead.
+	*/
+	get author() {
+		let author = this.#cachedAuthor;
+		if (!author && this.client.cache.isModuleEnabled("users")) author = this.client.cache.resolveLocal(this.client.cache.users.local, this.data.author.id, () => new User(this.client, this.data.author), (user) => user._patch(this.data.author));
+		if (!author) author = new User(this.client, this.data.author);
+		this.#cachedAuthor = author;
+		return this.#cachedAuthor;
+	}
+	get createdAt() {
+		return new Date(this.data.timestamp);
+	}
+	get editedAt() {
+		return this.data.edited_timestamp ? new Date(this.data.edited_timestamp) : void 0;
+	}
+	get createdTimestamp() {
+		return this.createdAt.getTime();
+	}
+	get editedTimestamp() {
+		return this.editedAt?.getTime();
+	}
+	get url() {
+		return `https://discord.com/channels/${this.guildId ?? "@me"}/${this.channelId}/${this.id}`;
+	}
+	inGuild() {
+		return this.guild !== void 0;
+	}
+	async fetch() {
+		const message = await this.client.helper.fetchMessage(this.channelId, this.id);
+		this.data = message.data;
+		this.#cachedAuthor = await this.client.cache.resolve(this.client.cache.users, message.data.author.id, () => new User(this.client, message.data.author));
+		return this;
+	}
+	/**
+	* Fetches the author of this message from cache or Discord API.
+	*
+	* **Note:** It is recommended to use this method instead of the `author` property
+	* if the users cache has short lifetime or is backed by an asynchronous remote cache.
+	*
+	* @param force - Whether to bypass the cache and force a request to the API.
+	* @returns A promise that resolves to the `User` who authored this message.
+	*/
+	async fetchAuthor(force = false) {
+		if (!force && this.client.cache.isModuleEnabled("users")) return this.client.cache.resolve(this.client.cache.users, this.data.author.id, () => new User(this.client, this.data.author), (user) => user._patch(this.data.author));
+		return this.client.helper.fetchUser(this.data.author.id, force);
+	}
+	async reply(options) {
+		return this.client.helper.replyMessage(this.channelId, this.id, options);
+	}
+	async sendToChannel(options) {
+		return this.client.helper.createMessage(this.channelId, options);
+	}
+	async edit(options) {
+		return this.client.helper.editMessage(this.channelId, this.id, options);
+	}
+	async _patch(data) {
+		this.data = {
+			...this.data,
+			...data
+		};
+		if (data.author && this.client.cache.isModuleEnabled("users")) if (this.client.cache.isModuleEnabled("users")) this.#cachedAuthor = await this.client.cache.resolve(this.client.cache.users, data.author.id, () => new User(this.client, data.author));
+		else this.#cachedAuthor?._patch(data.author);
+	}
+	#ensureChannelCache() {
+		const { client } = this;
+		let channel = client.cache.channels.get(this.channelId);
+		if (!channel) if (this.inGuild()) channel = this.guild.channels.get(this.channelId);
+		else {
+			channel = new DMChannel(client, {
+				id: this.channelId,
+				type: discord_api_types_v10.ChannelType.DM,
+				name: null,
+				recipients: [this.data.author, this.client.user.data]
+			});
+			console.log(channel);
+		}
+		if (!channel) throw new Error(`Channel not found: ${this.channelId}`);
+		client.cache.channels.set(this.channelId, channel);
+		return channel;
+	}
+	toJSON() {
+		return this.data;
+	}
+	toString() {
+		return this.data.content;
+	}
 };
+
+//#endregion
+//#region src/lib/structures/channel/GuildTextChannel.ts
+var GuildTextChannel = class extends (0, tiny_mixin.applyMixins)(BaseChannel, [GuildChannelMixin, TextBasedChannelMixin]) {};
+
+//#endregion
+//#region src/lib/structures/channel/GuildVoiceChannel.ts
+var GuildVoiceChannel = class extends (0, tiny_mixin.applyMixins)(BaseChannel, [
+	GuildChannelMixin,
+	TextBasedChannelMixin,
+	VoiceBasedChannelMixin
+]) {};
+
+//#endregion
+//#region src/lib/utils/channel.ts
 function createChannel(client, data) {
-  switch (data.type) {
-    case v10.ChannelType.GuildText:
-      return new GuildTextChannel(client, data);
-    case v10.ChannelType.GuildVoice:
-      return new GuildVoiceChannel(client, data);
-    default:
-      return null;
-  }
+	switch (data.type) {
+		case discord_api_types_v10.ChannelType.GuildText: return new GuildTextChannel(client, data);
+		case discord_api_types_v10.ChannelType.GuildVoice: return new GuildVoiceChannel(client, data);
+		case discord_api_types_v10.ChannelType.DM: return new DMChannel(client, data);
+		default: return null;
+	}
 }
 
-// src/lib/structures/Guild.ts
+//#endregion
+//#region src/lib/structures/Guild.ts
 var Guild = class extends BaseStructure {
-  constructor(client, data) {
-    super(client);
-    this.data = data;
-  }
-  cachedChannels;
-  get id() {
-    return this.data.id;
-  }
-  get name() {
-    return this.data.name;
-  }
-  get icon() {
-    return this.data.icon;
-  }
-  get banner() {
-    return this.data.banner;
-  }
-  get owner() {
-    return this.data.owner_id;
-  }
-  get mfaLevel() {
-    return this.data.mfa_level;
-  }
-  get verificationLevel() {
-    return this.data.verification_level;
-  }
-  get channels() {
-    if (!this.cachedChannels && (this.cachedChannels = new collection.Collection(), "channels" in this.data))
-      for (let data of this.data.channels) {
-        let channel = createChannel(this.client, data);
-        channel && this.cachedChannels.set(channel.id, channel);
-      }
-    return this.cachedChannels;
-  }
-  _patch(data) {
-    this.data = { ...this.data, ...data };
-  }
-  // public get roles() {
-  // 	return this.data.roles;
-  // }
+	channels = new _discordjs_collection.Collection();
+	constructor(client, data) {
+		super(client);
+		this.data = data;
+		this.#initChannels();
+	}
+	get id() {
+		return this.data.id;
+	}
+	get name() {
+		return this.data.name;
+	}
+	get icon() {
+		return this.data.icon;
+	}
+	get banner() {
+		return this.data.banner;
+	}
+	get owner() {
+		return this.data.owner_id;
+	}
+	get mfaLevel() {
+		return this.data.mfa_level;
+	}
+	get verificationLevel() {
+		return this.data.verification_level;
+	}
+	_patch(data) {
+		this.data = {
+			...this.data,
+			...data
+		};
+		this.#initChannels();
+	}
+	#initChannels() {
+		if (!("channels" in this.data)) return;
+		for (const id of this.channels.keys()) this.client.cache.channels.delete(id);
+		this.channels.clear();
+		for (const channelData of this.data.channels) {
+			const channel = createChannel(this.client, channelData);
+			if (channel) {
+				this.channels.set(channel.id, channel);
+				this.client.cache.channels.set(channel.id, channel);
+			}
+		}
+	}
 };
-var ClientHelper = class _ClientHelper {
-  constructor(client) {
-    Object.defineProperty(this, "client", {
-      value: client,
-      enumerable: false,
-      writable: false
-    });
-  }
-  async fetchMessage(channelId, messageId) {
-    let data = await this.client.rest.get(v10.Routes.channelMessage(channelId, messageId));
-    return new Message(this.client, data);
-  }
-  async deleteMessage(channelId, messageId) {
-    return this.client.rest.delete(v10.Routes.channelMessage(channelId, messageId));
-  }
-  async createMessage(channelId, options) {
-    return this.client.rest.post(v10.Routes.channelMessages(channelId), {
-      body: _ClientHelper.toAPICreateMessagePayload(options)
-    });
-  }
-  async replyMessage(channelId, messageId, options) {
-    return this.createMessage(channelId, {
-      ...options,
-      messageReference: {
-        channel_id: channelId,
-        message_id: messageId
-      }
-    });
-  }
-  async fetchGuild(guildId) {
-    let data = await this.client.rest.get(v10.Routes.guild(guildId));
-    return new Guild(this.client, data);
-  }
-  static toAPICreateMessagePayload(options) {
-    return {
-      content: options.content,
-      tts: options.tts,
-      embeds: options.embeds,
-      allowed_mentions: options.allowedMentions,
-      message_reference: options.messageReference,
-      flags: options.flags
-    };
-  }
+
+//#endregion
+//#region src/lib/client/ClientHelper.ts
+var ClientHelper = class ClientHelper {
+	constructor(client) {
+		Object.defineProperty(this, "client", {
+			value: client,
+			enumerable: false,
+			writable: false
+		});
+	}
+	async fetchUser(userId, force = false) {
+		let user;
+		if (this.client.cache.isModuleEnabled("users")) user = await this.client.cache.users.get(userId);
+		if (!user || force) {
+			const data = await this.client.rest.get(discord_api_types_v10.Routes.user(userId));
+			if (this.client.cache.isModuleEnabled("users")) user = await this.client.cache.resolve(this.client.cache.users, userId, () => new User(this.client, data), (u) => u._patch(data));
+			else user = new User(this.client, data);
+		}
+		return user;
+	}
+	async createDM(userId, force = false) {
+		if (!force) {
+			const channel = this.client.cache.channels.find((c) => c.isDM() && c.recipientId === userId);
+			if (channel && channel.isDM()) return channel;
+		}
+		const data = await this.client.rest.post(discord_api_types_v10.Routes.userChannels(), { body: { recipient_id: userId } });
+		const channel = new DMChannel(this.client, data);
+		await channel.fetchRecipients();
+		this.client.cache.channels.set(channel.id, channel);
+		return channel;
+	}
+	async fetchMessage(channelId, messageId, force = false) {
+		let message;
+		if (this.client.cache.isModuleEnabled("messages")) message = await this.client.cache.messages.get(messageId);
+		if (!message || force) {
+			const data = await this.client.rest.get(discord_api_types_v10.Routes.channelMessage(channelId, messageId));
+			if (this.client.cache.isModuleEnabled("messages")) message = await this.client.cache.resolve(this.client.cache.messages, messageId, () => new Message(this.client, data), (m) => m._patch(data));
+			else message = new Message(this.client, data);
+		}
+		return message;
+	}
+	async deleteMessage(channelId, messageId) {
+		await this.client.rest.delete(discord_api_types_v10.Routes.channelMessage(channelId, messageId));
+		if (this.client.cache.isModuleEnabled("messages")) await this.client.cache.messages.delete(messageId);
+	}
+	async createMessage(channelId, options) {
+		if (typeof options === "string") options = { content: options };
+		const data = this.client.rest.post(discord_api_types_v10.Routes.channelMessages(channelId), { body: ClientHelper.toAPICreateMessagePayload(options) });
+		const message = new Message(this.client, await data);
+		if (this.client.cache.isModuleEnabled("messages")) await this.client.cache.messages.set(message.id, message);
+		return message;
+	}
+	async editMessage(channelId, messageId, options) {
+		if (typeof options === "string") options = { content: options };
+		const data = await this.client.rest.patch(discord_api_types_v10.Routes.channelMessage(channelId, messageId), { body: ClientHelper.toAPICreateMessagePayload(options) });
+		let message;
+		if (this.client.cache.isModuleEnabled("messages")) message = await this.client.cache.resolve(this.client.cache.messages, messageId, () => new Message(this.client, data), (m) => m._patch(data));
+		else message = new Message(this.client, data);
+		return message;
+	}
+	async replyMessage(channelId, messageId, options) {
+		return this.createMessage(channelId, {
+			...options,
+			messageReference: {
+				channel_id: channelId,
+				message_id: messageId
+			}
+		});
+	}
+	async fetchGuild(guildId, force = false) {
+		let guild = this.client.cache.guilds.get(guildId);
+		if (!guild || force) {
+			const data = await this.client.rest.get(discord_api_types_v10.Routes.guild(guildId));
+			guild = new Guild(this.client, data);
+			this.client.cache.guilds.set(guildId, guild);
+		}
+		return guild;
+	}
+	async fetchChannel(channelId, force = false) {
+		let channel = this.client.cache.channels.get(channelId);
+		if (!channel || force) {
+			const data = await this.client.rest.get(discord_api_types_v10.Routes.channel(channelId));
+			channel = createChannel(this.client, data) ?? void 0;
+			if (!channel) throw new Error(`Channel not found: ${channelId}`);
+			this.client.cache.channels.set(channelId, channel);
+			if (channel.inGuild()) channel.guild.channels.set(channelId, channel);
+		}
+		return channel;
+	}
+	static toAPICreateMessagePayload(options) {
+		return {
+			content: options.content,
+			tts: options.tts,
+			embeds: options.embeds,
+			allowed_mentions: options.allowedMentions,
+			message_reference: options.messageReference,
+			flags: options.flags
+		};
+	}
 };
 
-// src/lib/client/Partial.ts
-var Partial = /* @__PURE__ */ ((Partial2) => (Partial2[Partial2.Message = 0] = "Message", Partial2[Partial2.User = 1] = "User", Partial2))(Partial || {});
-var IntentsBitField = class _IntentsBitField {
-  value;
-  constructor(input) {
-    this.value = _IntentsBitField.resolve(input);
-  }
-  static resolve(input) {
-    return Array.isArray(input) ? input.reduce((acc, intent) => acc | BigInt(intent), 0n) : BigInt(input);
-  }
-  has(intent) {
-    return (this.value & BigInt(intent)) !== 0n;
-  }
-  toBigInt() {
-    return this.value;
-  }
-  toNumber() {
-    return Number(this.value);
-  }
-  toJSON() {
-    return this.value.toString();
-  }
-  toString() {
-    return this.value.toString();
-  }
+//#endregion
+//#region src/lib/client/Partial.ts
+let Partial = /* @__PURE__ */ function(Partial) {
+	Partial[Partial["Message"] = 0] = "Message";
+	Partial[Partial["User"] = 1] = "User";
+	return Partial;
+}({});
+
+//#endregion
+//#region src/lib/utils/IntentsBitField.ts
+var IntentsBitField = class IntentsBitField {
+	value;
+	constructor(input) {
+		this.value = IntentsBitField.resolve(input);
+	}
+	static resolve(input) {
+		if (Array.isArray(input)) return input.reduce((acc, intent) => acc | BigInt(intent), 0n);
+		return BigInt(input);
+	}
+	has(intent) {
+		return (this.value & BigInt(intent)) !== 0n;
+	}
+	toBigInt() {
+		return this.value;
+	}
+	toNumber() {
+		return Number(this.value);
+	}
+	toJSON() {
+		return this.value.toString();
+	}
+	toString() {
+		return this.value.toString();
+	}
 };
 
-// src/lib/client/Client.ts
-var Client = class extends EventEmitter__default.default {
-  options;
-  shards;
-  rest;
-  helper;
-  guilds = new collection.Collection();
-  #user;
-  #ready = false;
-  constructor(options, rest$1) {
-    super();
-    let intents = options.intents instanceof IntentsBitField ? options.intents : new IntentsBitField(options.intents), sharding = {
-      shardsPerCluster: options.sharding?.shardsPerCluster ?? 1,
-      totalShards: options.sharding?.totalShards ?? 1
-    };
-    this.options = {
-      token: options.token,
-      intents,
-      sharding,
-      partials: new Set(options.partials ?? [])
-    }, this.rest = rest$1 ?? new rest.REST({ token: options.token }), this.shards = new gateway.ShardingManager(
-      {
-        ...this.options.sharding,
-        token: this.options.token,
-        intents: this.options.intents.toBigInt()
-      },
-      rest$1
-    ), this.helper = new ClientHelper(this), this.#setupShardsListeners();
-  }
-  get user() {
-    return this.#user;
-  }
-  async login() {
-    if (this.#user || this.shards.ready || this.shards.clusters.size > 0)
-      throw new Error("Cannot login twice");
-    return await this.shards.spawn(), new Promise((resolve, reject) => {
-      let cleanup = () => {
-        this.removeListener("ready", onReady), this.removeListener("error", onError);
-      }, onReady = () => {
-        cleanup(), resolve();
-      }, onError = (error) => {
-        cleanup(), reject(error);
-      };
-      this.once("ready", onReady), this.once("error", onError);
-    });
-  }
-  #setupShardsListeners() {
-    this.shards.on("dispatch", (_, shardId, payload) => this.#handleDispatch(shardId, payload)), this.shards.on("raw", (_, shardId, payload) => this.emit("raw", shardId, payload)), this.shards.once("ready", () => this.#tryEmitReady());
-  }
-  async #handleDispatch(shardId, payload) {
-    switch (this.emit("dispatch", shardId, payload), payload.t) {
-      case v10.GatewayDispatchEvents.Ready: {
-        this.#user ??= new User(this, payload.d.user), this.#tryEmitReady();
-        break;
-      }
-      case v10.GatewayDispatchEvents.MessageCreate: {
-        let message = new Message(this, payload.d);
-        if (message.partial && !this.options.partials.has(0 /* Message */))
-          return;
-        this.emit("messageCreate", message);
-        break;
-      }
-      case v10.GatewayDispatchEvents.MessageUpdate: {
-        let message = new Message(this, payload.d);
-        if (message.partial && !this.options.partials.has(0 /* Message */))
-          return;
-        this.emit("messageUpdate", message);
-        break;
-      }
-      case v10.GatewayDispatchEvents.MessageDelete: {
-        this.emit("messageDelete", {
-          id: payload.d.id,
-          channelId: payload.d.channel_id,
-          guildId: payload.d.guild_id
-        });
-        break;
-      }
-      case v10.GatewayDispatchEvents.UserUpdate: {
-        payload.d.id === this.#user?.id && (this.#user = new User(this, payload.d)), this.emit("userUpdate", new User(this, payload.d));
-        break;
-      }
-      case v10.GatewayDispatchEvents.GuildCreate: {
-        let guild = this.guilds.get(payload.d.id);
-        guild ? guild._patch(payload.d) : guild = new Guild(this, payload.d), this.guilds.set(payload.d.id, guild), payload.d.unavailable ? this.emit("guildCreate", guild) : this.emit("guildAvailable", guild);
-        break;
-      }
-      case v10.GatewayDispatchEvents.GuildDelete: {
-        let guild = this.guilds.get(payload.d.id);
-        if (!guild)
-          return;
-        this.guilds.delete(payload.d.id), this.emit("guildDelete", guild);
-        break;
-      }
-      case v10.GatewayDispatchEvents.GuildUpdate: {
-        let guild = this.guilds.get(payload.d.id);
-        guild ? guild._patch(payload.d) : (guild = new Guild(this, payload.d), this.guilds.set(payload.d.id, guild)), this.emit("guildUpdate", guild);
-        break;
-      }
-      case v10.GatewayDispatchEvents.ChannelCreate: {
-        let channel = createChannel(this, payload.d);
-        if (!channel)
-          return;
-        channel.inGuild() && channel.guild.channels.set(channel.id, channel), this.emit("channelCreate", channel);
-        break;
-      }
-      case v10.GatewayDispatchEvents.ChannelUpdate: {
-        let guild = this.guilds.get(payload.d.guild_id);
-        if (!guild)
-          return;
-        let channel = guild.channels.get(payload.d.id);
-        if (channel)
-          channel._patch(payload.d);
-        else {
-          if (channel = createChannel(this, payload.d), !channel)
-            return;
-          guild.channels.set(payload.d.id, channel);
-        }
-        this.emit("channelUpdate", channel);
-        break;
-      }
-      case v10.GatewayDispatchEvents.ChannelDelete: {
-        let guild = this.guilds.get(payload.d.guild_id);
-        if (!guild)
-          return;
-        let channel = guild.channels.get(payload.d.id);
-        if (!channel)
-          return;
-        guild.channels.delete(payload.d.id), this.emit("channelDelete", channel);
-        break;
-      }
-    }
-  }
-  /**
-   * We use this method to emit ready event only once since we have 2 ways to emit it.
-   * @private
-   */
-  #tryEmitReady() {
-    this.#ready || !this.#user || !this.shards.ready || (this.#ready = true, this.emit("ready", this.#user));
-  }
+//#endregion
+//#region src/lib/utils/cache/adapters/BaseCacheAdapter.ts
+var BaseCacheAdapter = class {};
+
+//#endregion
+//#region src/lib/utils/cache/adapters/LocalCacheAdapter.ts
+var LocalCacheAdapter = class extends BaseCacheAdapter {
+	collection = new _discordjs_collection.Collection();
+	#sweepTimer;
+	get(key) {
+		const entry = this.collection.get(key);
+		if (!entry) return;
+		if (entry.expiresAt && entry.expiresAt < Date.now()) {
+			this.collection.delete(key);
+			return;
+		}
+		this.#setupSweepTTL();
+		return entry.value;
+	}
+	set(key, value, ttl) {
+		const expiresAt = ttl ? Date.now() + ttl : void 0;
+		this.collection.set(key, {
+			value,
+			expiresAt
+		});
+		this.#setupSweepTTL();
+	}
+	delete(key) {
+		this.#setupSweepTTL();
+		this.collection.delete(key);
+	}
+	clear() {
+		this.collection.clear();
+		clearTimeout(this.#sweepTimer);
+		this.#sweepTimer = void 0;
+	}
+	has(key) {
+		this.#setupSweepTTL();
+		return this.get(key) !== void 0;
+	}
+	find(filter) {
+		for (const entry of this.collection.values()) if (filter(entry.value)) return entry.value;
+	}
+	sweep(filter) {
+		for (const [key, entry] of this.collection) if (filter(entry.value)) this.delete(key);
+	}
+	sweepTTL() {
+		for (const [key, entry] of this.collection) if (entry.expiresAt && entry.expiresAt < Date.now()) this.delete(key);
+	}
+	#setupSweepTTL() {
+		if (!this.collection.size) return;
+		if (this.#sweepTimer) return;
+		this.#sweepTimer = setTimeout(() => {
+			this.#sweepTimer = void 0;
+			this.sweepTTL();
+			this.#setupSweepTTL();
+		}, 1e3);
+	}
+};
+
+//#endregion
+//#region src/lib/utils/cache/HybridCache.ts
+var HybridCache = class {
+	local = new LocalCacheAdapter();
+	constructor(remote, defaultTTL) {
+		this.remote = remote;
+		this.defaultTTL = defaultTTL;
+	}
+	async get(key) {
+		const local = this.local.get(key);
+		if (local !== void 0) return local;
+		const remote = await this.remote?.get(key);
+		if (remote !== void 0) this.local.set(key, remote);
+		return remote;
+	}
+	async sweep(filter) {
+		this.local.sweep(filter);
+		await this.remote?.sweep(filter);
+	}
+	async set(key, value, ttl = this.defaultTTL) {
+		this.local.set(key, value, ttl);
+		await this.remote?.set(key, value, ttl);
+	}
+	async delete(key) {
+		this.local.delete(key);
+		await this.remote?.delete(key);
+	}
+	async clear() {
+		this.local.clear();
+		await this.remote?.clear();
+	}
+	async has(key) {
+		return await this.get(key) !== void 0;
+	}
+};
+
+//#endregion
+//#region src/lib/client/ClientCacheManager.ts
+var ClientCacheManager = class {
+	channels = new LocalCacheAdapter();
+	guilds = new LocalCacheAdapter();
+	#users;
+	#messages;
+	#sweepers = new _discordjs_collection.Collection();
+	constructor(options) {
+		this.options = options;
+	}
+	get users() {
+		let options;
+		if (typeof this.options.users === "object") options = this.options.users;
+		else options = { enabled: !!this.options.users };
+		if (!options.enabled) throw new Error("User cache is disabled");
+		if (!this.#users) this.#users = new HybridCache(options.adapter, options.ttl);
+		if (options.sweeper) this.#sweepers.set("users", setInterval(() => this.#users.sweep(options.sweeper.filter), options.sweeper.interval));
+		return this.#users;
+	}
+	get messages() {
+		let options;
+		if (typeof this.options.messages === "object") options = this.options.messages;
+		else options = { enabled: !!this.options.messages };
+		if (!options.enabled) throw new Error("Message cache is disabled");
+		if (!this.#messages) this.#messages = new HybridCache(options.adapter, options.ttl);
+		if (options.sweeper) this.#sweepers.set("messages", setInterval(() => this.#messages.sweep(options.sweeper.filter), options.sweeper.interval));
+		return this.#messages;
+	}
+	isModuleEnabled(module) {
+		return typeof this.options[module] === "object" ? this.options[module].enabled : !!this.options[module];
+	}
+	async resolve(cache, id, factory, patch) {
+		let value = await cache.get(id);
+		if (!value) {
+			value = factory();
+			await cache.set(id, value);
+		}
+		if (patch) patch(value);
+		return value;
+	}
+	resolveLocal(cache, id, factory, patch) {
+		let value = cache.get(id);
+		if (!value) {
+			value = factory();
+			cache.set(id, value);
+		}
+		if (patch) patch(value);
+		return value;
+	}
+};
+
+//#endregion
+//#region src/lib/client/dispatches/registry.ts
+const handlers = {};
+function registerHandler(event, handler) {
+	if (handlers[event]) throw new Error(`Handler for ${event} already registered`);
+	handlers[event] = handler;
+}
+
+//#endregion
+//#region src/lib/client/dispatches/handlers/message.ts
+async function onCreateAndUpdate$1(client, payload) {
+	let message;
+	if (client.cache.isModuleEnabled("messages")) message = await client.cache.resolve(client.cache.messages, payload.d.id, () => new Message(client, payload.d), (m) => m._patch(payload.d));
+	else message = new Message(client, payload.d);
+	if (message.partial && !client.options.partials.has(Partial.Message)) return;
+	client.emit(payload.t === discord_api_types_v10.GatewayDispatchEvents.MessageUpdate ? "messageUpdate" : "messageCreate", message);
+}
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.MessageCreate, onCreateAndUpdate$1);
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.MessageUpdate, onCreateAndUpdate$1);
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.MessageDelete, async (client, payload) => {
+	let message;
+	if (client.cache.isModuleEnabled("messages")) message = await client.cache.messages.get(payload.d.id);
+	if (!message) message = new Message(client, payload.d);
+	client.emit("messageDelete", message);
+});
+
+//#endregion
+//#region src/lib/client/dispatches/handlers/guild.ts
+async function onCreateAndUpdate(client, payload) {
+	const guild = await client.cache.resolve(client.cache.guilds, payload.d.id, () => new Guild(client, payload.d), (g) => g._patch(payload.d));
+	if (payload.t === discord_api_types_v10.GatewayDispatchEvents.GuildCreate) client.emit(payload.d.unavailable ? "guildCreate" : "guildAvailable", guild);
+	else client.emit("guildUpdate", guild);
+}
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.GuildCreate, onCreateAndUpdate);
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.GuildUpdate, onCreateAndUpdate);
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.GuildDelete, async (client, payload) => {
+	const guild = client.cache.guilds.get(payload.d.id);
+	if (!guild) return;
+	for (const channel of guild.channels.values()) client.cache.channels.delete(channel.id);
+	client.cache.guilds.delete(payload.d.id);
+	client.emit("guildDelete", guild);
+});
+
+//#endregion
+//#region src/lib/client/dispatches/handlers/channel.ts
+async function onCreateOrUpdate(client, payload) {
+	const channel = await client.cache.resolve(client.cache.channels, payload.d.id, () => createChannel(client, payload.d), (c) => c?._patch(payload.d));
+	if (!channel) return;
+	if (channel.inGuild() && !channel.guild.channels.has(channel.id)) channel.guild.channels.set(channel.id, channel);
+	client.emit(payload.t === discord_api_types_v10.GatewayDispatchEvents.ChannelCreate ? "channelCreate" : "channelUpdate", channel);
+}
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.ChannelCreate, onCreateOrUpdate);
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.ChannelUpdate, onCreateOrUpdate);
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.ChannelDelete, (client, payload) => {
+	const channel = client.cache.channels.get(payload.d.id);
+	const guild = client.cache.guilds.get(payload.d.guild_id);
+	if (guild) guild.channels.delete(payload.d.id);
+	if (!channel) return;
+	client.cache.channels.delete(payload.d.id);
+	client.emit("channelDelete", channel);
+});
+
+//#endregion
+//#region src/lib/client/dispatches/handlers/user.ts
+registerHandler(discord_api_types_v10.GatewayDispatchEvents.UserUpdate, async (client, payload) => {
+	if (payload.d.id === client.user?.id) client.user._patch(payload.d);
+	let user;
+	if (client.cache.isModuleEnabled("users")) user = await client.cache.resolve(client.cache.users, payload.d.id, () => new User(client, payload.d), (user) => user._patch(payload.d));
+	else user = new User(client, payload.d);
+	client.emit("userUpdate", user);
+});
+
+//#endregion
+//#region src/lib/client/Client.ts
+var Client = class extends node_events.default {
+	options;
+	shards;
+	rest;
+	helper;
+	cache;
+	#user;
+	#ready = false;
+	constructor(options, rest) {
+		super();
+		const intents = options.intents instanceof IntentsBitField ? options.intents : new IntentsBitField(options.intents);
+		const sharding = {
+			shardsPerCluster: options.sharding?.shardsPerCluster ?? 1,
+			totalShards: options.sharding?.totalShards ?? 1
+		};
+		this.options = {
+			token: options.token,
+			intents,
+			sharding,
+			partials: new Set(options.partials ?? []),
+			cache: options.cache ?? {}
+		};
+		this.rest = rest ?? new _bakit_rest.REST({ token: options.token });
+		this.shards = new _bakit_gateway.ShardingManager({
+			...this.options.sharding,
+			token: this.options.token,
+			intents: this.options.intents.toBigInt()
+		}, rest);
+		this.cache = new ClientCacheManager(this.options.cache);
+		this.helper = new ClientHelper(this);
+		this.#setupShardsListeners();
+	}
+	get user() {
+		return this.#user;
+	}
+	async login() {
+		if (this.#user || this.shards.ready || this.shards.clusters.size > 0) throw new Error("Cannot login twice");
+		await this.shards.spawn();
+		return new Promise((resolve, reject) => {
+			const cleanup = () => {
+				this.removeListener("ready", onReady);
+				this.removeListener("error", onError);
+			};
+			const onReady = () => {
+				cleanup();
+				resolve();
+			};
+			const onError = (error) => {
+				cleanup();
+				reject(error);
+			};
+			this.once("ready", onReady);
+			this.once("error", onError);
+		});
+	}
+	#setupShardsListeners() {
+		this.shards.on("dispatch", (_, shardId, payload) => this.#handleDispatch(shardId, payload));
+		this.shards.on("raw", (_, shardId, payload) => this.emit("raw", shardId, payload));
+		this.shards.once("ready", () => this.#tryEmitReady());
+	}
+	async #handleDispatch(shardId, payload) {
+		this.emit("dispatch", shardId, payload);
+		switch (payload.t) {
+			case discord_api_types_v10.GatewayDispatchEvents.Ready:
+				this.#user ??= new User(this, payload.d.user);
+				this.#tryEmitReady();
+				break;
+			default: {
+				const handler = handlers[payload.t];
+				if (handler) await handler(this, payload);
+				break;
+			}
+		}
+	}
+	/**
+	* We use this method to emit ready event only once since we have 2 ways to emit it.
+	* @private
+	*/
+	#tryEmitReady() {
+		if (this.#ready || !this.#user || !this.shards.ready) return;
+		this.#ready = true;
+		this.emit("ready", this.#user);
+	}
 };
 function createClient(options) {
-  return new Client(options);
+	return new Client(options);
 }
 
-Object.defineProperty(exports, "Cluster", {
+//#endregion
+exports.BaseCacheAdapter = BaseCacheAdapter;
+exports.BaseChannel = BaseChannel;
+exports.Client = Client;
+exports.ClientHelper = ClientHelper;
+Object.defineProperty(exports, 'Cluster', {
   enumerable: true,
-  get: function () { return gateway.Cluster; }
+  get: function () {
+    return _bakit_gateway.Cluster;
+  }
 });
-Object.defineProperty(exports, "Shard", {
+Object.defineProperty(exports, 'DEFAULT_REST_OPTIONS', {
   enumerable: true,
-  get: function () { return gateway.Shard; }
+  get: function () {
+    return _bakit_rest.DEFAULT_REST_OPTIONS;
+  }
 });
-Object.defineProperty(exports, "ShardState", {
+Object.defineProperty(exports, 'DiscordAPIV10', {
   enumerable: true,
-  get: function () { return gateway.ShardState; }
+  get: function () {
+    return discord_api_types_v10;
+  }
 });
-Object.defineProperty(exports, "ShardStrategy", {
+Object.defineProperty(exports, 'DiscordHTTPError', {
   enumerable: true,
-  get: function () { return gateway.ShardStrategy; }
+  get: function () {
+    return _bakit_rest.DiscordHTTPError;
+  }
 });
-Object.defineProperty(exports, "ShardingManager", {
+exports.Guild = Guild;
+exports.GuildTextChannel = GuildTextChannel;
+exports.GuildVoiceChannel = GuildVoiceChannel;
+exports.HybridCache = HybridCache;
+Object.defineProperty(exports, 'Intent', {
   enumerable: true,
-  get: function () { return gateway.ShardingManager; }
+  get: function () {
+    return discord_api_types_v10.GatewayIntentBits;
+  }
 });
-Object.defineProperty(exports, "DEFAULT_REST_OPTIONS", {
+exports.IntentsBitField = IntentsBitField;
+exports.LocalCacheAdapter = LocalCacheAdapter;
+exports.Message = Message;
+exports.Partial = Partial;
+Object.defineProperty(exports, 'REST', {
   enumerable: true,
-  get: function () { return rest.DEFAULT_REST_OPTIONS; }
+  get: function () {
+    return _bakit_rest.REST;
+  }
 });
-Object.defineProperty(exports, "DiscordHTTPError", {
+Object.defineProperty(exports, 'RESTAdapter', {
   enumerable: true,
-  get: function () { return rest.DiscordHTTPError; }
+  get: function () {
+    return _bakit_rest.RESTAdapter;
+  }
 });
-Object.defineProperty(exports, "REST", {
+Object.defineProperty(exports, 'RESTMethod', {
   enumerable: true,
-  get: function () { return rest.REST; }
+  get: function () {
+    return _bakit_rest.RESTMethod;
+  }
 });
-Object.defineProperty(exports, "RESTAdapter", {
+Object.defineProperty(exports, 'Service', {
   enumerable: true,
-  get: function () { return rest.RESTAdapter; }
+  get: function () {
+    return _bakit_service.Service;
+  }
 });
-Object.defineProperty(exports, "RESTMethod", {
+Object.defineProperty(exports, 'ServiceDriver', {
   enumerable: true,
-  get: function () { return rest.RESTMethod; }
+  get: function () {
+    return _bakit_service.ServiceDriver;
+  }
 });
-Object.defineProperty(exports, "createREST", {
+Object.defineProperty(exports, 'ServiceProcess', {
   enumerable: true,
-  get: function () { return rest.createREST; }
+  get: function () {
+    return _bakit_service.ServiceProcess;
+  }
 });
-Object.defineProperty(exports, "createRESTAdapter", {
+Object.defineProperty(exports, 'ServiceState', {
   enumerable: true,
-  get: function () { return rest.createRESTAdapter; }
+  get: function () {
+    return _bakit_service.ServiceState;
+  }
 });
-Object.defineProperty(exports, "Service", {
+Object.defineProperty(exports, 'Shard', {
   enumerable: true,
-  get: function () { return service.Service; }
+  get: function () {
+    return _bakit_gateway.Shard;
+  }
 });
-Object.defineProperty(exports, "ServiceDriver", {
+Object.defineProperty(exports, 'ShardState', {
   enumerable: true,
-  get: function () { return service.ServiceDriver; }
+  get: function () {
+    return _bakit_gateway.ShardState;
+  }
 });
-Object.defineProperty(exports, "ServiceProcess", {
+Object.defineProperty(exports, 'ShardStrategy', {
   enumerable: true,
-  get: function () { return service.ServiceProcess; }
+  get: function () {
+    return _bakit_gateway.ShardStrategy;
+  }
 });
-Object.defineProperty(exports, "ServiceState", {
+Object.defineProperty(exports, 'ShardingManager', {
   enumerable: true,
-  get: function () { return service.ServiceState; }
+  get: function () {
+    return _bakit_gateway.ShardingManager;
+  }
 });
-Object.defineProperty(exports, "TransportClient", {
+Object.defineProperty(exports, 'TransportClient', {
   enumerable: true,
-  get: function () { return service.TransportClient; }
+  get: function () {
+    return _bakit_service.TransportClient;
+  }
 });
-Object.defineProperty(exports, "TransportServer", {
+Object.defineProperty(exports, 'TransportServer', {
   enumerable: true,
-  get: function () { return service.TransportServer; }
+  get: function () {
+    return _bakit_service.TransportServer;
+  }
 });
-Object.defineProperty(exports, "createService", {
+exports.User = User;
+Object.defineProperty(exports, 'capitalize', {
   enumerable: true,
-  get: function () { return service.createService; }
+  get: function () {
+    return _bakit_utils.capitalize;
+  }
 });
-Object.defineProperty(exports, "createTransportClient", {
+exports.createClient = createClient;
+Object.defineProperty(exports, 'createREST', {
   enumerable: true,
-  get: function () { return service.createTransportClient; }
+  get: function () {
+    return _bakit_rest.createREST;
+  }
 });
-Object.defineProperty(exports, "createTransportServer", {
+Object.defineProperty(exports, 'createRESTAdapter', {
   enumerable: true,
-  get: function () { return service.createTransportServer; }
+  get: function () {
+    return _bakit_rest.createRESTAdapter;
+  }
 });
-Object.defineProperty(exports, "capitalize", {
+Object.defineProperty(exports, 'createService', {
   enumerable: true,
-  get: function () { return utils.capitalize; }
+  get: function () {
+    return _bakit_service.createService;
+  }
 });
-Object.defineProperty(exports, "instanceToObject", {
+Object.defineProperty(exports, 'createTransportClient', {
   enumerable: true,
-  get: function () { return utils.instanceToObject; }
+  get: function () {
+    return _bakit_service.createTransportClient;
+  }
 });
-Object.defineProperty(exports, "isCommonJS", {
+Object.defineProperty(exports, 'createTransportServer', {
   enumerable: true,
-  get: function () { return utils.isCommonJS; }
+  get: function () {
+    return _bakit_service.createTransportServer;
+  }
 });
-Object.defineProperty(exports, "isESM", {
+Object.defineProperty(exports, 'instanceToObject', {
   enumerable: true,
-  get: function () { return utils.isESM; }
+  get: function () {
+    return _bakit_utils.instanceToObject;
+  }
 });
-Object.defineProperty(exports, "isPlainObject", {
+Object.defineProperty(exports, 'isCommonJS', {
   enumerable: true,
-  get: function () { return utils.isPlainObject; }
+  get: function () {
+    return _bakit_utils.isCommonJS;
+  }
 });
-Object.defineProperty(exports, "isPromiseLike", {
+Object.defineProperty(exports, 'isESM', {
   enumerable: true,
-  get: function () { return utils.isPromiseLike; }
+  get: function () {
+    return _bakit_utils.isESM;
+  }
 });
-Object.defineProperty(exports, "promisify", {
+Object.defineProperty(exports, 'isPlainObject', {
   enumerable: true,
-  get: function () { return utils.promisify; }
+  get: function () {
+    return _bakit_utils.isPlainObject;
+  }
 });
-Object.defineProperty(exports, "sleep", {
+Object.defineProperty(exports, 'isPromiseLike', {
   enumerable: true,
-  get: function () { return utils.sleep; }
+  get: function () {
+    return _bakit_utils.isPromiseLike;
+  }
 });
-exports.DiscordAPIV10 = v10__namespace;
-Object.defineProperty(exports, "Intent", {
+Object.defineProperty(exports, 'promisify', {
   enumerable: true,
-  get: function () { return v10.GatewayIntentBits; }
+  get: function () {
+    return _bakit_utils.promisify;
+  }
 });
-exports.BaseChannel = BaseChannel;
-exports.Client = Client;
-exports.ClientHelper = ClientHelper;
-exports.Guild = Guild;
-exports.GuildTextChannel = GuildTextChannel;
-exports.GuildVoiceChannel = GuildVoiceChannel;
-exports.IntentsBitField = IntentsBitField;
-exports.Message = Message;
-exports.Partial = Partial;
-exports.User = User;
-exports.createClient = createClient;
+Object.defineProperty(exports, 'sleep', {
+  enumerable: true,
+  get: function () {
+    return _bakit_utils.sleep;
+  }
+});