asajs 3.0.2 → 3.0.4

package/dist/cjs/compilers/generator/Save.js

@@ -0,0 +1,87 @@
+"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 __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 __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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var Save_exports = {};
+__export(Save_exports, {
+  Save: () => Save
+});
+module.exports = __toCommonJS(Save_exports);
+var import_fs = __toESM(require("fs"));
+var import_Class = require("../../components/Class");
+var import_Random = require("../../components/Random");
+const _Save = class _Save extends import_Class.Class {
+  static write(file, data, options) {
+    import_fs.default.writeFileSync(file, JSON.stringify(data), options);
+  }
+  static read(path, options) {
+    return JSON.parse(import_fs.default.readFileSync(path, options));
+  }
+  static createFile(path, data, write = import_fs.default.writeFileSync, read = import_fs.default.readFileSync) {
+    if (!_Save.isSaveCreated && !import_fs.default.existsSync(".save")) import_fs.default.mkdirSync(".save");
+    _Save.isSaveCreated = true;
+    if (!import_fs.default.existsSync(".save/".concat(path))) {
+      const $ = data();
+      write(".save/".concat(path), $, "utf-8");
+      return $;
+    } else return read(".save/".concat(path), "utf-8");
+  }
+  static createJson(path, data) {
+    return _Save.createFile(path, data, this.write, this.read);
+  }
+  static updateFile(path, data, write = import_fs.default.writeFileSync, read = import_fs.default.readFileSync) {
+    if (!_Save.isSaveCreated && !import_fs.default.existsSync(".save")) import_fs.default.mkdirSync(".save");
+    const backup = read(".save/".concat(path), "utf-8");
+    write(".save/".concat(path), data());
+    return backup;
+  }
+  static updateJson(path, data) {
+    return _Save.updateFile(path, data, import_fs.default.read, import_fs.default.readFileSync);
+  }
+  static uuid() {
+    return _Save.createJson("uuid", () => ({
+      uuid: [import_Random.Random.getUUID(), import_Random.Random.getUUID()]
+    })).uuid;
+  }
+  static resource(mcVersion = "stable") {
+    return _Save.createJson("compile-".concat(mcVersion), () => ({
+      isDevelopment: true,
+      folderName: import_Random.Random.getName()
+    }));
+  }
+  static getBuildID() {
+    return _Save.createJson("buildID", () => [import_Random.Random.genString(16)])[0];
+  }
+};
+__publicField(_Save, "isSaveCreated", false);
+let Save = _Save;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Save
+});

package/dist/cjs/compilers/generator/SearchFiles.js

@@ -0,0 +1,70 @@
+"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 SearchFiles_exports = {};
+__export(SearchFiles_exports, {
+  SearchFiles: () => SearchFiles
+});
+module.exports = __toCommonJS(SearchFiles_exports);
+var import_Class = require("../../components/Class");
+var import_fs = __toESM(require("fs"));
+function searchForEachFileRecursion(path, callback, $1 = "", $2 = "", $3 = "") {
+  var _a;
+  if (import_fs.default.statSync(path).isDirectory())
+    for (const file of import_fs.default.readdirSync(path))
+      searchForEachFileRecursion(
+        "".concat(path, "/").concat(file),
+        callback,
+        file,
+        "".concat($2, "/").concat(file),
+        (_a = $2.match(/(?<=\/)\w+$/)) == null ? void 0 : _a[0]
+      );
+  else
+    callback({
+      file: $1,
+      folder: $3 === "" ? void 0 : $3,
+      path: $2.slice(1)
+    });
+}
+class SearchFiles extends import_Class.Class {
+  static array(folderPath, prefix) {
+    const paths = [];
+    SearchFiles.forEach(
+      folderPath,
+      (value) => paths.push("".concat(prefix ? "".concat(prefix, "/") : "").concat(value.path))
+    );
+    return paths;
+  }
+  static forEach(folderPath, callback) {
+    searchForEachFileRecursion(folderPath, callback);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SearchFiles
+});

package/dist/cjs/compilers/generator/Sounds.js

