asajs 3.0.2 → 3.0.4

package/dist/cjs/compilers/Encoder.js

@@ -0,0 +1,90 @@
+"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 Encoder_exports = {};
+__export(Encoder_exports, {
+  Encoder: () => Encoder
+});
+module.exports = __toCommonJS(Encoder_exports);
+var import_fs = __toESM(require("fs"));
+var import_Class = require("../components/Class");
+var import_PreCompile = require("./PreCompile");
+var import_Object = require("./reader/Object");
+const _Encoder = class _Encoder extends import_Class.Class {
+  static start() {
+    for (const path of import_PreCompile.jsonFilePath) {
+      const code = _Encoder.readCode(path);
+      const encode = _Encoder.encode(code);
+      _Encoder.replaceCode(path, encode);
+      _Encoder.count++;
+    }
+  }
+  static replaceCode(path, code) {
+    import_fs.default.writeFileSync(path, (0, import_PreCompile.WritePreComment)(code).replaceAll("\\\\", "\\"), "utf-8");
+  }
+  static encode(code) {
+    return Array.isArray(code) ? _Encoder.encodeArray(code) : _Encoder.encodeObject(code);
+  }
+  static encodeArray(code) {
+    return code.map((value) => {
+      const valueType = typeof value;
+      if (valueType === "object") {
+        return _Encoder.encode(value);
+      } else if (valueType === "string") return _Encoder.encodeString(value);
+      else return value;
+    });
+  }
+  static encodeObject(code) {
+    return import_Object.Obj.map(code, (key, value) => {
+      const valueType = typeof value;
+      key = _Encoder.encodeString(key);
+      if (valueType === "object") {
+        return {
+          key,
+          value: _Encoder.encode(value)
+        };
+      } else if (valueType === "string") {
+        return { key, value: _Encoder.encodeString(value) };
+      } else return { key, value };
+    });
+  }
+  static encodeString(code) {
+    return Array.from(code).map((char) => "\\u".concat(char.charCodeAt(0).toString(16).padStart(4, "0"))).join("");
+  }
+  static readCode(path) {
+    return JSON.parse(import_fs.default.readFileSync(path, "utf-8"));
+  }
+};
+__publicField(_Encoder, "count", 0);
+let Encoder = _Encoder;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Encoder
+});

package/dist/cjs/compilers/Installer.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 __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 Installer_exports = {};
+__export(Installer_exports, {
+  ResourcePacks: () => ResourcePacks
+});
+module.exports = __toCommonJS(Installer_exports);
+var import_fs = __toESM(require("fs"));
+var import_Save = require("./generator/Save");
+var import_UIBuilder = require("./generator/UIBuilder");
+var import_Config = require("./Config");
+class ResourcePacks {
+  constructor(data) {
+    __publicField(this, "gamePath");
+    __publicField(this, "gameDataPath");
+    __publicField(this, "installPath");
+    __publicField(this, "globalResoucePacksPath");
+    const config = import_Config.Configs.getConfig();
+    if (config.installer.installPath && config.installer.customPath) {
+      this.gamePath = config.installer.installPath;
+    } else {
+      switch (process.platform) {
+        case "win32":
+          this.gamePath = "".concat(process.env.LOCALAPPDATA, "/Packages/").concat(data.installGame, "/LocalState");
+          break;
+        case "linux":
+          this.gamePath = "".concat(process.env.HOME, "/.local/share/mcpelauncher");
+          if (!import_fs.default.existsSync(this.gamePath))
+            this.gamePath = "".concat(process.env.HOME, "/.var/app/io.mrarm.mcpelauncher/data/mcpelauncher");
+          break;
+        default:
+          this.gamePath = "";
+      }
+    }
+    this.gameDataPath = "".concat(this.gamePath, "/games/com.mojang");
+    this.installPath = "".concat(this.gameDataPath, "/").concat(data.installFolder);
+    this.globalResoucePacksPath = "".concat(this.gameDataPath, "/minecraftpe/global_resource_packs.json");
+  }
+  isPackInstalled(uuid, version) {
+    const globalResourcePacks = import_fs.default.existsSync(
+      this.globalResoucePacksPath
+    ) ? JSON.parse(import_fs.default.readFileSync(this.globalResoucePacksPath, "utf-8")) : [];
+    const versionIsArray = Array.isArray(version);
+    if (versionIsArray) version = JSON.stringify(version);
+    for (const packData of globalResourcePacks) {
+      if (packData.pack_id === uuid && (versionIsArray ? JSON.stringify(packData.version) : packData.version) === version)
+        return true;
+    }
+    return false;
+  }
+  installPack(uuid, version) {
+    if (this.isPackInstalled(uuid, version)) return;
+    const globalResourcePacks = import_fs.default.existsSync(
+      this.globalResoucePacksPath
+    ) ? JSON.parse(import_fs.default.readFileSync(this.globalResoucePacksPath, "utf-8")) : [];
+    import_fs.default.writeFileSync(
+      this.globalResoucePacksPath,
+      JSON.stringify([
+        {
+          pack_id: uuid,
+          version
+        },
+        ...globalResourcePacks
+      ]),
+      "utf-8"
+    );
+  }
+  uninstallPack(uuid, version) {
+    const globalResourcePacks = import_fs.default.existsSync(
+      this.globalResoucePacksPath
+    ) ? JSON.parse(import_fs.default.readFileSync(this.globalResoucePacksPath, "utf-8")) : [];
+    const versionIsArray = Array.isArray(version);
+    if (versionIsArray) version = JSON.stringify(version);
+    let i = -1;
+    for (const packData of globalResourcePacks) {
+      i++;
+      if (packData.pack_id === uuid && (versionIsArray ? JSON.stringify(packData.version) : packData.version) === version) {
+        globalResourcePacks.splice(i, 1);
+        break;
+      }
+    }
+    import_fs.default.writeFileSync(this.globalResoucePacksPath, JSON.stringify(globalResourcePacks));
+  }
+  getInstallPath() {
+    return "".concat(this.installPath, "/").concat(import_Save.Save.getBuildID());
+  }
+  packLink() {
+    import_UIBuilder.UIBuilder.delete(".minecraft");
+    import_fs.default.symlinkSync(this.getInstallPath(), ".minecraft", "junction");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourcePacks
+});

