bakit 2.2.3 → 3.0.0

package/dist/index.js

@@ -1,364 +1,522 @@
-import { attachEventBus } from '@bakit/utils';
-export { Collection, attachEventBus, capitalize, createEventBus, createQueue, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
-import { ChannelType, GatewayDispatchEvents } from 'discord-api-types/v10';
-export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, createGatewayManager, createWorker } from '@bakit/gateway';
-export { createREST } from '@bakit/rest';
-export { RPCError, createIPCClient, createIPCServer, createService, createTransportClient, createTransportServer, deserializeRPCError, getIPCPath, serializeRPCError } from '@bakit/service';
+import { ShardingManager } from '@bakit/gateway';
+export { Cluster, Shard, ShardState, ShardStrategy, ShardingManager } from '@bakit/gateway';
+import { REST } from '@bakit/rest';
+export { DEFAULT_REST_OPTIONS, DiscordHTTPError, REST, RESTAdapter, RESTMethod, createREST, createRESTAdapter } from '@bakit/rest';
+export { Service, ServiceDriver, ServiceProcess, ServiceState, TransportClient, TransportServer, createService, createTransportClient, createTransportServer } from '@bakit/service';
+import { getSnowflakeDate } from '@bakit/utils';
+export { capitalize, instanceToObject, isCommonJS, isESM, isPlainObject, isPromiseLike, promisify, sleep } from '@bakit/utils';
+import EventEmitter from 'events';
+import { Collection } from '@discordjs/collection';
+import { Routes, GatewayDispatchEvents, ChannelType } from 'discord-api-types/v10';
+import * as v10 from 'discord-api-types/v10';
+export { v10 as DiscordAPIV10 };
+export { GatewayIntentBits as Intent } from 'discord-api-types/v10';
+import { createMixin, applyMixins } from 'tiny-mixin';
 
-// src/lib/client/index.ts
+// src/modules/gateway.ts
 
-// src/lib/structures/user.ts
-function createUser(client, data) {
-  return {
-    get client() {
-      return client;
-    },
-    get id() {
-      return data.id;
-    },
-    get username() {
-      return data.username;
-    },
-    get discriminator() {
-      return data.discriminator;
-    },
-    get globalName() {
-      return data.global_name;
-    },
-    get avatar() {
-      return data.avatar;
-    },
-    get system() {
-      return data.system;
-    },
-    get mfaEnabled() {
-      return data.mfa_enabled;
-    },
-    get banner() {
-      return data.banner;
-    },
-    get accentColor() {
-      return data.accent_color ?? void 0;
-    },
-    get locale() {
-      return data.locale;
-    },
-    get verified() {
-      return data.verified;
-    },
-    get email() {
-      return data.email;
-    },
-    get flags() {
-      return data.flags;
-    },
-    get premiumType() {
-      return data.premium_type;
-    },
-    get publicFlags() {
-      return data.public_flags;
-    }
-  };
-}
+// 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 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}>`;
+  }
+};
+
+// 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;
+  }
+};
 