@@ -0,0 +1,91 @@
+"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 Sounds_exports = {};
+__export(Sounds_exports, {
+  SoundHandler: () => SoundHandler
+});
+module.exports = __toCommonJS(Sounds_exports);
+var import_fs = __toESM(require("fs"));
+var import_jsonc_parser = require("jsonc-parser");
+var import_Class = require("../../components/Class");
+var import_Random = require("../../components/Random");
+var import_PreCompile = require("../PreCompile");
+const sounds = {};
+class SoundHandler extends import_Class.Class {
+  static get(path) {
+    if (sounds[path]) {
+      return sounds[path];
+    } else {
+      return sounds[path] = "jsonui_scripting.".concat(import_Random.Random.getName());
+    }
+  }
+  static compile(installPath) {
+    const soundIds = Object.keys(sounds);
+    if (soundIds.length) {
+      if (!import_fs.default.existsSync("".concat(installPath, "/sounds"))) import_fs.default.mkdirSync("".concat(installPath, "/sounds"));
+      const soundDefinitions = {};
+      for (const soundPath of soundIds) {
+        const soundId = sounds[soundPath];
+        soundDefinitions[soundId] = {
+          category: "ui",
+          sounds: [
+            {
+              load_on_low_memory: true,
+              name: soundPath,
+              stream: true,
+              volume: 1
+            }
+          ]
+        };
+      }
+      let bak;
+      if (import_fs.default.existsSync(".bedrock/sounds/sound_definitions.json")) {
+        bak = (0, import_jsonc_parser.parse)(
+          import_fs.default.readFileSync(".bedrock/sounds/sound_definitions.json", "utf-8")
+        ).sound_definitions;
+      }
+      (0, import_PreCompile.UIWriteJson)(
+        "".concat(installPath, "/sounds/sound_definitions.json"),
+        {
+          format_version: "1.20.20",
+          sound_definitions: {
+            ...bak,
+            ...soundDefinitions
+          }
+        },
+        "utf-8"
+      );
+    }
+    return soundIds.length;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SoundHandler
+});

package/dist/cjs/compilers/generator/Template.js

