bakit 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/index.js

@@ -1,48 +1,25 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/index.ts
-import "reflect-metadata";
+import { Collection, SlashCommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandBuilder, ChatInputCommandInteraction, Message, Client, Events, codeBlock } from 'discord.js';
+import glob from 'tiny-glob';
+import { pathToFileURL } from 'url';
+import { AsyncLocalStorage } from 'async_hooks';
 
 // src/BakitClient.ts
-import { Client, codeBlock, Events } from "discord.js";
-
-// src/command/CommandRegistry.ts
-import { Collection as Collection2, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandGroupBuilder } from "discord.js";
-import glob from "tiny-glob";
-import { pathToFileURL } from "url";
-
-// src/command/CommandEntry.ts
-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"]: void 0,
-    ["ERROR"]: void 0,
-    ["POST"]: void 0,
-    ["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");
-    this.pre = this.createMainHookDecorator("PRE");
-    this.post = this.createMainHookDecorator("POST");
-    this.error = this.createMainHookDecorator("ERROR");
+    this.main = this.createMainHookDecorator("MAIN" /* Main */), this.pre = this.createMainHookDecorator("PRE" /* Pre */), this.post = this.createMainHookDecorator("POST" /* Post */), this.error = this.createMainHookDecorator("ERROR" /* Error */);
   }
   setTarget(target) {
     this.target = target;
@@ -58,14 +35,12 @@ var BaseEntry = class {
     };
   }
   addHook(state, target, descriptor) {
-    if (this.target && this.target !== target.constructor) {
+    if (this.target && this.target !== target.constructor)
       throw new Error("Hook is used at wrong constructor.");
-    }
-    const { value: method } = descriptor;
-    if (typeof method !== "function") {
+    let { value: method } = descriptor;
+    if (typeof method != "function")
       throw new Error("Invalid target method for hook.");
-    }
-    const hook = {
+    let hook = {
       state,
       method,
       entry: this
@@ -76,210 +51,99 @@ var BaseEntry = class {
 
 // src/command/CommandEntry.ts
 var BaseCommandEntry = class extends BaseEntry {
-  static {
-    __name(this, "BaseCommandEntry");
-  }
-  options;
   constructor(options) {
-    super(), this.options = options;
-  }
-};
-var BaseCommandGroupEntry = class extends BaseCommandEntry {
-  static {
-    __name(this, "BaseCommandGroupEntry");
+    super();
+    this.options = options;
   }
+}, BaseCommandGroupEntry = class extends BaseCommandEntry {
   children = new Collection();
   subcommand(options) {
-    const fullOptions = typeof options === "string" ? {
-      name: options,
-      description: `${options} command`
-    } : {
-      description: `${options.name} command`,
-      ...options
-    };
-    if (this.children.has(fullOptions.name)) {
+    let 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.`);
-    }
-    const subcommand = new SubcommandEntry(fullOptions, this);
-    this.children.set(fullOptions.name, subcommand);
-    return subcommand;
-  }
-};
-var RootCommandEntry = class extends BaseCommandGroupEntry {
-  static {
-    __name(this, "RootCommandEntry");
+    let subcommand = new SubcommandEntry(fullOptions, this);
+    return this.children.set(fullOptions.name, subcommand), subcommand;
   }
+}, RootCommandEntry = class extends BaseCommandGroupEntry {
   group(options) {
-    const fullOptions = typeof options === "string" ? {
-      name: options,
-      description: `${options} command`
-    } : {
-      description: `${options.name} command`,
-      ...options
-    };
-    if (this.children.has(fullOptions.name)) {
+    let 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.`);
-    }
-    const group = new CommandGroupEntry(fullOptions, this);
-    this.children.set(fullOptions.name, group);
-    return group;
+    let group = new CommandGroupEntry(fullOptions, this);
+    return this.children.set(fullOptions.name, group), group;
   }
-};
-var CommandGroupEntry = class extends BaseCommandGroupEntry {
-  static {
-    __name(this, "CommandGroupEntry");
-  }
-  parent;
+}, CommandGroupEntry = class extends BaseCommandGroupEntry {
   constructor(options, parent) {
-    super(options), this.parent = parent;
-  }
-};
-var SubcommandEntry = class extends BaseCommandEntry {
-  static {
-    __name(this, "SubcommandEntry");
+    super(options);
+    this.parent = parent;
   }
-  parent;
+}, SubcommandEntry = class extends BaseCommandEntry {
   constructor(options, parent) {
-    super(options), this.parent = parent;
+    super(options);
+    this.parent = parent;
   }
 };
 
 // src/command/Command.ts
-(function(CommandAPI2) {
-  const rootEntries = /* @__PURE__ */ new WeakMap();
+var CommandAPI;
+((CommandAPI2) => {
+  let rootEntries = /* @__PURE__ */ new WeakMap();
   function use(root) {
     return (target) => {
-      root.setTarget(target);
-      rootEntries.set(target, root);
+      root.setTarget(target), 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 = {}));
+})(CommandAPI ||= {});
 function CommandFactory(options) {
-  if (typeof options === "string") {
-    options = {
-      name: options
-    };
-  }
-  if (!options.description) {
-    options.description = options.name;
-  }
-  return new RootCommandEntry(options);
+  return typeof options == "string" && (options = { name: options }), options.description || (options.description = options.name), new RootCommandEntry(options);
 }
-__name(CommandFactory, "CommandFactory");
 var Command = Object.assign(CommandFactory, CommandAPI);
-var CommandAPI;
 
 // src/command/argument/Argument.ts
-var ArgumentType = /* @__PURE__ */ (function(ArgumentType2) {
-  ArgumentType2["String"] = "string";
-  ArgumentType2["Integer"] = "integer";
-  ArgumentType2["Number"] = "number";
-  ArgumentType2["User"] = "user";
-  ArgumentType2["Member"] = "member";
-  return ArgumentType2;
-})({});
+var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => (ArgumentType2.String = "string", ArgumentType2.Integer = "integer", ArgumentType2.Number = "number", ArgumentType2.User = "user", ArgumentType2.Member = "member", ArgumentType2))(ArgumentType || {});
 
 // src/command/argument/Arg.ts
-var ARGS_KEY = Symbol("args");
-var cache = /* @__PURE__ */ new WeakMap();
+var store = /* @__PURE__ */ new WeakMap();
 function getMethodArguments(method, init = false) {
-  let args = cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
-  if (!args) {
-    args = [];
-    if (init) {
-      Reflect.defineMetadata(ARGS_KEY, args, method);
-      cache.set(method, args);
-    }
-  }
-  return init ? args : Object.freeze([
-    ...args
-  ]);
+  let args = store.get(method);
+  return args || (args = [], init && store.set(method, args)), 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
-    };
-    if (!fullOptions.description) {
-      fullOptions.description = fullOptions.name;
-    }
-    if (!("required" in fullOptions)) {
-      fullOptions.required = true;
-    }
-    return function(target, key, _index) {
-      const method = Object.getOwnPropertyDescriptor(target, key)?.value;
-      if (!method) {
+    let fullOptions = { ...typeof options == "string" ? { name: options } : options, type };
+    return fullOptions.description || (fullOptions.description = fullOptions.name), "required" in fullOptions || (fullOptions.required = true), function(target, key, _index) {
+      let method = Object.getOwnPropertyDescriptor(target, key)?.value;
+      if (!method)
         throw new Error("No method found");
-      }
-      const args = getMethodArguments(method, true);
-      args.unshift(fullOptions);
+      getMethodArguments(method, true).unshift(fullOptions);
     };
   };
 }
-__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);
+var string = createArgument("string" /* String */), integer = createArgument("integer" /* Integer */), number = createArgument("number" /* Number */), user = createArgument("user" /* User */), member = createArgument("member" /* Member */);
 function describeArgumentExpectation(arg) {
-  const parts = [
-    arg.type
-  ];
+  let parts = [arg.type];
   switch (arg.type) {
-    case ArgumentType.String: {
-      if (arg.minLength && !arg.maxLength) {
-        parts.push(`\u2265 ${String(arg.minLength)}`);
-      }
-      if (!arg.minLength && arg.maxLength) {
-        parts.push(`\u2264 ${String(arg.maxLength)}`);
-      }
-      if (arg.minLength && arg.maxLength) {
-        parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
-      }
+    case "string" /* String */: {
+      arg.minLength && !arg.maxLength && parts.push(`\u2265 ${String(arg.minLength)}`), !arg.minLength && arg.maxLength && parts.push(`\u2264 ${String(arg.maxLength)}`), arg.minLength && arg.maxLength && parts.push(`${String(arg.minLength)} - ${String(arg.maxLength)}`);
       break;
     }
-    case ArgumentType.Number:
-    case ArgumentType.Integer: {
-      if (arg.minValue !== void 0 && arg.maxValue === void 0) {
-        parts.push(`\u2265 ${String(arg.minValue)}`);
-      }
-      if (arg.minValue === void 0 && arg.maxValue !== void 0) {
-        parts.push(`\u2264 ${String(arg.maxValue)}`);
-      }
-      if (arg.minValue !== void 0 && arg.maxValue !== void 0) {
-        parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
-      }
-      break;
-    }
-    case ArgumentType.User:
-    case ArgumentType.Member: {
+    case "number" /* Number */:
+    case "integer" /* Integer */: {
+      arg.minValue !== void 0 && arg.maxValue === void 0 && parts.push(`\u2265 ${String(arg.minValue)}`), arg.minValue === void 0 && arg.maxValue !== void 0 && parts.push(`\u2264 ${String(arg.maxValue)}`), arg.minValue !== void 0 && arg.maxValue !== void 0 && parts.push(`${String(arg.minValue)} - ${String(arg.maxValue)}`);
       break;
     }
   }
   return parts.join(", ");
 }
-__name(describeArgumentExpectation, "describeArgumentExpectation");
 function format(arg) {
-  const { name, required, tuple } = arg;
-  const opening = required ? "<" : "[";
-  const closing = required ? ">" : "]";
-  const prefix = tuple ? "..." : "";
-  return `${opening}${prefix}${name}: ${describeArgumentExpectation(arg)}${closing}`;
+  let { name, required, tuple } = arg, opening = required ? "<" : "[", closing = required ? ">" : "]";
+  return `${opening}${tuple ? "..." : ""}${name}: ${describeArgumentExpectation(arg)}${closing}`;
 }
-__name(format, "format");
 var Arg = {
   getMethodArguments,
   createArgument,
@@ -294,164 +158,108 @@ var Arg = {
 
 // src/command/CommandRegistry.ts
 var CommandRegistry = class _CommandRegistry {
-  static {
-    __name(this, "CommandRegistry");
-  }
-  static constructors = new Collection2();
-  static instances = new Collection2();
+  static constructors = new Collection();
+  static instances = new Collection();
   /**
-  * 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) {
+    let root = Command.getRoot(constructor);
+    if (!root)
       throw new Error(`No root found for "${constructor.name}"`);
-    }
-    const { options } = root;
-    this.constructors.set(options.name, constructor);
-    this.instances.set(options.name, new constructor());
+    let { options } = root;
+    this.constructors.set(options.name, constructor), 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) => {
-      const fileURL = pathToFileURL(file).toString();
-      const { default: constructor } = await import(fileURL);
-      _CommandRegistry.add(constructor);
-      return constructor;
+    let loaders = (await glob(pattern)).map(async (file) => {
+      let fileURL = pathToFileURL(file).toString(), { default: constructor } = await import(fileURL);
+      return _CommandRegistry.add(constructor), constructor;
     });
-    if (parallel) {
+    if (parallel)
       return await Promise.all(loaders);
-    }
-    const result = [];
-    for (const loader of loaders) {
+    let result = [];
+    for (let loader of loaders)
       result.push(await loader);
-    }
     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) {
+    let root = Command.getRoot(constructor);
+    if (!root)
       throw new Error(`No root found for "${constructor.name}"`);
-    }
-    const { options } = root;
-    const builder = new SlashCommandBuilder().setName(options.name).setDescription(options.description).setNSFW(Boolean(options.nsfw));
-    const args = this.getMainHookArguments(root);
-    if (root.children.size) {
-      this.buildSlashCommandSubcommands(builder, root, args);
-    } else {
-      this.buildSlashCommandOptions(builder, args);
-    }
-    return builder.toJSON();
+    let { options } = root, builder = new SlashCommandBuilder().setName(options.name).setDescription(options.description).setNSFW(!!options.nsfw), args = this.getMainHookArguments(root);
+    return root.children.size ? this.buildSlashCommandSubcommands(builder, root, args) : this.buildSlashCommandOptions(builder, args), builder.toJSON();
   }
   static getMainHookArguments(entry) {
-    const { hooks } = entry;
-    const mainHook = hooks[HookExecutionState.Main];
+    let { hooks } = entry, mainHook = hooks.MAIN;
     return mainHook ? Arg.getMethodArguments(mainHook.method) : [];
   }
   static buildSlashCommandSubcommands(parent, entry, inheritedArgs) {
-    const { children } = entry;
-    for (const child of children.values()) {
+    let { children } = entry;
+    for (let child of children.values())
       if (child instanceof CommandGroupEntry && parent instanceof SlashCommandBuilder) {
-        const { options } = child;
-        const group = new SlashCommandSubcommandGroupBuilder().setName(options.name).setDescription(options.description);
+        let { options } = child, group = new SlashCommandSubcommandGroupBuilder().setName(options.name).setDescription(options.description);
         this.buildSlashCommandSubcommands(group, child, [
           ...inheritedArgs,
           ...this.getMainHookArguments(child)
-        ]);
-        parent.addSubcommandGroup(group);
+        ]), parent.addSubcommandGroup(group);
       } else if (child instanceof SubcommandEntry) {
-        const { options } = child;
-        const subcommand = new SlashCommandSubcommandBuilder().setName(options.name).setDescription(options.description);
+        let { options } = child, subcommand = new SlashCommandSubcommandBuilder().setName(options.name).setDescription(options.description);
         this.buildSlashCommandOptions(subcommand, [
           ...inheritedArgs,
           ...this.getMainHookArguments(child)
-        ]);
-        parent.addSubcommand(subcommand);
+        ]), parent.addSubcommand(subcommand);
       }
-    }
   }
   static buildSlashCommandOptions(builder, args) {
-    const argGroup = Object.groupBy(args, ({ required }) => required ? "required" : "optional");
-    const orderedArgs = [
-      ...argGroup.required || [],
-      ...argGroup.optional || []
-    ];
-    for (const arg of orderedArgs) {
+    let argGroup = Object.groupBy(args, ({ required }) => required ? "required" : "optional"), orderedArgs = [...argGroup.required || [], ...argGroup.optional || []];
+    for (let arg of orderedArgs)
       this.attachSlashCommandOption(builder, arg);
-    }
   }
   static attachSlashCommandOption(builder, arg) {
-    const setupOption = /* @__PURE__ */ __name((option) => {
-      return option.setName(arg.name).setDescription(arg.description || arg.name).setRequired(Boolean(arg.required));
-    }, "setupOption");
+    let setupOption = (option) => option.setName(arg.name).setDescription(arg.description || arg.name).setRequired(!!arg.required);
     switch (arg.type) {
-      case ArgumentType.String: {
+      case "string" /* String */: {
         builder.addStringOption((data) => {
-          const option = setupOption(data);
-          if (arg.maxLength) {
-            option.setMaxLength(arg.maxLength);
-          }
-          if (arg.minLength) {
-            option.setMinLength(arg.minLength);
-          }
-          return option;
+          let option = setupOption(data);
+          return arg.maxLength && option.setMaxLength(arg.maxLength), arg.minLength && option.setMinLength(arg.minLength), option;
         });
         break;
       }
-      case ArgumentType.Integer: {
+      case "integer" /* Integer */: {
         builder.addIntegerOption((data) => {
-          const option = setupOption(data);
-          if (arg.maxValue) {
-            option.setMaxValue(arg.maxValue);
-          }
-          if (arg.minValue) {
-            option.setMinValue(arg.minValue);
-          }
-          return option;
+          let option = setupOption(data);
+          return arg.maxValue && option.setMaxValue(arg.maxValue), arg.minValue && option.setMinValue(arg.minValue), option;
         });
         break;
       }
-      case ArgumentType.Number: {
+      case "number" /* Number */: {
         builder.addNumberOption((data) => {
-          const option = setupOption(data);
-          if (arg.maxValue) {
-            option.setMaxValue(arg.maxValue);
-          }
-          if (arg.minValue) {
-            option.setMinValue(arg.minValue);
-          }
-          return option;
+          let option = setupOption(data);
+          return arg.maxValue && option.setMaxValue(arg.maxValue), arg.minValue && option.setMinValue(arg.minValue), option;
         });
         break;
       }
-      case ArgumentType.User:
-      case ArgumentType.Member: {
+      case "user" /* User */:
+      case "member" /* Member */: {
         builder.addUserOption((option) => setupOption(option));
         break;
       }
     }
   }
 };
-
-// src/command/Context.ts
-import { ChatInputCommandInteraction, Message } from "discord.js";
 var BaseContext = class {
-  static {
-    __name(this, "BaseContext");
-  }
-  source;
   constructor(source) {
     this.source = source;
   }
@@ -471,25 +279,21 @@ var BaseContext = class {
     return this.source.guildId;
   }
   inGuild() {
-    return Boolean(this.guildId);
+    return !!this.guildId;
   }
   inCachedGuild() {
-    if (this.isChatInput()) {
+    if (this.isChatInput())
       return this.source.inCachedGuild();
-    } else if (this.isMessage()) {
+    if (this.isMessage())
       return this.source.inGuild();
-    } else {
-      throw new Error("Invalid source");
-    }
+    throw new Error("Invalid source");
   }
   get author() {
-    if (this.isChatInput()) {
+    if (this.isChatInput())
       return this.source.user;
-    } else if (this.isMessage()) {
+    if (this.isMessage())
       return this.source.author;
-    } else {
-      throw new Error("Invalid source");
-    }
+    throw new Error("Invalid source");
   }
   isChatInput() {
     return this.source instanceof ChatInputCommandInteraction;
@@ -497,96 +301,63 @@ var BaseContext = class {
   isMessage() {
     return this.source instanceof Message;
   }
-};
-var ChatInputContext = class extends BaseContext {
-  static {
-    __name(this, "ChatInputContext");
-  }
+}, ChatInputContext = class extends BaseContext {
   async send(options) {
-    if (typeof options === "string") {
-      options = {
-        content: options
-      };
-    }
-    const sendOptions = {
+    typeof options == "string" && (options = { content: options });
+    let sendOptions = {
       ...options,
       withResponse: true
     };
-    if (this.source.deferred || this.source.replied) {
-      return await this.source.followUp(sendOptions);
-    }
-    const response = await this.source.reply(sendOptions);
-    return response.resource?.message;
-  }
-};
-var MessageContext = class extends BaseContext {
-  static {
-    __name(this, "MessageContext");
+    return this.source.deferred || this.source.replied ? await this.source.followUp(sendOptions) : (await this.source.reply(sendOptions)).resource?.message;
   }
+}, MessageContext = class extends BaseContext {
   async send(options) {
-    const { channel } = this;
-    if (!channel?.isSendable()) {
+    let { channel } = this;
+    if (!channel?.isSendable())
       throw new Error("Invalid channel or channel is not sendable");
-    }
     return await channel.send(options);
   }
 };
 
 // src/utils/user.ts
 function extractId(value) {
-  const idMatch = value.match(/^<@!?(\d+)>$/);
-  if (idMatch) {
+  let idMatch = value.match(/^<@!?(\d+)>$/);
+  if (idMatch)
     return idMatch[1];
-  }
-  const numericMatch = value.match(/^(\d{17,19})$/);
-  if (numericMatch) {
-    return numericMatch[1];
-  }
-  return null;
+  let numericMatch = value.match(/^(\d{17,19})$/);
+  return numericMatch ? numericMatch[1] : null;
 }
-__name(extractId, "extractId");
 
 // src/errors/CommandSyntaxError.ts
-var CommandSyntaxErrorType = /* @__PURE__ */ (function(CommandSyntaxErrorType2) {
-  CommandSyntaxErrorType2["MissingRequireArgument"] = "MISSING_REQUIRE_ARGUMENT";
-  CommandSyntaxErrorType2["InvalidArgument"] = "INVALID_ARGUMENT";
-  CommandSyntaxErrorType2["InvalidVariadicArgumentValue"] = "INVALID_VARIADIC_ARGUMENT_VALUE";
-  return CommandSyntaxErrorType2;
-})({});
-var CommandSyntaxError = class extends Error {
-  static {
-    __name(this, "CommandSyntaxError");
-  }
+var CommandSyntaxErrorType = /* @__PURE__ */ ((CommandSyntaxErrorType2) => (CommandSyntaxErrorType2.MissingRequireArgument = "MISSING_REQUIRE_ARGUMENT", CommandSyntaxErrorType2.InvalidArgument = "INVALID_ARGUMENT", CommandSyntaxErrorType2.InvalidVariadicArgumentValue = "INVALID_VARIADIC_ARGUMENT_VALUE", CommandSyntaxErrorType2))(CommandSyntaxErrorType || {}), CommandSyntaxError = class extends Error {
   arg;
   type;
   expected;
   received;
   constructor(options) {
-    let message;
-    const { arg, type, received } = options;
-    const expected = Arg.describeArgumentExpectation(arg);
+    let message, { arg, type, received } = options, expected = Arg.describeArgumentExpectation(arg);
     switch (type) {
-      case "MISSING_REQUIRE_ARGUMENT": {
-        message = [
-          `Missing required argument "${arg.name}"`,
-          `> Expected: ${expected}`
-        ].join("\n");
+      case "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */: {
+        message = [`Missing required argument "${arg.name}"`, `> Expected: ${expected}`].join(`
+`);
         break;
       }
-      case "INVALID_ARGUMENT": {
+      case "INVALID_ARGUMENT" /* InvalidArgument */: {
         message = [
           `Invalid value received for argument "${arg.name}"`,
           `> Expected: ${expected}`,
           `> Received: ${String(received)}`
-        ].join("\n");
+        ].join(`
+`);
         break;
       }
-      case "INVALID_VARIADIC_ARGUMENT_VALUE": {
+      case "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */: {
         message = [
           `Invalid value received for variadic argument "${arg.name}"`,
           `> Expected: ${expected}`,
           `> Received: ${String(received)}`
-        ].join("\n");
+        ].join(`
+`);
         break;
       }
       default: {
@@ -594,12 +365,7 @@ var CommandSyntaxError = class extends Error {
         break;
       }
     }
-    super(message);
-    this.arg = arg;
-    this.type = type;
-    this.expected = expected;
-    this.received = received;
-    Error.captureStackTrace(this, this.constructor);
+    super(message), this.arg = arg, this.type = type, this.expected = expected, this.received = received, Error.captureStackTrace(this, this.constructor);
   }
   get name() {
     return `CommandSyntaxError[${this.type}]`;
@@ -608,283 +374,207 @@ 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;
   }
   static create(message) {
-    const client = message.client;
-    const { enableMentionPrefix } = client.options;
-    const prefixes = [
+    let client = message.client, { enableMentionPrefix } = client.options, prefix = [
       // Custom prefixes specified in options
       ...client.options.prefixes ?? [],
       // Use bot mention as prefix if enabled
-      ...enableMentionPrefix ? [
-        client.user.toString()
-      ] : []
-    ];
-    const prefix = prefixes.find((p) => message.content.startsWith(p)) ?? null;
-    if (!prefix) {
+      ...enableMentionPrefix ? [client.user.toString()] : []
+    ].find((p) => message.content.startsWith(p)) ?? null;
+    if (!prefix)
       return;
-    }
-    const values = message.content.slice(prefix.length).trim().split(/\s+/);
+    let values = message.content.slice(prefix.length).trim().split(/\s+/);
     return new _ArgumentResolver({
       message,
       startAt: 1,
+      // Skip the command trigger
       values,
       args: [],
       prefix
     });
   }
   async resolve(args) {
-    const child = new _ArgumentResolver({
+    let child = new _ArgumentResolver({
       prefix: this.options.prefix,
       message: this.options.message,
       values: this.options.values,
       args,
       startAt: this.options.startAt
     });
-    child.parsedValues = [
-      ...this.parsedValues
-    ];
-    if (!child.options.args.length) {
-      return child;
-    }
-    if (this.specifiedAmount >= child.options.args.length) {
-      await child.absoluteParse();
-    } else {
-      await child.dynamicParse();
-    }
-    return child;
+    return child.parsedValues = [...this.parsedValues], child.options.args.length && (this.specifiedAmount >= child.options.args.length ? await child.absoluteParse() : await child.dynamicParse()), child;
   }
   async absoluteParse() {
-    const { args, values, startAt } = this.options;
-    let valueIndex = startAt;
-    let argIndex = 0;
-    while (valueIndex < values.length && argIndex < args.length) {
-      const value = values[valueIndex];
-      const arg = args[argIndex];
+    let { args, values, startAt } = this.options, valueIndex = startAt, argIndex = 0;
+    for (; valueIndex < values.length && argIndex < args.length; ) {
+      let value = values[valueIndex], arg = args[argIndex];
       if (arg.tuple) {
         this.parsedValues.push(...await this.resolveTuple(arg, valueIndex, argIndex));
         break;
       }
-      const matchedValue = await this.matchValue(arg, value);
-      if (matchedValue === null) {
+      let matchedValue = await this.matchValue(arg, value);
+      if (matchedValue === null)
         throw new CommandSyntaxError({
           arg,
-          type: CommandSyntaxErrorType.InvalidArgument,
+          type: "INVALID_ARGUMENT" /* InvalidArgument */,
           received: value
         });
-      }
-      this.parsedValues.push(matchedValue);
-      valueIndex++;
-      argIndex++;
+      this.parsedValues.push(matchedValue), valueIndex++, argIndex++;
     }
   }
   async dynamicParse() {
-    const { args, values } = this.options;
-    let argIndex = 0;
-    let valueIndex = this.options.startAt + 1;
-    while (valueIndex < values.length && argIndex < args.length) {
-      const value = values[valueIndex];
-      const arg = args[argIndex];
+    let { args, values } = this.options, argIndex = 0, valueIndex = this.options.startAt + 1;
+    for (; valueIndex < values.length && argIndex < args.length; ) {
+      let value = values[valueIndex], arg = args[argIndex];
       if (arg.tuple) {
         this.parsedValues.push(...await this.resolveTuple(arg, valueIndex, argIndex));
         break;
       }
-      const matchedValue = await this.matchValue(arg, value);
-      if (matchedValue !== null) {
-        this.parsedValues.push(matchedValue);
-        valueIndex++;
-      } else if (arg.required) {
+      let matchedValue = await this.matchValue(arg, value);
+      if (matchedValue !== null)
+        this.parsedValues.push(matchedValue), valueIndex++;
+      else if (arg.required)
         throw new CommandSyntaxError({
           arg,
-          type: CommandSyntaxErrorType.MissingRequireArgument,
+          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
           received: value
         });
-      }
       argIndex++;
     }
-    while (argIndex < args.length) {
-      const arg = args[argIndex];
-      if (arg.required) {
+    for (; argIndex < args.length; ) {
+      let arg = args[argIndex];
+      if (arg.required)
         throw new CommandSyntaxError({
           arg,
-          type: CommandSyntaxErrorType.MissingRequireArgument,
+          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
           received: "nothing"
         });
-      }
       argIndex++;
     }
   }
   async resolveTuple(arg, startIndex, argIndex) {
-    const { args } = this.options;
-    if (argIndex !== args.length - 1) {
+    let { args } = this.options;
+    if (argIndex !== args.length - 1)
       throw new SyntaxError("Tuple argument must be the last argument");
-    }
-    const values = [];
-    for (const rest of this.values.slice(startIndex)) {
-      const matchedValue = await this.matchValue(arg, rest);
-      if (matchedValue === null) {
+    let values = [];
+    for (let rest of this.values.slice(startIndex)) {
+      let matchedValue = await this.matchValue(arg, rest);
+      if (matchedValue === null)
         throw new CommandSyntaxError({
           arg,
-          type: CommandSyntaxErrorType.InvalidVariadicArgumentValue,
+          type: "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */,
           received: rest
         });
-      }
       values.push(matchedValue);
     }
-    if (values.length === 0 && arg.required) {
+    if (values.length === 0 && arg.required)
       throw new CommandSyntaxError({
         arg,
-        type: CommandSyntaxErrorType.MissingRequireArgument,
+        type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
         received: "nothing"
       });
-    }
     return values;
   }
   async matchValue(arg, value) {
     switch (arg.type) {
-      case ArgumentType.User:
+      case "user" /* User */:
         return await this.matchUserValue(arg, value);
-      case ArgumentType.Integer:
+      case "integer" /* Integer */:
         return this.matchIntegerValue(arg, value);
-      case ArgumentType.Number:
+      case "number" /* Number */:
         return this.matchNumberValue(arg, value);
-      case ArgumentType.String:
+      case "string" /* String */:
         return this.matchStringValue(arg, value);
       default:
         return null;
     }
   }
   async matchUserValue(arg, value) {
-    const userId = extractId(value);
-    if (!userId) {
-      return null;
-    }
-    const user2 = await this.client.users.fetch(userId).catch(() => null);
-    if (!user2) {
+    let userId = extractId(value);
+    if (!userId)
       return null;
-    }
-    return user2;
+    let user2 = await this.client.users.fetch(userId).catch(() => null);
+    return user2 || null;
   }
   matchIntegerValue(arg, value) {
-    const intVal = parseInt(value, 10);
-    if (isNaN(intVal)) {
-      return null;
-    }
-    if (arg.minValue !== void 0 && intVal < arg.minValue) {
-      return null;
-    }
-    if (arg.maxValue !== void 0 && intVal > arg.maxValue) {
-      return null;
-    }
-    return intVal;
+    let intVal = parseInt(value, 10);
+    return isNaN(intVal) || arg.minValue !== void 0 && intVal < arg.minValue || arg.maxValue !== void 0 && intVal > arg.maxValue ? null : intVal;
   }
   matchNumberValue(arg, value) {
-    const numVal = parseFloat(value);
-    if (isNaN(numVal)) {
-      return null;
-    }
-    if (arg.minValue !== void 0 && numVal < arg.minValue) {
-      return null;
-    }
-    if (arg.maxValue !== void 0 && numVal > arg.maxValue) {
-      return null;
-    }
-    return numVal;
+    let numVal = parseFloat(value);
+    return isNaN(numVal) || arg.minValue !== void 0 && numVal < arg.minValue || arg.maxValue !== void 0 && numVal > arg.maxValue ? null : numVal;
   }
   matchStringValue(arg, value) {
-    if (arg.minLength !== void 0 && value.length < arg.minLength) {
-      return null;
-    }
-    if (arg.maxLength !== void 0 && value.length > arg.maxLength) {
-      return null;
-    }
-    return value;
+    return arg.minLength !== void 0 && value.length < arg.minLength || arg.maxLength !== void 0 && value.length > arg.maxLength ? null : value;
   }
   static resolveChatInput(interaction, arg) {
     switch (arg.type) {
-      case ArgumentType.String:
+      case "string" /* String */:
         return interaction.options.getString(arg.name, arg.required);
-      case ArgumentType.Integer:
+      case "integer" /* Integer */:
         return interaction.options.getInteger(arg.name, arg.required);
-      case ArgumentType.Number:
+      case "number" /* Number */:
         return interaction.options.getNumber(arg.name, arg.required);
-      case ArgumentType.User:
+      case "user" /* User */:
         return interaction.options.getUser(arg.name, arg.required);
-      case ArgumentType.Member:
+      case "member" /* Member */:
         return interaction.options.getMember(arg.name);
       default:
         return null;
     }
   }
 };
-
-// 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() {
-    const state = this.storage.getStore();
-    if (!state) {
+    let state = this.storage.getStore();
+    if (!state)
       throw new Error("No active context, did you forget to wrap it with StateBox.wrap()?");
-    }
     return state;
   }
-  static run(fn, store = {}) {
-    return this.storage.run(store, fn);
+  static run(fn, store2 = {}) {
+    return this.storage.run(store2, fn);
   }
   static wrap(fn) {
-    const currentStore = this.storage.getStore();
-    if (!currentStore) {
+    let currentStore = this.storage.getStore();
+    if (!currentStore)
       throw new Error("No active context, cannot wrap function outside a StateBox.run()");
-    }
     return () => this.run(fn, currentStore);
   }
   static use(defaultValue) {
     return (target, key) => {
       Object.defineProperty(target, key, {
         get() {
-          const states = _StateBox.getState();
-          if (!(key in states)) {
-            states[key] = defaultValue;
-          }
-          return states[key];
+          let states = _StateBox.getState();
+          return key in states || (states[key] = defaultValue), states[key];
         },
         set(value) {
-          const states = _StateBox.getState();
+          let states = _StateBox.getState();
           states[key] = value;
         },
         enumerable: true,
@@ -896,376 +586,258 @@ 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
-(function(ListenerAPI2) {
-  ListenerAPI2.ENTRY_KEY = Symbol("entry");
+var ListenerAPI;
+((ListenerAPI2) => {
+  let entries = /* @__PURE__ */ new WeakMap();
   function use(entry) {
     return (target) => {
-      Reflect.defineMetadata(ListenerAPI2.ENTRY_KEY, entry, target);
+      entries.set(target, entry);
     };
   }
-  __name(use, "use");
   ListenerAPI2.use = use;
   function getEntry(target) {
-    return Reflect.getMetadata(ListenerAPI2.ENTRY_KEY, target);
+    return entries.get(target);
   }
-  __name(getEntry, "getEntry");
   ListenerAPI2.getEntry = getEntry;
-})(ListenerAPI || (ListenerAPI = {}));
+})(ListenerAPI ||= {});
 function ListenerFactory(options) {
-  const fullOptions = typeof options !== "object" ? {
-    name: options,
-    once: false
-  } : {
-    once: false,
-    ...options
-  };
+  let 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) {
+    let entry = Listener.getEntry(constructor);
+    if (!entry)
       throw new Error(`No entry found for "${constructor.name}"`);
-    }
-    const { options } = entry;
+    let { options } = entry;
     if (!options.emitter) {
-      if (!this.client) {
+      if (!this.client)
         throw new Error("Client is not ready.");
-      }
       options.emitter = this.client;
     }
-    const instance = new constructor();
-    const executor = this.createExecutor(constructor, instance);
-    this.constructors.add(constructor);
-    this.instances.set(constructor, instance);
-    this.executors.set(instance, executor);
-    options.emitter[options.once ? "once" : "on"](options.name, (...args) => {
-      void executor(...args);
+    let instance = new constructor(), executor = this.createExecutor(constructor, instance);
+    this.constructors.add(constructor), this.instances.set(constructor, instance), this.executors.set(instance, executor), options.emitter[options.once ? "once" : "on"](options.name, (...args) => {
+      executor(...args);
     });
   }
   /**
-  * 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) {
+    let entry = Listener.getEntry(constructor);
+    if (!entry)
       return false;
-    }
     this.constructors.delete(constructor);
-    const instance = this.instances.get(constructor);
-    if (!instance) {
+    let instance = this.instances.get(constructor);
+    if (!instance)
       return false;
-    }
     this.instances.delete(constructor);
-    const executor = this.executors.get(instance);
-    if (!executor) {
+    let executor = this.executors.get(instance);
+    if (!executor)
       return false;
-    }
-    const { name, emitter } = entry.options;
-    emitter?.removeListener(name, executor);
-    this.executors.delete(instance);
-    return true;
+    let { name, emitter } = entry.options;
+    return emitter?.removeListener(name, executor), this.executors.delete(instance), 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) {
-      if (this.remove(constructor)) {
-        removedAmount++;
-      }
-    }
+    for (let constructor of this.constructors)
+      this.remove(constructor) && removedAmount++;
     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;
   }
   static createExecutor(constructor, instance) {
-    const entry = Listener.getEntry(constructor);
-    if (!entry) {
+    let entry = Listener.getEntry(constructor);
+    if (!entry)
       throw new Error("Missing listener entry");
-    }
-    const { hooks } = entry;
+    let { hooks } = entry;
     return async function(...args) {
-      const mainHook = hooks[HookExecutionState.Main];
-      const preHook = hooks[HookExecutionState.Pre];
-      const postHook = hooks[HookExecutionState.Post];
-      const errorHook = hooks[HookExecutionState.Error];
-      if (!mainHook) {
-        return;
-      }
-      try {
-        if (preHook) {
-          await preHook.method.call(instance, ...args);
-        }
-        await mainHook.method.call(instance, ...args);
-        if (postHook) {
-          await postHook.method.call(instance, ...args);
-        }
-      } catch (error) {
-        if (errorHook) {
-          await errorHook.method.call(instance, error, ...args);
-        } else {
-          throw error;
+      let mainHook = hooks.MAIN, preHook = hooks.PRE, postHook = hooks.POST, errorHook = hooks.ERROR;
+      if (mainHook)
+        try {
+          preHook && await preHook.method.call(instance, ...args), await mainHook.method.call(instance, ...args), postHook && await postHook.method.call(instance, ...args);
+        } catch (error) {
+          if (errorHook)
+            await errorHook.method.call(
+              instance,
+              error,
+              ...args
+            );
+          else
+            throw error;
         }
-      }
     };
   }
   /**
-  * 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) => {
-      const fileURL = pathToFileURL2(file).toString();
-      const { default: constructor } = await import(fileURL);
-      this.add(constructor);
-      return constructor;
+    let loaders = (await glob(pattern)).map(async (file) => {
+      let fileURL = pathToFileURL(file).toString(), { default: constructor } = await import(fileURL);
+      return this.add(constructor), constructor;
     });
-    if (parallel) {
+    if (parallel)
       return Promise.all(loaders);
-    }
-    const result = [];
-    for (const loader of loaders) {
+    let result = [];
+    for (let loader of loaders)
       result.push(await loader);
-    }
     return result;
   }
 };
 
 // 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.on(Events.InteractionCreate, (interaction) => void this.handleInteraction(interaction));
-    this.on(Events.MessageCreate, (message) => void this.handleMessage(message));
-  }
-  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) {
-      return;
-    }
-    const content = [
-      codeBlock(error.message),
-      "Required Syntax:",
-      codeBlock(`${prefix}${root.options.name} ${requiredSyntax}`)
-    ].join("\n");
-    return {
-      content
-    };
-  }, "getSyntaxErrorMessage");
+    options.getSyntaxErrorMessage === void 0 && (options.getSyntaxErrorMessage = _BakitClient.getSyntaxErrorMessage), super(options), ListenerRegistry.setClient(this), 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) => {
+    let requiredSyntax = args.map((x) => Arg.format(x)).join(" "), root = Command.getRoot(command.constructor);
+    return root ? {
+      content: [
+        codeBlock(error.message),
+        "Required Syntax:",
+        codeBlock(`${prefix}${root.options.name} ${requiredSyntax}`)
+      ].join(`
+`)
+    } : void 0;
+  };
   async registerApplicationCommands(client) {
-    const commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
+    let commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
     await client.application.commands.set(commands);
   }
   async handleMessage(message) {
-    if (message.author.bot) {
-      return;
-    }
-    const context = new MessageContext(message);
-    const resolver = ArgumentResolver.create(message);
-    if (!resolver) {
+    if (message.author.bot)
       return;
-    }
-    const { trigger } = resolver;
-    const command = CommandRegistry.instances.get(trigger);
-    if (!command) {
+    let context = new MessageContext(message), resolver = ArgumentResolver.create(message);
+    if (!resolver)
       return;
-    }
-    await StateBox.run(() => this.handleMessageHooks(context, command, resolver));
+    let { trigger } = resolver, command = CommandRegistry.instances.get(trigger);
+    command && await StateBox.run(() => this.handleMessageHooks(context, command, resolver));
   }
   async handleInteraction(interaction) {
-    if (!interaction.isChatInputCommand()) {
+    if (!interaction.isChatInputCommand())
       return;
-    }
-    const { commandName } = interaction;
-    const command = CommandRegistry.instances.get(commandName);
-    if (!command) {
+    let { commandName } = interaction, command = CommandRegistry.instances.get(commandName);
+    if (!command)
       return;
-    }
-    const context = new ChatInputContext(interaction);
+    let context = new ChatInputContext(interaction);
     await StateBox.run(() => this.handleChatInputHooks(context, command));
   }
   async handleChatInputHooks(context, instance) {
-    const targetHooks = this.getChatInputTargetHooks(context.source, instance);
-    let inheritedArgs = [];
-    for (const hooks of [
-      targetHooks.root,
-      targetHooks.group,
-      targetHooks.subcommand
-    ]) {
-      if (!hooks) {
+    let targetHooks = this.getChatInputTargetHooks(context.source, instance), inheritedArgs = [];
+    for (let hooks of [targetHooks.root, targetHooks.group, targetHooks.subcommand]) {
+      if (!hooks)
         continue;
-      }
-      const newArgs = await this.runChatInputHooks(context, instance, hooks, inheritedArgs);
-      if (newArgs) {
-        inheritedArgs = newArgs;
-      }
+      let newArgs = await this.runChatInputHooks(context, instance, hooks, inheritedArgs);
+      newArgs && (inheritedArgs = newArgs);
     }
   }
   async handleMessageHooks(context, instance, resolver) {
-    if (!resolver) {
-      return;
-    }
-    const root = Command.getRoot(instance.constructor);
-    if (!root) {
-      return;
-    }
-    resolver = await this.runMessageHooks(context, instance, root.hooks, resolver);
-    if (!resolver) {
+    if (!resolver)
       return;
-    }
-    await this.handleChildMessageHooks(context, root, instance, resolver);
+    let root = Command.getRoot(instance.constructor);
+    root && (resolver = await this.runMessageHooks(context, instance, root.hooks, resolver), resolver && await this.handleChildMessageHooks(context, root, instance, resolver));
   }
   async handleChildMessageHooks(context, parent, instance, resolver, skip = 1) {
-    if (!resolver) {
+    if (!resolver)
       return;
-    }
-    const usedValues = resolver.parsedValues.length;
-    const nextTrigger = resolver.values[usedValues + skip];
-    const child = parent.children.get(nextTrigger);
-    if (!child) {
-      return;
-    }
-    resolver = await this.runMessageHooks(context, instance, child.hooks, resolver);
-    if (child instanceof CommandGroupEntry) {
-      await this.handleChildMessageHooks(context, child, instance, resolver, skip + 1);
-    }
+    let usedValues = resolver.parsedValues.length, nextTrigger = resolver.values[usedValues + skip], child = parent.children.get(nextTrigger);
+    child && (resolver = await this.runMessageHooks(context, instance, child.hooks, resolver), child instanceof CommandGroupEntry && await this.handleChildMessageHooks(context, child, instance, resolver, skip + 1));
   }
   async runMessageHooks(context, instance, hooks, resolver) {
-    const mainHook = hooks[HookExecutionState.Main];
-    if (!mainHook) {
+    let mainHook = hooks.MAIN;
+    if (!mainHook)
       return resolver;
-    }
-    const args = Arg.getMethodArguments(mainHook.method);
+    let args = Arg.getMethodArguments(mainHook.method);
     try {
       resolver = await resolver.resolve(args);
     } catch (error) {
       if (error instanceof CommandSyntaxError) {
-        const errorContent = await this.options.getSyntaxErrorMessage?.(instance, error, context, args, resolver.options.prefix);
-        if (errorContent) {
-          await context.send(errorContent);
-        }
-        return null;
+        let errorContent = await this.options.getSyntaxErrorMessage?.(
+          instance,
+          error,
+          context,
+          args,
+          resolver.options.prefix
+        );
+        return errorContent && await context.send(errorContent), null;
       }
       throw error;
     }
-    await this.runHooks(context, instance, hooks, resolver.parsedValues);
-    return resolver;
+    return await this.runHooks(context, instance, hooks, resolver.parsedValues), resolver;
   }
   async runChatInputHooks(context, instance, hooks, inheritedArgs) {
-    const mainHook = hooks[HookExecutionState.Main];
-    if (!mainHook) {
+    let mainHook = hooks.MAIN;
+    if (!mainHook)
       return;
-    }
-    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;
+    let newArgs = Arg.getMethodArguments(mainHook.method).map(
+      (arg) => ArgumentResolver.resolveChatInput(context.source, arg)
+    ), argValues = [...inheritedArgs, ...newArgs];
+    return await this.runHooks(context, instance, hooks, argValues), argValues;
   }
   async runHooks(context, instance, hooks, args) {
-    const mainHook = hooks[HookExecutionState.Main];
-    const preHook = hooks[HookExecutionState.Pre];
-    const postHook = hooks[HookExecutionState.Post];
-    const errorHook = hooks[HookExecutionState.Error];
-    if (!mainHook) {
+    let mainHook = hooks.MAIN, preHook = hooks.PRE, postHook = hooks.POST, errorHook = hooks.ERROR;
+    if (!mainHook)
       return;
-    }
-    const execute = /* @__PURE__ */ __name(async (hook, error) => {
-      if (!hook) {
-        return;
-      }
-      if (hook.state === HookExecutionState.Error) {
-        await hook.method.call(instance, error, context, ...args);
-      } else {
-        await hook.method.call(instance, context, ...args);
-      }
-    }, "execute");
+    let execute = async (hook, error) => {
+      hook && (hook.state === "ERROR" /* Error */ ? await hook.method.call(instance, error, context, ...args) : await hook.method.call(instance, context, ...args));
+    };
     try {
-      await execute(preHook);
-      await execute(mainHook);
-      await execute(postHook);
+      await execute(preHook), await execute(mainHook), await execute(postHook);
     } catch (error) {
-      if (errorHook) {
+      if (errorHook)
         await execute(errorHook, error);
-      } else {
+      else
         throw error;
-      }
     }
   }
   getChatInputTargetHooks(interaction, instance) {
-    const subcommandName = interaction.options.getSubcommand(false);
-    const groupName = interaction.options.getSubcommandGroup(false);
-    const root = Command.getRoot(instance.constructor);
-    if (!root) {
+    let subcommandName = interaction.options.getSubcommand(false), groupName = interaction.options.getSubcommandGroup(false), root = Command.getRoot(instance.constructor);
+    if (!root)
       throw new Error("No root found.");
-    }
     let group;
     if (groupName) {
-      const child = root.children.get(groupName);
-      if (child instanceof CommandGroupEntry) {
-        group = child;
-      }
+      let child = root.children.get(groupName);
+      child instanceof CommandGroupEntry && (group = child);
     }
     let subcommand;
     if (subcommandName) {
-      const parent = group || root;
-      const child = parent.children.get(subcommandName);
-      if (child instanceof SubcommandEntry) {
-        subcommand = child;
-      }
+      let child = (group || root).children.get(subcommandName);
+      child instanceof SubcommandEntry && (subcommand = child);
     }
     return {
       root: root.hooks,
@@ -1274,29 +846,5 @@ var BakitClient = class _BakitClient extends Client {
     };
   }
 };
-export {
-  Arg,
-  ArgumentType,
-  BakitClient,
-  BaseCommandEntry,
-  BaseCommandGroupEntry,
-  BaseContext,
-  ChatInputContext,
-  Command,
-  CommandAPI,
-  CommandFactory,
-  CommandGroupEntry,
-  CommandRegistry,
-  CommandSyntaxError,
-  CommandSyntaxErrorType,
-  Listener,
-  ListenerAPI,
-  ListenerEntry,
-  ListenerFactory,
-  ListenerRegistry,
-  MessageContext,
-  RootCommandEntry,
-  StateBox,
-  SubcommandEntry,
-  extractId
-};
+
+export { Arg, ArgumentType, BakitClient, BaseCommandEntry, BaseCommandGroupEntry, BaseContext, ChatInputContext, Command, CommandAPI, CommandFactory, CommandGroupEntry, CommandRegistry, CommandSyntaxError, CommandSyntaxErrorType, Listener, ListenerAPI, ListenerEntry, ListenerFactory, ListenerRegistry, MessageContext, RootCommandEntry, StateBox, SubcommandEntry, extractId };