-// src/lib/structures/message.ts
-function createMessage(client, data) {
-  let author, mentions, referencedMessage;
-  return {
-    get client() {
-      return client;
-    },
-    get id() {
-      return data.id;
-    },
-    get channelId() {
-      return data.channel_id;
-    },
+// 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 };
+  }
+};
+var TextBasedChannelMixin = createMixin((base) => {
+  class TextBasedChannel extends base {
+    send(options) {
+      return this.client.helper.createMessage(this.id, options);
+    }
+  }
+  return TextBasedChannel;
+}), VoiceBasedChannelMixin = createMixin((base) => {
+  class VoiceBasedChannel extends base {
+  }
+  return VoiceBasedChannel;
+}), GuildChannelMixin = createMixin((base) => {
+  class GuildChannel extends base {
     get guildId() {
-      if ("guild_id" in data)
-        return data.guild_id;
-    },
-    get author() {
-      return author || (author = createUser(client, data.author)), author;
-    },
-    get content() {
-      return data.content;
-    },
-    get timestamp() {
-      return data.timestamp;
-    },
-    get editedTimestamp() {
-      return data.edited_timestamp ?? void 0;
-    },
-    get tts() {
-      return data.tts;
-    },
-    get mentionEveryone() {
-      return data.mention_everyone;
-    },
-    get mentions() {
-      return mentions || (mentions = data.mentions.map((x) => createUser(client, x))), mentions;
-    },
-    get mentionRoles() {
-      return data.mention_roles;
-    },
-    get nonce() {
-      return data.nonce;
-    },
-    get pinned() {
-      return data.pinned;
-    },
-    get webhookId() {
-      return data.webhook_id;
-    },
-    get type() {
-      return data.type;
-    },
-    get applicationId() {
-      return data.application_id;
-    },
-    get flags() {
-      return data.flags;
-    },
-    get referencedMessage() {
-      if (data.referenced_message)
-        return referencedMessage || (referencedMessage = createMessage(client, data.referenced_message)), referencedMessage;
-    },
-    get position() {
-      return data.position;
+      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;
+});
+var GuildTextChannel = class extends applyMixins(BaseChannel, [
+  GuildChannelMixin,
+  TextBasedChannelMixin
+]) {
+};
+var GuildVoiceChannel = class extends applyMixins(BaseChannel, [
+  GuildChannelMixin,
+  TextBasedChannelMixin,
+  VoiceBasedChannelMixin
+]) {
+};
 function createChannel(client, data) {
   switch (data.type) {
     case ChannelType.GuildText:
-      return createGuildTextChannel(client, data);
-    case ChannelType.DM:
-      return createDMChannel(client, data);
-    case ChannelType.PublicThread:
-      return createPublicThreadChannel(client, data);
-    case ChannelType.PrivateThread:
-      return createPrivateThreadChannel(client, data);
+      return new GuildTextChannel(client, data);
     case ChannelType.GuildVoice:
-      return createVoiceChannel(client, data);
-    case ChannelType.GuildStageVoice:
-      return createStageChannel(client, data);
+      return new GuildVoiceChannel(client, data);
     default:
-      return createBaseChannel(client, data);
+      return null;
   }
 }
-function createBaseChannel(client, data) {
-  return {
-    get client() {
-      return client;
-    },
-    get id() {
-      return data.id;
-    },
-    get type() {
-      return data.type;
-    },
-    isTextBased() {
-      return data.type === ChannelType.GuildText || data.type === ChannelType.DM || data.type === ChannelType.PublicThread || data.type === ChannelType.PrivateThread;
-    },
-    isVoiceBased() {
-      return data.type === ChannelType.GuildVoice || data.type === ChannelType.GuildStageVoice;
-    },
-    isGuildBased() {
-      return data.type === ChannelType.GuildText || data.type === ChannelType.GuildVoice || data.type === ChannelType.GuildStageVoice || data.type === ChannelType.PublicThread || data.type === ChannelType.PrivateThread;
-    },
-    isThreadBased() {
-      return data.type === ChannelType.PublicThread || data.type === ChannelType.PrivateThread;
-    },
-    isDm() {
-      return data.type === ChannelType.DM;
-    },
-    isGuildText() {
-      return data.type === ChannelType.GuildText;
-    },
-    isVoice() {
-      return data.type === ChannelType.GuildVoice;
-    },
-    isStage() {
-      return data.type === ChannelType.GuildStageVoice;
-    },
-    isPublicThread() {
-      return data.type === ChannelType.PublicThread;
-    },
-    isPrivateThread() {
-      return data.type === ChannelType.PrivateThread;
-    }
-  };
-}
-function createGuildTextChannel(client, data) {
-  return {
-    ...createBaseChannel(client, data),
-    ...createGuildBasedChannelSingleton(data),
-    ...createTextBasedChannelSingleton(client, data)
-  };
-}
-function createDMChannel(client, data) {
-  let recipients;
-  return {
-    ...createBaseChannel(client, data),
-    ...createTextBasedChannelSingleton(client, data),
-    get recipients() {
-      if (data.recipients)
-        return recipients || (recipients = data.recipients.map((x) => createUser(client, x))), recipients;
-    }
-  };
-}
-function createPublicThreadChannel(client, data) {
-  return {
-    ...createBaseChannel(client, data),
-    ...createThreadBasedChannelSingleton(client, data)
-  };
-}
-function createPrivateThreadChannel(client, data) {
-  return {
-    ...createBaseChannel(client, data),
-    ...createThreadBasedChannelSingleton(client, data)
-  };
-}
-function createVoiceChannel(client, data) {
-  return {
-    ...createBaseChannel(client, data),
-    ...createVoiceBasedChannelSingleton(),
-    ...createGuildBasedChannelSingleton(data),
-    ...createTextBasedChannelSingleton(client, data)
-  };
-}
-function createStageChannel(client, data) {
-  return {
-    ...createBaseChannel(client, data),
-    ...createVoiceBasedChannelSingleton(),
-    ...createGuildBasedChannelSingleton(data),
-    ...createTextBasedChannelSingleton(client, data)
-  };
-}
-function createTextBasedChannelSingleton(client, data) {
-  return {
-    get lastMessageId() {
-      return data.last_message_id ?? void 0;
-    },
-    async send(options) {
-      return client.helpers.channel.createMessage(data.id, options);
-    }
-  };
-}
-function createVoiceBasedChannelSingleton(_client, _data) {
-  return {
-    async join() {
-    }
-  };
-}
-function createGuildBasedChannelSingleton(data) {
-  return {
-    get name() {
-      return data.name;
-    },
-    get guildId() {
-      return data.guild_id;
-    },
-    get parentId() {
-      return data.parent_id ?? void 0;
-    }
-  };
-}
-function createGuildTextBasedChannelSingleton(client, data) {
-  return {
-    ...createGuildBasedChannelSingleton(data),
-    ...createTextBasedChannelSingleton(client, data)
-  };
-}
-function createThreadBasedChannelSingleton(client, data) {
-  return {
-    ...createGuildTextBasedChannelSingleton(client, data),
-    get messageCount() {
-      return data.message_count;
-    },
-    get memberCount() {
-      return data.member_count;
-    },
-    get ownerId() {
-      return data.owner_id;
-    },
-    get totalMessageSent() {
-      return data.total_message_sent;
-    },
-    get appliedTags() {
-      return data.applied_tags;
-    }
-  };
-}
 
-// src/lib/client/helpers/channel.ts
-function createChannelHelpers(client) {
-  return {
-    async getById(id) {
-      try {
-        let data = await client.rest.get(`/channels/${id}`);
-        return createChannel(client, data);
-      } catch {
-        return;
+// 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(), "channels" in this.data))
+      for (let data of this.data.channels) {
+        let channel = createChannel(this.client, data);
+        channel && this.cachedChannels.set(channel.id, channel);
       }
-    },
-    async createMessage(channelId, options) {
-      typeof options == "string" && (options = { content: options });
-      let message = await client.rest.post(
-        `/channels/${channelId}/messages`,
-        {
-          content: options.content,
-          flags: options.flags
-        }
-      );
-      return createMessage(client, message);
-    },
-    async deleteMessage(channelId, messageId) {
-      await client.rest.delete(`/channels/${channelId}/messages/${messageId}`);
-    }
-  };
-}
-
-// src/lib/client/helpers/user.ts
-function createUserHelpers(client) {
-  return {
-    async getById(id) {
-      try {
-        let data = await client.rest.get(`/users/${id}`);
-        return createUser(client, data);
-      } catch {
-        return;
+    return this.cachedChannels;
+  }
+  _patch(data) {
+    this.data = { ...this.data, ...data };
+  }
+  // public get roles() {
+  // 	return this.data.roles;
+  // }
+};
+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(Routes.channelMessage(channelId, messageId));
+    return new Message(this.client, data);
+  }
+  async deleteMessage(channelId, messageId) {
+    return this.client.rest.delete(Routes.channelMessage(channelId, messageId));
+  }
+  async createMessage(channelId, options) {
+    return this.client.rest.post(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 getCurrent() {
-      let data = await client.rest.get("/users/@me");
-      return createUser(client, data);
-    }
-  };
-}
+    });
+  }
+  async fetchGuild(guildId) {
+    let data = await this.client.rest.get(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
+    };
+  }
+};
 
