bakit 1.0.0-beta.12 → 1.0.0-beta.13

package/dist/index.d.ts

@@ -252,7 +252,6 @@ declare class ListenerEntry<E extends EventsLike, K extends keyof E> extends Bas
 }
 
 declare namespace ListenerAPI {
-    const ENTRY_KEY: unique symbol;
     function use<E extends EventsLike, K extends keyof E>(entry: ListenerEntry<E, K>): (target: ConstructorLike) => void;
     function getEntry<E extends EventsLike, K extends keyof E>(target: ConstructorLike): ListenerEntry<E, K> | undefined;
 }

package/dist/index.js

@@ -1,14 +1,17 @@
-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";
 
@@ -16,33 +19,23 @@ 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"]: void 0,
-    ["ERROR"]: void 0,
-    ["POST"]: void 0,
-    ["PRE"]: void 0
+    ["MAIN" /* Main */]: void 0,
+    ["ERROR" /* Error */]: void 0,
+    ["POST" /* Post */]: void 0,
+    ["PRE" /* 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;
@@ -76,27 +69,15 @@ 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.`);
     }
@@ -106,17 +87,8 @@ 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.`);
     }
@@ -126,26 +98,21 @@ 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
-(function(CommandAPI2) {
+var CommandAPI;
+((CommandAPI2) => {
   const rootEntries = /* @__PURE__ */ new WeakMap();
   function use(root) {
     return (target) => {
@@ -153,65 +120,49 @@ var SubcommandEntry = class extends BaseCommandEntry {
       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__ */ (function(ArgumentType2) {
+var ArgumentType = /* @__PURE__ */ ((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");
-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);
+  let args = store.get(method);
   if (!args) {
     args = [];
     if (init) {
-      Reflect.defineMetadata(ARGS_KEY, args, method);
-      cache.set(method, args);
+      store.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;
     }
@@ -228,18 +179,15 @@ function createArgument(type) {
     };
   };
 }
-__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 */);
+var integer = createArgument("integer" /* Integer */);
+var number = createArgument("number" /* Number */);
+var user = createArgument("user" /* User */);
+var member = createArgument("member" /* Member */);
 function describeArgumentExpectation(arg) {
-  const parts = [
-    arg.type
-  ];
+  const parts = [arg.type];
   switch (arg.type) {
-    case ArgumentType.String: {
+    case "string" /* String */: {
       if (arg.minLength && !arg.maxLength) {
         parts.push(`\u2265 ${String(arg.minLength)}`);
       }
@@ -251,8 +199,8 @@ function describeArgumentExpectation(arg) {
       }
       break;
     }
-    case ArgumentType.Number:
-    case ArgumentType.Integer: {
+    case "number" /* Number */:
+    case "integer" /* Integer */: {
       if (arg.minValue !== void 0 && arg.maxValue === void 0) {
         parts.push(`\u2265 ${String(arg.minValue)}`);
       }
@@ -264,14 +212,9 @@ function describeArgumentExpectation(arg) {
       }
       break;
     }
-    case ArgumentType.User:
-    case ArgumentType.Member: {
-      break;
-    }
   }
   return parts.join(", ");
 }
-__name(describeArgumentExpectation, "describeArgumentExpectation");
 function format(arg) {
   const { name, required, tuple } = arg;
   const opening = required ? "<" : "[";
@@ -279,7 +222,6 @@ function format(arg) {
   const prefix = tuple ? "..." : "";
   return `${opening}${prefix}${name}: ${describeArgumentExpectation(arg)}${closing}`;
 }
-__name(format, "format");
 var Arg = {
   getMethodArguments,
   createArgument,
@@ -294,15 +236,12 @@ 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) {
@@ -313,11 +252,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) => {
@@ -336,10 +275,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) {
@@ -357,7 +296,7 @@ var CommandRegistry = class _CommandRegistry {
   }
   static getMainHookArguments(entry) {
     const { hooks } = entry;
-    const mainHook = hooks[HookExecutionState.Main];
+    const mainHook = hooks["MAIN" /* Main */];
     return mainHook ? Arg.getMethodArguments(mainHook.method) : [];
   }
   static buildSlashCommandSubcommands(parent, entry, inheritedArgs) {
@@ -384,20 +323,17 @@ 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 = /* @__PURE__ */ __name((option) => {
+    const setupOption = (option) => {
       return option.setName(arg.name).setDescription(arg.description || arg.name).setRequired(Boolean(arg.required));
-    }, "setupOption");
+    };
     switch (arg.type) {
-      case ArgumentType.String: {
+      case "string" /* String */: {
         builder.addStringOption((data) => {
           const option = setupOption(data);
           if (arg.maxLength) {
@@ -410,7 +346,7 @@ var CommandRegistry = class _CommandRegistry {
         });
         break;
       }
-      case ArgumentType.Integer: {
+      case "integer" /* Integer */: {
         builder.addIntegerOption((data) => {
           const option = setupOption(data);
           if (arg.maxValue) {
@@ -423,7 +359,7 @@ var CommandRegistry = class _CommandRegistry {
         });
         break;
       }
-      case ArgumentType.Number: {
+      case "number" /* Number */: {
         builder.addNumberOption((data) => {
           const option = setupOption(data);
           if (arg.maxValue) {
@@ -436,8 +372,8 @@ var CommandRegistry = class _CommandRegistry {
         });
         break;
       }
-      case ArgumentType.User:
-      case ArgumentType.Member: {
+      case "user" /* User */:
+      case "member" /* Member */: {
         builder.addUserOption((option) => setupOption(option));
         break;
       }
@@ -446,12 +382,11 @@ 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;
   }
@@ -499,14 +434,9 @@ 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,
@@ -520,9 +450,6 @@ var ChatInputContext = class extends BaseContext {
   }
 };
 var MessageContext = class extends BaseContext {
-  static {
-    __name(this, "MessageContext");
-  }
   async send(options) {
     const { channel } = this;
     if (!channel?.isSendable()) {
@@ -544,19 +471,15 @@ function extractId(value) {
   }
   return null;
 }
-__name(extractId, "extractId");
 
 // src/errors/CommandSyntaxError.ts
-var CommandSyntaxErrorType = /* @__PURE__ */ (function(CommandSyntaxErrorType2) {
+var CommandSyntaxErrorType = /* @__PURE__ */ ((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;
@@ -566,14 +489,11 @@ var CommandSyntaxError = class extends Error {
     const { arg, type, received } = options;
     const 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("\n");
         break;
       }
-      case "INVALID_ARGUMENT": {
+      case "INVALID_ARGUMENT" /* InvalidArgument */: {
         message = [
           `Invalid value received for argument "${arg.name}"`,
           `> Expected: ${expected}`,
@@ -581,7 +501,7 @@ var CommandSyntaxError = class extends Error {
         ].join("\n");
         break;
       }
-      case "INVALID_VARIADIC_ARGUMENT_VALUE": {
+      case "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */: {
         message = [
           `Invalid value received for variadic argument "${arg.name}"`,
           `> Expected: ${expected}`,
@@ -608,33 +528,27 @@ 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;
@@ -646,9 +560,7 @@ 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) {
@@ -658,6 +570,7 @@ var ArgumentResolver = class _ArgumentResolver {
     return new _ArgumentResolver({
       message,
       startAt: 1,
+      // Skip the command trigger
       values,
       args: [],
       prefix
@@ -671,9 +584,7 @@ var ArgumentResolver = class _ArgumentResolver {
       args,
       startAt: this.options.startAt
     });
-    child.parsedValues = [
-      ...this.parsedValues
-    ];
+    child.parsedValues = [...this.parsedValues];
     if (!child.options.args.length) {
       return child;
     }
@@ -699,7 +610,7 @@ var ArgumentResolver = class _ArgumentResolver {
       if (matchedValue === null) {
         throw new CommandSyntaxError({
           arg,
-          type: CommandSyntaxErrorType.InvalidArgument,
+          type: "INVALID_ARGUMENT" /* InvalidArgument */,
           received: value
         });
       }
@@ -726,7 +637,7 @@ var ArgumentResolver = class _ArgumentResolver {
       } else if (arg.required) {
         throw new CommandSyntaxError({
           arg,
-          type: CommandSyntaxErrorType.MissingRequireArgument,
+          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
           received: value
         });
       }
@@ -737,7 +648,7 @@ var ArgumentResolver = class _ArgumentResolver {
       if (arg.required) {
         throw new CommandSyntaxError({
           arg,
-          type: CommandSyntaxErrorType.MissingRequireArgument,
+          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
           received: "nothing"
         });
       }
@@ -755,7 +666,7 @@ var ArgumentResolver = class _ArgumentResolver {
       if (matchedValue === null) {
         throw new CommandSyntaxError({
           arg,
-          type: CommandSyntaxErrorType.InvalidVariadicArgumentValue,
+          type: "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */,
           received: rest
         });
       }
@@ -764,7 +675,7 @@ var ArgumentResolver = class _ArgumentResolver {
     if (values.length === 0 && arg.required) {
       throw new CommandSyntaxError({
         arg,
-        type: CommandSyntaxErrorType.MissingRequireArgument,
+        type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
         received: "nothing"
       });
     }
@@ -772,13 +683,13 @@ var ArgumentResolver = class _ArgumentResolver {
   }
   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;
@@ -832,15 +743,15 @@ var ArgumentResolver = class _ArgumentResolver {
   }
   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;
@@ -851,9 +762,6 @@ 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() {
@@ -863,8 +771,8 @@ var StateBox = class _StateBox {
     }
     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();
@@ -896,61 +804,46 @@ 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) => {
+  const 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 = {}));
 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) {
@@ -973,10 +866,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) {
@@ -998,9 +891,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) {
@@ -1011,9 +904,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;
   }
@@ -1024,10 +917,10 @@ var ListenerRegistry = class {
     }
     const { 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];
+      const mainHook = hooks["MAIN" /* Main */];
+      const preHook = hooks["PRE" /* Pre */];
+      const postHook = hooks["POST" /* Post */];
+      const errorHook = hooks["ERROR" /* Error */];
       if (!mainHook) {
         return;
       }
@@ -1041,7 +934,11 @@ var ListenerRegistry = class {
         }
       } catch (error) {
         if (errorHook) {
-          await errorHook.method.call(instance, error, ...args);
+          await errorHook.method.call(
+            instance,
+            error,
+            ...args
+          );
         } else {
           throw error;
         }
@@ -1049,11 +946,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) => {
@@ -1075,20 +972,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 = /* @__PURE__ */ __name((command, error, context, args, prefix) => {
+  static getSyntaxErrorMessage = (command, error, context, args, prefix) => {
     const requiredSyntax = args.map((x) => Arg.format(x)).join(" ");
     const root = Command.getRoot(command.constructor);
     if (!root) {
@@ -1102,7 +999,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);
@@ -1138,11 +1035,7 @@ 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;
       }
@@ -1182,7 +1075,7 @@ var BakitClient = class _BakitClient extends Client {
     }
   }
   async runMessageHooks(context, instance, hooks, resolver) {
-    const mainHook = hooks[HookExecutionState.Main];
+    const mainHook = hooks["MAIN" /* Main */];
     if (!mainHook) {
       return resolver;
     }
@@ -1191,7 +1084,13 @@ 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);
         }
@@ -1203,36 +1102,35 @@ var BakitClient = class _BakitClient extends Client {
     return resolver;
   }
   async runChatInputHooks(context, instance, hooks, inheritedArgs) {
-    const mainHook = hooks[HookExecutionState.Main];
+    const mainHook = hooks["MAIN" /* 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[HookExecutionState.Main];
-    const preHook = hooks[HookExecutionState.Pre];
-    const postHook = hooks[HookExecutionState.Post];
-    const errorHook = hooks[HookExecutionState.Error];
+    const mainHook = hooks["MAIN" /* Main */];
+    const preHook = hooks["PRE" /* Pre */];
+    const postHook = hooks["POST" /* Post */];
+    const errorHook = hooks["ERROR" /* Error */];
     if (!mainHook) {
       return;
     }
-    const execute = /* @__PURE__ */ __name(async (hook, error) => {
+    const execute = async (hook, error) => {
       if (!hook) {
         return;
       }
-      if (hook.state === HookExecutionState.Error) {
+      if (hook.state === "ERROR" /* 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);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "1.0.0-beta.12",
+	"version": "1.0.0-beta.13",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"exports": {
@@ -38,7 +38,6 @@
 		"discord.js": "^14.0.0"
 	},
 	"dependencies": {
-		"reflect-metadata": "^0.2.2",
 		"tiny-glob": "^0.2.9",
 		"type-fest": "^4.41.0"
 	},