bakit 1.0.0-beta.10 → 1.0.0-beta.12

package/dist/index.js

@@ -1,20 +1,14 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/index.ts
 import "reflect-metadata";
 
 // src/BakitClient.ts
-import {
-  Client,
-  codeBlock,
-  Events
-} from "discord.js";
+import { Client, codeBlock, Events } from "discord.js";
 
 // src/command/CommandRegistry.ts
-import {
-  Collection as Collection2,
-  SlashCommandBuilder,
-  SlashCommandSubcommandBuilder,
-  SlashCommandSubcommandGroupBuilder
-} from "discord.js";
+import { Collection as Collection2, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from "discord.js";
 import glob from "tiny-glob";
 import { pathToFileURL } from "url";
 
@@ -22,23 +16,33 @@ import { pathToFileURL } from "url";
 import { Collection } from "discord.js";
 
 // src/base/BaseEntry.ts
+var HookExecutionState = /* @__PURE__ */ (function(HookExecutionState2) {
+  HookExecutionState2["Main"] = "MAIN";
+  HookExecutionState2["Pre"] = "PRE";
+  HookExecutionState2["Post"] = "POST";
+  HookExecutionState2["Error"] = "ERROR";
+  return HookExecutionState2;
+})({});
 var BaseEntry = class {
+  static {
+    __name(this, "BaseEntry");
+  }
   target;
   hooks = {
-    ["MAIN" /* Main */]: void 0,
-    ["ERROR" /* Error */]: void 0,
-    ["POST" /* Post */]: void 0,
-    ["PRE" /* Pre */]: void 0
+    ["MAIN"]: void 0,
+    ["ERROR"]: void 0,
+    ["POST"]: void 0,
+    ["PRE"]: void 0
   };
   main;
   pre;
   post;
   error;
   constructor() {
-    this.main = this.createMainHookDecorator("MAIN" /* Main */);
-    this.pre = this.createMainHookDecorator("PRE" /* Pre */);
-    this.post = this.createMainHookDecorator("POST" /* Post */);
-    this.error = this.createMainHookDecorator("ERROR" /* Error */);
+    this.main = this.createMainHookDecorator("MAIN");
+    this.pre = this.createMainHookDecorator("PRE");
+    this.post = this.createMainHookDecorator("POST");
+    this.error = this.createMainHookDecorator("ERROR");
   }
   setTarget(target) {
     this.target = target;
@@ -72,15 +76,27 @@ var BaseEntry = class {
 
 // src/command/CommandEntry.ts
 var BaseCommandEntry = class extends BaseEntry {
+  static {
+    __name(this, "BaseCommandEntry");
+  }
+  options;
   constructor(options) {
-    super();
-    this.options = options;
+    super(), this.options = options;
   }
 };
 var BaseCommandGroupEntry = class extends BaseCommandEntry {
+  static {
+    __name(this, "BaseCommandGroupEntry");
+  }
   children = new Collection();
   subcommand(options) {
-    const fullOptions = typeof options === "string" ? { name: options, description: `${options} command` } : { description: `${options.name} command`, ...options };
+    const fullOptions = typeof options === "string" ? {
+      name: options,
+      description: `${options} command`
+    } : {
+      description: `${options.name} command`,
+      ...options
+    };
     if (this.children.has(fullOptions.name)) {
       throw new Error(`Entry "${fullOptions.name}" is already existed.`);
     }
@@ -90,8 +106,17 @@ var BaseCommandGroupEntry = class extends BaseCommandEntry {
   }
 };
 var RootCommandEntry = class extends BaseCommandGroupEntry {
+  static {
+    __name(this, "RootCommandEntry");
+  }
   group(options) {
-    const fullOptions = typeof options === "string" ? { name: options, description: `${options} command` } : { description: `${options.name} command`, ...options };
+    const fullOptions = typeof options === "string" ? {
+      name: options,
+      description: `${options} command`
+    } : {
+      description: `${options.name} command`,
+      ...options
+    };
     if (this.children.has(fullOptions.name)) {
       throw new Error(`Entry "${fullOptions.name}" is already existed.`);
     }
@@ -101,21 +126,26 @@ var RootCommandEntry = class extends BaseCommandGroupEntry {
   }
 };
 var CommandGroupEntry = class extends BaseCommandGroupEntry {
+  static {
+    __name(this, "CommandGroupEntry");
+  }
+  parent;
   constructor(options, parent) {
-    super(options);
-    this.parent = parent;
+    super(options), this.parent = parent;
   }
 };
 var SubcommandEntry = class extends BaseCommandEntry {
+  static {
+    __name(this, "SubcommandEntry");
+  }
+  parent;
   constructor(options, parent) {
-    super(options);
-    this.parent = parent;
+    super(options), this.parent = parent;
   }
 };
 
 // src/command/Command.ts
-var CommandAPI;
-((CommandAPI2) => {
+(function(CommandAPI2) {
   const rootEntries = /* @__PURE__ */ new WeakMap();
   function use(root) {
     return (target) => {
@@ -123,32 +153,38 @@ var CommandAPI;
       rootEntries.set(target, root);
     };
   }
+  __name(use, "use");
   CommandAPI2.use = use;
   function getRoot(constructor) {
     return rootEntries.get(constructor);
   }
+  __name(getRoot, "getRoot");
   CommandAPI2.getRoot = getRoot;
 })(CommandAPI || (CommandAPI = {}));
 function CommandFactory(options) {
   if (typeof options === "string") {
-    options = { name: options };
+    options = {
+      name: options
+    };
   }
   if (!options.description) {
     options.description = options.name;
   }
   return new RootCommandEntry(options);
 }
+__name(CommandFactory, "CommandFactory");
 var Command = Object.assign(CommandFactory, CommandAPI);
+var CommandAPI;
 
 // src/command/argument/Argument.ts
-var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => {
+var ArgumentType = /* @__PURE__ */ (function(ArgumentType2) {
   ArgumentType2["String"] = "string";
   ArgumentType2["Integer"] = "integer";
   ArgumentType2["Number"] = "number";
   ArgumentType2["User"] = "user";
   ArgumentType2["Member"] = "member";
   return ArgumentType2;
-})(ArgumentType || {});
+})({});
 
 // src/command/argument/Arg.ts
 var ARGS_KEY = Symbol("args");
@@ -162,12 +198,20 @@ function getMethodArguments(method, init = false) {
       cache.set(method, args);
     }
   }
-  return init ? args : Object.freeze([...args]);
+  return init ? args : Object.freeze([
+    ...args
+  ]);
 }
+__name(getMethodArguments, "getMethodArguments");
 function createArgument(type) {
   return function(options) {
-    const objOptions = typeof options === "string" ? { name: options } : options;
-    const fullOptions = { ...objOptions, type };
+    const objOptions = typeof options === "string" ? {
+      name: options
+    } : options;
+    const fullOptions = {
+      ...objOptions,
+      type
+    };
     if (!fullOptions.description) {
       fullOptions.description = fullOptions.name;
     }
@@ -184,15 +228,18 @@ function createArgument(type) {
     };
   };
 }
-var string = createArgument("string" /* String */);
-var integer = createArgument("integer" /* Integer */);
-var number = createArgument("number" /* Number */);
-var user = createArgument("user" /* User */);
-var member = createArgument("member" /* Member */);
+__name(createArgument, "createArgument");
+var string = createArgument(ArgumentType.String);
+var integer = createArgument(ArgumentType.Integer);
+var number = createArgument(ArgumentType.Number);
+var user = createArgument(ArgumentType.User);
+var member = createArgument(ArgumentType.Member);
 function describeArgumentExpectation(arg) {
-  const parts = [arg.type];
+  const parts = [
+    arg.type
+  ];
   switch (arg.type) {
-    case "string" /* String */: {
+    case ArgumentType.String: {
       if (arg.minLength && !arg.maxLength) {
         parts.push(`\u2265 ${String(arg.minLength)}`);
       }
@@ -204,8 +251,8 @@ function describeArgumentExpectation(arg) {
       }
       break;
     }
-    case "number" /* Number */:
-    case "integer" /* Integer */: {
+    case ArgumentType.Number:
+    case ArgumentType.Integer: {
       if (arg.minValue !== void 0 && arg.maxValue === void 0) {
         parts.push(`\u2265 ${String(arg.minValue)}`);
       }
@@ -217,13 +264,14 @@ function describeArgumentExpectation(arg) {
       }
       break;
     }
-    case "user" /* User */:
-    case "member" /* Member */: {
+    case ArgumentType.User:
+    case ArgumentType.Member: {
       break;
     }
   }
   return parts.join(", ");
 }
+__name(describeArgumentExpectation, "describeArgumentExpectation");
 function format(arg) {
   const { name, required, tuple } = arg;
   const opening = required ? "<" : "[";
@@ -231,6 +279,7 @@ function format(arg) {
   const prefix = tuple ? "..." : "";
   return `${opening}${prefix}${name}: ${describeArgumentExpectation(arg)}${closing}`;
 }
+__name(format, "format");
 var Arg = {
   getMethodArguments,
   createArgument,
@@ -245,12 +294,15 @@ var Arg = {
 
 // src/command/CommandRegistry.ts
 var CommandRegistry = class _CommandRegistry {
+  static {
+    __name(this, "CommandRegistry");
+  }
   static constructors = new Collection2();
   static instances = new Collection2();
   /**
-   * Add a command to the registry.
-   * @param constructor The command class you want to add.
-   */
+  * Add a command to the registry.
+  * @param constructor The command class you want to add.
+  */
   static add(constructor) {
     const root = Command.getRoot(constructor);
     if (!root) {
@@ -261,11 +313,11 @@ var CommandRegistry = class _CommandRegistry {
     this.instances.set(options.name, new constructor());
   }
   /**
-   * Load and add all commands which matched provided glob pattern to the registry.
-   * @param pattern glob pattern to load.
-   * @param parallel load all matched results in parallel, enabled by default.
-   * @returns All loaded command constructors.
-   */
+  * Load and add all commands which matched provided glob pattern to the registry.
+  * @param pattern glob pattern to load.
+  * @param parallel load all matched results in parallel, enabled by default.
+  * @returns All loaded command constructors.
+  */
   static async load(pattern, parallel = true) {
     const files = await glob(pattern);
     const loaders = files.map(async (file) => {
@@ -284,10 +336,10 @@ var CommandRegistry = class _CommandRegistry {
     return result;
   }
   /**
-   * Build a command into application command data.
-   * @param constructor The command class you want to build.
-   * @returns a REST JSON version of the application command data.
-   */
+  * Build a command into application command data.
+  * @param constructor The command class you want to build.
+  * @returns a REST JSON version of the application command data.
+  */
   static buildSlashCommand(constructor) {
     const root = Command.getRoot(constructor);
     if (!root) {
@@ -305,7 +357,7 @@ var CommandRegistry = class _CommandRegistry {
   }
   static getMainHookArguments(entry) {
     const { hooks } = entry;
-    const mainHook = hooks["MAIN" /* Main */];
+    const mainHook = hooks[HookExecutionState.Main];
     return mainHook ? Arg.getMethodArguments(mainHook.method) : [];
   }
   static buildSlashCommandSubcommands(parent, entry, inheritedArgs) {
@@ -332,17 +384,20 @@ var CommandRegistry = class _CommandRegistry {
   }
   static buildSlashCommandOptions(builder, args) {
     const argGroup = Object.groupBy(args, ({ required }) => required ? "required" : "optional");
-    const orderedArgs = [...argGroup.required || [], ...argGroup.optional || []];
+    const orderedArgs = [
+      ...argGroup.required || [],
+      ...argGroup.optional || []
+    ];
     for (const arg of orderedArgs) {
       this.attachSlashCommandOption(builder, arg);
     }
   }
   static attachSlashCommandOption(builder, arg) {
-    const setupOption = (option) => {
+    const setupOption = /* @__PURE__ */ __name((option) => {
       return option.setName(arg.name).setDescription(arg.description || arg.name).setRequired(Boolean(arg.required));
-    };
+    }, "setupOption");
     switch (arg.type) {
-      case "string" /* String */: {
+      case ArgumentType.String: {
         builder.addStringOption((data) => {
           const option = setupOption(data);
           if (arg.maxLength) {
@@ -355,7 +410,7 @@ var CommandRegistry = class _CommandRegistry {
         });
         break;
       }
-      case "integer" /* Integer */: {
+      case ArgumentType.Integer: {
         builder.addIntegerOption((data) => {
           const option = setupOption(data);
           if (arg.maxValue) {
@@ -368,7 +423,7 @@ var CommandRegistry = class _CommandRegistry {
         });
         break;
       }
-      case "number" /* Number */: {
+      case ArgumentType.Number: {
         builder.addNumberOption((data) => {
           const option = setupOption(data);
           if (arg.maxValue) {
@@ -381,8 +436,8 @@ var CommandRegistry = class _CommandRegistry {
         });
         break;
       }
-      case "user" /* User */:
-      case "member" /* Member */: {
+      case ArgumentType.User:
+      case ArgumentType.Member: {
         builder.addUserOption((option) => setupOption(option));
         break;
       }
@@ -391,11 +446,12 @@ var CommandRegistry = class _CommandRegistry {
 };
 
 // src/command/Context.ts
-import {
-  ChatInputCommandInteraction,
-  Message
-} from "discord.js";
+import { ChatInputCommandInteraction, Message } from "discord.js";
 var BaseContext = class {
+  static {
+    __name(this, "BaseContext");
+  }
+  source;
   constructor(source) {
     this.source = source;
   }
@@ -443,9 +499,14 @@ var BaseContext = class {
   }
 };
 var ChatInputContext = class extends BaseContext {
+  static {
+    __name(this, "ChatInputContext");
+  }
   async send(options) {
     if (typeof options === "string") {
-      options = { content: options };
+      options = {
+        content: options
+      };
     }
     const sendOptions = {
       ...options,
@@ -459,6 +520,9 @@ var ChatInputContext = class extends BaseContext {
   }
 };
 var MessageContext = class extends BaseContext {
+  static {
+    __name(this, "MessageContext");
+  }
   async send(options) {
     const { channel } = this;
     if (!channel?.isSendable()) {
@@ -480,15 +544,19 @@ function extractId(value) {
   }
   return null;
 }
+__name(extractId, "extractId");
 
 // src/errors/CommandSyntaxError.ts
-var CommandSyntaxErrorType = /* @__PURE__ */ ((CommandSyntaxErrorType2) => {
+var CommandSyntaxErrorType = /* @__PURE__ */ (function(CommandSyntaxErrorType2) {
   CommandSyntaxErrorType2["MissingRequireArgument"] = "MISSING_REQUIRE_ARGUMENT";
   CommandSyntaxErrorType2["InvalidArgument"] = "INVALID_ARGUMENT";
   CommandSyntaxErrorType2["InvalidVariadicArgumentValue"] = "INVALID_VARIADIC_ARGUMENT_VALUE";
   return CommandSyntaxErrorType2;
-})(CommandSyntaxErrorType || {});
+})({});
 var CommandSyntaxError = class extends Error {
+  static {
+    __name(this, "CommandSyntaxError");
+  }
   arg;
   type;
   expected;
@@ -498,11 +566,14 @@ var CommandSyntaxError = class extends Error {
     const { arg, type, received } = options;
     const expected = Arg.describeArgumentExpectation(arg);
     switch (type) {
-      case "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */: {
-        message = [`Missing required argument "${arg.name}"`, `> Expected: ${expected}`].join("\n");
+      case "MISSING_REQUIRE_ARGUMENT": {
+        message = [
+          `Missing required argument "${arg.name}"`,
+          `> Expected: ${expected}`
+        ].join("\n");
         break;
       }
-      case "INVALID_ARGUMENT" /* InvalidArgument */: {
+      case "INVALID_ARGUMENT": {
         message = [
           `Invalid value received for argument "${arg.name}"`,
           `> Expected: ${expected}`,
@@ -510,7 +581,7 @@ var CommandSyntaxError = class extends Error {
         ].join("\n");
         break;
       }
-      case "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */: {
+      case "INVALID_VARIADIC_ARGUMENT_VALUE": {
         message = [
           `Invalid value received for variadic argument "${arg.name}"`,
           `> Expected: ${expected}`,
@@ -537,27 +608,33 @@ var CommandSyntaxError = class extends Error {
 
 // src/command/argument/ArgumentResolver.ts
 var ArgumentResolver = class _ArgumentResolver {
+  static {
+    __name(this, "ArgumentResolver");
+  }
+  options;
+  parsedValues = [];
   constructor(options) {
     this.options = options;
   }
-  parsedValues = [];
   /**
-   * Get the first value as the command trigger.
-   */
+  * Get the first value as the command trigger.
+  */
   get trigger() {
     return this.options.values[0];
   }
   /**
-   * Get amount of specified argument values.
-   */
+  * Get amount of specified argument values.
+  */
   get specifiedAmount() {
     return this.options.values.length - this.options.startAt;
   }
   /**
-   * Get parsed raw values from content.
-   */
+  * Get parsed raw values from content.
+  */
   get values() {
-    return [...this.options.values];
+    return [
+      ...this.options.values
+    ];
   }
   get client() {
     return this.options.message.client;
@@ -569,7 +646,9 @@ var ArgumentResolver = class _ArgumentResolver {
       // Custom prefixes specified in options
       ...client.options.prefixes ?? [],
       // Use bot mention as prefix if enabled
-      ...enableMentionPrefix ? [client.user.toString()] : []
+      ...enableMentionPrefix ? [
+        client.user.toString()
+      ] : []
     ];
     const prefix = prefixes.find((p) => message.content.startsWith(p)) ?? null;
     if (!prefix) {
@@ -579,7 +658,6 @@ var ArgumentResolver = class _ArgumentResolver {
     return new _ArgumentResolver({
       message,
       startAt: 1,
-      // Skip the command trigger
       values,
       args: [],
       prefix
@@ -593,7 +671,9 @@ var ArgumentResolver = class _ArgumentResolver {
       args,
       startAt: this.options.startAt
     });
-    child.parsedValues = [...this.parsedValues];
+    child.parsedValues = [
+      ...this.parsedValues
+    ];
     if (!child.options.args.length) {
       return child;
     }
@@ -619,7 +699,7 @@ var ArgumentResolver = class _ArgumentResolver {
       if (matchedValue === null) {
         throw new CommandSyntaxError({
           arg,
-          type: "INVALID_ARGUMENT" /* InvalidArgument */,
+          type: CommandSyntaxErrorType.InvalidArgument,
           received: value
         });
       }
@@ -646,7 +726,7 @@ var ArgumentResolver = class _ArgumentResolver {
       } else if (arg.required) {
         throw new CommandSyntaxError({
           arg,
-          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
+          type: CommandSyntaxErrorType.MissingRequireArgument,
           received: value
         });
       }
@@ -657,7 +737,7 @@ var ArgumentResolver = class _ArgumentResolver {
       if (arg.required) {
         throw new CommandSyntaxError({
           arg,
-          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
+          type: CommandSyntaxErrorType.MissingRequireArgument,
           received: "nothing"
         });
       }
@@ -675,7 +755,7 @@ var ArgumentResolver = class _ArgumentResolver {
       if (matchedValue === null) {
         throw new CommandSyntaxError({
           arg,
-          type: "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */,
+          type: CommandSyntaxErrorType.InvalidVariadicArgumentValue,
           received: rest
         });
       }
@@ -684,7 +764,7 @@ var ArgumentResolver = class _ArgumentResolver {
     if (values.length === 0 && arg.required) {
       throw new CommandSyntaxError({
         arg,
-        type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
+        type: CommandSyntaxErrorType.MissingRequireArgument,
         received: "nothing"
       });
     }
@@ -692,13 +772,13 @@ var ArgumentResolver = class _ArgumentResolver {
   }
   async matchValue(arg, value) {
     switch (arg.type) {
-      case "user" /* User */:
+      case ArgumentType.User:
         return await this.matchUserValue(arg, value);
-      case "integer" /* Integer */:
+      case ArgumentType.Integer:
         return this.matchIntegerValue(arg, value);
-      case "number" /* Number */:
+      case ArgumentType.Number:
         return this.matchNumberValue(arg, value);
-      case "string" /* String */:
+      case ArgumentType.String:
         return this.matchStringValue(arg, value);
       default:
         return null;
@@ -752,15 +832,15 @@ var ArgumentResolver = class _ArgumentResolver {
   }
   static resolveChatInput(interaction, arg) {
     switch (arg.type) {
-      case "string" /* String */:
+      case ArgumentType.String:
         return interaction.options.getString(arg.name, arg.required);
-      case "integer" /* Integer */:
+      case ArgumentType.Integer:
         return interaction.options.getInteger(arg.name, arg.required);
-      case "number" /* Number */:
+      case ArgumentType.Number:
         return interaction.options.getNumber(arg.name, arg.required);
-      case "user" /* User */:
+      case ArgumentType.User:
         return interaction.options.getUser(arg.name, arg.required);
-      case "member" /* Member */:
+      case ArgumentType.Member:
         return interaction.options.getMember(arg.name);
       default:
         return null;
@@ -771,6 +851,9 @@ var ArgumentResolver = class _ArgumentResolver {
 // src/libs/StateBox.ts
 import { AsyncLocalStorage } from "async_hooks";
 var StateBox = class _StateBox {
+  static {
+    __name(this, "StateBox");
+  }
   static STATES_KEY = Symbol("states");
   static storage = new AsyncLocalStorage();
   static getState() {
@@ -813,46 +896,61 @@ var StateBox = class _StateBox {
 
 // src/listener/ListenerEntry.ts
 var ListenerEntry = class extends BaseEntry {
+  static {
+    __name(this, "ListenerEntry");
+  }
+  options;
   constructor(options) {
-    super();
-    this.options = options;
+    super(), this.options = options;
   }
 };
 
 // src/listener/Listener.ts
-var ListenerAPI;
-((ListenerAPI2) => {
+(function(ListenerAPI2) {
   ListenerAPI2.ENTRY_KEY = Symbol("entry");
   function use(entry) {
     return (target) => {
       Reflect.defineMetadata(ListenerAPI2.ENTRY_KEY, entry, target);
     };
   }
+  __name(use, "use");
   ListenerAPI2.use = use;
   function getEntry(target) {
     return Reflect.getMetadata(ListenerAPI2.ENTRY_KEY, target);
   }
+  __name(getEntry, "getEntry");
   ListenerAPI2.getEntry = getEntry;
 })(ListenerAPI || (ListenerAPI = {}));
 function ListenerFactory(options) {
-  const fullOptions = typeof options !== "object" ? { name: options, once: false } : { once: false, ...options };
+  const fullOptions = typeof options !== "object" ? {
+    name: options,
+    once: false
+  } : {
+    once: false,
+    ...options
+  };
   return new ListenerEntry(fullOptions);
 }
+__name(ListenerFactory, "ListenerFactory");
 var Listener = Object.assign(ListenerFactory, ListenerAPI);
+var ListenerAPI;
 
 // src/listener/ListenerRegistry.ts
 import glob2 from "tiny-glob";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var ListenerRegistry = class {
+  static {
+    __name(this, "ListenerRegistry");
+  }
   static client;
   static constructors = /* @__PURE__ */ new Set();
   static instances = /* @__PURE__ */ new WeakMap();
   static executors = /* @__PURE__ */ new WeakMap();
   /**
-   * Add and register a listener to the registry.
-   * If `options.emitter` is not provided, the registry will use the base `client` by default.
-   * @param constructor The listener class you want to add.
-   */
+  * Add and register a listener to the registry.
+  * If `options.emitter` is not provided, the registry will use the base `client` by default.
+  * @param constructor The listener class you want to add.
+  */
   static add(constructor) {
     const entry = Listener.getEntry(constructor);
     if (!entry) {
@@ -875,10 +973,10 @@ var ListenerRegistry = class {
     });
   }
   /**
-   * Remove and unregister a listener from the registry.
-   * @param constructor The listener class you want to remove.
-   * @returns `boolean`, returns `true` if the listener is removed successfully.
-   */
+  * Remove and unregister a listener from the registry.
+  * @param constructor The listener class you want to remove.
+  * @returns `boolean`, returns `true` if the listener is removed successfully.
+  */
   static remove(constructor) {
     const entry = Listener.getEntry(constructor);
     if (!entry) {
@@ -900,9 +998,9 @@ var ListenerRegistry = class {
     return true;
   }
   /**
-   * Remove and unregister all listeners from the registry.
-   * @returns Amount of removed listeners.
-   */
+  * Remove and unregister all listeners from the registry.
+  * @returns Amount of removed listeners.
+  */
   static removeAll() {
     let removedAmount = 0;
     for (const constructor of this.constructors) {
@@ -913,9 +1011,9 @@ var ListenerRegistry = class {
     return removedAmount;
   }
   /**
-   * Set base client for the registry to fallback as default emitter. This should be used only by BakitClient and stay untouched.
-   * @param newClient base client to set for the registry.
-   */
+  * Set base client for the registry to fallback as default emitter. This should be used only by BakitClient and stay untouched.
+  * @param newClient base client to set for the registry.
+  */
   static setClient(newClient) {
     this.client = newClient;
   }
@@ -926,10 +1024,10 @@ var ListenerRegistry = class {
     }
     const { hooks } = entry;
     return async function(...args) {
-      const mainHook = hooks["MAIN" /* Main */];
-      const preHook = hooks["PRE" /* Pre */];
-      const postHook = hooks["POST" /* Post */];
-      const errorHook = hooks["ERROR" /* Error */];
+      const mainHook = hooks[HookExecutionState.Main];
+      const preHook = hooks[HookExecutionState.Pre];
+      const postHook = hooks[HookExecutionState.Post];
+      const errorHook = hooks[HookExecutionState.Error];
       if (!mainHook) {
         return;
       }
@@ -943,11 +1041,7 @@ var ListenerRegistry = class {
         }
       } catch (error) {
         if (errorHook) {
-          await errorHook.method.call(
-            instance,
-            error,
-            ...args
-          );
+          await errorHook.method.call(instance, error, ...args);
         } else {
           throw error;
         }
@@ -955,11 +1049,11 @@ var ListenerRegistry = class {
     };
   }
   /**
-   * Load and add all listeners which matched provided glob pattern to the registry.
-   * @param pattern glob pattern to load.
-   * @param parallel load all matched results in parallel, enabled by default.
-   * @returns All loaded listener constructors.
-   */
+  * Load and add all listeners which matched provided glob pattern to the registry.
+  * @param pattern glob pattern to load.
+  * @param parallel load all matched results in parallel, enabled by default.
+  * @returns All loaded listener constructors.
+  */
   static async load(pattern, parallel = true) {
     const files = await glob2(pattern);
     const loaders = files.map(async (file) => {
@@ -981,20 +1075,20 @@ var ListenerRegistry = class {
 
 // src/BakitClient.ts
 var BakitClient = class _BakitClient extends Client {
+  static {
+    __name(this, "BakitClient");
+  }
   constructor(options) {
     if (options.getSyntaxErrorMessage === void 0) {
       options.getSyntaxErrorMessage = _BakitClient.getSyntaxErrorMessage;
     }
     super(options);
     ListenerRegistry["setClient"](this);
-    this.once(
-      Events.ClientReady,
-      (client) => void this.registerApplicationCommands(client)
-    );
+    this.once(Events.ClientReady, (client) => void this.registerApplicationCommands(client));
     this.on(Events.InteractionCreate, (interaction) => void this.handleInteraction(interaction));
     this.on(Events.MessageCreate, (message) => void this.handleMessage(message));
   }
-  static getSyntaxErrorMessage = (command, error, context, args, prefix) => {
+  static getSyntaxErrorMessage = /* @__PURE__ */ __name((command, error, context, args, prefix) => {
     const requiredSyntax = args.map((x) => Arg.format(x)).join(" ");
     const root = Command.getRoot(command.constructor);
     if (!root) {
@@ -1008,7 +1102,7 @@ var BakitClient = class _BakitClient extends Client {
     return {
       content
     };
-  };
+  }, "getSyntaxErrorMessage");
   async registerApplicationCommands(client) {
     const commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
     await client.application.commands.set(commands);
@@ -1044,7 +1138,11 @@ var BakitClient = class _BakitClient extends Client {
   async handleChatInputHooks(context, instance) {
     const targetHooks = this.getChatInputTargetHooks(context.source, instance);
     let inheritedArgs = [];
-    for (const hooks of [targetHooks.root, targetHooks.group, targetHooks.subcommand]) {
+    for (const hooks of [
+      targetHooks.root,
+      targetHooks.group,
+      targetHooks.subcommand
+    ]) {
       if (!hooks) {
         continue;
       }
@@ -1084,7 +1182,7 @@ var BakitClient = class _BakitClient extends Client {
     }
   }
   async runMessageHooks(context, instance, hooks, resolver) {
-    const mainHook = hooks["MAIN" /* Main */];
+    const mainHook = hooks[HookExecutionState.Main];
     if (!mainHook) {
       return resolver;
     }
@@ -1093,13 +1191,7 @@ var BakitClient = class _BakitClient extends Client {
       resolver = await resolver.resolve(args);
     } catch (error) {
       if (error instanceof CommandSyntaxError) {
-        const errorContent = await this.options.getSyntaxErrorMessage?.(
-          instance,
-          error,
-          context,
-          args,
-          resolver.options.prefix
-        );
+        const errorContent = await this.options.getSyntaxErrorMessage?.(instance, error, context, args, resolver.options.prefix);
         if (errorContent) {
           await context.send(errorContent);
         }
@@ -1111,35 +1203,36 @@ var BakitClient = class _BakitClient extends Client {
     return resolver;
   }
   async runChatInputHooks(context, instance, hooks, inheritedArgs) {
-    const mainHook = hooks["MAIN" /* Main */];
+    const mainHook = hooks[HookExecutionState.Main];
     if (!mainHook) {
       return;
     }
-    const newArgs = Arg.getMethodArguments(mainHook.method).map(
-      (arg) => ArgumentResolver.resolveChatInput(context.source, arg)
-    );
-    const argValues = [...inheritedArgs, ...newArgs];
+    const newArgs = Arg.getMethodArguments(mainHook.method).map((arg) => ArgumentResolver.resolveChatInput(context.source, arg));
+    const argValues = [
+      ...inheritedArgs,
+      ...newArgs
+    ];
     await this.runHooks(context, instance, hooks, argValues);
     return argValues;
   }
   async runHooks(context, instance, hooks, args) {
-    const mainHook = hooks["MAIN" /* Main */];
-    const preHook = hooks["PRE" /* Pre */];
-    const postHook = hooks["POST" /* Post */];
-    const errorHook = hooks["ERROR" /* Error */];
+    const mainHook = hooks[HookExecutionState.Main];
+    const preHook = hooks[HookExecutionState.Pre];
+    const postHook = hooks[HookExecutionState.Post];
+    const errorHook = hooks[HookExecutionState.Error];
     if (!mainHook) {
       return;
     }
-    const execute = async (hook, error) => {
+    const execute = /* @__PURE__ */ __name(async (hook, error) => {
       if (!hook) {
         return;
       }
-      if (hook.state === "ERROR" /* Error */) {
+      if (hook.state === HookExecutionState.Error) {
         await hook.method.call(instance, error, context, ...args);
       } else {
         await hook.method.call(instance, context, ...args);
       }
-    };
+    }, "execute");
     try {
       await execute(preHook);
       await execute(mainHook);