package/dist/cjs/compilers/PreCompile.js

@@ -0,0 +1,86 @@
+"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 PreCompile_exports = {};
+__export(PreCompile_exports, {
+  UIWriteJson: () => UIWriteJson,
+  WritePreComment: () => WritePreComment,
+  jsonFilePath: () => jsonFilePath
+});
+module.exports = __toCommonJS(PreCompile_exports);
+var import_fs = __toESM(require("fs"));
+var import_Config = require("./Config");
+if (!import_fs.default.existsSync("comment.txt")) {
+  import_fs.default.writeFileSync("comment.txt", "", "utf-8");
+}
+const timeMap = {};
+console.time = function(label) {
+  timeMap[label] = performance.now();
+};
+console.timeLog = function(tag, ...data) {
+  const now = performance.now();
+  const time = now - timeMap[tag];
+  console.log(
+    "\x1B[90m[".concat(time.toFixed(2), "ms]"),
+    "\x1B[32m[".concat(tag, "]\x1B[0m"),
+    ">>",
+    ...data,
+    "\x1B[0m"
+  );
+};
+console.timeEnd = function(label) {
+  delete timeMap[label];
+};
+function WritePreComment(data) {
+  const comment = "This file is generated by the JSONUI SCRIPTING compiler. Do not edit it directly.";
+  if (import_fs.default.readFileSync("comment.txt", "utf-8").trim() !== "") {
+    const info = import_fs.default.readFileSync("comment.txt", "utf-8").replaceAll("\n", "\n * ");
+    return "/*\n * ".concat(comment, "\n * ----------------------------------------------------------------------\n * ").concat(info, "\n */\n").concat(JSON.stringify(
+      data
+    ));
+  } else {
+    return "// ".concat(comment, "\n").concat(JSON.stringify(data));
+  }
+}
+const jsonFilePath = [];
+function UIWriteJson(file, data, options) {
+  const writeData = JSON.stringify(data);
+  if (writeData == "{}") return;
+  if (import_Config.Configs.getConfig().compiler.encodeJson) {
+    import_fs.default.writeFileSync(file, writeData, options);
+  } else {
+    import_fs.default.writeFileSync(file, WritePreComment(data), options);
+  }
+  jsonFilePath.push(file);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UIWriteJson,
+  WritePreComment,
+  jsonFilePath
+});

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