@@ -0,0 +1,54 @@
+"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 Template_exports = {};
+__export(Template_exports, {
+  firstRun: () => firstRun
+});
+module.exports = __toCommonJS(Template_exports);
+var import_template = require("../../template");
+var import_GenerateDir = require("./GenerateDir");
+var import_fs = __toESM(require("fs"));
+function firstRun() {
+  const template = {
+    ".gitignore": import_template.gitignore,
+    "asakiyuki.config.cjs": import_template.config.replace("{packname}", "JsonUI Scripting").replace("{packdescription}", "Build with JsonUI Scripting <3").replace("{autoinstall}", "true").replace("{development}", "true").replace("{preview}", "false"),
+    "asakiyuki.global_variables.cjs": import_template.globalVariables,
+    "asakiyuki.env.cjs": import_template.env
+  };
+  for (const file in template) {
+    if (!import_fs.default.existsSync(file)) {
+      (0, import_GenerateDir.GenerateDir)(file);
+      import_fs.default.writeFileSync(file, template[file], "utf-8");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  firstRun
+});

package/dist/cjs/compilers/generator/UIBuilder.js

@@ -0,0 +1,123 @@
+"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 UIBuilder_exports = {};
+__export(UIBuilder_exports, {
+  UIBuilder: () => UIBuilder
+});
+module.exports = __toCommonJS(UIBuilder_exports);
+var import_fs = __toESM(require("fs"));
+var import_jsonc_parser = require("jsonc-parser");
+var import_JsonBuilder = require("./JsonBuilder");
+var import_SearchFiles = require("./SearchFiles");
+var import_GenerateDir = require("./GenerateDir");
+var import_PreCompile = require("../PreCompile");
+class UIBuilder {
+  static delete(installPath) {
+    try {
+      import_fs.default.unlinkSync(installPath);
+    } catch (error) {
+      if (import_fs.default.existsSync(installPath)) import_fs.default.rmSync(installPath, { recursive: true });
+    }
+  }
+  static jsonUI(installPath) {
+    const build = import_JsonBuilder.JsonBuilder.save.build;
+    let count = 0;
+    for (const file in build) {
+      const namespace = build[file].namespace;
+      delete build[file].namespace;
+      for (const jsonUI in build[file]) build[file][jsonUI] = build[file][jsonUI].getUI();
+      console.timeLog(
+        "COMPILER",
+        "".concat(file, " ").concat(Object.keys(build[file]).length, " elements has generated!")
+      );
+      build[file].namespace = namespace;
+      (0, import_PreCompile.UIWriteJson)("".concat(installPath, "/@/").concat(file), build[file], "utf-8");
+      delete build[file];
+      count++;
+    }
+    return count;
+  }
+  static modify(installPath) {
+    if (!import_fs.default.existsSync("".concat(installPath, "/ui"))) import_fs.default.mkdirSync("".concat(installPath, "/ui"));
+    let count = 0;
+    const modify = import_JsonBuilder.JsonBuilder.save.modify;
+    for (const key in modify) {
+      (0, import_GenerateDir.GenerateDir)(installPath, key);
+      for (const element in modify[key]) modify[key][element] = modify[key][element].getUI();
+      console.timeLog(
+        "COMPILER",
+        "".concat(key, " ").concat(Object.keys(modify[key]).length, " modify element(s) has generated!")
+      );
+      (0, import_PreCompile.UIWriteJson)("".concat(installPath, "/").concat(key), modify[key], "utf-8");
+      delete modify[key];
+      count++;
+    }
+    return count;
+  }
+  static uiDefs(installPath) {
+    const arr = import_SearchFiles.SearchFiles.array("".concat(installPath, "/@"), "@");
+    (0, import_PreCompile.UIWriteJson)("".concat(installPath, "/ui/_ui_defs.json"), { ui_defs: arr }, "utf-8");
+    return arr.length;
+  }
+  static contents(installPath) {
+    const arr = import_SearchFiles.SearchFiles.array(installPath);
+    (0, import_PreCompile.UIWriteJson)(
+      "".concat(installPath, "/contents.json"),
+      {
+        content: arr.map((v) => ({ path: v }))
+      },
+      "utf-8"
+    );
+    return arr.length;
+  }
+  static texturesList(installPath) {
+    const arr = import_SearchFiles.SearchFiles.array(installPath).filter((v) => /\.(png|jpg|jpeg)$/.test(v)).map((v) => v.replace(/\.(png|jpg|jpeg)$/, ""));
+    let textureList = [];
+    if (import_fs.default.existsSync(".bedrock/textures/textures_list.json")) {
+      const texturesList = import_fs.default.readFileSync(".bedrock/textures/textures_list.json", "utf-8");
+      textureList = (0, import_jsonc_parser.parse)(texturesList);
+    }
+    if (!import_fs.default.existsSync("".concat(installPath, "/textures"))) import_fs.default.mkdirSync("".concat(installPath, "/textures"));
+    (0, import_PreCompile.UIWriteJson)(
+      "".concat(installPath, "/textures/textures_list.json"),
+      [...arr, ...textureList],
+      "utf-8"
+    );
+    return arr.length;
+  }
+  static globalVariables(installPath) {
+    const globalVariables = import_JsonBuilder.JsonBuilder.save.globalVariables;
+    (0, import_PreCompile.UIWriteJson)("".concat(installPath, "/ui/_global_variables.json"), globalVariables, "utf-8");
+    return Object.keys(globalVariables).length;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UIBuilder
+});

package/dist/cjs/compilers/reader/Audio.js

@@ -0,0 +1,81 @@
+"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 Audio_exports = {};
+__export(Audio_exports, {
+  FormatAudio: () => FormatAudio
+});
+module.exports = __toCommonJS(Audio_exports);
+var import_fs = __toESM(require("fs"));
+var import_SearchFiles = require("../generator/SearchFiles");
+var import_child_process = require("child_process");
+var import_Log = require("../generator/Log");
+function FormatAudio() {
+  const reg = /\.(mp3|m4a|mp4|mov|opus|acc|flac)$/;
+  const files = import_SearchFiles.SearchFiles.array(".bedrock", ".bedrock").filter(
+    (path) => reg.test(path)
+  );
+  if (!files.length) return;
+  try {
+    (0, import_child_process.spawnSync)("ffmpeg", ["-version"], {
+      stdio: ["ignore", "ignore", "ignore"]
+    }).error;
+    console.timeLog(
+      "Compiler",
+      ">> Starting to convert all found audio files to WAV format"
+    );
+    for (const file of files) {
+      const out = file.replace(reg, ".wav");
+      (0, import_child_process.execSync)("ffmpeg -i ".concat(file, " ").concat(out), {
+        stdio: "ignore"
+      });
+      import_fs.default.rmSync(file);
+      console.timeLog(
+        "Compiler",
+        ">> Reformatting of ".concat(file.replace(
+          /^\.bedrock\//,
+          ""
+        ), " is complete.")
+      );
+    }
+    console.timeLog(
+      "Compiler",
+      ">> Successfully reformatted ".concat(files.length, " audio file(s).")
+    );
+    console.log();
+  } catch (error) {
+    import_Log.Log.warning(
+      "You need to install 'ffmpeg' to your system environment variables to automatic convert all audio files to a format minecraft can read."
+    );
+    console.log();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormatAudio
+});

package/dist/cjs/compilers/reader/Color.js

@@ -0,0 +1,65 @@
+"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 Color_exports = {};
+__export(Color_exports, {
+  ColorHandler: () => ColorHandler
+});
+module.exports = __toCommonJS(Color_exports);
+var import_Class = require("../../components/Class");
+class ColorHandler extends import_Class.Class {
+  static parse(data) {
+    if (data.startsWith("#")) data = data.slice(1);
+    try {
+      const color = parseInt(data, 16);
+      switch (data.length) {
+        case 3:
+          return [(color >> 8 & 15) / 15, (color >> 4 & 15) / 15, (color & 15) / 15];
+        case 6:
+          return [
+            (color >> 16 & 255) / 255,
+            (color >> 8 & 255) / 255,
+            (color & 255) / 255
+          ];
+        case 4:
+          return [
+            (color >> 16 & 15) / 15,
+            (color >> 8 & 15) / 15,
+            (color >> 4 & 15) / 15,
+            (color & 15) / 15
+          ];
+        case 8:
+          return [
+            (color >> 24 & 255) / 255,
+            (color >> 16 & 255) / 255,
+            (color >> 8 & 255) / 255,
+            (color & 255) / 255
+          ];
+        default:
+          return null;
+      }
+    } catch (error) {
+      console.error(error);
+      return null;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ColorHandler
+});

package/dist/cjs/compilers/reader/CurrentLine.js

@@ -0,0 +1,36 @@
+"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 CurrentLine_exports = {};
+__export(CurrentLine_exports, {
+  CurrentLine: () => CurrentLine
+});
+module.exports = __toCommonJS(CurrentLine_exports);
+const regex = {
+  win32: /[A-Z]:(.+):\d+:\d+/g,
+  linux: /\/(.+):\d+:\d+/g
+};
+function CurrentLine() {
+  var _a;
+  const lines = (_a = new Error("Code Line").stack) == null ? void 0 : _a.match(regex[process.platform]);
+  return lines ? lines[lines.length - 1] : "Unknown";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CurrentLine
+});

package/dist/cjs/compilers/reader/Env.js

@@ -0,0 +1,21 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 Env_exports = {};
+module.exports = __toCommonJS(Env_exports);
+var import_Object = require("./Object");
+import_Object.Obj.forEach(
+  require("".concat(process.cwd(), "/asakiyuki.env.cjs")).env,
+  (key, value) => process.env[key] = value
+);

package/dist/cjs/compilers/reader/GlobalVariables.js

@@ -0,0 +1,23 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 GlobalVariables_exports = {};
+module.exports = __toCommonJS(GlobalVariables_exports);
+var import_Object = require("./Object");
+var import_JsonBuilder = require("../generator/JsonBuilder");
+var import_ReadProperties = require("./ReadProperties");
+import_Object.Obj.forEach(
+  require("".concat(process.cwd(), "/asakiyuki.global_variables.cjs")).global_variables,
+  (key, value) => import_JsonBuilder.JsonBuilder.registerGlobalVariable(key, (0, import_ReadProperties.ReadValue)(value))
+);