-// src/lib/client/helpers/index.ts
-function createHelpers(client) {
-  return {
-    user: createUserHelpers(client),
-    channel: createChannelHelpers(client)
-  };
-}
+// 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();
+  }
+};
 
-// src/lib/client/index.ts
-function createClient(rest) {
-  let self = attachEventBus({
-    rest,
-    helpers: void 0
-  });
-  return Object.assign(self, { helpers: createHelpers(self) }), self.on("raw", (payload) => {
-    switch (payload.t) {
-      case GatewayDispatchEvents.MessageCreate:
-        self.emit("messageCreate", createMessage(self, payload.d));
-        return;
+// src/lib/client/Client.ts
+var Client = class extends EventEmitter {
+  options;
+  shards;
+  rest;
+  helper;
+  guilds = new Collection();
+  #user;
+  #ready = false;
+  constructor(options, rest) {
+    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 ?? new REST({ token: options.token }), this.shards = new ShardingManager(
+      {
+        ...this.options.sharding,
+        token: this.options.token,
+        intents: this.options.intents.toBigInt()
+      },
+      rest
+    ), 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 GatewayDispatchEvents.Ready: {
+        this.#user ??= new User(this, payload.d.user), this.#tryEmitReady();
+        break;
+      }
+      case 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 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 GatewayDispatchEvents.MessageDelete: {
+        this.emit("messageDelete", {
+          id: payload.d.id,
+          channelId: payload.d.channel_id,
+          guildId: payload.d.guild_id
+        });
+        break;
+      }
+      case 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 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 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 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 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 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 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;
+      }
     }
-  }), self;
+  }
+  /**
+   * 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));
+  }
+};
+function createClient(options) {
+  return new Client(options);
 }
 
-export { createBaseChannel, createChannel, createClient, createDMChannel, createGuildBasedChannelSingleton, createGuildTextBasedChannelSingleton, createGuildTextChannel, createMessage, createPrivateThreadChannel, createPublicThreadChannel, createStageChannel, createTextBasedChannelSingleton, createThreadBasedChannelSingleton, createUser, createVoiceBasedChannelSingleton, createVoiceChannel };
+export { BaseChannel, Client, ClientHelper, Guild, GuildTextChannel, GuildVoiceChannel, IntentsBitField, Message, Partial, User, createClient };