bakit 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as discord_js from 'discord.js';
-import { Awaitable, ChatInputCommandInteraction, CacheType, Message, InteractionReplyOptions, MessageCreateOptions, User, Collection, RESTPostAPIApplicationCommandsJSONBody, Client, ClientOptions, IntentsBitField, ClientEvents } from 'discord.js';
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { Awaitable, ChatInputCommandInteraction, CacheType, Message, InteractionReplyOptions, MessageCreateOptions, User, Collection, RESTPostAPIApplicationCommandsJSONBody, ClientOptions, Client, IntentsBitField, ClientEvents } from 'discord.js';
 import { SetOptional } from 'type-fest';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import EventEmitter from 'node:events';
 
 type ConstructorLike = new (...args: unknown[]) => object;
@@ -91,13 +91,15 @@ declare class SubcommandEntry extends BaseCommandEntry {
     parent: BaseCommandGroupEntry;
     constructor(options: BaseCommandEntryOptions, parent: BaseCommandGroupEntry);
 }
+type CommandEntry = RootCommandEntry | CommandGroupEntry | SubcommandEntry;
 
 declare enum ArgumentType {
     String = "string",
     Integer = "integer",
     Number = "number",
     User = "user",
-    Member = "member"
+    Member = "member",
+    Literal = "literal"
 }
 interface BaseArgumentOptions {
     type: ArgumentType;
@@ -127,13 +129,17 @@ interface UserArgumentOptions extends BaseArgumentOptions {
 interface MemberArgumentOptions extends BaseArgumentOptions {
     type: ArgumentType.Member;
 }
+interface LiteralArgumentOptions extends Omit<BaseArgumentOptions, "name"> {
+    type: ArgumentType.Literal;
+    value: string;
+}
 type ArgumentOptions = StringArgumentOptions | IntegerArgumentOptions | NumberArgumentOptions | UserArgumentOptions | MemberArgumentOptions;
 
 declare function getMethodArguments(method: CommandHook["method"]): readonly ArgumentOptions[];
 declare function getMethodArguments(method: CommandHook["method"], init: true): ArgumentOptions[];
 declare function createArgument<Options extends ArgumentOptions>(type: Options["type"]): (options: Omit<Options, "type"> | string) => (target: object, key: string | symbol, _index: number) => void;
-declare function describeArgumentExpectation(arg: ArgumentOptions): string;
-declare function format(arg: ArgumentOptions): string;
+declare function describeArgumentExpectation(arg: ArgumentOptions | LiteralArgumentOptions): string;
+declare function format(arg: ArgumentOptions | LiteralArgumentOptions): string;
 declare const Arg: {
     getMethodArguments: typeof getMethodArguments;
     createArgument: typeof createArgument;
@@ -146,6 +152,36 @@ declare const Arg: {
     member: (options: string | Omit<MemberArgumentOptions, "type">) => (target: object, key: string | symbol, _index: number) => void;
 };
 
+interface ArgumentResolverOptions {
+    message: Message;
+    values: string[];
+    prefix: string;
+}
+declare class ArgumentResolver {
+    private _values;
+    prefix: string;
+    message: Message;
+    private _parsedValues;
+    private _args;
+    constructor(_values: string[], prefix: string, message: Message);
+    get commandName(): string;
+    get values(): readonly string[];
+    get parsedValues(): readonly unknown[];
+    get args(): readonly (ArgumentOptions | LiteralArgumentOptions)[];
+    get client(): BakitClient<true>;
+    static initialize(message: Message): Promise<ArgumentResolver | undefined>;
+    resolve(entry: CommandEntry, at?: number): Promise<void>;
+    protected parseExact(args: ArgumentOptions[], values: string[]): Promise<unknown[]>;
+    protected parseFlexible(args: ArgumentOptions[], values: string[]): Promise<unknown[]>;
+    private matchValue;
+    private matchUserValue;
+    private matchMemberValue;
+    private matchIntegerValue;
+    private matchNumberValue;
+    private matchStringValue;
+    static resolveChatInputOption(interaction: ChatInputCommandInteraction, arg: ArgumentOptions): string | number | discord_js.GuildMember | discord_js.User | discord_js.APIInteractionDataResolvedGuildMember | null;
+}
+
 declare namespace CommandAPI {
     function use(root: RootCommandEntry): (target: ConstructorLike) => void;
     function getRoot(constructor: ConstructorLike): RootCommandEntry | undefined;
@@ -199,9 +235,31 @@ declare class CommandSyntaxError extends Error {
     get name(): string;
 }
 
-type GetSyntaxErrorMessageFunction = (command: object, error: CommandSyntaxError, context: MessageContext, args: readonly ArgumentOptions[], prefix: string) => Awaitable<MessageCreateOptions | undefined>;
+type GetSyntaxErrorMessageFunction = (command: object, error: CommandSyntaxError, context: MessageContext, resolver: ArgumentResolver) => Awaitable<MessageCreateOptions | undefined>;
+declare const defaultGetSyntaxErrorMessage: GetSyntaxErrorMessageFunction;
+
+declare class CommandDispatcher {
+    client: BakitClient;
+    constructor(client: BakitClient);
+    getPrefixes(message: Message): Promise<string[]>;
+    handleChatInput(interaction: ChatInputCommandInteraction): Promise<void>;
+    private getChatInputTriggerChain;
+    private resolveChatInputEntry;
+    handleMessage(message: Message): Promise<void>;
+    private resolveCommandEntryChain;
+    private executeChain;
+    private executeHooks;
+}
+
+declare class DispatcherManager {
+    client: BakitClient;
+    command: CommandDispatcher;
+    constructor(client: BakitClient);
+}
+
+type GetPrefixFunction = (message: Message) => Awaitable<string[] | string>;
 interface BakitClientOptions extends ClientOptions {
-    prefixes?: string[];
+    prefixes?: (string | GetPrefixFunction)[];
     enableMentionPrefix?: boolean;
     getSyntaxErrorMessage?: GetSyntaxErrorMessageFunction | null;
 }
@@ -209,25 +267,16 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     options: Omit<BakitClientOptions, "intents"> & {
         intents: IntentsBitField;
     };
+    dispatchers: DispatcherManager;
     constructor(options: BakitClientOptions);
-    static getSyntaxErrorMessage: GetSyntaxErrorMessageFunction;
-    private registerApplicationCommands;
-    private handleMessage;
-    private handleInteraction;
-    private handleChatInputHooks;
-    private handleMessageHooks;
-    private handleChildMessageHooks;
-    private runMessageHooks;
-    private runChatInputHooks;
-    private runHooks;
-    private getChatInputTargetHooks;
+    isReady(): this is BakitClient<true>;
+    private initializeHandlers;
 }
 
 declare function extractId(value: string): string | null;
 
 type States = Record<string | symbol, unknown>;
 declare class StateBox {
-    private static readonly STATES_KEY;
     static storage: AsyncLocalStorage<States>;
     private static getState;
     static run<R>(fn: () => R, store?: {}): R;
@@ -298,16 +347,4 @@ declare abstract class ListenerRegistry {
     static load(pattern: string, parallel?: boolean): Promise<ConstructorLike[]>;
 }
 
-/**
- * This file is used to redeclare original client to the custom one
- * Most of the structure is from Base, but some might be not
- */
-
-
-declare module "discord.js" {
-	interface Base {
-		client: BakitClient<true>;
-	}
-}
-
-export { Arg, type ArgumentOptions, ArgumentType, BakitClient, type BakitClientOptions, type BaseArgumentOptions, BaseCommandEntry, type BaseCommandEntryOptions, BaseCommandGroupEntry, BaseContext, ChatInputContext, type ChatInputContextSendOptions, Command, CommandAPI, CommandFactory, CommandGroupEntry, type CommandHook, CommandRegistry, CommandSyntaxError, type CommandSyntaxErrorOptions, CommandSyntaxErrorType, type Context, type ContextSendOptions, type CreateCommandOptions, type ErrorCommandHookMethod, type ErrorListenerHookMethod, type EventsLike, type GetSyntaxErrorMessageFunction, type IntegerArgumentOptions, Listener, ListenerAPI, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerRegistry, type MainCommandHookMethod, type MainListenerHookMethod, type MemberArgumentOptions, MessageContext, type MessageContextSendOptions, type NumberArgumentOptions, RootCommandEntry, StateBox, type States, type StringArgumentOptions, SubcommandEntry, type UserArgumentOptions, extractId };
+export { Arg, type ArgumentOptions, ArgumentResolver, type ArgumentResolverOptions, ArgumentType, BakitClient, type BakitClientOptions, type BaseArgumentOptions, BaseCommandEntry, type BaseCommandEntryOptions, BaseCommandGroupEntry, BaseContext, ChatInputContext, type ChatInputContextSendOptions, Command, CommandAPI, type CommandEntry, CommandFactory, CommandGroupEntry, type CommandHook, CommandRegistry, CommandSyntaxError, type CommandSyntaxErrorOptions, CommandSyntaxErrorType, type Context, type ContextSendOptions, type CreateCommandOptions, type ErrorCommandHookMethod, type ErrorListenerHookMethod, type EventsLike, type GetPrefixFunction, type GetSyntaxErrorMessageFunction, type IntegerArgumentOptions, Listener, ListenerAPI, ListenerEntry, type ListenerEntryOptions, ListenerFactory, type ListenerHook, ListenerRegistry, type LiteralArgumentOptions, type MainCommandHookMethod, type MainListenerHookMethod, type MemberArgumentOptions, MessageContext, type MessageContextSendOptions, type NumberArgumentOptions, RootCommandEntry, StateBox, type States, type StringArgumentOptions, SubcommandEntry, type UserArgumentOptions, defaultGetSyntaxErrorMessage, extractId };

package/dist/index.js

@@ -1,7 +1,7 @@
-import { Collection, SlashCommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandBuilder, ChatInputCommandInteraction, Message, Client, Events, codeBlock } from 'discord.js';
+import { Collection, SlashCommandBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandBuilder, ChatInputCommandInteraction, Message, codeBlock, Client, Events } from 'discord.js';
+import { AsyncLocalStorage } from 'async_hooks';
 import glob from 'tiny-glob';
 import { pathToFileURL } from 'url';
-import { AsyncLocalStorage } from 'async_hooks';
 
 // src/BakitClient.ts
 
@@ -49,63 +49,177 @@ var BaseEntry = class {
   }
 };
 
-// src/command/CommandEntry.ts
-var BaseCommandEntry = class extends BaseEntry {
+// src/listener/ListenerEntry.ts
+var ListenerEntry = class extends BaseEntry {
   constructor(options) {
     super();
     this.options = options;
   }
-}, BaseCommandGroupEntry = class extends BaseCommandEntry {
-  children = new Collection();
-  subcommand(options) {
-    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.`);
-    let subcommand = new SubcommandEntry(fullOptions, this);
-    return this.children.set(fullOptions.name, subcommand), subcommand;
+};
+
+// src/listener/Listener.ts
+var ListenerAPI;
+((ListenerAPI2) => {
+  let entries = /* @__PURE__ */ new WeakMap();
+  function use(entry) {
+    return (target) => {
+      entries.set(target, entry);
+    };
   }
-}, RootCommandEntry = class extends BaseCommandGroupEntry {
-  group(options) {
-    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.`);
-    let group = new CommandGroupEntry(fullOptions, this);
-    return this.children.set(fullOptions.name, group), group;
+  ListenerAPI2.use = use;
+  function getEntry(target) {
+    return entries.get(target);
   }
-}, CommandGroupEntry = class extends BaseCommandGroupEntry {
-  constructor(options, parent) {
-    super(options);
-    this.parent = parent;
+  ListenerAPI2.getEntry = getEntry;
+})(ListenerAPI ||= {});
+function ListenerFactory(options) {
+  let fullOptions = typeof options != "object" ? { name: options, once: false } : { once: false, ...options };
+  return new ListenerEntry(fullOptions);
+}
+var Listener = Object.assign(ListenerFactory, ListenerAPI);
+var StateBox = class _StateBox {
+  static storage = new AsyncLocalStorage();
+  static getState() {
+    let state = this.storage.getStore();
+    if (!state)
+      throw new Error("No active context, did you forget to wrap it with StateBox.wrap()?");
+    return state;
   }
-}, SubcommandEntry = class extends BaseCommandEntry {
-  constructor(options, parent) {
-    super(options);
-    this.parent = parent;
+  static run(fn, store2 = {}) {
+    return this.storage.run(store2, fn);
+  }
+  static wrap(fn) {
+    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) => {
+      let generalKey = key;
+      Object.defineProperty(target, key, {
+        get() {
+          let states = _StateBox.getState();
+          return key in states || (states[generalKey] = defaultValue), states[generalKey];
+        },
+        set(value) {
+          let states = _StateBox.getState();
+          states[generalKey] = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    };
   }
 };
-
-// src/command/Command.ts
-var CommandAPI;
-((CommandAPI2) => {
-  let rootEntries = /* @__PURE__ */ new WeakMap();
-  function use(root) {
-    return (target) => {
-      root.setTarget(target), rootEntries.set(target, root);
+var ListenerRegistry = class {
+  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.
+   */
+  static add(constructor) {
+    let entry = Listener.getEntry(constructor);
+    if (!entry)
+      throw new Error(`No entry found for "${constructor.name}"`);
+    let { options } = entry;
+    if (!options.emitter) {
+      if (!this.client)
+        throw new Error("Client is not ready.");
+      options.emitter = this.client;
+    }
+    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.
+   */
+  static remove(constructor) {
+    let entry = Listener.getEntry(constructor);
+    if (!entry)
+      return false;
+    this.constructors.delete(constructor);
+    let instance = this.instances.get(constructor);
+    if (!instance)
+      return false;
+    this.instances.delete(constructor);
+    let executor = this.executors.get(instance);
+    if (!executor)
+      return false;
+    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.
+   */
+  static removeAll() {
+    let removedAmount = 0;
+    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.
+   */
+  static setClient(newClient) {
+    this.client = newClient;
+  }
+  static createExecutor(constructor, instance) {
+    let entry = Listener.getEntry(constructor);
+    if (!entry)
+      throw new Error("Missing listener entry");
+    let { hooks } = entry, execute = async (...args) => {
+      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;
+        }
+    };
+    return async (...args) => {
+      await StateBox.run(() => execute(...args));
     };
   }
-  CommandAPI2.use = use;
-  function getRoot(constructor) {
-    return rootEntries.get(constructor);
+  /**
+   * 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) {
+    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)
+      return Promise.all(loaders);
+    let result = [];
+    for (let loader of loaders)
+      result.push(await loader);
+    return result;
   }
-  CommandAPI2.getRoot = getRoot;
-})(CommandAPI ||= {});
-function CommandFactory(options) {
-  return typeof options == "string" && (options = { name: options }), options.description || (options.description = options.name), new RootCommandEntry(options);
-}
-var Command = Object.assign(CommandFactory, CommandAPI);
+};
 
 // src/command/argument/Argument.ts
-var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => (ArgumentType2.String = "string", ArgumentType2.Integer = "integer", ArgumentType2.Number = "number", ArgumentType2.User = "user", ArgumentType2.Member = "member", ArgumentType2))(ArgumentType || {});
+var ArgumentType = /* @__PURE__ */ ((ArgumentType2) => (ArgumentType2.String = "string", ArgumentType2.Integer = "integer", ArgumentType2.Number = "number", ArgumentType2.User = "user", ArgumentType2.Member = "member", ArgumentType2.Literal = "literal", ArgumentType2))(ArgumentType || {});
 
 // src/command/argument/Arg.ts
 var store = /* @__PURE__ */ new WeakMap();
@@ -141,7 +255,9 @@ function describeArgumentExpectation(arg) {
   return parts.join(", ");
 }
 function format(arg) {
-  let { name, required, tuple } = arg, opening = required ? "<" : "[", closing = required ? ">" : "]";
+  if (arg.type === "literal" /* Literal */)
+    return arg.value;
+  let { required, tuple, name } = arg, opening = required ? "<" : "[", closing = required ? ">" : "]";
   return `${opening}${tuple ? "..." : ""}${name}: ${describeArgumentExpectation(arg)}${closing}`;
 }
 var Arg = {
@@ -156,24 +272,263 @@ var Arg = {
   member
 };
 
-// src/command/CommandRegistry.ts
-var CommandRegistry = class _CommandRegistry {
-  static constructors = new Collection();
-  static instances = new Collection();
-  /**
-   * Add a command to the registry.
-   * @param constructor The command class you want to add.
-   */
-  static add(constructor) {
-    let root = Command.getRoot(constructor);
-    if (!root)
-      throw new Error(`No root found for "${constructor.name}"`);
-    let { options } = root;
-    this.constructors.set(options.name, constructor), this.instances.set(options.name, new constructor());
+// src/utils/user.ts
+function extractId(value) {
+  let idMatch = value.match(/^<@!?(\d+)>$/);
+  if (idMatch)
+    return idMatch[1];
+  let numericMatch = value.match(/^(\d{17,19})$/);
+  return numericMatch ? numericMatch[1] : null;
+}
+
+// src/errors/CommandSyntaxError.ts
+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, { arg, type, received } = options, expected = Arg.describeArgumentExpectation(arg);
+    switch (type) {
+      case "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */: {
+        message = [`Missing required argument "${arg.name}"`, `> Expected: ${expected}`].join(`
+`);
+        break;
+      }
+      case "INVALID_ARGUMENT" /* InvalidArgument */: {
+        message = [
+          `Invalid value received for argument "${arg.name}"`,
+          `> Expected: ${expected}`,
+          `> Received: ${String(received)}`
+        ].join(`
+`);
+        break;
+      }
+      case "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */: {
+        message = [
+          `Invalid value received for variadic argument "${arg.name}"`,
+          `> Expected: ${expected}`,
+          `> Received: ${String(received)}`
+        ].join(`
+`);
+        break;
+      }
+      default: {
+        message = "Unknown error";
+        break;
+      }
+    }
+    super(message), this.arg = arg, this.type = type, this.expected = expected, this.received = received, Error.captureStackTrace(this, this.constructor);
   }
-  /**
-   * Load and add all commands which matched provided glob pattern to the registry.
-   * @param pattern glob pattern to load.
+  get name() {
+    return `CommandSyntaxError[${this.type}]`;
+  }
+};
+
+// src/command/argument/ArgumentResolver.ts
+var ArgumentResolver = class _ArgumentResolver {
+  constructor(_values, prefix, message) {
+    this._values = _values;
+    this.prefix = prefix;
+    this.message = message;
+  }
+  _parsedValues = [];
+  _args = [];
+  get commandName() {
+    return this._values[0];
+  }
+  get values() {
+    return this._values;
+  }
+  get parsedValues() {
+    return this._parsedValues;
+  }
+  get args() {
+    return this._args;
+  }
+  get client() {
+    return this.message.client;
+  }
+  static async initialize(message) {
+    let prefix = (await message.client.dispatchers.command.getPrefixes(message)).find((p) => message.content.startsWith(p));
+    if (!prefix)
+      return;
+    let values = message.content.slice(prefix.length).trim().split(/\s+/);
+    return new _ArgumentResolver(values, prefix, message);
+  }
+  async resolve(entry, at = 1) {
+    let mainHook = entry.hooks.MAIN, args = mainHook ? [...Arg.getMethodArguments(mainHook.method)] : [], nextAt = at;
+    if (args.length) {
+      let values = this.values.slice(at), parsedValues = args.length >= values.length ? await this.parseExact(args, values) : await this.parseFlexible(args, values);
+      nextAt += parsedValues.length, this._args.push(...args), this._parsedValues.push(...parsedValues);
+    }
+    let nextValue = this._values[nextAt];
+    if (!nextValue || !("children" in entry))
+      return;
+    let childEntry = entry.children.get(nextValue);
+    childEntry && (this._args.push({
+      type: "literal" /* Literal */,
+      value: nextValue
+    }), await this.resolve(childEntry, nextAt + 1));
+  }
+  async parseExact(args, values) {
+    let parsedValues = [];
+    for (let i = 0; i < args.length; i++) {
+      let arg = args[i], value = values[i], matchedValue = await this.matchValue(arg, value);
+      if (matchedValue === null)
+        throw new CommandSyntaxError({
+          arg,
+          type: "INVALID_ARGUMENT" /* InvalidArgument */,
+          received: value
+        });
+      parsedValues.push(matchedValue);
+    }
+    return parsedValues;
+  }
+  async parseFlexible(args, values) {
+    let argIndex = 0, valueIndex = 0, parsedValues = [];
+    for (; argIndex < args.length; ) {
+      let arg = args[argIndex], value = values[valueIndex], matchedValue = await this.matchValue(arg, value);
+      if (matchedValue !== null)
+        parsedValues.push(matchedValue), valueIndex++;
+      else if (arg.required)
+        throw new CommandSyntaxError({
+          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
+          received: value,
+          arg
+        });
+      argIndex++;
+    }
+    return parsedValues;
+  }
+  async matchValue(arg, value) {
+    if (!value)
+      return null;
+    switch (arg.type) {
+      case "user" /* User */:
+        return await this.matchUserValue(arg, value);
+      case "member" /* Member */:
+        return await this.matchMemberValue(arg, value);
+      case "integer" /* Integer */:
+        return this.matchIntegerValue(arg, value);
+      case "number" /* Number */:
+        return this.matchNumberValue(arg, value);
+      case "string" /* String */:
+        return this.matchStringValue(arg, value);
+      default:
+        return null;
+    }
+  }
+  async matchUserValue(arg, value) {
+    let userId = extractId(value);
+    return userId ? await this.client.users.fetch(userId).catch(() => null) : null;
+  }
+  async matchMemberValue(arg, value) {
+    let userId = extractId(value);
+    if (!userId)
+      return;
+    let { guild } = this.message;
+    if (guild)
+      return await guild.members.fetch(userId).catch(() => null);
+  }
+  matchIntegerValue(arg, value) {
+    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) {
+    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) {
+    return arg.minLength !== void 0 && value.length < arg.minLength || arg.maxLength !== void 0 && value.length > arg.maxLength ? null : value;
+  }
+  static resolveChatInputOption(interaction, arg) {
+    switch (arg.type) {
+      case "string" /* String */:
+        return interaction.options.getString(arg.name, arg.required);
+      case "integer" /* Integer */:
+        return interaction.options.getInteger(arg.name, arg.required);
+      case "number" /* Number */:
+        return interaction.options.getNumber(arg.name, arg.required);
+      case "user" /* User */:
+        return interaction.options.getUser(arg.name, arg.required);
+      case "member" /* Member */:
+        return interaction.options.getMember(arg.name);
+      default:
+        return null;
+    }
+  }
+};
+var BaseCommandEntry = class extends BaseEntry {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+}, BaseCommandGroupEntry = class extends BaseCommandEntry {
+  children = new Collection();
+  subcommand(options) {
+    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.`);
+    let subcommand = new SubcommandEntry(fullOptions, this);
+    return this.children.set(fullOptions.name, subcommand), subcommand;
+  }
+}, RootCommandEntry = class extends BaseCommandGroupEntry {
+  group(options) {
+    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.`);
+    let group = new CommandGroupEntry(fullOptions, this);
+    return this.children.set(fullOptions.name, group), group;
+  }
+}, CommandGroupEntry = class extends BaseCommandGroupEntry {
+  constructor(options, parent) {
+    super(options);
+    this.parent = parent;
+  }
+}, SubcommandEntry = class extends BaseCommandEntry {
+  constructor(options, parent) {
+    super(options);
+    this.parent = parent;
+  }
+};
+
+// src/command/Command.ts
+var CommandAPI;
+((CommandAPI2) => {
+  let rootEntries = /* @__PURE__ */ new WeakMap();
+  function use(root) {
+    return (target) => {
+      root.setTarget(target), rootEntries.set(target, root);
+    };
+  }
+  CommandAPI2.use = use;
+  function getRoot(constructor) {
+    return rootEntries.get(constructor);
+  }
+  CommandAPI2.getRoot = getRoot;
+})(CommandAPI ||= {});
+function CommandFactory(options) {
+  return typeof options == "string" && (options = { name: options }), options.description || (options.description = options.name), new RootCommandEntry(options);
+}
+var Command = Object.assign(CommandFactory, CommandAPI);
+var CommandRegistry = class _CommandRegistry {
+  static constructors = new Collection();
+  static instances = new Collection();
+  /**
+   * Add a command to the registry.
+   * @param constructor The command class you want to add.
+   */
+  static add(constructor) {
+    let root = Command.getRoot(constructor);
+    if (!root)
+      throw new Error(`No root found for "${constructor.name}"`);
+    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.
    */
@@ -319,532 +674,148 @@ var BaseContext = class {
   }
 };
 
-// src/utils/user.ts
-function extractId(value) {
-  let idMatch = value.match(/^<@!?(\d+)>$/);
-  if (idMatch)
-    return idMatch[1];
-  let numericMatch = value.match(/^(\d{17,19})$/);
-  return numericMatch ? numericMatch[1] : null;
-}
+// src/utils/command.ts
+var defaultGetSyntaxErrorMessage = (command, error, context, resolver) => {
+  let requiredSyntax = resolver.args.map((x) => Arg.format(x)).join(" "), root = Command.getRoot(command.constructor);
+  return root ? {
+    content: [
+      codeBlock(error.message),
+      "Required Syntax:",
+      codeBlock(`${resolver.prefix}${root.options.name} ${requiredSyntax}`)
+    ].join(`
+`)
+  } : void 0;
+};
 
-// src/errors/CommandSyntaxError.ts
-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, { arg, type, received } = options, expected = Arg.describeArgumentExpectation(arg);
-    switch (type) {
-      case "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */: {
-        message = [`Missing required argument "${arg.name}"`, `> Expected: ${expected}`].join(`
-`);
-        break;
-      }
-      case "INVALID_ARGUMENT" /* InvalidArgument */: {
-        message = [
-          `Invalid value received for argument "${arg.name}"`,
-          `> Expected: ${expected}`,
-          `> Received: ${String(received)}`
-        ].join(`
-`);
-        break;
-      }
-      case "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */: {
-        message = [
-          `Invalid value received for variadic argument "${arg.name}"`,
-          `> Expected: ${expected}`,
-          `> Received: ${String(received)}`
-        ].join(`
-`);
-        break;
-      }
-      default: {
-        message = "Unknown error";
-        break;
+// src/dispatchers/CommandDispatcher.ts
+var CommandDispatcher = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getPrefixes(message) {
+    let { options, user: user2 } = this.client, results = await Promise.all(
+      (options.prefixes ?? []).map(async (prefix) => {
+        if (typeof prefix == "string")
+          return [prefix];
+        let result = await prefix(message);
+        return Array.isArray(result) ? result : [result];
+      })
+    ), prefixes = [...options.enableMentionPrefix && user2 ? [user2.toString()] : [], ...results.flat()];
+    return Array.from(new Set(prefixes));
+  }
+  async handleChatInput(interaction) {
+    let { commandName } = interaction, constructor = CommandRegistry.constructors.get(commandName), instance = CommandRegistry.instances.get(commandName);
+    if (!constructor || !instance)
+      return;
+    let root = Command.getRoot(constructor);
+    if (!root)
+      return;
+    let context = new ChatInputContext(interaction), triggerChain = this.getChatInputTriggerChain(interaction), chain = this.resolveCommandEntryChain(root, triggerChain), parsedValues = chain.flatMap((entry) => this.resolveChatInputEntry(interaction, entry));
+    await StateBox.run(() => this.executeChain(chain, context, instance, parsedValues));
+  }
+  getChatInputTriggerChain(interaction) {
+    let chain = [], subcommand = interaction.options.getSubcommand(false), subcommandGroup = interaction.options.getSubcommandGroup(false);
+    return subcommandGroup && chain.push(subcommandGroup), subcommand && chain.push(subcommand), chain;
+  }
+  resolveChatInputEntry(interaction, entry) {
+    let mainHook = entry.hooks.MAIN;
+    return (mainHook ? Arg.getMethodArguments(mainHook.method) : []).map((arg) => ArgumentResolver.resolveChatInputOption(interaction, arg));
+  }
+  async handleMessage(message) {
+    let resolver = await ArgumentResolver.initialize(message);
+    if (!resolver)
+      return;
+    let constructor = CommandRegistry.constructors.get(resolver.commandName), instance = CommandRegistry.instances.get(resolver.commandName);
+    if (!constructor || !instance)
+      return;
+    let root = Command.getRoot(constructor);
+    if (!root)
+      return;
+    let context = new MessageContext(message);
+    try {
+      await resolver.resolve(root);
+    } catch (error) {
+      if (error instanceof CommandSyntaxError) {
+        let payload = await this.client.options.getSyntaxErrorMessage?.(
+          instance,
+          error,
+          context,
+          resolver
+        );
+        payload && await context.send(payload);
+      } else
+        throw error;
+    }
+    let literalTriggers = resolver.args.filter((arg) => arg.type === "literal" /* Literal */).map((arg) => arg.value), entryChain = this.resolveCommandEntryChain(root, literalTriggers), values = resolver.parsedValues;
+    await StateBox.run(() => this.executeChain(entryChain, context, instance, values));
+  }
+  resolveCommandEntryChain(root, triggers) {
+    return triggers.reduce(
+      (acc, trigger) => {
+        let parent = acc.at(-1);
+        if (parent && "children" in parent) {
+          let child = parent.children.get(trigger);
+          child && acc.push(child);
+        }
+        return acc;
+      },
+      [root]
+    );
+  }
+  async executeChain(chain, context, instance, values) {
+    for (let entry of chain)
+      await this.executeHooks(entry, context, instance, values);
+  }
+  async executeHooks(entry, context, instance, values) {
+    let { hooks } = entry;
+    if (!hooks.MAIN)
+      return;
+    let execute = async (hook, error) => {
+      if (hook) {
+        if (hook.state === "ERROR" /* Error */) {
+          await hook.method.call(instance, error, context, ...values);
+          return;
+        }
+        await hook.method.call(instance, context, ...values);
       }
+    };
+    try {
+      await execute(hooks.PRE), await execute(hooks.MAIN), await execute(hooks.POST);
+    } catch (error) {
+      if (hooks.ERROR)
+        await execute(hooks.ERROR, error);
+      else
+        throw error;
     }
-    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}]`;
+};
+
+// src/dispatchers/DispatcherManager.ts
+var DispatcherManager = class {
+  constructor(client) {
+    this.client = client;
+    this.command = new CommandDispatcher(client);
   }
+  command;
 };
 
-// src/command/argument/ArgumentResolver.ts
-var ArgumentResolver = class _ArgumentResolver {
+// src/BakitClient.ts
+var BakitClient = class extends Client {
+  dispatchers;
   constructor(options) {
-    this.options = options;
-  }
-  parsedValues = [];
-  /**
-   * Get the first value as the command trigger.
-   */
-  get trigger() {
-    return this.options.values[0];
-  }
-  /**
-   * Get amount of specified argument values.
-   */
-  get specifiedAmount() {
-    return this.options.values.length - this.options.startAt;
+    options.getSyntaxErrorMessage === void 0 && (options.getSyntaxErrorMessage = defaultGetSyntaxErrorMessage), super(options), ListenerRegistry.setClient(this), this.dispatchers = new DispatcherManager(this), this.initializeHandlers();
   }
-  /**
-   * Get parsed raw values from content.
-   */
-  get values() {
-    return [...this.options.values];
+  isReady() {
+    return super.isReady();
   }
-  get client() {
-    return this.options.message.client;
-  }
-  static create(message) {
-    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()] : []
-    ].find((p) => message.content.startsWith(p)) ?? null;
-    if (!prefix)
-      return;
-    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) {
-    let child = new _ArgumentResolver({
-      prefix: this.options.prefix,
-      message: this.options.message,
-      values: this.options.values,
-      args,
-      startAt: this.options.startAt
+  initializeHandlers() {
+    this.on(
+      Events.MessageCreate,
+      (message) => void this.dispatchers.command.handleMessage(message)
+    ), this.on(Events.InteractionCreate, (interaction) => {
+      interaction.isChatInputCommand() && this.dispatchers.command.handleChatInput(interaction);
     });
-    return child.parsedValues = [...this.parsedValues], child.options.args.length && (this.specifiedAmount >= child.options.args.length ? await child.absoluteParse() : await child.dynamicParse()), child;
-  }
-  async absoluteParse() {
-    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;
-      }
-      let matchedValue = await this.matchValue(arg, value);
-      if (matchedValue === null)
-        throw new CommandSyntaxError({
-          arg,
-          type: "INVALID_ARGUMENT" /* InvalidArgument */,
-          received: value
-        });
-      this.parsedValues.push(matchedValue), valueIndex++, argIndex++;
-    }
-  }
-  async dynamicParse() {
-    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;
-      }
-      let matchedValue = await this.matchValue(arg, value);
-      if (matchedValue !== null)
-        this.parsedValues.push(matchedValue), valueIndex++;
-      else if (arg.required)
-        throw new CommandSyntaxError({
-          arg,
-          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
-          received: value
-        });
-      argIndex++;
-    }
-    for (; argIndex < args.length; ) {
-      let arg = args[argIndex];
-      if (arg.required)
-        throw new CommandSyntaxError({
-          arg,
-          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
-          received: "nothing"
-        });
-      argIndex++;
-    }
-  }
-  async resolveTuple(arg, startIndex, argIndex) {
-    let { args } = this.options;
-    if (argIndex !== args.length - 1)
-      throw new SyntaxError("Tuple argument must be the last argument");
-    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: "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */,
-          received: rest
-        });
-      values.push(matchedValue);
-    }
-    if (values.length === 0 && arg.required)
-      throw new CommandSyntaxError({
-        arg,
-        type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
-        received: "nothing"
-      });
-    return values;
-  }
-  async matchValue(arg, value) {
-    switch (arg.type) {
-      case "user" /* User */:
-        return await this.matchUserValue(arg, value);
-      case "integer" /* Integer */:
-        return this.matchIntegerValue(arg, value);
-      case "number" /* Number */:
-        return this.matchNumberValue(arg, value);
-      case "string" /* String */:
-        return this.matchStringValue(arg, value);
-      default:
-        return null;
-    }
-  }
-  async matchUserValue(arg, value) {
-    let userId = extractId(value);
-    if (!userId)
-      return null;
-    let user2 = await this.client.users.fetch(userId).catch(() => null);
-    return user2 || null;
-  }
-  matchIntegerValue(arg, value) {
-    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) {
-    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) {
-    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 "string" /* String */:
-        return interaction.options.getString(arg.name, arg.required);
-      case "integer" /* Integer */:
-        return interaction.options.getInteger(arg.name, arg.required);
-      case "number" /* Number */:
-        return interaction.options.getNumber(arg.name, arg.required);
-      case "user" /* User */:
-        return interaction.options.getUser(arg.name, arg.required);
-      case "member" /* Member */:
-        return interaction.options.getMember(arg.name);
-      default:
-        return null;
-    }
-  }
-};
-var StateBox = class _StateBox {
-  static STATES_KEY = Symbol("states");
-  static storage = new AsyncLocalStorage();
-  static getState() {
-    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, store2 = {}) {
-    return this.storage.run(store2, fn);
-  }
-  static wrap(fn) {
-    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() {
-          let states = _StateBox.getState();
-          return key in states || (states[key] = defaultValue), states[key];
-        },
-        set(value) {
-          let states = _StateBox.getState();
-          states[key] = value;
-        },
-        enumerable: true,
-        configurable: true
-      });
-    };
-  }
-};
-
-// src/listener/ListenerEntry.ts
-var ListenerEntry = class extends BaseEntry {
-  constructor(options) {
-    super();
-    this.options = options;
-  }
-};
-
-// src/listener/Listener.ts
-var ListenerAPI;
-((ListenerAPI2) => {
-  let entries = /* @__PURE__ */ new WeakMap();
-  function use(entry) {
-    return (target) => {
-      entries.set(target, entry);
-    };
-  }
-  ListenerAPI2.use = use;
-  function getEntry(target) {
-    return entries.get(target);
-  }
-  ListenerAPI2.getEntry = getEntry;
-})(ListenerAPI ||= {});
-function ListenerFactory(options) {
-  let fullOptions = typeof options != "object" ? { name: options, once: false } : { once: false, ...options };
-  return new ListenerEntry(fullOptions);
-}
-var Listener = Object.assign(ListenerFactory, ListenerAPI);
-var ListenerRegistry = class {
-  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.
-   */
-  static add(constructor) {
-    let entry = Listener.getEntry(constructor);
-    if (!entry)
-      throw new Error(`No entry found for "${constructor.name}"`);
-    let { options } = entry;
-    if (!options.emitter) {
-      if (!this.client)
-        throw new Error("Client is not ready.");
-      options.emitter = this.client;
-    }
-    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.
-   */
-  static remove(constructor) {
-    let entry = Listener.getEntry(constructor);
-    if (!entry)
-      return false;
-    this.constructors.delete(constructor);
-    let instance = this.instances.get(constructor);
-    if (!instance)
-      return false;
-    this.instances.delete(constructor);
-    let executor = this.executors.get(instance);
-    if (!executor)
-      return false;
-    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.
-   */
-  static removeAll() {
-    let removedAmount = 0;
-    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.
-   */
-  static setClient(newClient) {
-    this.client = newClient;
-  }
-  static createExecutor(constructor, instance) {
-    let entry = Listener.getEntry(constructor);
-    if (!entry)
-      throw new Error("Missing listener entry");
-    let { hooks } = entry;
-    return async function(...args) {
-      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.
-   */
-  static async load(pattern, parallel = true) {
-    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)
-      return Promise.all(loaders);
-    let result = [];
-    for (let loader of loaders)
-      result.push(await loader);
-    return result;
-  }
-};
-
-// src/BakitClient.ts
-var BakitClient = class _BakitClient extends Client {
-  constructor(options) {
-    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) {
-    let commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
-    await client.application.commands.set(commands);
-  }
-  async handleMessage(message) {
-    if (message.author.bot)
-      return;
-    let context = new MessageContext(message), resolver = ArgumentResolver.create(message);
-    if (!resolver)
-      return;
-    let { trigger } = resolver, command = CommandRegistry.instances.get(trigger);
-    command && await StateBox.run(() => this.handleMessageHooks(context, command, resolver));
-  }
-  async handleInteraction(interaction) {
-    if (!interaction.isChatInputCommand())
-      return;
-    let { commandName } = interaction, command = CommandRegistry.instances.get(commandName);
-    if (!command)
-      return;
-    let context = new ChatInputContext(interaction);
-    await StateBox.run(() => this.handleChatInputHooks(context, command));
-  }
-  async handleChatInputHooks(context, instance) {
-    let targetHooks = this.getChatInputTargetHooks(context.source, instance), inheritedArgs = [];
-    for (let hooks of [targetHooks.root, targetHooks.group, targetHooks.subcommand]) {
-      if (!hooks)
-        continue;
-      let newArgs = await this.runChatInputHooks(context, instance, hooks, inheritedArgs);
-      newArgs && (inheritedArgs = newArgs);
-    }
-  }
-  async handleMessageHooks(context, instance, resolver) {
-    if (!resolver)
-      return;
-    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)
-      return;
-    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) {
-    let mainHook = hooks.MAIN;
-    if (!mainHook)
-      return resolver;
-    let args = Arg.getMethodArguments(mainHook.method);
-    try {
-      resolver = await resolver.resolve(args);
-    } catch (error) {
-      if (error instanceof CommandSyntaxError) {
-        let errorContent = await this.options.getSyntaxErrorMessage?.(
-          instance,
-          error,
-          context,
-          args,
-          resolver.options.prefix
-        );
-        return errorContent && await context.send(errorContent), null;
-      }
-      throw error;
-    }
-    return await this.runHooks(context, instance, hooks, resolver.parsedValues), resolver;
-  }
-  async runChatInputHooks(context, instance, hooks, inheritedArgs) {
-    let mainHook = hooks.MAIN;
-    if (!mainHook)
-      return;
-    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) {
-    let mainHook = hooks.MAIN, preHook = hooks.PRE, postHook = hooks.POST, errorHook = hooks.ERROR;
-    if (!mainHook)
-      return;
-    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);
-    } catch (error) {
-      if (errorHook)
-        await execute(errorHook, error);
-      else
-        throw error;
-    }
-  }
-  getChatInputTargetHooks(interaction, instance) {
-    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) {
-      let child = root.children.get(groupName);
-      child instanceof CommandGroupEntry && (group = child);
-    }
-    let subcommand;
-    if (subcommandName) {
-      let child = (group || root).children.get(subcommandName);
-      child instanceof SubcommandEntry && (subcommand = child);
-    }
-    return {
-      root: root.hooks,
-      group: group?.hooks,
-      subcommand: subcommand?.hooks
-    };
   }
 };
 
-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, ArgumentResolver, ArgumentType, BakitClient, BaseCommandEntry, BaseCommandGroupEntry, BaseContext, ChatInputContext, Command, CommandAPI, CommandFactory, CommandGroupEntry, CommandRegistry, CommandSyntaxError, CommandSyntaxErrorType, Listener, ListenerAPI, ListenerEntry, ListenerFactory, ListenerRegistry, MessageContext, RootCommandEntry, StateBox, SubcommandEntry, defaultGetSyntaxErrorMessage, extractId };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "1.0.0-beta.14",
+	"version": "1.0.0-beta.16",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"exports": {