asajs 3.0.2 → 3.0.4

package/dist/cjs/compilers/BindingFunctions.js

@@ -0,0 +1,267 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BindingFunctions_exports = {};
+__export(BindingFunctions_exports, {
+  BindingFunctions: () => BindingFunctions,
+  funcObj: () => funcObj
+});
+module.exports = __toCommonJS(BindingFunctions_exports);
+var import_Class = require("../components/Class");
+var import_Random = require("../components/Random");
+var import_BindingCompiler = require("./BindingCompiler");
+var import_Log = require("./generator/Log");
+var import_CurrentLine = require("./reader/CurrentLine");
+const funcObj = {
+  sum: (arg, params) => {
+    const bindingName = import_Random.Random.bindingName();
+    arg.addBindings({
+      source_property_name: "(".concat(params.join(" + "), ")"),
+      target_property_name: bindingName
+    });
+    return bindingName;
+  },
+  sumAvg: (arg, params) => {
+    const bindingName = import_Random.Random.bindingName();
+    arg.addBindings({
+      source_property_name: "((".concat(params.join(" + "), ") / ").concat(params.length, ")"),
+      target_property_name: bindingName
+    });
+    return bindingName;
+  },
+  max: (arg, params) => {
+    let current = params[0];
+    for (const nextBinding of params.slice(1)) {
+      arg.addBindings({
+        source_property_name: [
+          "(".concat(current, " >= ").concat(nextBinding, ") * ").concat(current, " + (").concat(current, " < ").concat(nextBinding, ") * ").concat(nextBinding)
+        ],
+        target_property_name: current = import_Random.Random.bindingName()
+      });
+    }
+    return current;
+  },
+  min: (arg, params) => {
+    let current = params[0];
+    for (const nextBinding of params.slice(1)) {
+      arg.addBindings({
+        source_property_name: [
+          "(".concat(current, " <= ").concat(nextBinding, ") * ").concat(current, " + (").concat(current, " > ").concat(nextBinding, ") * ").concat(nextBinding)
+        ],
+        target_property_name: current = import_Random.Random.bindingName()
+      });
+    }
+    return current;
+  },
+  abs: (arg, [binding]) => {
+    const bindingName = import_Random.Random.bindingName();
+    arg.addBindings({
+      source_property_name: "((-1 + (".concat(binding, " > 0) * 2) * ").concat(binding, ")"),
+      target_property_name: bindingName
+    });
+    return bindingName;
+  },
+  isEven: (arg, params) => {
+    const bindingName = import_Random.Random.bindingName();
+    if (params.length > 1) {
+      params.map((binding) => {
+        const bindingName2 = import_Random.Random.bindingName();
+        arg.addBindings({
+          source_property_name: ["(".concat(binding, " % 2) == 0")],
+          target_property_name: bindingName2
+        });
+        return bindingName2;
+      });
+      arg.addBindings({
+        source_property_name: "(".concat(params.join(" and "), ")"),
+        target_property_name: bindingName
+      });
+    } else {
+      arg.addBindings({
+        source_property_name: ["(".concat(params[0], " % 2) == 0")],
+        target_property_name: bindingName
+      });
+    }
+    return bindingName;
+  },
+  isOdd: (arg, params) => {
+    const bindingName = import_Random.Random.bindingName();
+    if (params.length > 1) {
+      params.map((binding) => {
+        const bindingName2 = import_Random.Random.bindingName();
+        arg.addBindings({
+          source_property_name: ["(".concat(binding, " % 2) == 1")],
+          target_property_name: bindingName2
+        });
+        return bindingName2;
+      });
+      arg.addBindings({
+        source_property_name: "(".concat(params.join(" and "), ")"),
+        target_property_name: bindingName
+      });
+    } else {
+      arg.addBindings({
+        source_property_name: ["(".concat(params[0], " % 2) == 1")],
+        target_property_name: bindingName
+      });
+    }
+    return bindingName;
+  },
+  int: (arg, [float, intLength]) => {
+    const sumBnd = [];
+    const _intLength = Number.isNaN(+intLength) ? -1 : +intLength;
+    let bindingName = import_Random.Random.bindingName();
+    if (_intLength < 0) {
+      arg.setProperties({
+        property_bag: {
+          [bindingName]: 0
+        }
+      });
+      arg.addBindings({
+        source_property_name: "(".concat(bindingName, " + (").concat(bindingName, " < ").concat(float, ") - (").concat(bindingName, " > ").concat(float, "))"),
+        target_property_name: bindingName
+      });
+    } else {
+      let calcBindingName = import_Random.Random.bindingName();
+      arg.addBindings({
+        source_property_name: ["abs(".concat(float, ")")],
+        target_property_name: calcBindingName = import_Random.Random.bindingName()
+      });
+      for (let i = _intLength - 1; i >= 0; i--) {
+        arg.addBindings({
+          source_property_name: "(".concat(Math.pow(10, i), " * (").concat(Array.from(
+            {
+              length: 10
+            },
+            (v, c) => "(".concat(calcBindingName, " > ").concat((c + 1) * Math.pow(10, i) - 1, ")")
+          ).join(" + "), "))"),
+          target_property_name: bindingName = import_Random.Random.bindingName()
+        });
+        sumBnd.push(bindingName);
+        if (i !== 0)
+          arg.addBindings({
+            source_property_name: "(".concat(calcBindingName, " - ").concat(bindingName, ")"),
+            target_property_name: calcBindingName = import_Random.Random.bindingName()
+          });
+      }
+      arg.addBindings([
+        {
+          source_property_name: "(".concat(sumBnd.join(" + "), ")"),
+          target_property_name: bindingName = import_Random.Random.bindingName()
+        },
+        {
+          source_property_name: "(".concat(bindingName, " * (1 - (").concat(float, " < 0) * 2))"),
+          target_property_name: bindingName = import_Random.Random.bindingName()
+        }
+      ]);
+    }
+    return bindingName;
+  },
+  slice: (arg, [str, start, end]) => {
+    const bindingName = import_Random.Random.bindingName();
+    if (!(import_BindingCompiler.BindingCompiler.isString(str) || import_BindingCompiler.BindingCompiler.isHasBinding(str))) str = "'".concat(str, "'");
+    if (end) {
+      arg.addBindings({
+        source_property_name: [" '%.{".concat(end, " - ").concat(start, "}s' * slice(").concat(str, ", ").concat(start, ") ")],
+        target_property_name: bindingName
+      });
+    } else {
+      arg.addBindings({
+        source_property_name: [
+          Number.isNaN(+start) ? " '__START__{ ".concat(str, " }' - '__START__{ '%.{ ").concat(start, " }s' * ").concat(str, " }' ") : " '__START__{ ".concat(str, " }' - '__START__{ '%.").concat(start, "s' * ").concat(str, " }' ")
+        ],
+        target_property_name: bindingName
+      });
+    }
+    return bindingName;
+  },
+  pow: (arg, [num1, num2]) => {
+    const bindingName = import_Random.Random.bindingName();
+    if (import_BindingCompiler.BindingCompiler.isNumber(num2)) {
+      const $2 = +num2;
+      if (import_BindingCompiler.BindingCompiler.isNumber(num1)) return Math.pow(+num1, $2);
+      else {
+        if ($2 === 0) return 1;
+        else if ($2 > 0) return Array.from({ length: $2 }, () => num1).join(" * ");
+        else return "1 / ".concat(Array.from({ length: $2 * -1 }, () => num1).join(" / "));
+      }
+    } else {
+      for (let i = 1; i <= 32; i++) {
+        arg.addBindings({
+          source_property_name: "(".concat(num2, " / ((").concat(num1, " < ").concat(i, ") * ").concat(num2, "))"),
+          target_property_name: "".concat(bindingName).concat(i)
+        });
+        arg.addBindings({
+          source_property_name: "(".concat(num2, " / ((").concat(num1, " > ").concat(i * -1, ") * ").concat(num2, "))"),
+          target_property_name: "".concat(bindingName, "_").concat(i)
+        });
+      }
+      arg.addBindings({
+        source_property_name: "( ".concat(Array.from(
+          { length: 32 },
+          (v, i) => "".concat(bindingName).concat(i + 1)
+        ).join(" * "), " / ").concat(Array.from(
+          { length: 32 },
+          (v, i) => "".concat(bindingName, "_").concat(i + 1)
+        ).join(" / "), ")"),
+        target_property_name: bindingName
+      });
+    }
+    return bindingName;
+  },
+  sqrt: (arg, [num]) => {
+    const bindingName = import_Random.Random.bindingName();
+    if (import_BindingCompiler.BindingCompiler.isNumber(num)) {
+      return "".concat(Math.sqrt(+num));
+    } else {
+      const binding2 = import_Random.Random.bindingName();
+      const x = 100;
+      arg.addBindings([
+        {
+          source_property_name: "(".concat(num, " * ").concat(x, " / 2)"),
+          target_property_name: bindingName
+        },
+        {
+          source_property_name: "[ abs((".concat(bindingName, " * ").concat(bindingName, ") - ").concat(num, ") > 1 ]"),
+          target_property_name: binding2
+        },
+        {
+          source_property_name: "( (".concat(num, " < 0) * -1 + (").concat(num, " > -1) * (").concat(binding2, " * ((").concat(bindingName, " + ").concat(num, " / ").concat(bindingName, ") / 2) + (not ").concat(binding2, ") * ").concat(bindingName, ") )"),
+          target_property_name: bindingName
+        }
+      ]);
+    }
+    return bindingName;
+  }
+};
+class BindingFunctions extends import_Class.Class {
+  static register(name, callback, override) {
+    const n = name;
+    if (override || !funcObj[n]) {
+      funcObj[n] = callback;
+    } else
+      import_Log.Log.error(
+        "".concat((0, import_CurrentLine.CurrentLine)(), " '").concat(n, "' function already exists, do you want to override it?")
+      );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BindingFunctions,
+  funcObj
+});