@@ -0,0 +1,51 @@
+"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 GenerateDir_exports = {};
+__export(GenerateDir_exports, {
+  GenerateDir: () => GenerateDir
+});
+module.exports = __toCommonJS(GenerateDir_exports);
+var import_fs = __toESM(require("fs"));
+function GenerateDir(installPath, path) {
+  path = path ? "".concat(installPath, "/").concat(path) : installPath;
+  if (!import_fs.default.existsSync(path)) {
+    let lastPath = "";
+    const folderPath = path.split("/") || [];
+    folderPath.pop();
+    for (const folder of folderPath) {
+      if (!(folder === "" || import_fs.default.existsSync("".concat(lastPath).concat(folder))))
+        import_fs.default.mkdirSync("".concat(lastPath).concat(folder));
+      lastPath = "".concat(lastPath).concat(folder, "/");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenerateDir
+});

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

@@ -0,0 +1,66 @@
+"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 JsonBuilder_exports = {};
+__export(JsonBuilder_exports, {
+  JsonBuilder: () => JsonBuilder
+});
+module.exports = __toCommonJS(JsonBuilder_exports);
+var import_Class = require("../../components/Class");
+var import_Config = require("../Config");
+var import_CurrentLine = require("../reader/CurrentLine");
+var import_Log = require("./Log");
+class JsonBuilder extends import_Class.Class {
+  static registerGlobalVariable(key, value) {
+    this.save.globalVariables["$".concat(key)] = value;
+  }
+  static registerElement(namespace, element) {
+    var _a, _b;
+    const extension = import_Config.Configs.getConfig().compiler.fileExtension;
+    const buildFile = (_a = this.save.build)[_b = "".concat(namespace).concat(extension === "" ? "" : ".".concat(extension))] || (_a[_b] = { namespace });
+    for (const e in buildFile) {
+      if (e.split("@")[0] === element.getFullPath().split("@")[0]) {
+        import_Log.Log.error(
+          "".concat((0, import_CurrentLine.CurrentLine)(), " element has a duplicate name and namespace, which can be override.")
+        );
+        break;
+      }
+    }
+    buildFile[element.getFullPath()] = element;
+  }
+  static getModify(modifyFile, modifyElement) {
+    var _a;
+    return (_a = this.save.modify[modifyFile]) == null ? void 0 : _a[modifyElement];
+  }
+  static registerModify(modifyFile, modifyElement, modify) {
+    var _a, _b;
+    const modifyFileSave = (_b = (_a = this.save.modify)[modifyFile]) != null ? _b : _a[modifyFile] = {};
+    return modifyFileSave[modifyElement] = modify;
+  }
+}
+__publicField(JsonBuilder, "save", {
+  build: {},
+  globalVariables: {},
+  modify: {}
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonBuilder
+});

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

@@ -0,0 +1,65 @@
+"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 LangBuilder_exports = {};
+__export(LangBuilder_exports, {
+  LangBuilder: () => LangBuilder
+});
+module.exports = __toCommonJS(LangBuilder_exports);
+var import_fs = __toESM(require("fs"));
+var import_Class = require("../../components/Class");
+var import_LocalizeText = require("../../components/LocalizeText");
+class LangBuilder extends import_Class.Class {
+  static build(buildPath) {
+    import_fs.default.mkdirSync("".concat(buildPath, "/texts"), { recursive: true });
+    for (const langFile in import_LocalizeText.localizeText) {
+      const langContent = import_LocalizeText.localizeText[langFile];
+      let text = "## The entire text below is built entirely using JSONUI SCRIPTING!";
+      for (const key in langContent) {
+        text += "\n".concat(key, "=").concat(langContent[key]);
+      }
+      if (import_fs.default.existsSync(".bedrock/texts/".concat(langFile, ".lang"))) {
+        const content = import_fs.default.readFileSync(".bedrock/texts/".concat(langFile, ".lang"), "utf-8");
+        import_fs.default.writeFileSync(
+          "".concat(buildPath, "/texts/").concat(langFile, ".lang"),
+          "".concat(content, "\n\n").concat(text),
+          "utf-8"
+        );
+        console.timeLog("COMPILER", "".concat(langFile, ".lang has been updated!"));
+      } else {
+        import_fs.default.writeFileSync("".concat(buildPath, "/texts/").concat(langFile, ".lang"), text, "utf-8");
+        console.timeLog("COMPILER", "".concat(langFile, ".lang has been generated!"));
+      }
+    }
+    return Object.keys(import_LocalizeText.localizeText).length;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LangBuilder
+});

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

@@ -0,0 +1,45 @@
+"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 Log_exports = {};
+__export(Log_exports, {
+  Log: () => Log,
+  Logs: () => Logs
+});
+module.exports = __toCommonJS(Log_exports);
+var import_Class = require("../../components/Class");
+const Logs = [];
+class Log extends import_Class.Class {
+  static warning(message) {
+    Logs.push({
+      type: "warning",
+      message: "\x1B[93m[Warning]\x1B[0m >> ".concat(message)
+    });
+  }
+  static error(message) {
+    Logs.push({
+      type: "error",
+      message: "\x1B[31m[Error]\x1B[0m >> ".concat(message)
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Log,
+  Logs
+});

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

@@ -0,0 +1,63 @@
+"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 Manifest_exports = {};
+__export(Manifest_exports, {
+  Manifest: () => Manifest
+});
+module.exports = __toCommonJS(Manifest_exports);
+var import_Manifest = require("../../types/objects/Manifest");
+var import_Save = require("./Save");
+class Manifest {
+  constructor(header, type = import_Manifest.Type.Resources, metadata) {
+    __publicField(this, "manifest");
+    const uuid = import_Save.Save.uuid();
+    this.manifest = {
+      format_version: 2,
+      header: {
+        name: header.name,
+        uuid: header.uuid || uuid[0],
+        description: header.description,
+        version: header.version || [1, 0, 0]
+      },
+      modules: [
+        {
+          type,
+          uuid: uuid[1],
+          version: [1, 0, 0]
+        }
+      ],
+      metadata: metadata && {
+        authors: metadata.authors,
+        license: metadata.license,
+        url: metadata.url,
+        product_type: metadata.producType,
+        generated_with: metadata.generatedWith
+      }
+    };
+  }
+  buildJson() {
+    return JSON.stringify(this.manifest, null, 4);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Manifest
+});