@arox/framework 0.1.1 → 0.1.2-beta.1

package/dist/index.js

@@ -1,15 +1,1194 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "version", {
-    enumerable: true,
-    get: function() {
-        return version;
-    }
-});
-const _export_star = require("@swc/helpers/_/_export_star");
-_export_star._(require("#structures"), exports);
-_export_star._(require("./utils/logger/Logger"), exports);
-_export_star._(require("#ctx"), exports);
-const version = "v0.1.1";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/utils/util.ts
+function deleteMessageAfterSent(message, time = 15e3) {
+  return new Promise((r) => {
+    setTimeout(() => {
+      message.delete().catch(() => {
+      });
+      r();
+    }, time);
+  });
+}
+function getPrefix(opts) {
+  if (typeof opts === "string") {
+    return opts;
+  }
+  if (opts.enabled && opts.prefix) {
+    return opts.prefix;
+  }
+  return false;
+}
+var init_util = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/utils/util.ts"() {
+    "use strict";
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/utils/Files.ts
+function getFiles(baseDir) {
+  return import_fast_glob.default.sync(["**/*.ts", "**/*.js"], {
+    cwd: baseDir,
+    absolute: true,
+    ignore: [
+      "**/*.d.ts",
+      "node_modules/**",
+      ".git/**",
+      "dist/**",
+      "lib/**",
+      "out/**",
+      "build/**",
+      ".next/**",
+      "coverage/**"
+    ]
+  });
+}
+function getProjectRoot() {
+  if (!require.main?.filename) {
+    return process.cwd();
+  }
+  return import_path.default.dirname(require.main.filename);
+}
+var import_fast_glob, import_path;
+var init_Files = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/utils/Files.ts"() {
+    "use strict";
+    import_fast_glob = __toESM(require("fast-glob"));
+    import_path = __toESM(require("path"));
+  }
+});
+
+// node_modules/@sapphire/timestamp/dist/esm/index.mjs
+var __defProp2, __defNormalProp, __name, __publicField, days, months, tokens, tokenResolvers, _Timestamp, Timestamp;
+var init_esm = __esm({
+  "node_modules/@sapphire/timestamp/dist/esm/index.mjs"() {
+    "use strict";
+    __defProp2 = Object.defineProperty;
+    __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+    __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+    months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+    tokens = /* @__PURE__ */ new Map([
+      ["Y", 4],
+      ["Q", 1],
+      ["M", 4],
+      ["D", 4],
+      ["d", 4],
+      ["X", 1],
+      ["x", 1],
+      ["H", 2],
+      ["h", 2],
+      ["a", 1],
+      ["A", 1],
+      ["m", 2],
+      ["s", 2],
+      ["S", 3],
+      ["Z", 2],
+      ["l", 4],
+      ["L", 4],
+      ["T", 1],
+      ["t", 1]
+    ]);
+    tokenResolvers = /* @__PURE__ */ new Map([
+      // Dates
+      ["Y", (time) => String(time.getFullYear()).slice(2)],
+      ["YY", (time) => String(time.getFullYear()).slice(2)],
+      ["YYY", (time) => String(time.getFullYear())],
+      ["YYYY", (time) => String(time.getFullYear())],
+      ["Q", (time) => String((time.getMonth() + 1) / 3)],
+      ["M", (time) => String(time.getMonth() + 1)],
+      ["MM", (time) => String(time.getMonth() + 1).padStart(2, "0")],
+      ["MMM", (time) => months[time.getMonth()]],
+      ["MMMM", (time) => months[time.getMonth()]],
+      ["D", (time) => String(time.getDate())],
+      ["DD", (time) => String(time.getDate()).padStart(2, "0")],
+      ["DDD", (time) => String(Math.floor(
+        (time.getTime() - new Date(time.getFullYear(), 0, 0).getTime()) / 864e5
+        /* Day */
+      ))],
+      ["DDDD", (time) => String(Math.floor(
+        (time.getTime() - new Date(time.getFullYear(), 0, 0).getTime()) / 864e5
+        /* Day */
+      ))],
+      [
+        "d",
+        (time) => {
+          const day = String(time.getDate());
+          if (day !== "11" && day.endsWith("1")) return `${day}st`;
+          if (day !== "12" && day.endsWith("2")) return `${day}nd`;
+          if (day !== "13" && day.endsWith("3")) return `${day}rd`;
+          return `${day}th`;
+        }
+      ],
+      ["dd", (time) => days[time.getDay()].slice(0, 2)],
+      ["ddd", (time) => days[time.getDay()].slice(0, 3)],
+      ["dddd", (time) => days[time.getDay()]],
+      ["X", (time) => String(
+        time.valueOf() / 1e3
+        /* Second */
+      )],
+      ["x", (time) => String(time.valueOf())],
+      // Locales
+      ["H", (time) => String(time.getHours())],
+      ["HH", (time) => String(time.getHours()).padStart(2, "0")],
+      ["h", (time) => String(time.getHours() % 12 || 12)],
+      ["hh", (time) => String(time.getHours() % 12 || 12).padStart(2, "0")],
+      ["a", (time) => time.getHours() < 12 ? "am" : "pm"],
+      ["A", (time) => time.getHours() < 12 ? "AM" : "PM"],
+      ["m", (time) => String(time.getMinutes())],
+      ["mm", (time) => String(time.getMinutes()).padStart(2, "0")],
+      ["s", (time) => String(time.getSeconds())],
+      ["ss", (time) => String(time.getSeconds()).padStart(2, "0")],
+      ["S", (time) => String(time.getMilliseconds())],
+      ["SS", (time) => String(time.getMilliseconds()).padStart(2, "0")],
+      ["SSS", (time) => String(time.getMilliseconds()).padStart(3, "0")],
+      ["T", (time) => `${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`],
+      [
+        "t",
+        (time) => `${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")}:${String(time.getSeconds()).padStart(2, "0")} ${time.getHours() < 12 ? "am" : "pm"}`
+      ],
+      ["L", (time) => `${String(time.getMonth() + 1).padStart(2, "0")}/${String(time.getDate()).padStart(2, "0")}/${String(time.getFullYear())}`],
+      ["l", (time) => `${String(time.getMonth() + 1)}/${String(time.getDate()).padStart(2, "0")}/${String(time.getFullYear())}`],
+      ["LL", (time) => `${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())}`],
+      ["ll", (time) => `${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())}`],
+      [
+        "LLL",
+        (time) => `${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(
+          time.getHours() % 12 || 12
+        )}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+      ],
+      [
+        "lll",
+        (time) => `${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(
+          time.getHours() % 12 || 12
+        )}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+      ],
+      [
+        "LLLL",
+        (time) => `${days[time.getDay()]}, ${months[time.getMonth()]} ${String(time.getDate()).padStart(2, "0")}, ${String(time.getFullYear())} ${String(
+          time.getHours() % 12 || 12
+        )}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+      ],
+      [
+        "llll",
+        (time) => `${days[time.getDay()].slice(0, 3)} ${months[time.getMonth()].slice(0, 3)} ${String(time.getDate()).padStart(2, "0")}, ${String(
+          time.getFullYear()
+        )} ${String(time.getHours() % 12 || 12)}:${String(time.getMinutes()).padStart(2, "0")} ${time.getHours() < 12 ? "AM" : "PM"}`
+      ],
+      [
+        "Z",
+        (time) => {
+          const offset = time.getTimezoneOffset();
+          const unsigned = offset >= 0;
+          const absolute = Math.abs(offset);
+          return `${unsigned ? "+" : "-"}${String(Math.floor(absolute / 60)).padStart(2, "0")}:${String(absolute % 60).padStart(2, "0")}`;
+        }
+      ],
+      [
+        "ZZ",
+        (time) => {
+          const offset = time.getTimezoneOffset();
+          const unsigned = offset >= 0;
+          const absolute = Math.abs(offset);
+          return `${unsigned ? "+" : "-"}${String(Math.floor(absolute / 60)).padStart(2, "0")}:${String(absolute % 60).padStart(2, "0")}`;
+        }
+      ]
+    ]);
+    _Timestamp = class _Timestamp2 {
+      /**
+       * Starts a new Timestamp and parses the pattern.
+       * @since 1.0.0
+       * @param pattern The pattern to parse
+       */
+      constructor(pattern) {
+        __publicField(this, "pattern");
+        __publicField(this, "template");
+        this.pattern = pattern;
+        this.template = _Timestamp2.parse(pattern);
+      }
+      /**
+       * Display the current date with the current pattern.
+       * @since 1.0.0
+       * @param time The time to display
+       */
+      display(time = /* @__PURE__ */ new Date()) {
+        return _Timestamp2.display(this.template, time);
+      }
+      /**
+       * Display the current date utc with the current pattern.
+       * @since 1.0.0
+       * @param time The time to display in utc
+       */
+      displayUTC(time) {
+        return _Timestamp2.display(this.template, _Timestamp2.utc(time));
+      }
+      /**
+       * Edits the current pattern.
+       * @since 1.0.0
+       * @param pattern The new pattern for this instance
+       * @chainable
+       */
+      edit(pattern) {
+        this.pattern = pattern;
+        this.template = _Timestamp2.parse(pattern);
+        return this;
+      }
+      /**
+       * Defines the toString behavior of Timestamp.
+       */
+      toString() {
+        return this.display();
+      }
+      /**
+       * Display the current date with the current pattern.
+       * @since 1.0.0
+       * @param pattern The pattern to parse
+       * @param time The time to display
+       */
+      static displayArbitrary(pattern, time = /* @__PURE__ */ new Date()) {
+        return _Timestamp2.display(_Timestamp2.parse(pattern), time);
+      }
+      /**
+       * Display the current date utc with the current pattern.
+       * @since 1.0.0
+       * @param pattern The pattern to parse
+       * @param time The time to display
+       */
+      static displayUTCArbitrary(pattern, time = /* @__PURE__ */ new Date()) {
+        return _Timestamp2.display(_Timestamp2.parse(pattern), _Timestamp2.utc(time));
+      }
+      /**
+       * Creates a UTC Date object to work with.
+       * @since 1.0.0
+       * @param time The date to convert to utc
+       */
+      static utc(time = /* @__PURE__ */ new Date()) {
+        time = _Timestamp2.resolveDate(time);
+        return new Date(time.valueOf() + time.getTimezoneOffset() * 6e4);
+      }
+      /**
+       * Display the current date with the current pattern.
+       * @since 1.0.0
+       * @param template The pattern to parse
+       * @param time The time to display
+       */
+      static display(template, time) {
+        let output = "";
+        const parsedTime = _Timestamp2.resolveDate(time);
+        for (const { content, type } of template) output += content || tokenResolvers.get(type)(parsedTime);
+        return output;
+      }
+      /**
+       * Parses the pattern.
+       * @since 1.0.0
+       * @param pattern The pattern to parse
+       */
+      static parse(pattern) {
+        const template = [];
+        for (let i = 0; i < pattern.length; i++) {
+          let current = "";
+          const currentChar = pattern[i];
+          const tokenMax = tokens.get(currentChar);
+          if (typeof tokenMax === "number") {
+            current += currentChar;
+            while (pattern[i + 1] === currentChar && current.length < tokenMax) current += pattern[++i];
+            template.push({ type: current, content: null });
+          } else if (currentChar === "[") {
+            while (i + 1 < pattern.length && pattern[i + 1] !== "]") current += pattern[++i];
+            i++;
+            template.push({ type: "literal", content: current || "[" });
+          } else {
+            current += currentChar;
+            while (i + 1 < pattern.length && !tokens.has(pattern[i + 1]) && pattern[i + 1] !== "[") current += pattern[++i];
+            template.push({ type: "literal", content: current });
+          }
+        }
+        return template;
+      }
+      /**
+       * Resolves a date.
+       * @since 1.0.0
+       * @param time The time to parse
+       */
+      static resolveDate(time) {
+        return time instanceof Date ? time : new Date(time);
+      }
+    };
+    __name(_Timestamp, "Timestamp");
+    Timestamp = _Timestamp;
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/utils/logger/ILogger.ts
+var LogLevel;
+var init_ILogger = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/utils/logger/ILogger.ts"() {
+    "use strict";
+    LogLevel = /* @__PURE__ */ (function(LogLevel2) {
+      LogLevel2[LogLevel2["Trace"] = 10] = "Trace";
+      LogLevel2[LogLevel2["Debug"] = 20] = "Debug";
+      LogLevel2[LogLevel2["Info"] = 30] = "Info";
+      LogLevel2[LogLevel2["Warn"] = 40] = "Warn";
+      LogLevel2[LogLevel2["Error"] = 50] = "Error";
+      LogLevel2[LogLevel2["Fatal"] = 60] = "Fatal";
+      LogLevel2[LogLevel2["None"] = 100] = "None";
+      return LogLevel2;
+    })({});
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/utils/logger/Logger.ts
+var import_console, import_util, colorette, Logger, LoggerStyle, LoggerTimestamp, LoggerLevel, Logger_default, LoggerStyleEffect, LoggerStyleText, LoggerStyleBackground, I18nLoggerAdapter;
+var init_Logger = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/utils/logger/Logger.ts"() {
+    "use strict";
+    import_console = require("console");
+    import_util = require("util");
+    colorette = __toESM(require("colorette"));
+    init_esm();
+    init_ILogger();
+    init_ILogger();
+    Logger = class _Logger {
+      level;
+      formats;
+      join;
+      depth;
+      console;
+      static instance = null;
+      static LOG_METHODS = /* @__PURE__ */ new Map([
+        [LogLevel.Trace, "trace"],
+        [LogLevel.Debug, "debug"],
+        [LogLevel.Info, "info"],
+        [LogLevel.Warn, "warn"],
+        [LogLevel.Error, "error"],
+        [LogLevel.Fatal, "error"]
+      ]);
+      static DEFAULT_COLORS = /* @__PURE__ */ new Map([
+        [LogLevel.Trace, colorette.gray],
+        [LogLevel.Debug, colorette.magenta],
+        [LogLevel.Info, colorette.cyan],
+        [LogLevel.Warn, colorette.yellow],
+        [LogLevel.Error, colorette.red],
+        [LogLevel.Fatal, colorette.bgRed],
+        [LogLevel.None, colorette.white]
+      ]);
+      static DEFAULT_NAMES = /* @__PURE__ */ new Map([
+        [LogLevel.Trace, "TRACE"],
+        [LogLevel.Debug, "DEBUG"],
+        [LogLevel.Info, "INFO"],
+        [LogLevel.Warn, "WARN"],
+        [LogLevel.Error, "ERROR"],
+        [LogLevel.Fatal, "FATAL"],
+        [LogLevel.None, ""]
+      ]);
+      constructor(options = {}) {
+        this.level = options.level ?? LogLevel.Info;
+        this.console = new import_console.Console(options.stdout ?? process.stdout, options.stderr ?? process.stderr);
+        this.formats = this.createFormatMap(options.format, options.defaultFormat ?? options.format?.none ?? {});
+        this.join = options.join ?? " ";
+        this.depth = options.depth ?? 2;
+      }
+      static getInstance() {
+        if (!this.instance) {
+          this.instance = new _Logger();
+        }
+        return this.instance;
+      }
+      static get stylize() {
+        return colorette.isColorSupported;
+      }
+      setLevel(level) {
+        this.level = level;
+      }
+      has(level) {
+        return level >= this.level;
+      }
+      trace(...values) {
+        this.write(LogLevel.Trace, ...values);
+      }
+      debug(...values) {
+        this.write(LogLevel.Debug, ...values);
+      }
+      info(...values) {
+        this.write(LogLevel.Info, ...values);
+      }
+      log(...values) {
+        this.write(LogLevel.Info, ...values);
+      }
+      warn(...values) {
+        this.write(LogLevel.Warn, ...values);
+      }
+      error(...values) {
+        this.write(LogLevel.Error, ...values);
+      }
+      fatal(...values) {
+        this.write(LogLevel.Fatal, ...values);
+      }
+      write(level, ...values) {
+        if (level < this.level) return;
+        const method = _Logger.LOG_METHODS.get(level);
+        const formatter = this.formats.get(level) ?? this.formats.get(LogLevel.None);
+        const message = formatter.run(this.preprocess(values));
+        switch (method) {
+          case "trace":
+            this.console.trace(message);
+            break;
+          case "debug":
+            this.console.debug(message);
+            break;
+          case "info":
+            this.console.info(message);
+            break;
+          case "warn":
+            this.console.warn(message);
+            break;
+          case "error":
+            this.console.error(message);
+            break;
+          default:
+            this.console.log(message);
+        }
+      }
+      preprocess(values) {
+        const inspectOptions = {
+          colors: colorette.isColorSupported,
+          depth: this.depth
+        };
+        return values.map((value) => typeof value === "string" ? value : (0, import_util.inspect)(value, inspectOptions)).join(this.join);
+      }
+      createFormatMap(options = {}, defaults) {
+        const map = /* @__PURE__ */ new Map();
+        for (const [level, color] of _Logger.DEFAULT_COLORS) {
+          const name = _Logger.DEFAULT_NAMES.get(level);
+          const levelOptions = options[this.getLevelKey(level)] ?? this.createDefaultLevel(defaults, color, name ?? "");
+          map.set(level, levelOptions instanceof LoggerLevel ? levelOptions : new LoggerLevel(levelOptions));
+        }
+        return map;
+      }
+      createDefaultLevel(defaults, color, name) {
+        return new LoggerLevel({
+          ...defaults,
+          timestamp: defaults.timestamp === null ? null : {
+            ...defaults.timestamp,
+            color
+          },
+          infix: name.length ? `${color(name.padEnd(5, " "))} ` : ""
+        });
+      }
+      getLevelKey(level) {
+        const keys = {
+          [LogLevel.Trace]: "trace",
+          [LogLevel.Debug]: "debug",
+          [LogLevel.Info]: "info",
+          [LogLevel.Warn]: "warn",
+          [LogLevel.Error]: "error",
+          [LogLevel.Fatal]: "fatal",
+          [LogLevel.None]: "none"
+        };
+        return keys[level];
+      }
+    };
+    LoggerStyle = class {
+      style;
+      constructor(resolvable = {}) {
+        if (typeof resolvable === "function") {
+          this.style = resolvable;
+        } else {
+          const styles = this.buildStyleArray(resolvable);
+          this.style = this.combineStyles(styles);
+        }
+      }
+      run(value) {
+        return this.style(String(value));
+      }
+      buildStyleArray(options) {
+        const styles = [];
+        if (options.effects) {
+          styles.push(...options.effects.map((effect) => colorette[effect]));
+        }
+        if (options.text) {
+          styles.push(colorette[options.text]);
+        }
+        if (options.background) {
+          styles.push(colorette[options.background]);
+        }
+        return styles;
+      }
+      combineStyles(styles) {
+        if (styles.length === 0) return colorette.reset;
+        if (styles.length === 1) return styles[0];
+        return ((text) => styles.reduce((result, style) => style(result), text));
+      }
+    };
+    LoggerTimestamp = class {
+      timestamp;
+      utc;
+      color;
+      formatter;
+      constructor(options = {}) {
+        this.timestamp = new Timestamp(options.pattern ?? "YYYY-MM-DD HH:mm:ss");
+        this.utc = options.utc ?? false;
+        this.color = options.color === null ? null : new LoggerStyle(options.color);
+        this.formatter = options.formatter ?? ((timestamp) => `${timestamp} `);
+      }
+      run() {
+        const date = /* @__PURE__ */ new Date();
+        const result = this.utc ? this.timestamp.displayUTC(date) : this.timestamp.display(date);
+        return this.formatter(this.color ? this.color.run(result) : result);
+      }
+    };
+    LoggerLevel = class {
+      timestamp;
+      infix;
+      message;
+      constructor(options = {}) {
+        this.timestamp = options.timestamp === null ? null : new LoggerTimestamp(options.timestamp);
+        this.infix = options.infix ?? "";
+        this.message = options.message === null ? null : new LoggerStyle(options.message);
+      }
+      run(content) {
+        const prefix = (this.timestamp?.run() ?? "") + this.infix;
+        if (prefix.length) {
+          const formatter = this.message ? (line) => prefix + this.message?.run(line) : (line) => prefix + line;
+          return content.split("\n").map(formatter).join("\n");
+        }
+        return this.message ? this.message.run(content) : content;
+      }
+    };
+    Logger_default = Logger.getInstance();
+    LoggerStyleEffect = /* @__PURE__ */ (function(LoggerStyleEffect2) {
+      LoggerStyleEffect2["Reset"] = "reset";
+      LoggerStyleEffect2["Bold"] = "bold";
+      LoggerStyleEffect2["Dim"] = "dim";
+      LoggerStyleEffect2["Italic"] = "italic";
+      LoggerStyleEffect2["Underline"] = "underline";
+      LoggerStyleEffect2["Inverse"] = "inverse";
+      LoggerStyleEffect2["Hidden"] = "hidden";
+      LoggerStyleEffect2["Strikethrough"] = "strikethrough";
+      return LoggerStyleEffect2;
+    })({});
+    LoggerStyleText = /* @__PURE__ */ (function(LoggerStyleText2) {
+      LoggerStyleText2["Black"] = "black";
+      LoggerStyleText2["Red"] = "red";
+      LoggerStyleText2["Green"] = "green";
+      LoggerStyleText2["Yellow"] = "yellow";
+      LoggerStyleText2["Blue"] = "blue";
+      LoggerStyleText2["Magenta"] = "magenta";
+      LoggerStyleText2["Cyan"] = "cyan";
+      LoggerStyleText2["White"] = "white";
+      LoggerStyleText2["Gray"] = "gray";
+      LoggerStyleText2["BlackBright"] = "blackBright";
+      LoggerStyleText2["RedBright"] = "redBright";
+      LoggerStyleText2["GreenBright"] = "greenBright";
+      LoggerStyleText2["YellowBright"] = "yellowBright";
+      LoggerStyleText2["BlueBright"] = "blueBright";
+      LoggerStyleText2["MagentaBright"] = "magentaBright";
+      LoggerStyleText2["CyanBright"] = "cyanBright";
+      LoggerStyleText2["WhiteBright"] = "whiteBright";
+      return LoggerStyleText2;
+    })({});
+    LoggerStyleBackground = /* @__PURE__ */ (function(LoggerStyleBackground2) {
+      LoggerStyleBackground2["Black"] = "bgBlack";
+      LoggerStyleBackground2["Red"] = "bgRed";
+      LoggerStyleBackground2["Green"] = "bgGreen";
+      LoggerStyleBackground2["Yellow"] = "bgYellow";
+      LoggerStyleBackground2["Blue"] = "bgBlue";
+      LoggerStyleBackground2["Magenta"] = "bgMagenta";
+      LoggerStyleBackground2["Cyan"] = "bgCyan";
+      LoggerStyleBackground2["White"] = "bgWhite";
+      LoggerStyleBackground2["BlackBright"] = "bgBlackBright";
+      LoggerStyleBackground2["RedBright"] = "bgRedBright";
+      LoggerStyleBackground2["GreenBright"] = "bgGreenBright";
+      LoggerStyleBackground2["YellowBright"] = "bgYellowBright";
+      LoggerStyleBackground2["BlueBright"] = "bgBlueBright";
+      LoggerStyleBackground2["MagentaBright"] = "bgMagentaBright";
+      LoggerStyleBackground2["CyanBright"] = "bgCyanBright";
+      LoggerStyleBackground2["WhiteBright"] = "bgWhiteBright";
+      return LoggerStyleBackground2;
+    })({});
+    I18nLoggerAdapter = class {
+      type = "logger";
+      constructor(logger) {
+        this.logger = logger;
+      }
+      log(...args) {
+        this.logger.debug("[i18next]", ...args);
+      }
+      warn(...args) {
+        this.logger.warn("[i18next]", ...args);
+      }
+      error(...args) {
+        this.logger.error("[i18next]", ...args);
+      }
+    };
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/utils/index.ts
+var init_utils = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/utils/index.ts"() {
+    "use strict";
+    init_util();
+    init_Files();
+    init_Logger();
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/context.ts
+function setClient(client) {
+  currentClient = client;
+}
+function clearClient() {
+  currentClient = null;
+}
+var currentClient;
+var init_context = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/context.ts"() {
+    "use strict";
+    currentClient = null;
+  }
+});
+
+// src/events/ready.ts
+var require_ready = __commonJS({
+  "src/events/ready.ts"() {
+    "use strict";
+    var import_discord4 = require("discord.js");
+    init_structures();
+    new EventBuilder(import_discord4.Events.ClientReady).onExecute(async function(context) {
+      if (context.client.options.autoRegisterCommands) {
+        await context.client.registerCommands();
+      }
+    });
+  }
+});
+
+// src/events/interaction.ts
+var require_interaction = __commonJS({
+  "src/events/interaction.ts"() {
+    "use strict";
+    var import_discord4 = require("discord.js");
+    init_structures();
+    new EventBuilder(import_discord4.Events.InteractionCreate, false).onExecute(async function(context, interaction) {
+      if (!interaction.isChatInputCommand()) return;
+      const command = context.client.commands.get(interaction.commandName);
+      const ctx = new Context(context.client, { interaction });
+      if (!command) {
+        await interaction.reply({
+          content: ctx.t("error.command.notfound", { defaultValue: "Command not found or disabled." }),
+          flags: import_discord4.MessageFlags.Ephemeral
+        });
+        return;
+      }
+      if (!command.supportsSlash) {
+        await interaction.reply({
+          content: ctx.t("error.command.disabled", { defaultValue: "Command not found or disabled." }),
+          flags: import_discord4.MessageFlags.Ephemeral
+        });
+        return;
+      }
+      try {
+        ctx.locale = interaction.locale;
+        context.logger.debug(`${ctx.author?.tag ?? "Unknown"} used ${command.data.name}(interaction)`);
+        if (command._onInteraction) await command._onInteraction(ctx.toJSON());
+      } catch (error) {
+        context.client.logger.error(`Error executing command ${command.data.name}:`, error);
+        if (interaction.replied || interaction.deferred) {
+          await interaction.followUp({
+            content: "There was an error while executing this command!",
+            flags: import_discord4.MessageFlags.Ephemeral
+          });
+        } else {
+          await interaction.reply({
+            content: "There was an error while executing this command!",
+            flags: import_discord4.MessageFlags.Ephemeral
+          });
+        }
+      }
+    });
+  }
+});
+
+// src/events/message.ts
+var require_message = __commonJS({
+  "src/events/message.ts"() {
+    "use strict";
+    var import_discord4 = require("discord.js");
+    init_structures();
+    init_utils();
+    new EventBuilder(import_discord4.Events.MessageCreate, false, async function(context, message) {
+      if (message.author.bot) return;
+      const prefix = context.client.prefix;
+      if (typeof prefix !== "string" || prefix.length === 0 || !message.content.startsWith(prefix)) return;
+      const args = message.content.slice(prefix.length).trim().split(/ +/);
+      const commandName = args.shift()?.toLowerCase();
+      if (!commandName) return;
+      const commandAlias = context.client.aliases.findKey((cmd) => cmd.has(commandName));
+      const ctx = new Context(context.client, {
+        message,
+        args
+      });
+      let command = context.client.commands.get(commandAlias ?? commandName);
+      if (!command) {
+        await message.reply({
+          content: ctx.t("error.command.notfound", { defaultValue: "Command not found or disabled." }),
+          allowedMentions: { repliedUser: false }
+        }).then(deleteMessageAfterSent);
+        return;
+      }
+      if (!command.supportsPrefix) {
+        await message.reply({
+          content: ctx.t("error.command.disabled", { defaultValue: "Command not found or disabled." }),
+          allowedMentions: { repliedUser: false }
+        }).then(deleteMessageAfterSent);
+        return;
+      }
+      try {
+        context.logger.debug(`${ctx.author?.tag ?? "Unknown"} used ${command.data.name}(message)`);
+        if (command._onMessage) await command._onMessage(ctx.toJSON());
+      } catch (error) {
+        context.client.logger.error(`Error executing command ${command.data.name}:`, error);
+      }
+    });
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/structures/core/Client.ts
+var import_discord, import_path2, import_fs, defaultOpts, Client;
+var init_Client = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/structures/core/Client.ts"() {
+    "use strict";
+    import_discord = require("discord.js");
+    import_path2 = __toESM(require("path"));
+    init_utils();
+    init_context();
+    import_fs = require("fs");
+    defaultOpts = {
+      includePaths: ["events", "commands"],
+      autoRegisterCommands: true
+    };
+    Client = class extends import_discord.Client {
+      logger;
+      commands;
+      aliases;
+      prefix;
+      i18n;
+      constructor(opts) {
+        super({
+          ...defaultOpts,
+          ...opts
+        });
+        this.logger = new Logger(opts.logger);
+        this.commands = new import_discord.Collection();
+        this.aliases = new import_discord.Collection();
+        this.prefix = getPrefix(this.options.prefix ?? { enabled: false });
+        if (this.options.i18n) {
+          this.i18n = this.options.i18n;
+          this.i18n.use(new I18nLoggerAdapter(this.logger));
+        }
+        setClient(this);
+        try {
+          require_ready();
+          require_interaction();
+          if (this.prefix) require_message();
+        } finally {
+          clearClient();
+        }
+      }
+      async login(token) {
+        if (this.options.includePaths) {
+          for (const p of this.options.includePaths) {
+            await this.#loadDir(import_path2.default.join(getProjectRoot(), p)).catch((error) => this.logger.error(`Error loading ${p}:`, error));
+          }
+        }
+        if (this.i18n && !this.i18n.isInitialized) {
+          await this.i18n.init();
+        }
+        return super.login(token);
+      }
+      async #loadDir(dir) {
+        if (!(0, import_fs.existsSync)(dir)) {
+          this.logger.debug(`Directory not found: ${dir}`);
+          return;
+        }
+        const files = getFiles(dir);
+        for (const file of files) {
+          await this.#loadFile(file);
+        }
+      }
+      async #loadFile(file) {
+        try {
+          delete require.cache[require.resolve(file)];
+          setClient(this);
+          require(file);
+        } catch (error) {
+          this.logger.error(`Error loading file ${file}:`, error);
+        } finally {
+          clearClient();
+        }
+      }
+      async registerCommands() {
+        if (!this.token) {
+          this.logger.warn("registerCommands skipped: client token is not set.");
+          return;
+        }
+        if (!this.application) {
+          this.logger.warn("registerCommands skipped: client application is not ready.");
+          return;
+        }
+        const slashCommands = this.commands.filter((cmd) => cmd.supportsSlash).map((cmd) => cmd.data.toClientJSON(this));
+        const rest = new import_discord.REST({ version: "10" }).setToken(this.token);
+        try {
+          this.logger.debug(`Started refreshing ${slashCommands.length} application (/) commands.`);
+          await rest.put(import_discord.Routes.applicationCommands(this.application.id), { body: slashCommands });
+          this.logger.info(`Loaded ${slashCommands.length} application (/) commands.`);
+        } catch (error) {
+          this.logger.error("Failed to register commands:", error);
+        }
+      }
+    };
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/structures/core/index.ts
+var init_core = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/structures/core/index.ts"() {
+    "use strict";
+    init_Client();
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/Command.ts
+var CommandBuilder;
+var init_Command = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/Command.ts"() {
+    "use strict";
+    init_context();
+    CommandBuilder = class {
+      client;
+      logger;
+      #supportsSlash;
+      #supportsPrefix;
+      _onMessage;
+      _onInteraction;
+      get supportsSlash() {
+        return this.#supportsSlash && this._onInteraction;
+      }
+      get supportsPrefix() {
+        return this.#supportsPrefix && this._onMessage;
+      }
+      constructor(data) {
+        this.data = data;
+        const client = currentClient;
+        if (!client) throw new Error("Client is not defined");
+        this.client = client;
+        this.logger = client.logger;
+        let commandJSON = data.toJSON();
+        this.#supportsPrefix = commandJSON.prefix_support ?? false;
+        this.#supportsSlash = commandJSON.slash_support ?? false;
+        if (!this.#supportsPrefix && !this.#supportsSlash) {
+          throw new Error(`Command ${data.name} must support either slash or prefix commands.`);
+        }
+        if (this.client.commands.has(data.name)) throw new Error(`Command name "${data.name}" is already registered.`);
+        const existingAliasOwner = this.client.aliases.findKey((aliases) => aliases.has(data.name));
+        if (existingAliasOwner) {
+          throw new Error(`Command name "${data.name}" is already registered as an alias for command "${existingAliasOwner}".`);
+        }
+        for (const alias of commandJSON.aliases) {
+          if (this.client.commands.has(alias)) {
+            throw new Error(`Alias "${alias}" is already registered as a command name.`);
+          }
+          const conflictingCommand = this.client.aliases.findKey((aliases) => aliases.has(alias));
+          if (conflictingCommand) {
+            throw new Error(`Alias "${alias}" is already registered as an alias for command "${conflictingCommand}".`);
+          }
+        }
+        this.client.commands.set(commandJSON.name, this);
+        if (commandJSON.aliases.length > 0) {
+          this.client.aliases.set(commandJSON.name, new Set(commandJSON.aliases));
+        }
+        this.logger.debug(`Loaded Command ${commandJSON.name}`);
+      }
+      onMessage(func) {
+        this._onMessage = func;
+        return this;
+      }
+      onInteraction(func) {
+        this._onInteraction = func;
+        return this;
+      }
+    };
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/Context.ts
+var import_discord2, Context;
+var init_Context = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/Context.ts"() {
+    "use strict";
+    import_discord2 = require("discord.js");
+    Context = class {
+      args;
+      data;
+      locale;
+      constructor(client, payload) {
+        this.client = client;
+        this.args = payload.args ?? [];
+        if ("interaction" in payload) {
+          this.data = payload.interaction;
+        } else {
+          this.data = payload.message;
+        }
+      }
+      isInteraction() {
+        return this.data instanceof import_discord2.ChatInputCommandInteraction;
+      }
+      isMessage() {
+        return this.data instanceof import_discord2.Message;
+      }
+      get author() {
+        if (this.isInteraction()) {
+          return this.data.user;
+        }
+        if (this.isMessage()) {
+          return this.data.author;
+        }
+        return null;
+      }
+      t(key, options) {
+        if (!this.client.i18n) {
+          throw new Error("i18n is not initialized");
+        }
+        const locale = this.locale ?? (Array.isArray(this.client.i18n.options.fallbackLng) ? this.client.i18n.options.fallbackLng[0] : this.client.i18n.options.fallbackLng) ?? "en";
+        const t = this.client.i18n.getFixedT(locale);
+        const result = t(key, options);
+        if (result === key && options?.defaultValue) {
+          return options.defaultValue;
+        }
+        return result;
+      }
+      toJSON() {
+        const { data, args, author } = this;
+        if (this.isInteraction()) {
+          return {
+            kind: "interaction",
+            interaction: data,
+            author,
+            t: this.t.bind(this)
+          };
+        }
+        return {
+          kind: "message",
+          message: data,
+          args,
+          author,
+          t: this.t.bind(this)
+        };
+      }
+    };
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/Event.ts
+var EventBuilder;
+var init_Event = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/Event.ts"() {
+    "use strict";
+    init_context();
+    EventBuilder = class {
+      client;
+      logger;
+      #handler;
+      #bound = false;
+      #listener = async (...args) => {
+        if (!this.#handler) return;
+        try {
+          await this.#handler(this, ...args);
+        } catch (error) {
+          this.client.logger.error(`Error executing event ${this.name} (${this.constructor.name}):`, error);
+        }
+      };
+      constructor(name, once = false, _handler) {
+        this.name = name;
+        this.once = once;
+        if (!currentClient) throw new Error("Client is not defined");
+        this.client = currentClient;
+        this.logger = currentClient.logger;
+        if (_handler) {
+          this.#handler = _handler;
+          this.#register();
+        }
+      }
+      #register() {
+        if (this.#bound || !this.#handler) return;
+        if (this.once) {
+          this.client.once(this.name, this.#listener);
+        } else {
+          this.client.on(this.name, this.#listener);
+        }
+        this.#bound = true;
+        this.logger.debug(`Loaded Event ${String(this.name)}`);
+      }
+      onExecute(func) {
+        this.#handler = func;
+        this.#register();
+        return this;
+      }
+    };
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/utils/normalizeArray.ts
+function normalizeArray(arr) {
+  if (Array.isArray(arr[0])) return [...arr[0]];
+  return arr;
+}
+var init_normalizeArray = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/utils/normalizeArray.ts"() {
+    "use strict";
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/Builder.ts
+var import_discord3, ApplicationCommandBuilder;
+var init_Builder = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/Builder.ts"() {
+    "use strict";
+    import_discord3 = require("discord.js");
+    init_normalizeArray();
+    ApplicationCommandBuilder = class extends import_discord3.SlashCommandBuilder {
+      constructor() {
+        super();
+      }
+      prefix_support = true;
+      slash_support = true;
+      aliases = [];
+      setAliases(...alias) {
+        Reflect.set(this, "aliases", normalizeArray(alias));
+        return this;
+      }
+      addAliases(...alias) {
+        const currentAliases = Reflect.get(this, "aliases") || [];
+        Reflect.set(this, "aliases", normalizeArray([...currentAliases, ...normalizeArray(alias)]));
+        return this;
+      }
+      setPrefixSupport(support) {
+        Reflect.set(this, "prefix_support", support);
+        return this;
+      }
+      setSlashSupport(support) {
+        Reflect.set(this, "slash_support", support);
+        return this;
+      }
+      toJSON() {
+        return super.toJSON();
+      }
+      toClientJSON(_client) {
+        return { ...this.toJSON() };
+      }
+    };
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/index.ts
+var init_builder = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/structures/builder/index.ts"() {
+    "use strict";
+    init_Command();
+    init_Context();
+    init_Event();
+    init_Builder();
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/structures/index.ts
+var init_structures = __esm({
+  "unplugin-oxc:/home/runner/work/framework/framework/src/structures/index.ts"() {
+    "use strict";
+    init_core();
+    init_builder();
+  }
+});
+
+// unplugin-oxc:/home/runner/work/framework/framework/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApplicationCommandBuilder: () => ApplicationCommandBuilder,
+  Client: () => Client,
+  CommandBuilder: () => CommandBuilder,
+  Context: () => Context,
+  EventBuilder: () => EventBuilder,
+  I18nLoggerAdapter: () => I18nLoggerAdapter,
+  LogLevel: () => LogLevel,
+  Logger: () => Logger,
+  LoggerLevel: () => LoggerLevel,
+  LoggerStyle: () => LoggerStyle,
+  LoggerStyleBackground: () => LoggerStyleBackground,
+  LoggerStyleEffect: () => LoggerStyleEffect,
+  LoggerStyleText: () => LoggerStyleText,
+  LoggerTimestamp: () => LoggerTimestamp,
+  clearClient: () => clearClient,
+  currentClient: () => currentClient,
+  setClient: () => setClient,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+init_structures();
+init_Logger();
+init_context();
+var version = "v0.1.2-beta.1";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationCommandBuilder,
+  Client,
+  CommandBuilder,
+  Context,
+  EventBuilder,
+  I18nLoggerAdapter,
+  LogLevel,
+  Logger,
+  LoggerLevel,
+  LoggerStyle,
+  LoggerStyleBackground,
+  LoggerStyleEffect,
+  LoggerStyleText,
+  LoggerTimestamp,
+  clearClient,
+  currentClient,
+  setClient,
+  version
+});