package/dist/cjs/compilers/Compiler.js

@@ -0,0 +1,158 @@
+"use strict";
+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 __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);
+var Compiler_exports = {};
+__export(Compiler_exports, {
+  installer: () => installer
+});
+module.exports = __toCommonJS(Compiler_exports);
+var import_fs = __toESM(require("fs"));
+var import_Manifest = require("./generator/Manifest");
+var import_UIBuilder = require("./generator/UIBuilder");
+var import_Config = require("./Config");
+var import_Compress = require("./Compress");
+var import_Sounds = require("./generator/Sounds");
+var import_Audio = require("./reader/Audio");
+var import_Log = require("./generator/Log");
+var import_Encoder = require("./Encoder");
+var import_PreCompile = require("./PreCompile");
+var import_LocalizeText = require("../components/LocalizeText");
+var import_LangBuilder = require("./generator/LangBuilder");
+var import_Installer = require("../types/objects/Installer");
+var import_Installer2 = require("./Installer");
+const config = import_Config.Configs.getConfig();
+const installer = new import_Installer2.ResourcePacks({
+  installGame: config.installer.previewVersion ? import_Installer.Minecraft.Preview : import_Installer.Minecraft.Stable,
+  installFolder: config.installer.developEvironment ? import_Installer.ResourcePack.Development : import_Installer.ResourcePack.Production
+});
+function manifestBuild(installPath) {
+  const { name, description, uuid, version, baseGameVersion } = config.manifest;
+  const manifest = new import_Manifest.Manifest({ name, description, uuid, version });
+  manifest.manifest.header.min_engine_version = baseGameVersion;
+  (0, import_PreCompile.UIWriteJson)("".concat(installPath, "/manifest.json"), manifest.manifest, "utf-8");
+}
+let isRunned = false;
+process.on("beforeExit", () => {
+  if (isRunned) return;
+  isRunned = true;
+  const installPath = installer.getInstallPath();
+  config.installer.autoInstall = config.installer.autoInstall && import_fs.default.existsSync(installer.installPath);
+  const buildPath = config.installer.autoInstall ? installPath : ".build";
+  import_UIBuilder.UIBuilder.delete(buildPath);
+  if (import_fs.default.existsSync(".build")) import_fs.default.rmSync(".build", { recursive: true });
+  if (import_fs.default.existsSync(".minecraft")) import_fs.default.unlinkSync(".minecraft");
+  if (!import_fs.default.existsSync(".bedrock")) import_fs.default.mkdirSync(".bedrock");
+  if (!import_fs.default.existsSync("".concat(buildPath))) import_fs.default.mkdirSync("".concat(buildPath));
+  if (!import_fs.default.existsSync("".concat(buildPath, "/@"))) import_fs.default.mkdirSync("".concat(buildPath, "/@"));
+  try {
+    console.log("---------- COMPILING ----------");
+    (0, import_Audio.FormatAudio)();
+    if (config.installer.autoInstall) {
+      installer.packLink();
+      console.timeLog("COMPILER", "Symlink completed!");
+      console.log();
+    }
+    import_fs.default.cpSync(".bedrock", buildPath, { recursive: true });
+    console.timeLog("COMPILER", "Copy bedrock resources completed!");
+    console.log();
+    console.timeLog("COMPILER", "".concat(import_UIBuilder.UIBuilder.jsonUI(buildPath), " custom file(s) compiled!"));
+    console.log();
+    console.timeLog("COMPILER", "".concat(import_UIBuilder.UIBuilder.modify(buildPath), " modify file(s) compiled!"));
+    console.log();
+    if (Object.keys(import_LocalizeText.localizeText).length) {
+      console.timeLog("COMPILER", "".concat(import_LangBuilder.LangBuilder.build(buildPath), " lang file(s) compiled!"));
+      console.log();
+    }
+    manifestBuild(buildPath);
+    console.timeLog("COMPILER", "Manifest file has been compiled!");
+    console.timeLog(
+      "COMPILER",
+      "ui/_ui_defs.json ".concat(import_UIBuilder.UIBuilder.uiDefs(buildPath), " files path(s) found!")
+    );
+    console.timeLog(
+      "COMPILER",
+      "ui/_global_variables.json ".concat(import_UIBuilder.UIBuilder.globalVariables(
+        buildPath
+      ), " variable(s) compiled!")
+    );
+    console.timeLog(
+      "COMPILER",
+      "textures/textures_list.json ".concat(import_UIBuilder.UIBuilder.texturesList(buildPath), " files path(s) found!")
+    );
+    const soundLength = import_Sounds.SoundHandler.compile(buildPath);
+    if (soundLength)
+      console.timeLog(
+        "COMPILER",
+        "sounds/sound_definitions.json ".concat(soundLength, " sound id has regisrer!")
+      );
+    console.timeLog(
+      "COMPILER",
+      "contents.json ".concat(import_UIBuilder.UIBuilder.contents(buildPath), " file path(s) found!")
+    );
+    if (config.installer.autoInstall) {
+      installer.installPack(config.manifest.uuid, config.manifest.version);
+      console.timeLog("COMPILER", "Resource Pack has been installed!");
+    }
+    if (config.compiler.autoCompress) {
+      (0, import_Compress.CompressPack)(buildPath);
+      console.timeLog("COMPILER", "Minecraft-UIBuild.mcpack Pack compress completed!");
+    }
+    if (config.compiler.encodeJson) {
+      import_Encoder.Encoder.start();
+      console.timeLog("COMPILER", "Encoded ".concat(import_Encoder.Encoder.count, " JSON file(s) successfully!"));
+    }
+    console.log();
+    console.timeLog("COMPILER", "Compile completed!");
+    if (import_Log.Logs.length) {
+      console.log("\n---------- Build Log ----------");
+      for (const log of import_Log.Logs) {
+        if (log.type === "warning") console.warn(log.message);
+        else if (log.type === "error") console.error(log.message);
+      }
+    }
+    console.log("\n---------- INFO ----------");
+    console.log("Name: \x1B[96m".concat(config.manifest.name, "\x1B[0m"));
+    console.log("Description: \x1B[96m".concat(config.manifest.description, "\x1B[0m"));
+    console.log("UUID: \x1B[96m".concat(config.manifest.uuid, "\x1B[0m"));
+    console.log(
+      "Pack Version: \x1B[96m".concat(config.manifest.version[0], ".").concat(config.manifest.version[1], ".").concat(config.manifest.version[2], "\x1B[0m")
+    );
+    console.log(
+      "Base Game Version: \x1B[96m".concat(config.manifest.baseGameVersion[0], ".").concat(config.manifest.baseGameVersion[1], ".").concat(config.manifest.baseGameVersion[2], "\x1B[0m")
+    );
+    if (config.installer.autoInstall)
+      console.log("Install Path: \x1B[96m".concat(installPath, "\x1B[0m"));
+  } catch (error) {
+    console.timeLog("COMPILER", "An error occurred while compiling!");
+    console.error(error);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installer
+});

package/dist/cjs/compilers/Compress.js

@@ -0,0 +1,55 @@
+"use strict";
+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 __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);
+var Compress_exports = {};
+__export(Compress_exports, {
+  CompressPack: () => CompressPack
+});
+module.exports = __toCommonJS(Compress_exports);
+var import_fs = __toESM(require("fs"));
+var import_adm_zip = __toESM(require("adm-zip"));
+var import_SearchFiles = require("./generator/SearchFiles");
+function CompressPack(buildPath) {
+  if (import_fs.default.existsSync("Minecraft-UIBuild.mcpack"))
+    import_fs.default.rmSync("Minecraft-UIBuild.mcpack");
+  const zip = new import_adm_zip.default(void 0, {
+    fs: import_fs.default
+  });
+  import_SearchFiles.SearchFiles.forEach(buildPath, (path) => {
+    const pathSplit = path.path.split("/");
+    zip.addLocalFile(
+      "".concat(buildPath, "/").concat(path.path),
+      pathSplit.length !== 1 ? pathSplit.slice(0, pathSplit.length - 1).join("/") : void 0
+    );
+  });
+  zip.writeZip("Minecraft-UIBuild.mcpack");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompressPack
+});

