bakit 3.0.0 → 3.1.0

package/dist/index.mjs

@@ -0,0 +1,908 @@
+import { Cluster, Shard, ShardState, ShardStrategy, ShardingManager, ShardingManager as ShardingManager$1 } from "@bakit/gateway";
+import { DEFAULT_REST_OPTIONS, DiscordHTTPError, REST, REST as REST$1, RESTAdapter, RESTMethod, createREST, createRESTAdapter } from "@bakit/rest";
+import { Service, ServiceDriver, ServiceProcess, ServiceState, TransportClient, TransportServer, createService, createTransportClient, createTransportServer } from "@bakit/service";
+import { capitalize, getSnowflakeDate, instanceToObject, isCommonJS, isESM, isPlainObject, isPromiseLike, promisify, sleep } from "@bakit/utils";
+import EventEmitter from "node:events";
+import * as DiscordAPIV10 from "discord-api-types/v10";
+import { ChannelType, GatewayDispatchEvents, GatewayIntentBits, GatewayIntentBits as Intent, Routes } from "discord-api-types/v10";
+import { Collection } from "@discordjs/collection";
+import { applyMixins, createMixin } from "tiny-mixin";
+
+//#region src/lib/structures/BaseStructure.ts
+var BaseStructure = class {
+	constructor(client) {
+		Object.defineProperty(this, "client", {
+			value: client,
+			enumerable: false,
+			writable: false
+		});
+	}
+	toJSON() {
+		return {};
+	}
+};
+
+//#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 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}>`;
+	}
+};
+
+//#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;
+	}
+	isDM() {
+		return this.type === 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
+		};
+	}
+};
+
+//#endregion
+//#region src/lib/mixins/ChannelMixin.ts
+const TextBasedChannelMixin = createMixin((base) => {
+	class TextBasedChannel extends base {
+		send(options) {
+			return this.client.helper.createMessage(this.id, options);
+		}
+	}
+	return TextBasedChannel;
+});
+const VoiceBasedChannelMixin = createMixin((base) => {
+	class VoiceBasedChannel extends base {}
+	return VoiceBasedChannel;
+});
+const GuildChannelMixin = 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 applyMixins(BaseChannel, [TextBasedChannelMixin]) {
+	#cachedRecipients;
+	constructor(client, data) {
+		super(client, data);
+	}
+	get recipients() {
+		if (!this.#cachedRecipients) {
+			this.#cachedRecipients = new 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(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 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;
+	}
+};
+
+//#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: 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 applyMixins(BaseChannel, [GuildChannelMixin, TextBasedChannelMixin]) {};
+
+//#endregion
+//#region src/lib/structures/channel/GuildVoiceChannel.ts
+var GuildVoiceChannel = class extends applyMixins(BaseChannel, [
+	GuildChannelMixin,
+	TextBasedChannelMixin,
+	VoiceBasedChannelMixin
+]) {};
+
+//#endregion
+//#region src/lib/utils/channel.ts
+function createChannel(client, data) {
+	switch (data.type) {
+		case ChannelType.GuildText: return new GuildTextChannel(client, data);
+		case ChannelType.GuildVoice: return new GuildVoiceChannel(client, data);
+		case ChannelType.DM: return new DMChannel(client, data);
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/lib/structures/Guild.ts
+var Guild = class extends BaseStructure {
+	channels = new 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);
+			}
+		}
+	}
+};
+
+//#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(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(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(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(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(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(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(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(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
+		};
+	}
+};
+
+//#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();
+	}
+};
+
+//#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 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 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 === GatewayDispatchEvents.MessageUpdate ? "messageUpdate" : "messageCreate", message);
+}
+registerHandler(GatewayDispatchEvents.MessageCreate, onCreateAndUpdate$1);
+registerHandler(GatewayDispatchEvents.MessageUpdate, onCreateAndUpdate$1);
+registerHandler(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 === GatewayDispatchEvents.GuildCreate) client.emit(payload.d.unavailable ? "guildCreate" : "guildAvailable", guild);
+	else client.emit("guildUpdate", guild);
+}
+registerHandler(GatewayDispatchEvents.GuildCreate, onCreateAndUpdate);
+registerHandler(GatewayDispatchEvents.GuildUpdate, onCreateAndUpdate);
+registerHandler(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 === GatewayDispatchEvents.ChannelCreate ? "channelCreate" : "channelUpdate", channel);
+}
+registerHandler(GatewayDispatchEvents.ChannelCreate, onCreateOrUpdate);
+registerHandler(GatewayDispatchEvents.ChannelUpdate, onCreateOrUpdate);
+registerHandler(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(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 EventEmitter {
+	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 REST$1({ token: options.token });
+		this.shards = new ShardingManager$1({
+			...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 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);
+}
+
+//#endregion
+export { BaseCacheAdapter, BaseChannel, Client, ClientHelper, Cluster, DEFAULT_REST_OPTIONS, DiscordAPIV10, DiscordHTTPError, Guild, GuildTextChannel, GuildVoiceChannel, HybridCache, Intent, IntentsBitField, LocalCacheAdapter, Message, Partial, REST, RESTAdapter, RESTMethod, Service, ServiceDriver, ServiceProcess, ServiceState, Shard, ShardState, ShardStrategy, ShardingManager, TransportClient, TransportServer, User, capitalize, createClient, createREST, createRESTAdapter, createService, createTransportClient, createTransportServer, instanceToObject, isCommonJS, isESM, isPlainObject, isPromiseLike, promisify, sleep };
+//# sourceMappingURL=index.mjs.map