bakit 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,1020 @@
+// 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/command/argument/Argument.ts
+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 Arg = class _Arg {
+  static cache = /* @__PURE__ */ new WeakMap();
+  static string = _Arg.createArgument("string" /* String */);
+  static integer = _Arg.createArgument("integer" /* Integer */);
+  static number = _Arg.createArgument("number" /* Number */);
+  static user = _Arg.createArgument("user" /* User */);
+  static member = _Arg.createArgument("member" /* Member */);
+  static getMethodArguments(method, init = false) {
+    let args = this.cache.get(method) ?? Reflect.getMetadata(ARGS_KEY, method);
+    if (!args) {
+      args = [];
+      if (init) {
+        Reflect.defineMetadata(ARGS_KEY, args, method);
+        this.cache.set(method, args);
+      }
+    }
+    return init ? args : Object.freeze([...args]);
+  }
+  static format(arg) {
+    const { name, required, tuple } = arg;
+    const opening = required ? "<" : "[";
+    const closing = required ? ">" : "]";
+    const prefix = tuple ? "..." : "";
+    return `${opening}${prefix}${name}: ${this.describeArgumentExpectation(arg)}${closing}`;
+  }
+  static describeArgumentExpectation(arg) {
+    const parts = [arg.type];
+    switch (arg.type) {
+      case "string" /* 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)}`);
+        }
+        break;
+      }
+      case "number" /* Number */:
+      case "integer" /* 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 "user" /* User */:
+      case "member" /* Member */: {
+        break;
+      }
+    }
+    return parts.join(", ");
+  }
+  static 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) {
+          throw new Error("No method found");
+        }
+        const args = _Arg.getMethodArguments(method, true);
+        args.unshift(fullOptions);
+      };
+    };
+  }
+};
+
+// src/command/CommandEntry.ts
+var HookExecutionState = /* @__PURE__ */ ((HookExecutionState2) => {
+  HookExecutionState2["Main"] = "main";
+  HookExecutionState2["Pre"] = "pre";
+  HookExecutionState2["Post"] = "post";
+  HookExecutionState2["Error"] = "error";
+  return HookExecutionState2;
+})(HookExecutionState || {});
+var HOOKS_KEY = Symbol("hooks");
+var BaseCommandEntry = class _BaseCommandEntry {
+  constructor(options) {
+    this.options = options;
+  }
+  static cache = /* @__PURE__ */ new WeakMap();
+  main = _BaseCommandEntry.createMainHookDecorator("main" /* Main */, this);
+  pre = _BaseCommandEntry.createMainHookDecorator("pre" /* Pre */, this);
+  post = _BaseCommandEntry.createMainHookDecorator("post" /* Post */, this);
+  error = _BaseCommandEntry.createErrorHookDecorator("error" /* Error */, this);
+  static getHooks(constructor, init = false) {
+    let hooks = this.cache.get(constructor) ?? Reflect.getMetadata(HOOKS_KEY, constructor);
+    if (!hooks) {
+      hooks = [];
+      if (init) {
+        Reflect.defineMetadata(HOOKS_KEY, hooks, constructor);
+        this.cache.set(constructor, hooks);
+      }
+    }
+    return init ? hooks : Object.freeze([...hooks]);
+  }
+  static createMainHookDecorator(state, entry) {
+    return (target, _key, descriptor) => {
+      this.addHook(target, state, descriptor.value, entry);
+    };
+  }
+  static createErrorHookDecorator(state, entry) {
+    return (target, _key, descriptor) => {
+      this.addHook(target, state, descriptor.value, entry);
+    };
+  }
+  static addHook(target, state, method, entry) {
+    const { constructor } = target;
+    const hooks = _BaseCommandEntry.getHooks(constructor, true);
+    if (typeof method !== "function") {
+      throw new Error("CommandEntry decorator must be used with a class method.");
+    }
+    if (hooks.some((hook) => hook.state === state && hook.entry === entry)) {
+      throw new Error(`Hook "${state}" is already defined for entry "${entry.options.name}".`);
+    }
+    if ("parent" in entry) {
+      const parentHook = hooks.find(
+        (hook) => hook.entry === entry.parent && hook.state === "main" /* Main */
+      );
+      if (parentHook) {
+        const parentArgs = Arg.getMethodArguments(parentHook.method);
+        if (parentArgs.at(-1)?.tuple) {
+          throw new Error(
+            `Cannot add hook "${state}" to entry "${entry.options.name}" because its parent "${entry.parent.options.name}" has a tuple argument.`
+          );
+        }
+      }
+    }
+    hooks.push({
+      state,
+      entry,
+      method
+    });
+  }
+};
+var BaseCommandGroupEntry = class extends BaseCommandEntry {
+  children = new Collection();
+  subcommand(options) {
+    if (typeof options === "string") {
+      options = { name: options };
+    }
+    if (!options.description) {
+      options.description = options.name;
+    }
+    if (this.children.has(options.name)) {
+      throw new Error(`Entry with name "${options.name}" already exists.`);
+    }
+    if (!(this instanceof CommandGroupEntry) && !(this instanceof RootCommandEntry)) {
+      throw new Error(`Invalid parent "${this.constructor.name}"`);
+    }
+    const entry = new SubcommandEntry(options, this);
+    this.children.set(entry.options.name, entry);
+    return entry;
+  }
+};
+var CommandGroupEntry = class extends BaseCommandGroupEntry {
+  constructor(options, parent) {
+    super(options);
+    this.options = options;
+    this.parent = parent;
+  }
+};
+var RootCommandEntry = class extends BaseCommandGroupEntry {
+  constructor(options) {
+    super(options);
+    this.options = options;
+  }
+  group(options) {
+    if (typeof options === "string") {
+      options = { name: options };
+    }
+    if (!options.description) {
+      options.description = options.name;
+    }
+    if (this.children.has(options.name)) {
+      throw new Error(`Entry with name "${options.name}" already exists.`);
+    }
+    const entry = new CommandGroupEntry(options, this);
+    this.children.set(entry.options.name, entry);
+    return entry;
+  }
+};
+var SubcommandEntry = class extends BaseCommandEntry {
+  constructor(options, parent) {
+    super(options);
+    this.options = options;
+    this.parent = parent;
+  }
+};
+
+// src/command/Command.ts
+var ROOT_KEY = Symbol("root");
+var Command = class {
+  static create(options) {
+    if (typeof options === "string") {
+      options = { name: options };
+    }
+    if (!options.description) {
+      options.description = options.name;
+    }
+    return new RootCommandEntry(options);
+  }
+  static use(command) {
+    return (target) => {
+      Reflect.defineMetadata(ROOT_KEY, command, target);
+    };
+  }
+  static getRoot(constructor) {
+    return Reflect.getMetadata(ROOT_KEY, constructor);
+  }
+};
+
+// src/command/CommandRegistry.ts
+var CommandRegistry = class _CommandRegistry {
+  static constructors = new Collection2();
+  static instances = new Collection2();
+  static add(constructor) {
+    const 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());
+  }
+  static buildSlashCommand(constructor) {
+    const builder = new SlashCommandBuilder();
+    const root = Command.getRoot(constructor);
+    if (!root) {
+      throw new Error(`No root found for "${constructor.name}"`);
+    }
+    const { options } = root;
+    builder.setName(options.name);
+    builder.setDescription(options.description || "");
+    builder.setNSFW(Boolean(options.nsfw));
+    this.buildSlashCommandOptions(builder, constructor);
+    return builder.toJSON();
+  }
+  static async loadDirectory(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;
+    });
+    if (parallel) {
+      return await Promise.all(loaders);
+    }
+    const result = [];
+    for (const loader of loaders) {
+      result.push(await loader);
+    }
+    return result;
+  }
+  static buildSlashCommandOptions(builder, constructor) {
+    const root = Command.getRoot(constructor);
+    if (!root) {
+      throw new Error(`No root found for "${constructor.name}"`);
+    }
+    const hooks = new Collection2(
+      BaseCommandEntry.getHooks(constructor).filter((hook) => hook.state === "main" /* Main */).map((hook) => [hook.entry, hook])
+    );
+    const rootHook = hooks.get(root);
+    if (!root.children.size && hooks.size) {
+      if (!rootHook) {
+        return;
+      }
+      for (const arg of Arg.getMethodArguments(rootHook.method)) {
+        this.buildSlashCommandOption(builder, arg);
+      }
+      return;
+    }
+    for (const child of root.children.values()) {
+      const hook = hooks.get(child);
+      const inheritedArgs = [];
+      if (rootHook) {
+        inheritedArgs.push(...Arg.getMethodArguments(rootHook.method));
+      }
+      if (child instanceof SubcommandEntry) {
+        this.buildSubcommand(builder, child, hook, inheritedArgs);
+      } else if (child instanceof CommandGroupEntry) {
+        if (hook) {
+          inheritedArgs.push(...Arg.getMethodArguments(hook.method));
+        }
+        const { options } = child;
+        const group = new SlashCommandSubcommandGroupBuilder().setName(options.name).setDescription(options.description);
+        for (const subChild of child.children.values()) {
+          this.buildSubcommand(group, subChild, hooks.get(subChild), inheritedArgs);
+        }
+        builder.addSubcommandGroup(group);
+      }
+    }
+  }
+  static buildSubcommand(parent, entry, hook, inheritedArgs) {
+    const { options } = entry;
+    const subcommand = new SlashCommandSubcommandBuilder().setName(options.name).setDescription(options.description);
+    const args = [...inheritedArgs];
+    if (hook) {
+      args.push(...Arg.getMethodArguments(hook.method));
+    }
+    for (const arg of args) {
+      this.buildSlashCommandOption(subcommand, arg);
+    }
+    parent.addSubcommand(subcommand);
+  }
+  static buildSlashCommandOption(builder, arg) {
+    const setupOption = (option) => {
+      return option.setName(arg.name).setDescription(arg.description || arg.name).setRequired(Boolean(arg.required));
+    };
+    switch (arg.type) {
+      case "string" /* String */: {
+        builder.addStringOption((option) => setupOption(option));
+        break;
+      }
+      case "integer" /* Integer */: {
+        builder.addIntegerOption((option) => setupOption(option));
+        break;
+      }
+      case "number" /* Number */: {
+        builder.addNumberOption((option) => setupOption(option));
+        break;
+      }
+      case "user" /* User */:
+      case "member" /* Member */: {
+        builder.addUserOption((option) => setupOption(option));
+        break;
+      }
+    }
+  }
+};
+
+// src/command/index.ts
+import "reflect-metadata";
+
+// src/command/Context.ts
+import {
+  ChatInputCommandInteraction,
+  Message
+} from "discord.js";
+var BaseContext = class {
+  constructor(source) {
+    this.source = source;
+  }
+  get client() {
+    return this.source.client;
+  }
+  get channel() {
+    return this.source.channel;
+  }
+  get channelId() {
+    return this.source.channelId;
+  }
+  get guild() {
+    return this.source.guild;
+  }
+  get guildId() {
+    return this.source.guildId;
+  }
+  inGuild() {
+    return Boolean(this.guildId);
+  }
+  inCachedGuild() {
+    if (this.isChatInput()) {
+      return this.source.inCachedGuild();
+    } else if (this.isMessage()) {
+      return this.source.inGuild();
+    } else {
+      throw new Error("Invalid source");
+    }
+  }
+  get author() {
+    if (this.isChatInput()) {
+      return this.source.user;
+    } else if (this.isMessage()) {
+      return this.source.author;
+    } else {
+      throw new Error("Invalid source");
+    }
+  }
+  isChatInput() {
+    return this.source instanceof ChatInputCommandInteraction;
+  }
+  isMessage() {
+    return this.source instanceof Message;
+  }
+};
+var ChatInputContext = class extends BaseContext {
+  async send(options) {
+    if (typeof options === "string") {
+      options = { content: options };
+    }
+    const 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 {
+  async send(options) {
+    const { 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) {
+    return idMatch[1];
+  }
+  const numericMatch = value.match(/^(\d{17,19})$/);
+  if (numericMatch) {
+    return numericMatch[1];
+  }
+  return null;
+}
+
+// src/errors/CommandSyntaxError.ts
+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 {
+  arg;
+  type;
+  expected;
+  received;
+  constructor(options) {
+    let message;
+    const { arg, type, received } = options;
+    const expected = Arg.describeArgumentExpectation(arg);
+    switch (type) {
+      case "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */: {
+        message = [`Missing required argument "${arg.name}"`, `> Expected: ${expected}`].join("\n");
+        break;
+      }
+      case "INVALID_ARGUMENT" /* InvalidArgument */: {
+        message = [
+          `Invalid value received for argument "${arg.name}"`,
+          `> Expected: ${expected}`,
+          `> Received: ${String(received)}`
+        ].join("\n");
+        break;
+      }
+      case "INVALID_VARIADIC_ARGUMENT_VALUE" /* InvalidVariadicArgumentValue */: {
+        message = [
+          `Invalid value received for variadic argument "${arg.name}"`,
+          `> Expected: ${expected}`,
+          `> Received: ${String(received)}`
+        ].join("\n");
+        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);
+  }
+  get name() {
+    return `CommandSyntaxError[${this.type}]`;
+  }
+};
+
+// src/command/argument/ArgumentResolver.ts
+var ArgumentResolver = class _ArgumentResolver {
+  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;
+  }
+  /**
+   * Get parsed raw values from content.
+   */
+  get 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 = [
+      // 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) {
+      return;
+    }
+    const 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({
+      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;
+  }
+  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];
+      if (arg.tuple) {
+        this.parsedValues.push(...await this.resolveTuple(arg, valueIndex, argIndex));
+        break;
+      }
+      const 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() {
+    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];
+      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) {
+        throw new CommandSyntaxError({
+          arg,
+          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
+          received: value
+        });
+      }
+      argIndex++;
+    }
+    while (argIndex < args.length) {
+      const arg = args[argIndex];
+      if (arg.required) {
+        throw new CommandSyntaxError({
+          arg,
+          type: "MISSING_REQUIRE_ARGUMENT" /* MissingRequireArgument */,
+          received: "nothing"
+        });
+      }
+      argIndex++;
+    }
+  }
+  async resolveTuple(arg, startIndex, argIndex) {
+    const { 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) {
+        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) {
+    const userId = extractId(value);
+    if (!userId) {
+      return null;
+    }
+    const user = await this.client.users.fetch(userId).catch(() => null);
+    if (!user) {
+      return null;
+    }
+    return user;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+    }
+  }
+};
+
+// src/libs/StateBox.ts
+import { AsyncLocalStorage } from "async_hooks";
+var StateBox = class _StateBox {
+  static STATES_KEY = Symbol("states");
+  static storage = new AsyncLocalStorage();
+  static getState() {
+    const 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 wrap(fn) {
+    const 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];
+        },
+        set(value) {
+          const states = _StateBox.getState();
+          states[key] = value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    };
+  }
+};
+
+// src/BakitClient.ts
+var BakitClient = class _BakitClient extends Client {
+  constructor(options) {
+    if (options.getSyntaxErrorMessage === void 0) {
+      options.getSyntaxErrorMessage = _BakitClient.getSyntaxErrorMessage;
+    }
+    super(options);
+    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) => {
+    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
+    };
+  };
+  async registerApplicationCommands(client) {
+    const commands = CommandRegistry.constructors.map((c) => CommandRegistry.buildSlashCommand(c));
+    await client.application.commands.set(commands);
+  }
+  async handleMessage(message) {
+    if (message.author.bot) {
+      return;
+    }
+    const resolver = ArgumentResolver.create(message);
+    if (!resolver) {
+      return;
+    }
+    const { trigger } = resolver;
+    const command = CommandRegistry.instances.get(trigger);
+    if (!command) {
+      return;
+    }
+    const hooks = BaseCommandEntry.getHooks(command.constructor);
+    const context = new MessageContext(message);
+    await StateBox.run(() => this.handleMessageHooks(context, hooks, command, resolver));
+  }
+  async handleInteraction(interaction) {
+    if (!interaction.isChatInputCommand()) {
+      return;
+    }
+    const { commandName } = interaction;
+    const command = CommandRegistry.instances.get(commandName);
+    if (!command) {
+      return;
+    }
+    const hooks = BaseCommandEntry.getHooks(command.constructor);
+    const context = new ChatInputContext(interaction);
+    await StateBox.run(() => this.handleChatInputHooks(context, hooks, command));
+  }
+  async handleChatInputHooks(context, hooks, instance) {
+    const targetHooks = this.getChatInputTargetHooks(context.source, hooks);
+    let inheritedArgs = [];
+    for (const record of [targetHooks.root, targetHooks.group, targetHooks.subcommand]) {
+      const newArgs = await this.runChatInputHooks(context, instance, record, inheritedArgs);
+      if (newArgs) {
+        inheritedArgs = newArgs;
+      }
+    }
+  }
+  async handleMessageHooks(context, hooks, instance, resolver) {
+    if (!resolver) {
+      return;
+    }
+    const rootEntry = Command.getRoot(instance.constructor);
+    if (!rootEntry) return;
+    const rootRecord = this.createHookRecord(hooks.filter((hook) => hook.entry === rootEntry));
+    resolver = await this.runMessageHooks(context, instance, rootRecord, resolver);
+    if (!resolver) {
+      return;
+    }
+    const usedValues = resolver.parsedValues.length;
+    const nextTrigger = resolver.values[usedValues + 1];
+    const nextHook = hooks.find((hook) => hook.entry.options.name === nextTrigger);
+    const nextRecord = this.createHookRecord(nextHook ? [nextHook] : []);
+    resolver = await this.runMessageHooks(context, instance, nextRecord, resolver);
+    if (!resolver) {
+      return;
+    }
+    if (nextRecord.main?.entry instanceof CommandGroupEntry) {
+      const groupEntry = nextRecord.main.entry;
+      const subTrigger = resolver.values[usedValues + 2];
+      const subHook = hooks.find(
+        (h) => h.entry instanceof SubcommandEntry && h.entry.options.name === subTrigger && h.entry.parent === groupEntry
+      );
+      const subRecord = this.createHookRecord(subHook ? [subHook] : []);
+      resolver = await this.runMessageHooks(context, instance, subRecord, resolver);
+    }
+  }
+  async runMessageHooks(context, instance, record, resolver) {
+    if (!record.main) {
+      return resolver;
+    }
+    const args = Arg.getMethodArguments(record.main.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;
+      }
+      throw error;
+    }
+    try {
+      await record.pre?.method.call(instance, context, ...resolver.parsedValues);
+      await record.main.method.call(instance, context, ...resolver.parsedValues);
+      await record.post?.method.call(instance, context, ...resolver.parsedValues);
+    } catch (error) {
+      if (record.error) {
+        await record.error.method.call(instance, context, error, ...resolver.parsedValues);
+      } else {
+        throw error;
+      }
+    }
+    return resolver;
+  }
+  async runChatInputHooks(context, instance, record, inheritedArgs) {
+    if (!record.main) {
+      return;
+    }
+    const newArgs = Arg.getMethodArguments(record.main.method).map(
+      (arg) => ArgumentResolver.resolveChatInput(context.source, arg)
+    );
+    const argValues = [...inheritedArgs, ...newArgs];
+    try {
+      await record.pre?.method.call(instance, context, ...argValues);
+      await record.main.method.call(instance, context, ...argValues);
+      await record.post?.method.call(instance, context, ...argValues);
+    } catch (error) {
+      if (record.error) {
+        await record.error.method.call(instance, context, error, ...argValues);
+      } else {
+        throw error;
+      }
+    }
+    return argValues;
+  }
+  getChatInputTargetHooks(interaction, hooks) {
+    const subcommand = interaction.options.getSubcommand(false);
+    const subcommandGroup = interaction.options.getSubcommandGroup(false);
+    const root = this.createHookRecord(
+      hooks.filter((hook) => hook.entry instanceof RootCommandEntry)
+    );
+    const group = this.createHookRecord(
+      hooks.filter(({ entry }) => {
+        return entry instanceof CommandGroupEntry && entry.options.name === subcommandGroup;
+      })
+    );
+    const sub = this.createHookRecord(
+      hooks.filter(({ entry }) => {
+        if (!(entry instanceof SubcommandEntry) || !(entry.options.name === subcommand)) {
+          return false;
+        }
+        if (subcommandGroup) {
+          const { parent } = entry;
+          if (!(parent instanceof CommandGroupEntry) || parent.options.name !== subcommandGroup) {
+            return false;
+          }
+        }
+        return true;
+      })
+    );
+    return { root, group, subcommand: sub };
+  }
+  createHookRecord(hooks) {
+    return Object.values(HookExecutionState).reduce(
+      (acc, state) => {
+        acc[state] = hooks.find((h) => h.state === state);
+        return acc;
+      },
+      {}
+    );
+  }
+};
+export {
+  Arg,
+  ArgumentType,
+  BakitClient,
+  BaseCommandEntry,
+  BaseCommandGroupEntry,
+  BaseContext,
+  ChatInputContext,
+  Command,
+  CommandGroupEntry,
+  CommandRegistry,
+  CommandSyntaxError,
+  CommandSyntaxErrorType,
+  HOOKS_KEY,
+  HookExecutionState,
+  MessageContext,
+  RootCommandEntry,
+  StateBox,
+  SubcommandEntry,
+  extractId
+};