package/dist/cjs/compilers/Config.js

@@ -0,0 +1,138 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var Config_exports = {};
+__export(Config_exports, {
+  Configs: () => Configs,
+  config: () => config,
+  readObject: () => readObject
+});
+module.exports = __toCommonJS(Config_exports);
+var import_Save = require("./generator/Save");
+var import_Object = require("./reader/Object");
+var import_Template = require("./generator/Template");
+(0, import_Template.firstRun)();
+const defaultConfig = {
+  compiler: {
+    encodeJson: false,
+    autoCompress: false,
+    fileExtension: "json",
+    UI: {
+      nameLength: 32,
+      namespaceAmount: 16,
+      namespaceLength: 32,
+      obfuscateName: false,
+      obfuscateType: false
+    }
+  },
+  installer: {
+    autoInstall: true,
+    developEvironment: true,
+    previewVersion: false,
+    customPath: false,
+    installPath: void 0
+  },
+  manifest: {
+    name: "JsonUI Scripting",
+    description: "Build with JsonUI Scripting <3",
+    uuid: import_Save.Save.uuid()[0],
+    version: [1, 0, 0],
+    baseGameVersion: [1, 21, 80]
+  }
+};
+function readObject(obj, defaultObjValue) {
+  if (Array.isArray(defaultObjValue)) {
+    if (!obj) obj = [];
+    defaultObjValue.forEach((value, index) => {
+      var _a;
+      obj[index] = (_a = obj[index]) != null ? _a : value;
+    });
+    return obj;
+  } else {
+    if (!obj) obj = {};
+    import_Object.Obj.forEach(defaultObjValue || {}, (key, value) => {
+      var _a;
+      if (typeof value === "object") {
+        obj[key] = readObject(obj[key], defaultObjValue[key]);
+      } else {
+        obj[key] = (_a = obj[key]) != null ? _a : defaultObjValue[key];
+      }
+    });
+    return obj;
+  }
+}
+const _Configs = class _Configs {
+  /**
+   * Loads the configuration file and parses it into the `save` property.
+   */
+  constructor() {
+    /**
+     * The current loaded configuration saved to disk.
+     */
+    __publicField(this, "save");
+    this.save = require("".concat(process.cwd(), "/asakiyuki.config.cjs")).config;
+  }
+  /**
+   * Retrieves the current configuration, either from the saved configuration or the default values.
+   *
+   * @returns {Config} - The configuration object.
+   */
+  static getConfig() {
+    if (_Configs.config === void 0) {
+      const defaultConfig2 = _Configs.getDefaultConfig();
+      const saveConfig = new _Configs().save;
+      return readObject(saveConfig, defaultConfig2);
+    } else return _Configs.config;
+  }
+  /**
+   * Retrieves the default configuration values.
+   *
+   * @returns {Config} - The default configuration object.
+   */
+  static getDefaultConfig() {
+    return defaultConfig;
+  }
+  // Static helper methods not directly related to config loading/handling.
+  static apply() {
+  }
+  static bind() {
+  }
+  static call() {
+  }
+  static toString() {
+  }
+};
+/**
+ * The statically cached configuration.
+ */
+__publicField(_Configs, "config");
+__publicField(_Configs, "arguments", "");
+__publicField(_Configs, "caller", "");
+__publicField(_Configs, "length", "");
+__publicField(_Configs, "name", "");
+let Configs = _Configs;
+const config = Configs;
+Configs.getConfig();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Configs,
+  config,
+  readObject
+});