@scaffscript/core 0.2.1 → 0.2.5

package/dist/index.cjs

@@ -0,0 +1,2511 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+
+// src/utils/array.ts
+function swapAndPop(arr, idx) {
+  const lastIdx = arr.length - 1;
+  const last = arr[lastIdx];
+  arr[lastIdx] = arr[idx];
+  arr[idx] = last;
+  return arr.pop();
+}
+// src/utils/path.ts
+var import_path = __toESM(require("path"));
+function resolvePath(p) {
+  return import_path.default.resolve(p);
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function relativePath(p, root) {
+  return import_path.default.relative(root, p);
+}
+function isAbsolute(p) {
+  return import_path.default.isAbsolute(p);
+}
+function commonPath(paths) {
+  const split = paths.map((p) => p.split(/[\\/]/));
+  return !split.length ? null : split[0].filter((_, i) => split.every((p) => p[i] === split[0][i])).join("/");
+}
+// src/utils/log.ts
+var log = {
+  debug: (msg) => console.log("\x1B[90m[DEBUG]\x1B[0m ", msg),
+  info: (msg) => console.log("\x1B[36m[INFO]\x1B[0m  ", msg),
+  warn: (msg) => console.log("\x1B[33m[WARN]\x1B[0m  ", msg),
+  error: (msg) => console.log("\x1B[31m[ERROR]\x1B[0m ", msg)
+};
+// src/utils/fs.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_fs = require("fs");
+async function clearOutDir() {
+  await import_promises.default.rm(".out", { recursive: true, force: true });
+}
+async function fileExists(path2) {
+  if (typeof Bun !== "undefined") {
+    return Bun.file(path2).exists();
+  }
+  try {
+    await import_promises.default.access(path2, import_fs.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function deleteDir(target, root) {
+  const resolvedTarget = resolvePath(target);
+  const resolvedRoot = resolvePath(root);
+  const rel = relativePath(resolvedTarget, resolvedRoot);
+  if (!rel || rel === ".") {
+    log.error(`Failed to delete directory \x1B[32m${resolvedTarget}\x1B[0m: Cannot delete root directory.`);
+    return;
+  } else if (resolvedTarget === resolvedRoot) {
+    log.error(`Failed to delete directory \x1B[32m${resolvedTarget}\x1B[0m: Cannot delete root directory.`);
+    return;
+  } else if (rel.startsWith("..") || isAbsolute(rel)) {
+    log.error(`Failed to delete directory \x1B[32m${resolvedTarget}\x1B[0m: Outside root \x1B[32m${resolvedRoot}\x1B[0m.`);
+    return;
+  }
+  await import_promises.default.rm(resolvedTarget, { recursive: true, force: true });
+}
+// src/cli/args.ts
+async function parseArgs(...args) {
+  console.log("");
+  console.log("===========================================================================");
+  console.log("ScaffScript - A superset language of GML with TypeScript-like module system");
+  console.log("===========================================================================");
+  if (!args.length) {
+    log.error("No command specified. Add \x1B[32m--help\x1B[0m argument for more information. Aborting...");
+    return null;
+  }
+  const cmd = args[0];
+  switch (cmd) {
+    case "gen":
+    case "generate":
+      const yypPath = args[1];
+      if (!yypPath) {
+        log.error("No project path specified. Please specify a valid project path. Aborting...");
+        return null;
+      } else if (!yypPath.endsWith(".yyp")) {
+        log.error(`Invalid project path: \x1B[33m${yypPath}\x1B[0m. Please specify a valid \x1B[32m.yyp\x1B[0m file. Aborting...`);
+        return null;
+      }
+      const optionList = [...args].slice(2);
+      const options = {
+        integrate: optionList.includes("-i") || optionList.includes("--integrate"),
+        noIntegration: optionList.includes("-!i") || optionList.includes("--no-integration")
+      };
+      if (options.integrate && options.noIntegration) {
+        log.error("Cannot specify both \x1B[33m--integrate\x1B[0m and \x1B[33m--no-integration\x1B[0m. Aborting...");
+        return null;
+      }
+      const exists = await fileExists(normalizePath(resolvePath(yypPath)));
+      if (!exists) {
+        log.error(`Project path \x1B[33m${yypPath}\x1B[0m not found. Aborting...`);
+        return null;
+      }
+      return {
+        cmd: "generate",
+        options,
+        projectPath: normalizePath(resolvePath(yypPath))
+      };
+    case "help":
+    case "-h":
+    case "--help":
+      console.log(`\x1B[33mscaff \x1B[32m<command> \x1B[34m[args]\x1B[0m`);
+      console.log(`\x1B[32m<command>\x1B[0m:  The command to execute.`);
+      console.log(`\x1B[34m[args]\x1B[0m:     Optional arguments.`);
+      console.log("");
+      console.log("Commands:");
+      console.log("  generate <source_path> <project_path>      Generate source code from the given path to the given project");
+      console.log("    aliases: gen");
+      console.log("    example: generate ./src ./my-game.yyp");
+      console.log("  help                                       Show this help message");
+      console.log("    aliases: -h, --help");
+      console.log("");
+      return {
+        cmd: "help"
+      };
+    default:
+      log.error(`Invalid command: \x1B[33m${cmd}\x1B[0m. Aborting...`);
+      return null;
+  }
+}
+// src/fs/scan.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+
+// src/runtime/detect.ts
+var runtime = typeof Bun !== "undefined" ? "bun" : "node";
+
+// src/runtime/bun.ts
+var BunRuntime = {
+  async readText(path3) {
+    return Bun.file(path3).text();
+  },
+  async writeText(path3, data) {
+    await Bun.write(path3, data);
+  },
+  async delete(path3) {
+    await Bun.file(path3).delete();
+  },
+  async prompt(message) {
+    const input = prompt(message);
+    return input?.trim() ?? "";
+  }
+};
+
+// src/runtime/node.ts
+var fs3;
+var readline;
+async function ensureModules() {
+  if (!fs3)
+    fs3 = await import("fs/promises");
+  if (!readline)
+    readline = await import("readline/promises");
+}
+var NodeRuntime = {
+  async readText(path3) {
+    await ensureModules();
+    return fs3.readFile(path3, "utf8");
+  },
+  async writeText(path3, data) {
+    await ensureModules();
+    const { dirname } = await import("node:path");
+    await fs3.mkdir(dirname(path3), { recursive: true });
+    await fs3.writeFile(path3, data, "utf8");
+  },
+  async delete(path3) {
+    await ensureModules();
+    await fs3.unlink(path3);
+  },
+  async prompt(message) {
+    await ensureModules();
+    const { stdin, stdout } = await import("process");
+    const rl = readline.createInterface({
+      input: stdin,
+      output: stdout
+    });
+    const answer = await rl.question(message + " ");
+    rl.close();
+    return answer.trim();
+  }
+};
+
+// src/runtime/adapter.ts
+var fsRuntime = runtime === "bun" ? BunRuntime : NodeRuntime;
+// src/fs/scan.ts
+var DEFAULT_PATH = resolvePath("src");
+var CONFIG_FILES = [
+  "scaff.config.ts",
+  "scaff.config.mjs",
+  "scaff.config.js",
+  "scaff.config.cjs",
+  "scaff.config.json"
+];
+function dirIsIgnored(dir) {
+  const slugs = normalizePath(dir).split("/");
+  return slugs.find((slug) => slug.startsWith("_")) ? true : false;
+}
+async function findConfig(filename) {
+  let dir = process.cwd();
+  while (true) {
+    const full = import_node_path.join(dir, filename);
+    if (await fileExists(full)) {
+      return full;
+    }
+    const parent = import_node_path.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+async function getScaffFiles(path3) {
+  log.debug(`Scanning for \x1B[34m*.ss\x1B[0m and \x1B[34m*.gml\x1B[0m files in \x1B[32m${path3}\x1B[0m...`);
+  const files = await import_promises2.readdir(path3, { withFileTypes: true, recursive: true });
+  const vFiles = files.filter((file) => file.isFile() && !file.name.startsWith("_") && !dirIsIgnored(file.parentPath) && (file.name.endsWith(".ss") || file.name.endsWith(".gml"))).map((file) => {
+    return {
+      name: file.name,
+      path: normalizePath(resolvePath(file.parentPath)),
+      isScaff: file.name.endsWith(".ss"),
+      isIndex: file.name === "index.ss",
+      toGenerate: false,
+      content: "",
+      childs: []
+    };
+  });
+  log.info(`Found \x1B[32m${vFiles.filter((file) => file.isScaff).length} \x1B[34m*.ss\x1B[0m file(s) and \x1B[32m${vFiles.filter((file) => !file.isScaff).length}\x1B[0m \x1B[34m*.gml\x1B[0m file(s).`);
+  return vFiles;
+}
+async function getScaffConfig() {
+  let confPath = null;
+  for (const name of CONFIG_FILES) {
+    confPath = await findConfig(name);
+    if (confPath)
+      break;
+  }
+  let conf = {};
+  if (confPath) {
+    const ext = confPath.split(".").pop();
+    if (ext === "cjs" || ext === "json") {
+      conf = require(confPath);
+    } else {
+      const mod = await import(import_node_url.pathToFileURL(confPath).href);
+      conf = mod.default ?? mod;
+    }
+  }
+  if (!confPath) {
+    const pkgPath = await findConfig("package.json");
+    if (pkgPath) {
+      try {
+        const raw = await fsRuntime.readText(pkgPath);
+        const pkg = JSON.parse(raw);
+        if (pkg.scaff) {
+          conf = pkg.scaff;
+        }
+      } catch {}
+    }
+  }
+  return {
+    acceptAllIntegrations: conf.acceptAllIntegrations ?? false,
+    clearOutputDir: conf.clearOutputDir ?? false,
+    counterStart: conf.counterStart ?? 1,
+    debugLevel: conf.debugLevel ?? 0,
+    integrationOption: conf.integrationOption ?? {},
+    noBackup: conf.noBackup ?? false,
+    noIntegration: conf.noIntegration ?? true,
+    onNotFound: conf.onNotFound ?? "error",
+    path: conf.path ?? {},
+    production: conf.production ?? false,
+    source: conf.source ?? "./src",
+    tabType: conf.tabType ?? "1t",
+    targetPlatform: conf.targetPlatform ?? "all",
+    useGmAssetPath: conf.useGmAssetPath ?? false
+  };
+}
+// src/parser/regex.ts
+var commentRegex = /(?<!\/)\/\/(?!\/)[^\n]*|\/\*(?!\*)[\s\S]*?\*\//g;
+var implRegex = /impl\s+(?<name>[\w+]+)\s+\{\s+(?<body>[.\s\S]+?)\}/g;
+var implHeaderRegex = /impl\s+(?<name>\w+)\s*\{/g;
+var fnParamsRegex = /\((?<params>[^)]*)\)/g;
+var arrowFnHeaderRegex = /\b(?:(?:const|let|var)\s+)?(?<name>\w+)\s*=\s*(?<params>\([^)]*\)|\w+)\s*=>/g;
+var modControlRegex = /(?<cmd>export|import|include)\s+(?<mod>\*|\{[^}]+\}|[A-Za-z0-9_]+)\s+(?<src>from)\s+(?<path>["'][^"']+["'])\s*;?/g;
+var contentModRegex = /@(?<cmd>content|valueof|typeof|nameof)\s+(?<mod>[A-Za-z0-9_]+)/g;
+var useModRegex = /@use\s+(?<mod>[A-Za-z0-9_]+)\s+(?<body>\{[.\s\S]+?\})/g;
+var contentModShortRegex = /@:(?<mod>[A-Za-z0-9_]+)\s*/g;
+var specialValueRegex = /@(?<cmd>now|today|version|file|line|counter)/g;
+var tabRegex = {
+  oneTab: /^(\t*)/gm,
+  twoSpaces: /^(\ {2})*/gm,
+  fourSpaces: /^(\ {4})*/gm
+};
+var intgRegex = /intg\s+(?<targets>\*|\{[^}]+\}|[A-Za-z0-9_]+)\s+to\s+(?<path>["'][^"']+["'])\s*;?/g;
+var intgBlockRegex = /#\[(?<name>[^\]]+)\](?<body>[\s\S]*?(?=\n?#\[[^\]]+\]|$))/g;
+function countSubstring(str, sub) {
+  const regex = new RegExp(sub, "g");
+  const matches = str.match(regex);
+  return matches ? matches.length : 0;
+}
+function getTabLevels(str, tabType) {
+  const regex = tabType === "1t" ? tabRegex.oneTab : tabType === "2s" ? tabRegex.twoSpaces : tabRegex.fourSpaces;
+  const match = [...str.matchAll(regex)].map((m) => m[0]);
+  return match.map((m) => countSubstring(m, tabType === "1t" ? "\t" : tabType === "2s" ? "  " : "    "));
+}
+// package.json
+var package_default = {
+  name: "@scaffscript/core",
+  version: "0.2.3",
+  repository: {
+    type: "git",
+    url: "https://github.com/undervolta/scaffscript"
+  },
+  main: "dist/index.cjs",
+  devDependencies: {
+    "@types/bun": "latest"
+  },
+  peerDependencies: {
+    typescript: "^5"
+  },
+  bin: {
+    scaff: "./dist/index.cjs"
+  },
+  description: "A minimal superset language of GML with TypeScript-like module system",
+  files: [
+    "dist"
+  ],
+  keywords: [
+    "gamemaker",
+    "gml",
+    "scaff",
+    "script",
+    "superset",
+    "module",
+    "cli"
+  ],
+  license: "MIT",
+  scripts: {
+    build: "bun run build:all",
+    "build:node": "bun build src/index-node.ts --outfile dist/index.cjs --target node --format cjs",
+    "build:bun": "bun build src/index-bun.ts --outfile build/index.mjs --target bun --format esm",
+    "build:all": "bun run build:node && bun run build:bun",
+    dev: "bun run src/index-node.ts",
+    prelink: "bun run build"
+  },
+  type: "module"
+};
+
+// src/parser/special-value.ts
+function parseSpecialValues(file, counter) {
+  let res = file.content;
+  const matchComment = [...res.matchAll(commentRegex)];
+  for (const match of matchComment) {
+    res = res.replace(match[0], "");
+  }
+  const matchSpecial = [...res.matchAll(specialValueRegex)];
+  for (const match of matchSpecial) {
+    const { cmd } = match.groups;
+    switch (cmd) {
+      case "now":
+        res = res.replace(match[0], new Date().toISOString());
+        break;
+      case "today":
+        res = res.replace(match[0], new Date().toISOString().split("T")[0]);
+        break;
+      case "version":
+        res = res.replace(match[0], package_default.version);
+        break;
+      case "file":
+        res = res.replace(match[0], file.name);
+        break;
+      case "line":
+        res = res.replace(match[0], String(countSubstring(res.slice(0, match.index), `
+`) + 1));
+        break;
+      case "counter":
+        res = res.replace(match[0], String(counter.count));
+        counter.count++;
+        break;
+    }
+  }
+  return {
+    content: res,
+    counter: counter.count
+  };
+}
+
+// src/fs/grouping.ts
+async function readAndSplitFiles(files, config) {
+  const res = {
+    generate: [],
+    scaff: [],
+    normal: []
+  };
+  const intgRegex2 = /intg (\{[A-Za-z0-9,*\s]+\}|[A-Za-z0-9,*]+) to/;
+  const implFiles = [];
+  const exports2 = [];
+  const indexes = [];
+  const counter = { count: config.counterStart };
+  for (const file of files) {
+    file.content = (await fsRuntime.readText(`${file.path}/${file.name}`)).replace(/\r\n/g, `
+`);
+    file.toGenerate = intgRegex2.test(file.content);
+    file.name = file.name.replace(".ss", "");
+    if (file.isScaff) {
+      const { content: parsedContent, counter: newCounter } = parseSpecialValues(file, counter);
+      file.content = parsedContent;
+      counter.count = newCounter;
+    }
+    if (file.isIndex) {
+      file.name = "";
+      indexes.push({ file, depth: file.path.split("/").filter(Boolean).length });
+      continue;
+    }
+    const matchExport = [...file.content.matchAll(modControlRegex)];
+    implRegex.lastIndex = 0;
+    if (matchExport.length)
+      exports2.push({ file, depth: file.path.split("/").filter(Boolean).length });
+    else if (implRegex.test(file.content)) {
+      implRegex.lastIndex = 0;
+      const implMatches = [...file.content.matchAll(implRegex)];
+      if (implMatches.length) {
+        for (const match of implMatches) {
+          const className = match.groups.name;
+          if (className && file.content.includes(`class ${className} {`)) {
+            file.childs.push(file);
+            res.scaff.push(file);
+          } else
+            implFiles.push(file);
+          break;
+        }
+      } else
+        implFiles.push(file);
+    } else if (file.isScaff && file.toGenerate)
+      res.generate.push(file);
+    else if (file.isScaff)
+      res.scaff.push(file);
+    else
+      res.normal.push(file);
+  }
+  exports2.sort((a, b) => b.depth - a.depth);
+  indexes.sort((a, b) => b.depth - a.depth);
+  for (const fileHandle of exports2) {
+    implRegex.lastIndex = 0;
+    if (implRegex.test(fileHandle.file.content))
+      implFiles.push(fileHandle.file);
+    else if (fileHandle.file.isScaff && fileHandle.file.toGenerate)
+      res.generate.push(fileHandle.file);
+    else
+      res.scaff.push(fileHandle.file);
+  }
+  for (const fileHandle of indexes) {
+    implRegex.lastIndex = 0;
+    if (implRegex.test(fileHandle.file.content))
+      implFiles.push(fileHandle.file);
+    else if (fileHandle.file.isScaff && fileHandle.file.toGenerate)
+      res.generate.push(fileHandle.file);
+    else
+      res.scaff.push(fileHandle.file);
+  }
+  for (const file of implFiles) {
+    const classMatch = file.content.match(implRegex);
+    if (!classMatch)
+      continue;
+    const className = classMatch[0].split(" ")[1];
+    let classFile = res.scaff.find((f) => f.content.includes(`class ${className} {`));
+    if (!classFile)
+      classFile = res.generate.find((f) => f.content.includes(`class ${className} {`));
+    if (classFile)
+      classFile.childs.push(file);
+    else {
+      if (config.onNotFound === "error") {
+        log.error(`Class \x1B[33m${className}\x1B[0m not found for file \x1B[34m${file.name}\x1B[0m. Aborting...`);
+        return null;
+      }
+      log.warn(`Class \x1B[33m${className}\x1B[0m not found for file \x1B[34m${file.name}\x1B[0m. Skipping this file...`);
+    }
+  }
+  return res;
+}
+// src/parser/import-module.ts
+function countTabsBeforeSubstring(str, sub, tabChar) {
+  const idx = str.indexOf(sub);
+  if (idx === -1)
+    return -1;
+  const lineStart = str.lastIndexOf(`
+`, idx - 1) + 1;
+  const segment = str.slice(lineStart, idx);
+  let count = 0;
+  for (const ch of segment) {
+    if (ch === tabChar)
+      count++;
+    else
+      break;
+  }
+  return count;
+}
+function resolveImportPath(filePath, importPath, config) {
+  if (!config.path)
+    return resolvePath(`${filePath}/${importPath}`);
+  const useWildcard = Object.keys(config.path).filter((k) => k.endsWith("*")).find((k) => importPath.startsWith(k.slice(0, -1)));
+  if (useWildcard) {
+    const pathAlias = config.path[useWildcard]?.replace("*", "");
+    const dynPath = importPath.replace(useWildcard.slice(0, -2), "");
+    if (!pathAlias) {
+      log.error(`Path \x1B[33m${importPath}\x1B[0m not found in path aliases. Aborting...`);
+      return "";
+    }
+    if (pathAlias.startsWith("~")) {
+      return resolvePath(`${config.source}/${pathAlias.replace("~/", "").replace("~", "")}${dynPath}`);
+    }
+    return resolvePath(`${filePath}/${pathAlias}${dynPath}`);
+  } else if (config.path[importPath]) {
+    const pathAlias = config.path[importPath];
+    if (pathAlias.startsWith("~")) {
+      return resolvePath(`${config.source}/${pathAlias.replace("~/", "").replace("~", "")}`);
+    }
+    return resolvePath(`${filePath}/${pathAlias}`);
+  }
+  return resolvePath(`${filePath}/${importPath}`);
+}
+async function getModuleUsage(module2, fileGroup, file, config) {
+  const matches = [...file.content.matchAll(modControlRegex)].filter((match) => match.groups.cmd !== "export");
+  const limit = 10;
+  const results = [];
+  let isInvalid = false;
+  for (let i = 0;i < matches.length; i += limit) {
+    const batch = matches.slice(i, i + limit);
+    const res = await Promise.all(batch.map(async (match) => {
+      const { cmd, mod, path: path3 } = match.groups;
+      const res2 = {
+        cmd: null,
+        files: null,
+        modList: null,
+        targetPath: null,
+        targetStr: ""
+      };
+      if (!(cmd && mod && path3)) {
+        log.error(`Invalid module control statement: \x1B[34m${cmd} ${mod} from ${path3}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m. Aborting...`);
+        isInvalid = true;
+        return null;
+      }
+      const fromPath = normalizePath(resolveImportPath(file.path, path3.slice(1, -1), config));
+      const modList = {};
+      const alias = {};
+      if (!module2[fromPath]) {
+        if (cmd === "include" && mod.startsWith("{") && (mod.includes('"') || mod.includes("'"))) {
+          const files = mod.slice(1, -1).split(",").map((m) => m.trim());
+          const filePaths = [];
+          for (const f of files) {
+            const filePath = normalizePath(resolvePath(`${file.path}/${f.slice(1, -1)}`));
+            const targetFile = fileGroup.normal.find((fl) => {
+              let targetFile2 = `${fl.path}/${fl.name}`;
+              let currFile = filePath;
+              if (!targetFile2.endsWith(".gml"))
+                targetFile2 += ".gml";
+              if (!currFile.endsWith(".gml"))
+                currFile += ".gml";
+              return targetFile2 === currFile;
+            });
+            if (targetFile)
+              filePaths.push(targetFile);
+            else if (await fileExists(filePath))
+              filePaths.push(filePath);
+            else {
+              if (config.onNotFound === "error") {
+                log.error(`File \x1B[33m${f.slice(1, -1)}\x1B[0m from \x1B[32m${file.path}\x1B[0m not found. Aborting...`);
+                isInvalid = true;
+                return null;
+              } else
+                log.warn(`File \x1B[33m${f.slice(1, -1)}\x1B[0m from \x1B[32m${file.path}\x1B[0m not found. Skipping this file...`);
+            }
+          }
+          return {
+            cmd,
+            files: filePaths,
+            modList,
+            targetPath: fromPath,
+            targetStr: match[0]
+          };
+        }
+        log.error(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Aborting...`);
+        isInvalid = true;
+        return null;
+      }
+      if (mod === "*" || mod.startsWith("{") && mod.endsWith("}")) {
+        const targetMods = mod === "*" ? null : mod.slice(1, -1).split(",").map((m) => {
+          const split = m.split(":");
+          const key = split[0].trim();
+          if (split.length === 1)
+            alias[key] = key;
+          else
+            alias[key] = split[1].trim();
+          if (!module2[fromPath]) {
+            if (config.onNotFound === "error") {
+              log.error(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Aborting...`);
+              isInvalid = true;
+            } else
+              log.warn(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Skipping this module...`);
+            return null;
+          }
+          if (!module2[fromPath][key]) {
+            if (config.onNotFound === "error") {
+              log.error(`Module \x1B[33m${key}\x1B[0m from \x1B[32m${fromPath}\x1B[0m not found. Aborting...`);
+              isInvalid = true;
+            } else
+              log.warn(`Module \x1B[33m${key}\x1B[0m from \x1B[32m${fromPath}\x1B[0m not found. Skipping this module...`);
+            return null;
+          }
+          return key;
+        }).filter(Boolean);
+        Object.entries(module2[fromPath]).forEach(([key, value]) => {
+          if (mod === "*")
+            modList[key] = { name: key, as: key, value, usingAlias: false };
+          else if (targetMods.includes(key)) {
+            const usingAlias = key in alias && alias[key] !== key;
+            modList[alias[key] ?? key] = {
+              name: key,
+              as: alias[key] ?? key,
+              value,
+              usingAlias
+            };
+            if (usingAlias) {
+              if (!module2[fromPath])
+                module2[fromPath] = {};
+              module2[fromPath][`@${alias[key]}`] = value;
+            }
+          }
+        });
+      } else {
+        if (!module2[fromPath][mod]) {
+          if (config.onNotFound === "error") {
+            log.error(`Module \x1B[33m${mod}\x1B[0m from \x1B[32m${fromPath}\x1B[0m not found. Aborting...`);
+            isInvalid = true;
+          } else
+            log.warn(`Module \x1B[33m${mod}\x1B[0m from \x1B[32m${fromPath}\x1B[0m not found. Skipping this module...`);
+          return res2;
+        }
+        modList[mod] = {
+          name: mod,
+          as: mod,
+          value: module2[fromPath][mod],
+          usingAlias: false
+        };
+      }
+      return {
+        cmd,
+        files: null,
+        modList,
+        targetPath: fromPath,
+        targetStr: match[0]
+      };
+    }));
+    if (isInvalid)
+      break;
+    results.push(...res);
+  }
+  return !isInvalid && results.every((r) => r) ? results : null;
+}
+async function implementModules(module2, fileGroup, file, config, mods) {
+  if (!mods)
+    mods = await getModuleUsage(module2, fileGroup, file, config);
+  if (!mods)
+    return null;
+  const toRemove = [...file.content.matchAll(modControlRegex)];
+  for (const rm of toRemove) {
+    if (rm.groups?.cmd !== "include")
+      file.content = file.content.replace(rm[0], "");
+  }
+  for (const mod of mods) {
+    if (!mod)
+      return null;
+    if (!mod.cmd)
+      return null;
+    switch (mod.cmd) {
+      case "include":
+        let toReplace = "";
+        if (!mod.files) {
+          if (!mod.modList)
+            return null;
+          const modEntries = Object.entries(mod.modList);
+          const modLen = modEntries.length;
+          const modIterator = modEntries.entries();
+          for (const [idx, [_, include]] of modIterator) {
+            if (idx > 0)
+              switch (include.value.type) {
+                case "object":
+                case "method":
+                case "array":
+                case "enum":
+                  toReplace += `
+`;
+                  break;
+              }
+            toReplace += include.value.parsedStr + `
+`;
+            if (idx === modLen - 1)
+              toReplace += `
+`;
+          }
+          file.content = file.content.replace(mod.targetStr, toReplace);
+        } else {
+          for (const fileOrPath of mod.files) {
+            if (typeof fileOrPath === "string") {
+              const content = await fsRuntime.readText(fileOrPath);
+              toReplace += content + `
+
+`;
+            } else
+              toReplace += fileOrPath.content + `
+
+`;
+          }
+          file.content = file.content.replace(mod.targetStr, toReplace);
+        }
+        break;
+      case "import":
+        const cmdMatches = [...file.content.matchAll(contentModRegex)];
+        const shortCmdMatches = [
+          ...file.content.matchAll(contentModShortRegex)
+        ];
+        const useMatches = [...file.content.matchAll(useModRegex)];
+        for (const match of cmdMatches) {
+          const { cmd: contentCmd, mod: contentMod } = match.groups;
+          if (!contentCmd || !contentMod) {
+            log.error(`Invalid content module statement: \x1B[34m${contentCmd} ${contentMod}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m. Aborting...`);
+            return null;
+          }
+          if (!(`@${contentMod}` in mod.modList) && !(contentMod in mod.modList))
+            continue;
+          if (config.debugLevel >= 1)
+            log.debug(`Content module statement found: \x1B[34m${contentCmd} ${contentMod}\x1B[0m in \x1B[33m${file.name === "" ? "index" : file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m.`);
+          let parsedStr = "";
+          switch (contentCmd) {
+            case "content":
+              const tabChar = config.tabType === "1t" ? "\t" : config.tabType === "2s" ? "  " : "    ";
+              const tabCnt = countTabsBeforeSubstring(file.content, match[0], tabChar);
+              parsedStr = module2[mod.targetPath][`@${contentMod}` in module2[mod.targetPath] ? `@${contentMod}` : contentMod].parsedStr;
+              if (tabCnt > 0) {
+                const tabLevels = getTabLevels(parsedStr, config.tabType).map((l) => l + tabCnt);
+                file.content = file.content.replace(match[0], parsedStr.split(`
+`).map((l, i) => tabLevels[i] ? insertTabs(tabLevels[i], config.tabType) + l : l).join(`
+`));
+              } else
+                file.content = file.content.replace(match[0], parsedStr);
+              break;
+            case "nameof":
+              parsedStr = module2[mod.targetPath][`@${contentMod}` in module2[mod.targetPath] ? `@${contentMod}` : contentMod].name;
+              file.content = file.content.replace(`@nameof ${contentMod}`, parsedStr);
+              break;
+            case "typeof":
+              parsedStr = module2[mod.targetPath][`@${contentMod}` in module2[mod.targetPath] ? `@${contentMod}` : contentMod].type;
+              file.content = file.content.replace(`@typeof ${contentMod}`, `"${parsedStr}"`);
+              break;
+            case "valueof":
+              parsedStr = module2[mod.targetPath][`@${contentMod}` in module2[mod.targetPath] ? `@${contentMod}` : contentMod].value;
+              file.content = file.content.replace(`@valueof ${contentMod}`, parsedStr);
+              break;
+          }
+        }
+        for (const match of shortCmdMatches) {
+          const { mod: contentMod } = match.groups;
+          if (!contentMod) {
+            log.error(`Invalid content module statement: \x1B[34m@:${contentMod}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m. Aborting...`);
+            return null;
+          }
+          if (config.debugLevel >= 1)
+            log.debug(`Valueof module statement found: \x1B[34m${contentMod}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m.`);
+          if (!(`@${contentMod}` in mod.modList) && !(contentMod in mod.modList))
+            continue;
+          const parsedStr = module2[mod.targetPath][`@${contentMod}` in module2[mod.targetPath] ? `@${contentMod}` : contentMod].value;
+          file.content = file.content.replace(`@:${contentMod}`, parsedStr);
+        }
+        for (const match of useMatches) {
+          const { mod: contentMod, body } = match.groups;
+          if (!contentMod || !body) {
+            log.error(`Invalid content module statement: \x1B[34m@use ${contentMod} ${body}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m. Aborting...`);
+            return null;
+          }
+          if (!(`@${contentMod}` in mod.modList) && !(contentMod in mod.modList))
+            continue;
+          if (config.debugLevel >= 1)
+            log.debug(`Use module statement found: \x1B[34m@use ${contentMod} ${body}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m.`);
+          const lines = body.slice(1, -1).split(`
+`).filter(Boolean);
+          const pairs = lines.map((l) => l.split(":").map((p) => {
+            const delimIdx = p.lastIndexOf(",");
+            return p.slice(0, delimIdx === -1 ? undefined : delimIdx).trim();
+          }));
+          const tabChar = config.tabType === "1t" ? "\t" : config.tabType === "2s" ? "  " : "    ";
+          const tabCnt = countTabsBeforeSubstring(file.content.slice(file.content.lastIndexOf(`
+`, match.index), match.index + match[0].length), "@", tabChar);
+          const tabLevels = getTabLevels(body, config.tabType).map((l) => l + tabCnt);
+          const currMod = module2[mod.targetPath][`@${contentMod}` in module2[mod.targetPath] ? `@${contentMod}` : contentMod];
+          const modMember = Object.entries(currMod.member);
+          const tabLevel = tabCnt + tabLevels[Math.min(1, tabLevels.length - 1)];
+          let res = `{
+`;
+          for (const [idx, [mName, mVal]] of modMember.entries()) {
+            const pairIdx = pairs.findIndex((p) => p[0] === mName);
+            const pair = pairIdx > -1 ? pairs[pairIdx] : null;
+            const value = pair ? pair.length === 2 ? pair[1] : mVal.value : mVal.value;
+            if (value) {
+              res += `${insertTabs(tabLevel, config.tabType)}${mName}: ${value}${idx < modMember.length - 2 ? "," : ""}
+`;
+            }
+            if (pairIdx > -1)
+              swapAndPop(pairs, pairIdx);
+          }
+          for (const [idx, pair] of pairs.entries()) {
+            if (idx === 0)
+              res = res.slice(0, -1) + `,
+`;
+            res += `${insertTabs(tabLevel, config.tabType)}${pair[0]}: ${pair[1]}${idx < pairs.length - 1 ? "," : ""}
+`;
+          }
+          res += insertTabs(tabCnt, config.tabType) + "}";
+          file.content = file.content.replace(match[0], res);
+        }
+        break;
+    }
+    file.content = file.content.trim() + `
+`;
+  }
+  return mods;
+}
+
+// src/parser/export-module.ts
+function inferType(value) {
+  value = value.trim();
+  if (value.startsWith('"') || value.startsWith("'"))
+    return "string";
+  if (/^\d/.test(value))
+    return "number";
+  if (value === "true" || value === "false")
+    return "boolean";
+  if (value.startsWith("{") || value.includes("=>"))
+    return "method";
+  if (value.startsWith("["))
+    return "array";
+  if (value.startsWith("{"))
+    return "object";
+  return "any";
+}
+function inferInlineType(value) {
+  value = value.trim();
+  if (value.toLowerCase() === "string")
+    return "string";
+  if (value.toLowerCase() === "number")
+    return "number";
+  if (value.toLowerCase() === "boolean")
+    return "boolean";
+  if (value.toLowerCase() === "object")
+    return "object";
+  if (value.toLowerCase() === "array")
+    return "array";
+  if (value.toLowerCase() === "enum")
+    return "enum";
+  return "any";
+}
+function getDefaultValue(type) {
+  switch (type) {
+    case "string":
+      return '""';
+    case "number":
+      return "0";
+    case "boolean":
+      return "false";
+    case "object":
+      return "{}";
+    case "array":
+      return "[]";
+    default:
+      return null;
+  }
+}
+function getObjectMembers(module2, retryList, filePath, name, objCode, isType = false) {
+  const deleteCommentRegex = /\/\/[^\n]*|\/\*[\s\S]*?\*\//g;
+  const cleanObjCode = objCode.replace(deleteCommentRegex, "").replace(/\s+/g, "");
+  const shapes = isType ? cleanObjCode.split("=")[1].trim() : null;
+  const members = cleanObjCode.split("{")[1].replace("}", "").split(",");
+  const memberObj = {};
+  if (objCode.includes("extends")) {
+    const extendsMatch = objCode.match(/extends (\w+)/);
+    if (extendsMatch) {
+      const extendsName = extendsMatch[1];
+      if (!module2[filePath])
+        module2[filePath] = {};
+      if (!module2[filePath][extendsName])
+        retryList.push({ filePath, name, targetName: extendsName });
+      else {
+        const extendsInterface = module2[filePath][extendsName];
+        for (const [mName, m] of Object.entries(extendsInterface.member)) {
+          memberObj[mName] = { type: m.type, value: m.value };
+        }
+      }
+    }
+  } else if (isType && objCode.includes("&")) {
+    const andSplit = shapes.split("&").map((s) => s.trim().replace(";", ""));
+    for (const and of andSplit) {
+      if (and.startsWith("{"))
+        continue;
+      if (!module2[filePath])
+        module2[filePath] = {};
+      if (!module2[filePath][and])
+        retryList.push({ filePath, name, targetName: and });
+      else {
+        const extendsType = module2[filePath][and];
+        for (const [mName, m] of Object.entries(extendsType.member)) {
+          memberObj[mName] = { type: m.type, value: m.value };
+        }
+      }
+    }
+  }
+  for (const member of members) {
+    const parts = member.split(":").map((p) => p.replace(";", ""));
+    const defParts = parts.length === 1 ? parts[0].split("=") : parts[1].split("=");
+    const partFirst = defParts[0].trim().replace(";", "");
+    const memName = /\w+/.exec(parts[0].replace("?", ""))[0];
+    const defValue = defParts.length === 1 ? parts[0].endsWith("?") ? "undefined" : getDefaultValue(inferInlineType(partFirst)) : defParts[1].trim();
+    memberObj[memName] = { type: parts.length === 1 ? "any" : inferInlineType(partFirst), value: defValue };
+  }
+  return memberObj;
+}
+function countBraces(line) {
+  let count = 0;
+  let inString = false;
+  let stringChar = "";
+  for (let i = 0;i < line.length; i++) {
+    const char = line[i];
+    if (inString) {
+      if (char === stringChar && (i === 0 || line[i - 1] !== "\\")) {
+        inString = false;
+      }
+    } else {
+      if (char === '"' || char === "'") {
+        inString = true;
+        stringChar = char;
+      } else if (char === "{") {
+        count++;
+      } else if (char === "}") {
+        count--;
+      }
+    }
+  }
+  return count;
+}
+function parseFnParams(str) {
+  const match = str.match(fnParamsRegex);
+  let names = [];
+  let defaults = [];
+  let combined = [];
+  if (!match)
+    return {
+      names,
+      defaults,
+      combined
+    };
+  const params = match[0].slice(1, -1).split(",");
+  names = params.map((p) => p.trim().split("=")[0].trim());
+  defaults = params.map((p) => {
+    const def = p.trim().split("=");
+    return def.length > 1 ? def[1]?.trim() : def[0]?.trim().endsWith("?") ? "undefined" : null;
+  });
+  combined = names.map((n, i) => defaults[i] ? `${n.replaceAll("?", "")} = ${defaults[i]}` : n.replaceAll("?", ""));
+  return { names, defaults, combined };
+}
+function convertClassMethods(classBody) {
+  const methodRegex = /(\w+)\s*\(([^)]*)\)\s*{([\s\S]*?)}/g;
+  return classBody.replace(methodRegex, (match, methodName, params, body) => {
+    if (methodName === "function")
+      return match;
+    return `${methodName} = function(${params.replaceAll("?", " = undefined")}) {${body}}`;
+  });
+}
+function insertTabs(count, type) {
+  let str = "";
+  for (let i = 0;i < count; i++) {
+    str += type === "1t" ? "\t" : type === "2s" ? "  " : "    ";
+  }
+  return str;
+}
+function getExportedModules(files, config) {
+  const module2 = {};
+  if (files.generate.length == 0 && files.scaff.length == 0) {
+    log.warn("No files to get exported modules from.");
+    return module2;
+  }
+  const retryList = [];
+  let retryCount = 0;
+  let retryLastLen = 0;
+  let retryLen = 0;
+  for (const file of files.scaff) {
+    const filePath = file.isIndex ? file.path : `${file.path}/${file.name}`;
+    const lines = file.content.split(`
+`);
+    let i = 0;
+    while (i < lines.length) {
+      if (!lines[i]) {
+        i++;
+        continue;
+      }
+      const line = lines[i].trim();
+      if (!line.startsWith("export ")) {
+        i++;
+        continue;
+      }
+      if (line.startsWith("export function ")) {
+        const funcLines = [];
+        let braceCount = 0;
+        let j = i;
+        for (;j < lines.length; j++) {
+          const l = lines[j];
+          funcLines.push(l);
+          braceCount += countBraces(l);
+          if (braceCount <= 0 && (l?.trim().endsWith("}") || l?.trim().includes(";")))
+            break;
+        }
+        i = j + 1;
+        const funcCode = funcLines.join(`
+`);
+        const match = funcCode.match(/export function (\w+)/);
+        if (match) {
+          const name = match[1];
+          if (!module2[filePath])
+            module2[filePath] = {};
+          const body = funcCode.slice(funcCode.indexOf("{")).trim();
+          const params = parseFnParams(funcCode);
+          const parsedStr = `function ${name}(${params.combined.join(", ")}) ${body}`;
+          module2[filePath][name] = { name, value: body.slice(1, -1), type: "function", parsedStr };
+        }
+      } else if (line.startsWith("export class ")) {
+        const classLines = [];
+        let braceCount = 0;
+        let j = i;
+        for (;j < lines.length; j++) {
+          const l = lines[j];
+          classLines.push(l);
+          braceCount += countBraces(l);
+          if (braceCount <= 0 && (l?.trim().endsWith("}") || l?.trim().includes(";")))
+            break;
+        }
+        i = j + 1;
+        const classCode = classLines.join(`
+`);
+        const match = classCode.match(/export class (\w+)/);
+        if (match) {
+          const name = match[1];
+          const constructor = classCode.match(/constructor\s*\(([^)]*)\)/)?.[1] ?? "()";
+          if (!module2[filePath])
+            module2[filePath] = {};
+          const bodyMatch = classCode.match(/{([\s\S]*)}/);
+          let classBody = bodyMatch ? bodyMatch[1] : "";
+          if (classBody) {
+            classBody = classBody.replace(/^\s*constructor\s*\([^)]*\)\s*\n?/m, "");
+            classBody = convertClassMethods(classBody);
+            if (classBody.includes("=>")) {
+              const argsMatch = classBody.match(/\([^)]*\)\s*=>/)?.[0];
+              if (argsMatch)
+                classBody = classBody.replace(argsMatch, `function${argsMatch.replace("=>", "").replaceAll("?", " = undefined").trimEnd()}`);
+            }
+          }
+          const parsedStr = `function ${name}(${constructor.replaceAll("?", " = undefined")}) constructor {
+${insertTabs(1, config.tabType)}${classBody}
+}`;
+          module2[filePath][name] = { name, value: classCode.replace("export ", ""), type: "class", parsedStr };
+        }
+      } else if (line.startsWith("export interface ")) {
+        const interfaceLines = [];
+        let braceCount = 0;
+        let j = i;
+        for (;j < lines.length; j++) {
+          const l = lines[j];
+          interfaceLines.push(l);
+          braceCount += countBraces(l);
+          if (braceCount <= 0 && (l?.trim().endsWith("}") || l?.trim().includes(";")))
+            break;
+        }
+        i = j + 1;
+        const interfaceCode = interfaceLines.join(`
+`);
+        const match = interfaceCode.match(/export interface (\w+)/);
+        if (match) {
+          const name = match[1];
+          if (!module2[filePath])
+            module2[filePath] = {};
+          const member = getObjectMembers(module2, retryList, filePath, name, interfaceCode);
+          const parsedStr = "{" + interfaceCode.split("{")[1].split("}")[0] + "}";
+          module2[filePath][name] = { name, value: interfaceCode.replace("export ", ""), type: "interface", member, parsedStr };
+        }
+      } else if (line.startsWith("export enum ") || line.startsWith("export const enum ")) {
+        const enumLines = [];
+        let braceCount = 0;
+        let j = i;
+        for (;j < lines.length; j++) {
+          const l = lines[j];
+          enumLines.push(l);
+          braceCount += countBraces(l);
+          if (braceCount <= 0 && (l?.trim().endsWith("}") || l?.trim().includes(";")))
+            break;
+        }
+        i = j + 1;
+        const constEnum = line.startsWith("export const enum ");
+        const enumCode = enumLines.join(`
+`);
+        const match = !constEnum ? enumCode.match(/export enum (\w+)/) : enumCode.match(/export const enum (\w+)/);
+        if (match) {
+          const name = match[1];
+          if (!module2[filePath])
+            module2[filePath] = {};
+          const parsedStr = enumCode.replace(!constEnum ? "export " : "export const ", "").replace("?", " = undefined");
+          module2[filePath][name] = { name, value: parsedStr, type: "enum", parsedStr };
+        }
+      } else if (line.startsWith("export type ")) {
+        const typeLines = [];
+        let j = i;
+        let hasBrace = false;
+        let braceCount = 0;
+        for (;j < lines.length; j++) {
+          const l = lines[j];
+          typeLines.push(l);
+          if (l?.includes("{"))
+            hasBrace = true;
+          braceCount += countBraces(l);
+          if (!hasBrace && l?.includes(";"))
+            break;
+          if (hasBrace && braceCount <= 0 && (l?.trim().endsWith("}") || l?.trim().includes(";")))
+            break;
+        }
+        i = j + 1;
+        const typeCode = typeLines.join(`
+`);
+        const match = typeCode.match(/export type (\w+)/);
+        if (match) {
+          const name = match[1];
+          if (!module2[filePath])
+            module2[filePath] = {};
+          const member = getObjectMembers(module2, retryList, filePath, name, typeCode, true);
+          const parsedStr = "{" + typeCode.split("{")[1].split("}")[0] + "}";
+          module2[filePath][name] = { name, value: typeCode.replace("export ", ""), type: "type", member, parsedStr };
+        }
+      } else if (line.includes(" = ")) {
+        const parts = line.split(" = ");
+        if (parts.length >= 2) {
+          const decl = parts[0].trim();
+          const valuePart = parts.slice(1).join(" = ").trim().replace(/;$/, "");
+          const valueType = inferType(valuePart);
+          let name = decl?.replace(/^export\s+(const|let|var)?\s*/, "").trim();
+          if (valuePart.includes("=>")) {
+            if (valuePart.trim().endsWith("{")) {
+              const arrowLines = [];
+              let braceCount = 0;
+              let j = i;
+              for (;j < lines.length; j++) {
+                const l = lines[j];
+                arrowLines.push(l);
+                braceCount += countBraces(l);
+                if (braceCount <= 0 && (l?.trim().endsWith("}") || l?.trim().includes(";")))
+                  break;
+              }
+              i = j + 1;
+              const arrowCode = arrowLines.join(`
+`);
+              const arrowBlock = "{" + arrowCode.split("{")[1];
+              const params = parseFnParams(valuePart);
+              const parsedStr = `${name} = function(${params.combined.join(", ")}) ${arrowBlock}`;
+              if (!module2[filePath])
+                module2[filePath] = {};
+              module2[filePath][name] = { name, value: arrowBlock.slice(1, -1), type: "arrow-fn", parsedStr };
+            } else {
+              const params = parseFnParams(valuePart);
+              const body = valuePart.split("=>")[1].trim();
+              const parsedStr = `${name} = function(${params.combined.join(", ")}) { return ${body}; }`;
+              if (!module2[filePath])
+                module2[filePath] = {};
+              module2[filePath][name] = { name, value: body, type: "arrow-fn", parsedStr };
+            }
+          } else if (valuePart.startsWith("function")) {
+            if (valuePart.trim().endsWith("{")) {
+              const funcLines = [];
+              let braceCount = 0;
+              let j = i;
+              for (;j < lines.length; j++) {
+                const l = lines[j];
+                funcLines.push(l);
+                braceCount += countBraces(l);
+                if (braceCount <= 0 && (l?.trim().endsWith("}") || l?.trim().includes(";")))
+                  break;
+              }
+              i = j + 1;
+              const funcCode = funcLines.join(`
+`);
+              const funcBlock = "{" + funcCode.split("{")[1];
+              const params = parseFnParams(valuePart);
+              const parsedStr = `${name} = function(${params.combined.join(", ")}) ${funcBlock}`;
+              if (!module2[filePath])
+                module2[filePath] = {};
+              module2[filePath][name] = { name, value: funcBlock.slice(1, -1), type: "method", parsedStr };
+            } else {
+              const parsedStr = `${name} = ${valuePart}`;
+              if (!module2[filePath])
+                module2[filePath] = {};
+              module2[filePath][name] = { name, value: line.replace("export ", ""), type: "method", parsedStr };
+            }
+          } else {
+            let varType = "var";
+            if (decl?.includes("const"))
+              varType = "const";
+            else if (decl?.includes("let"))
+              varType = "let";
+            else if (decl?.includes("var"))
+              varType = "var";
+            const noVarKeyword = varType === "var" && !parts[0].includes("var");
+            if (!module2[filePath])
+              module2[filePath] = {};
+            const parsedStr = varType !== "const" ? `${varType === "let" ? "" : "var "}${name} = ${valuePart};` : `#macro ${name} ${valuePart}`;
+            module2[filePath][name] = { name, value: valuePart, type: varType === "const" ? "constant" : "variable", parsedStr };
+          }
+        }
+      }
+      i++;
+    }
+  }
+  retryLen = retryList.length;
+  while (retryCount < 10 && retryLastLen !== retryLen) {
+    for (const retry of retryList) {
+      if (!module2[retry.filePath])
+        continue;
+      if (!module2[retry.filePath][retry.targetName])
+        continue;
+      switch (module2[retry.filePath][retry.name].type) {
+        case "interface":
+          const currInterface = module2[retry.filePath][retry.name];
+          const extendsInterface = module2[retry.filePath][retry.targetName];
+          for (const [mName, m] of Object.entries(extendsInterface.member)) {
+            currInterface.member[mName] = { type: m.type, value: m.value };
+          }
+          break;
+        case "type":
+          const currType = module2[retry.filePath][retry.name];
+          const extendsType = module2[retry.filePath][retry.targetName];
+          for (const [mName, m] of Object.entries(extendsType.member)) {
+            currType.member[mName] = { type: m.type, value: m.value };
+          }
+          break;
+      }
+    }
+    retryLastLen = retryLen;
+    retryLen = retryList.length;
+    retryCount++;
+  }
+  return module2;
+}
+function reexportModule(module2, file, config) {
+  const reexportMatches = [...file.content.matchAll(modControlRegex)].filter((match) => match.groups?.cmd === "export");
+  if (!reexportMatches.length)
+    return false;
+  for (const match of reexportMatches) {
+    const { cmd, mod, path: path3 } = match.groups;
+    if (!(cmd && mod && path3)) {
+      log.error(`Invalid module control statement: \x1B[34m${cmd} ${mod} from ${path3}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m. Aborting...`);
+      return false;
+    }
+    const fromPath = normalizePath(resolveImportPath(file.path, path3.slice(1, -1), config));
+    const thisPath = file.isIndex ? file.path : `${file.path}/${file.name}`;
+    const alias = {};
+    if (mod === "*" || mod.startsWith("{") && mod.endsWith("}")) {
+      const targetMods = mod === "*" ? null : mod.slice(1, -1).split(",").map((m) => {
+        const split = m.split(":");
+        const key = split[0].trim();
+        if (split.length === 1)
+          alias[key] = key;
+        else
+          alias[key] = split[1].trim();
+        if (!module2[fromPath]) {
+          if (config.onNotFound === "error") {
+            log.error(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Aborting...`);
+            return false;
+          } else
+            log.warn(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Skipping this module...`);
+          return false;
+        }
+        if (!module2[fromPath][key]) {
+          if (config.onNotFound === "error") {
+            log.error(`Module \x1B[33m${key}\x1B[0m from \x1B[32m${fromPath}\x1B[0m not found. Aborting...`);
+            return false;
+          } else
+            log.warn(`Module \x1B[33m${key}\x1B[0m from \x1B[32m${fromPath}\x1B[0m not found. Skipping this module...`);
+          return false;
+        }
+        return key;
+      }).filter(Boolean);
+      if (!module2[fromPath]) {
+        if (config.onNotFound === "error") {
+          log.error(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Aborting...`);
+          return false;
+        } else
+          log.warn(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Skipping this module...`);
+        return false;
+      }
+      Object.entries(module2[fromPath]).forEach(([key, value]) => {
+        if (!module2[thisPath])
+          module2[thisPath] = {};
+        if (mod === "*")
+          module2[thisPath][key] = value;
+        else if (targetMods.includes(key)) {
+          const usingAlias = key in alias && alias[key] !== key;
+          if (usingAlias)
+            module2[thisPath][`@${alias[key]}`] = value;
+          else
+            module2[thisPath][key] = value;
+        }
+      });
+    } else {
+      if (!module2[fromPath]) {
+        if (config.onNotFound === "error") {
+          log.error(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Aborting...`);
+          return false;
+        } else
+          log.warn(`Path \x1B[33m${fromPath}\x1B[0m doesn't have any exported modules. Skipping this module...`);
+        return false;
+      }
+      if (!module2[fromPath][mod]) {
+        if (config.onNotFound === "error") {
+          log.error(`Module \x1B[33m${mod}\x1B[0m from \x1B[32m${fromPath}\x1B[0m not found. Aborting...`);
+          return false;
+        } else
+          log.warn(`Module \x1B[33m${mod}\x1B[0m from \x1B[32m${fromPath}\x1B[0m not found. Skipping this module...`);
+        return false;
+      }
+      if (!module2[thisPath])
+        module2[thisPath] = {};
+      module2[thisPath][mod] = module2[fromPath][mod];
+    }
+  }
+  return true;
+}
+// src/parser/class-implement.ts
+function convertArrowFn(str) {
+  return str.replace(arrowFnHeaderRegex, (match, _p1, _p2, _offset, _input, groups) => {
+    if (!groups?.name)
+      return match;
+    const rawParams = groups.params?.trim() ?? "";
+    const paramsSource = rawParams.startsWith("(") ? rawParams : `(${rawParams})`;
+    const params = parseFnParams(paramsSource);
+    return `${groups.name} = function(${params.combined.join(", ")})`;
+  });
+}
+function parseHeader(str, regex = implHeaderRegex) {
+  const results = [];
+  let match;
+  while ((match = regex.exec(str)) !== null) {
+    const name = match.groups.name;
+    const start = regex.lastIndex;
+    let braceCount = 1;
+    let inString = false;
+    let stringChar = "";
+    let i = start;
+    for (;i < str.length; i++) {
+      const char = str[i];
+      if (inString) {
+        if (char === stringChar && (i === 0 || str[i - 1] !== "\\")) {
+          inString = false;
+        }
+      } else {
+        if (char === '"' || char === "'") {
+          inString = true;
+          stringChar = char;
+        } else if (char === "{") {
+          braceCount++;
+        } else if (char === "}") {
+          braceCount--;
+          if (braceCount === 0)
+            break;
+        }
+      }
+    }
+    const body = str.slice(start, i);
+    results.push({ name, body });
+    regex.lastIndex = i + 1;
+  }
+  return results;
+}
+function implementClass(module2, fileGroup, config) {
+  if (fileGroup.generate.length == 0 && fileGroup.scaff.length == 0) {
+    log.warn("No files to implement classes from.");
+    return false;
+  }
+  const toImpl = [];
+  for (const file of fileGroup.scaff) {
+    if (file.childs.length > 0)
+      file.childs.forEach((child) => toImpl.push({ parent: file, file: child }));
+  }
+  for (const file of fileGroup.generate) {
+    if (file.childs.length > 0)
+      file.childs.forEach((child) => toImpl.push({ parent: file, file: child }));
+  }
+  for (const fileImpl of toImpl) {
+    const filePath = fileImpl.parent.isIndex ? fileImpl.parent.path : `${fileImpl.parent.path}/${fileImpl.parent.name}`;
+    const match = parseHeader(fileImpl.file.content);
+    const classNames = [];
+    for (const [mIdx, m] of match.entries()) {
+      const { name: className } = m;
+      let { body } = m;
+      body = convertClassMethods(body);
+      body = convertArrowFn(body);
+      if (!className || !body)
+        continue;
+      classNames.push(className);
+      if (!module2[filePath] || !module2[filePath][className]) {
+        let newFilePath = null;
+        for (const file of fileGroup.scaff) {
+          if (file.content.includes(`class ${className} {`)) {
+            newFilePath = file.isIndex ? file.path : `${file.path}/${file.name}`;
+            break;
+          }
+        }
+        if (!newFilePath) {
+          for (const file of fileGroup.generate) {
+            if (file.content.includes(`class ${className} {`)) {
+              newFilePath = file.isIndex ? file.path : `${file.path}/${file.name}`;
+              break;
+            }
+          }
+        }
+        if (!newFilePath) {
+          if (config.onNotFound === "error") {
+            log.error(`Class \x1B[33m${className}\x1B[0m not found for file \x1B[34m${fileImpl.file.name}\x1B[0m. Aborting...`);
+            return false;
+          } else {
+            log.warn(`Class \x1B[33m${className}\x1B[0m not found for file \x1B[34m${fileImpl.file.name}\x1B[0m. Skipping this class...`);
+            continue;
+          }
+        }
+        const classCloseBracket = module2[newFilePath][className].parsedStr.lastIndexOf("}");
+        module2[newFilePath][className].parsedStr = module2[newFilePath][className].parsedStr.slice(0, classCloseBracket) + `${body.replace(`
+`, "")}` + (mIdx < match.length - 1 ? `
+
+` : `
+}
+`);
+        if (mIdx === match.length - 1) {
+          for (const name of classNames) {
+            if (!module2[filePath] || !module2[filePath][name])
+              continue;
+            module2[filePath][name].parsedStr += `}
+`;
+          }
+        } else
+          classNames.splice(classNames.indexOf(className), 1);
+        continue;
+      } else {
+        const classCloseBracket = module2[filePath][className].parsedStr.lastIndexOf("}");
+        module2[filePath][className].parsedStr = module2[filePath][className].parsedStr.slice(0, classCloseBracket) + `${body.replace(`
+`, "")}` + (mIdx < match.length - 1 ? `
+
+` : `
+}
+`);
+      }
+    }
+  }
+  return true;
+}
+// types/gm-event.ts
+var EVENT = {
+  ALARM_0: 0,
+  ALARM_1: 1,
+  ALARM_2: 2,
+  ALARM_3: 3,
+  ALARM_4: 4,
+  ALARM_5: 5,
+  ALARM_6: 6,
+  ALARM_7: 7,
+  ALARM_8: 8,
+  ALARM_9: 9,
+  ALARM_10: 10,
+  ALARM_11: 11,
+  CLEAN_UP: 0,
+  CREATE: 0,
+  DESTROY: 0,
+  DRAW: 0,
+  DRAW_GUI: 64,
+  WINDOW_RESIZE: 65,
+  DRAW_BEGIN: 72,
+  DRAW_END: 73,
+  DRAW_GUI_BEGIN: 74,
+  DRAW_GUI_END: 75,
+  PREDRAW: 76,
+  POSTDRAW: 77,
+  GESTURE_TAP: 0,
+  GESTURE_DOUBLE_TAP: 1,
+  GESTURE_DRAG_START: 2,
+  GESTURE_DRAGGING: 3,
+  GESTURE_DRAG_END: 4,
+  GESTURE_FLICK: 5,
+  GESTURE_PINCH_START: 6,
+  GESTURE_PINCH_IN: 7,
+  GESTURE_PINCH_OUT: 8,
+  GESTURE_PINCH_END: 9,
+  GESTURE_ROTATE_START: 10,
+  GESTURE_ROTATING: 11,
+  GESTURE_ROTATE_END: 12,
+  GLOBAL_GESTURE_TAP: 64,
+  GLOBAL_GESTURE_DOUBLE_TAP: 65,
+  GLOBAL_GESTURE_DRAG_START: 66,
+  GLOBAL_GESTURE_DRAGGING: 67,
+  GLOBAL_GESTURE_DRAG_END: 68,
+  GLOBAL_GESTURE_FLICK: 69,
+  GLOBAL_GESTURE_PINCH_START: 70,
+  GLOBAL_GESTURE_PINCH_IN: 71,
+  GLOBAL_GESTURE_PINCH_OUT: 72,
+  GLOBAL_GESTURE_PINCH_END: 73,
+  GLOBAL_GESTURE_ROTATE_START: 74,
+  GLOBAL_GESTURE_ROTATING: 75,
+  GLOBAL_GESTURE_ROTATE_END: 76,
+  KEYBOARD_NO_KEY: 0,
+  KEYBOARD_ANY_KEY: 1,
+  KEYBOARD_BACKSPACE: 8,
+  KEYBOARD_TAB: 9,
+  KEYBOARD_ENTER: 13,
+  KEYBOARD_SHIFT: 16,
+  KEYBOARD_CONTROL: 17,
+  KEYBOARD_ALT: 18,
+  KEYBOARD_ESCAPE: 27,
+  KEYBOARD_SPACE: 32,
+  KEYBOARD_PAGE_UP: 33,
+  KEYBOARD_PAGE_DOWN: 34,
+  KEYBOARD_END: 35,
+  KEYBOARD_HOME: 36,
+  KEYBOARD_LEFT: 37,
+  KEYBOARD_UP: 38,
+  KEYBOARD_RIGHT: 39,
+  KEYBOARD_DOWN: 40,
+  KEYBOARD_INSERT: 45,
+  KEYBOARD_DELETE: 46,
+  KEYBOARD_0: 48,
+  KEYBOARD_1: 49,
+  KEYBOARD_2: 50,
+  KEYBOARD_3: 51,
+  KEYBOARD_4: 52,
+  KEYBOARD_5: 53,
+  KEYBOARD_6: 54,
+  KEYBOARD_7: 55,
+  KEYBOARD_8: 56,
+  KEYBOARD_9: 57,
+  KEYBOARD_A: 65,
+  KEYBOARD_B: 66,
+  KEYBOARD_C: 67,
+  KEYBOARD_D: 68,
+  KEYBOARD_E: 69,
+  KEYBOARD_F: 70,
+  KEYBOARD_G: 71,
+  KEYBOARD_H: 72,
+  KEYBOARD_I: 73,
+  KEYBOARD_J: 74,
+  KEYBOARD_K: 75,
+  KEYBOARD_L: 76,
+  KEYBOARD_M: 77,
+  KEYBOARD_N: 78,
+  KEYBOARD_O: 79,
+  KEYBOARD_P: 80,
+  KEYBOARD_Q: 81,
+  KEYBOARD_R: 82,
+  KEYBOARD_S: 83,
+  KEYBOARD_T: 84,
+  KEYBOARD_U: 85,
+  KEYBOARD_V: 86,
+  KEYBOARD_W: 87,
+  KEYBOARD_X: 88,
+  KEYBOARD_Y: 89,
+  KEYBOARD_Z: 90,
+  KEYBOARD_NUMPAD_0: 96,
+  KEYBOARD_NUMPAD_1: 97,
+  KEYBOARD_NUMPAD_2: 98,
+  KEYBOARD_NUMPAD_3: 99,
+  KEYBOARD_NUMPAD_4: 100,
+  KEYBOARD_NUMPAD_5: 101,
+  KEYBOARD_NUMPAD_6: 102,
+  KEYBOARD_NUMPAD_7: 103,
+  KEYBOARD_NUMPAD_8: 104,
+  KEYBOARD_NUMPAD_9: 105,
+  KEYBOARD_NUMPAD_MULTIPLY: 106,
+  KEYBOARD_NUMPAD_ADD: 107,
+  KEYBOARD_NUMPAD_SUBTRACT: 109,
+  KEYBOARD_NUMPAD_DECIMAL: 110,
+  KEYBOARD_NUMPAD_DIVIDE: 111,
+  KEYBOARD_F1: 112,
+  KEYBOARD_F2: 113,
+  KEYBOARD_F3: 114,
+  KEYBOARD_F4: 115,
+  KEYBOARD_F5: 116,
+  KEYBOARD_F6: 117,
+  KEYBOARD_F7: 118,
+  KEYBOARD_F8: 119,
+  KEYBOARD_F9: 120,
+  KEYBOARD_F10: 121,
+  KEYBOARD_F11: 122,
+  KEYBOARD_F12: 123,
+  MOUSE_DOWN_LEFT: 0,
+  MOUSE_DOWN_RIGHT: 1,
+  MOUSE_DOWN_MIDDLE: 2,
+  MOUSE_NO_BUTTON: 3,
+  MOUSE_PRESS_LEFT: 4,
+  MOUSE_PRESS_RIGHT: 5,
+  MOUSE_PRESS_MIDDLE: 6,
+  MOUSE_RELEASE_LEFT: 7,
+  MOUSE_RELEASE_RIGHT: 8,
+  MOUSE_RELEASE_MIDDLE: 9,
+  MOUSE_ENTER: 10,
+  MOUSE_LEAVE: 11,
+  GLOBAL_MOUSE_DOWN_LEFT: 50,
+  GLOBAL_MOUSE_DOWN_RIGHT: 51,
+  GLOBAL_MOUSE_DOWN_MIDDLE: 52,
+  GLOBAL_MOUSE_PRESS_LEFT: 53,
+  GLOBAL_MOUSE_PRESS_RIGHT: 54,
+  GLOBAL_MOUSE_PRESS_MIDDLE: 55,
+  GLOBAL_MOUSE_RELEASE_LEFT: 56,
+  GLOBAL_MOUSE_RELEASE_RIGHT: 57,
+  GLOBAL_MOUSE_RELEASE_MIDDLE: 58,
+  MOUSE_WHEEL_UP: 60,
+  MOUSE_WHEEL_DOWN: 61,
+  MOUSE_SCROLL_UP: 60,
+  MOUSE_SCROLL_DOWN: 61,
+  OUTSIDE_ROOM: 0,
+  INTERSECT_BOUNDARY: 1,
+  GAME_START: 2,
+  GAME_END: 3,
+  ROOM_START: 4,
+  ROOM_END: 5,
+  ANIMATION_END: 7,
+  PATH_END: 8,
+  USER_EVENT_0: 10,
+  USER_EVENT_1: 11,
+  USER_EVENT_2: 12,
+  USER_EVENT_3: 13,
+  USER_EVENT_4: 14,
+  USER_EVENT_5: 15,
+  USER_EVENT_6: 16,
+  USER_EVENT_7: 17,
+  USER_EVENT_8: 18,
+  USER_EVENT_9: 19,
+  USER_EVENT_10: 20,
+  USER_EVENT_11: 21,
+  USER_EVENT_12: 22,
+  USER_EVENT_13: 23,
+  USER_EVENT_14: 24,
+  USER_EVENT_15: 25,
+  OUTSIDE_VIEW_0: 40,
+  OUTSIDE_VIEW_1: 41,
+  OUTSIDE_VIEW_2: 42,
+  OUTSIDE_VIEW_3: 43,
+  OUTSIDE_VIEW_4: 44,
+  OUTSIDE_VIEW_5: 45,
+  OUTSIDE_VIEW_6: 46,
+  OUTSIDE_VIEW_7: 47,
+  INTERSECT_VIEW_0_BOUNDARY: 50,
+  INTERSECT_VIEW_1_BOUNDARY: 51,
+  INTERSECT_VIEW_2_BOUNDARY: 52,
+  INTERSECT_VIEW_3_BOUNDARY: 53,
+  INTERSECT_VIEW_4_BOUNDARY: 54,
+  INTERSECT_VIEW_5_BOUNDARY: 55,
+  INTERSECT_VIEW_6_BOUNDARY: 56,
+  INTERSECT_VIEW_7_BOUNDARY: 57,
+  ANIMATION_UPDATE: 58,
+  ANIMATION_EVENT: 59,
+  ASYNC_IMAGE_LOADED: 60,
+  ASYNC_HTTP: 62,
+  ASYNC_DIALOG: 63,
+  ASYNC_IN_APP_PURCHASE: 66,
+  ASYNC_CLOUD: 67,
+  ASYNC_NETWORKING: 68,
+  ASYNC_STEAM: 69,
+  ASYNC_SOCIAL: 70,
+  ASYNC_PUSH_NOTIFICATION: 71,
+  ASYNC_SAVE_LOAD: 72,
+  ASYNC_AUDIO_RECORDING: 73,
+  ASYNC_AUDIO_PLAYBACK: 74,
+  ASYNC_SYSTEM: 75,
+  BROADCAST_MESSAGE: 76,
+  WALLPAPER_SUBS_DATA: 81,
+  STEP: 0,
+  STEP_BEGIN: 1,
+  STEP_END: 2
+};
+var EventName = {
+  [0 /* CREATE */]: "Create",
+  [1 /* DESTROY */]: "Destroy",
+  [2 /* ALARM */]: "Alarm",
+  [3 /* STEP */]: "Step",
+  [4 /* COLLISION */]: "Collision",
+  [5 /* KEY_DOWN */]: "Keyboard",
+  [6 /* MOUSE */]: "Mouse",
+  [7 /* OTHER */]: "Other",
+  [8 /* DRAW */]: "Draw",
+  [9 /* KEY_PRESS */]: "KeyPress",
+  [10 /* KEY_RELEASE */]: "KeyRelease",
+  [12 /* CLEAN_UP */]: "CleanUp",
+  [13 /* GESTURE */]: "Gesture"
+};
+// src/generator/extract.ts
+function getEventFile(eventInput, numInput) {
+  let event = 0;
+  let needNum = true;
+  let dynNum = false;
+  switch (eventInput.toLowerCase()) {
+    case "create":
+      event = 0 /* CREATE */;
+      needNum = false;
+      break;
+    case "destroy":
+      event = 1 /* DESTROY */;
+      needNum = false;
+      break;
+    case "alarm":
+      event = 2 /* ALARM */;
+      break;
+    case "step":
+      event = 3 /* STEP */;
+      break;
+    case "collision":
+      event = 4 /* COLLISION */;
+      dynNum = true;
+      break;
+    case "keydown":
+    case "key_down":
+    case "keyboard":
+      event = 5 /* KEY_DOWN */;
+      break;
+    case "mouse":
+      event = 6 /* MOUSE */;
+      break;
+    case "other":
+    case "async":
+      event = 7 /* OTHER */;
+      break;
+    case "draw":
+      event = 8 /* DRAW */;
+      break;
+    case "keypress":
+    case "key_press":
+      event = 9 /* KEY_PRESS */;
+      break;
+    case "keyrelease":
+    case "key_release":
+      event = 10 /* KEY_RELEASE */;
+      break;
+    case "cleanup":
+    case "clean_up":
+      event = 12 /* CLEAN_UP */;
+      break;
+    case "gesture":
+      event = 13 /* GESTURE */;
+      break;
+    default:
+      event = null;
+  }
+  if (event === null)
+    return { type: null, needNum: false, dynamicNum: false, num: null, numStr: null, name: null, fileName: null, collObj: null };
+  const name = EventName[event];
+  let numStr = event === 4 /* COLLISION */ ? numInput : numInput.toUpperCase();
+  if (needNum && !dynNum && !(numStr in EVENT))
+    return { type: event, needNum, dynamicNum: dynNum, num: null, numStr, name, fileName: null, collObj: null };
+  return {
+    type: event,
+    num: EVENT[numStr] ?? 0,
+    needNum,
+    dynamicNum: dynNum,
+    numStr,
+    name,
+    fileName: event === 4 /* COLLISION */ ? `${name}_${numInput}` : `${name}_${EVENT[numStr] ?? 0}`,
+    collObj: event === 4 /* COLLISION */ ? `{"name":"${numInput}","path":"objects/${numInput}/${numInput}.yy",}` : null
+  };
+}
+function extractIntegrationData(file, config) {
+  const res = [];
+  let invalid = false;
+  const blocks = [];
+  for (const match of file.content.matchAll(intgBlockRegex)) {
+    const { name: header, body } = match.groups;
+    const flags = header.split("--")[1]?.split(" ").map((f) => f.trim()) ?? [];
+    const headerSplit = header.split("--")[0].split("as").map((h) => !h.includes("collision") ? h.trim().toLowerCase() : h.trim());
+    const name = headerSplit[0].replace("event", "").replace("ev", "").trim();
+    const eventType = headerSplit[0].endsWith("event") || headerSplit[0].endsWith("ev") ? name : headerSplit[1] ?? null;
+    if (!name || !body) {
+      if (config.onNotFound === "error") {
+        log.error(`Invalid integration block found: \x1B[34m${match[0]}\x1B[0m. Aborting...`);
+        return null;
+      } else {
+        log.warn(`Invalid integration block found: \x1B[34m${match[0]}\x1B[0m. Skipping this block...`);
+        continue;
+      }
+    }
+    let event = null;
+    if (eventType) {
+      const eventSplit = eventType.split(":").filter(Boolean).map((e) => e.trim());
+      event = getEventFile(eventSplit[0], eventSplit[1] ?? "");
+      if (event.type === null) {
+        if (config.onNotFound === "error") {
+          log.error(`Invalid event type \x1B[33m${eventType}\x1B[0m found: \x1B[34m#[${header}]\x1B[0m. Aborting...`);
+          return null;
+        } else {
+          log.warn(`Invalid event type \x1B[33m${eventType}\x1B[0m found: \x1B[34m#[${header}]\x1B[0m. Skipping this block...`);
+          continue;
+        }
+      } else if (event.numStr === null && event.needNum) {
+        if (config.onNotFound === "error") {
+          log.error(`Invalid event number \x1B[33m${event.numStr}\x1B[0m found: \x1B[34m#[${header}]\x1B[0m. Aborting...`);
+          return null;
+        } else {
+          log.warn(`Invalid event number \x1B[33m${event.numStr}\x1B[0m found: \x1B[34m#[${header}]\x1B[0m. Skipping this block...`);
+          continue;
+        }
+      }
+    }
+    if (config.debugLevel >= 1)
+      log.debug(`Integration block found: \x1B[34m#[${name}]\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m.`);
+    let processedBody = body.trim();
+    if (flags.includes("debug") && config.debugLevel >= 1)
+      processedBody = "";
+    if ((flags.includes("dev") || flags.includes("development")) && config.production)
+      processedBody = "";
+    if ((flags.includes("prod") || flags.includes("production")) && !config.production)
+      processedBody = "";
+    if (flags.includes("skip") || flags.includes("disabled"))
+      processedBody = "";
+    if (config.targetPlatform !== "all") {
+      const platformExclusion = flags.find((f) => f.startsWith("!"));
+      if (platformExclusion) {
+        if (platformExclusion.slice(1) === config.targetPlatform)
+          processedBody = "";
+      } else if (!flags.includes(config.targetPlatform) && !flags.includes("all"))
+        processedBody = "";
+    }
+    const existsBlock = blocks.find((b) => b.name === name);
+    if (existsBlock) {
+      existsBlock.body += (existsBlock.body !== "" ? `
+
+` : "") + processedBody;
+      if (flags.find((f) => f === "exclude") && !existsBlock.removeBodies.includes(processedBody))
+        existsBlock.removeBodies.push(processedBody);
+    } else {
+      blocks.push({
+        name,
+        body: processedBody,
+        path: "",
+        event,
+        backup: null,
+        flags,
+        removeBodies: flags.find((f) => f === "exclude") ? [processedBody] : []
+      });
+    }
+  }
+  [...file.content.matchAll(intgRegex)].forEach((match) => {
+    if (invalid)
+      return;
+    const { targets, path: path3 } = match.groups;
+    if (!targets || !path3) {
+      if (config.onNotFound === "error") {
+        log.error(`Invalid integration statement found: \x1B[34m${match[0]}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m. Aborting...`);
+        invalid = true;
+      } else
+        log.warn(`Invalid integration statement found: \x1B[34m${match[0]}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m. Skipping this statement...`);
+      return;
+    }
+    const targetPath = normalizePath(resolvePath(path3.slice(1, -1))).replace(".gml", "");
+    if (targets === "*") {
+      if (config.debugLevel >= 1)
+        log.debug(`Integration statement found: \x1B[34mintg * to ${path3}\x1B[0m in \x1B[33m${file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m.`);
+      res.push({
+        path: targetPath,
+        targets: blocks,
+        backup: null,
+        content: {}
+      });
+    } else {
+      const targetsArr = !targets.startsWith("{") ? [targets] : targets.slice(1, -1).split(",").map((t) => t.trim());
+      res.push({
+        path: targetPath,
+        targets: [],
+        backup: null,
+        content: {}
+      });
+      for (const target of targetsArr) {
+        const targetBlock = blocks.find((b) => b.name === target.toLowerCase());
+        if (!targetBlock) {
+          if (config.onNotFound === "error") {
+            log.error(`Target \x1B[33m${target}\x1B[0m not found for integration targets: \x1B[34m${targets}\x1B[0m. Aborting...`);
+            invalid = true;
+          } else
+            log.warn(`Target \x1B[33m${target}\x1B[0m not found for integration targets: \x1B[34m${targets}\x1B[0m. Skipping this statement...`);
+          return;
+        }
+        if (config.debugLevel >= 1)
+          log.debug(`Integration statement found: \x1B[34mintg ${target} to ${path3}\x1B[0m in \x1B[33m${file.name === "" ? "index" : file.name}\x1B[0m from \x1B[32m${file.path}\x1B[0m.`);
+        res.at(-1).targets.push(targetBlock);
+      }
+    }
+  });
+  if (invalid)
+    return null;
+  return res;
+}
+// src/generator/write.ts
+async function generateSourceCode(intgData, config, projectPath) {
+  const res = {};
+  const projectPathSplit = projectPath.split("/");
+  let generatedCnt = 0;
+  if (config.clearOutputDir) {
+    await clearOutDir();
+    log.debug(`Output directory cleared.`);
+  }
+  projectPathSplit.pop();
+  log.debug(`Generating source code...`);
+  for (const data of intgData) {
+    if (!data)
+      continue;
+    let genPath = data.path.replace(commonPath([resolvePath("./out"), data.path]) ?? "", "");
+    if (config.useGmAssetPath && genPath.includes("scripts"))
+      genPath += "/" + (data.path.split("scripts")[1]?.split("/").pop() ?? "");
+    const outFile = normalizePath(resolvePath(`./.out${genPath}.gml`));
+    const outFileSplit = outFile.split("/");
+    if (genPath === "") {
+      if (config.onNotFound === "error") {
+        log.error(`Failed to generate source code for \x1B[33m${data.path}\x1B[0m. Aborting...`);
+        return res;
+      } else {
+        log.warn(`Failed to generate source code for \x1B[33m${data.path}\x1B[0m. Skipping this file...`);
+        continue;
+      }
+    }
+    let body = "";
+    const dataLen = data.targets.length;
+    if (config.useGmAssetPath && genPath.includes("objects")) {
+      for (const [idx, target] of data.targets.entries()) {
+        if (!target.event) {
+          body += target.body + `
+`;
+          if (idx < dataLen - 1)
+            body += `
+`;
+        } else {
+          const eventFile = normalizePath(resolvePath(`./.out${genPath}/${target.event.fileName}.gml`));
+          const resolvedGenPath = eventFile.replace(".out/", "");
+          const resvGenPathSplit = resolvedGenPath.split("/");
+          const outFileName = resvGenPathSplit.pop();
+          const objectIdx = resvGenPathSplit.findIndex((slug) => slug === "objects");
+          const writePath = `${projectPathSplit.join("/")}/objects/${resvGenPathSplit.at(-1)}/${outFileName}`;
+          const writePathRel = writePath.split("/").slice(-3).join("/");
+          await fsRuntime.writeText(eventFile, target.body + `
+`);
+          data.content[resolvedGenPath] = target.body;
+          target.path = resolvedGenPath;
+          res[writePath] = {
+            fullPath: resolvedGenPath,
+            dirPath: `${resvGenPathSplit.slice(objectIdx + 1, -1).join("/")}`,
+            content: target.body,
+            backup: null,
+            isNew: false,
+            event: target.event,
+            toRemoves: target.removeBodies
+          };
+          generatedCnt++;
+          if (!config.noBackup) {
+            if (await fileExists(writePath)) {
+              try {
+                target.backup = await fsRuntime.readText(writePath);
+                res[writePath].backup = target.backup;
+                log.debug(`Backup created for \x1B[32m${writePathRel}\x1B[0m.`);
+              } catch (error) {
+                log.error(`Failed to create backup for \x1B[32m${writePathRel}\x1B[0m: ${error}`);
+              }
+            } else
+              log.debug(`File: \x1B[33m${writePathRel}\x1B[0m not found. No backup created.`);
+          }
+          log.info(`Source code generated for \x1B[34m${target.event.name + (target.event.numStr ? `\x1B[0m:\x1B[36m${target.event.numStr}\x1B[34m` : "")} Event\x1B[0m to \x1B[32m${writePathRel}\x1B[0m.`);
+        }
+      }
+      if (body !== "") {
+        await fsRuntime.writeText(outFile, body);
+        generatedCnt++;
+        log.debug(`Source code generated for \x1B[34m${outFileSplit.pop()}\x1B[0m to \x1B[32m${outFileSplit.slice(-2).join("/")}\x1B[0m. This file won't be integrated to the GM project due to non-regular GM asset path.`);
+      } else if (!generatedCnt)
+        log.warn(`No source code generated for \x1B[34m${outFileSplit.pop()}\x1B[0m to \x1B[32m${outFileSplit.slice(-3).join("/")}\x1B[0m.`);
+    } else {
+      for (const [idx, target] of data.targets.entries()) {
+        body += target.body + `
+`;
+        if (idx < dataLen - 1)
+          body += `
+`;
+      }
+      if (body !== "") {
+        const resolvedGenPath = normalizePath(resolvePath(`./${genPath}`)) + ".gml";
+        const resvGenPathSplit = resolvedGenPath.split("/");
+        const outFileName = resvGenPathSplit.pop();
+        const scriptIdx = resvGenPathSplit.findIndex((slug) => slug === "scripts");
+        const writePath = `${projectPathSplit.join("/")}/scripts/${outFileName.replace(".gml", "")}/${outFileName}`;
+        const writePathRel = writePath.split("/").slice(-3).join("/");
+        await fsRuntime.writeText(outFile, body);
+        data.content[resolvedGenPath] = body;
+        res[writePath] = {
+          fullPath: resolvedGenPath,
+          dirPath: `${resvGenPathSplit.slice(scriptIdx + 1, -1).join("/")}`,
+          content: body,
+          backup: null,
+          isNew: false,
+          event: null,
+          toRemoves: data.targets.reduce((acc, curr) => {
+            acc.push(...curr.removeBodies);
+            return acc;
+          }, [])
+        };
+        generatedCnt++;
+        if (!config.noBackup) {
+          if (await fileExists(writePath)) {
+            try {
+              data.backup = await fsRuntime.readText(writePath);
+              res[writePath].backup = data.backup;
+              log.debug(`Backup created for \x1B[32m${writePathRel}\x1B[0m.`);
+            } catch (error) {
+              log.error(`Failed to create backup for \x1B[32m${writePathRel}\x1B[0m: ${error}`);
+            }
+          } else
+            log.debug(`File: \x1B[33m${writePathRel}\x1B[0m not found. No backup created.`);
+        }
+        log.info(`Source code generated for \x1B[34m${outFileSplit.pop()}\x1B[0m to \x1B[32m${outFileSplit.slice(-3).join("/")}\x1B[0m.`);
+      } else
+        log.warn(`No source code generated for \x1B[34m${outFileSplit.pop()}\x1B[0m to \x1B[32m${outFileSplit.slice(-3).join("/")}\x1B[0m.`);
+    }
+  }
+  log.info(`All source code generated. Generated \x1B[32m${generatedCnt}\x1B[0m file(s).`);
+  return res;
+}
+// src/generator/gm-asset.ts
+function stripTrailingCommas(input) {
+  const result = [];
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === '"') {
+      result.push(ch);
+      i++;
+      while (i < input.length) {
+        const sc = input[i];
+        result.push(sc);
+        if (sc === "\\") {
+          i++;
+          if (i < input.length) {
+            result.push(input[i]);
+            i++;
+          }
+        } else if (sc === '"') {
+          i++;
+          break;
+        } else {
+          i++;
+        }
+      }
+      continue;
+    }
+    if (ch === ",") {
+      let j = i + 1;
+      while (j < input.length && /\s/.test(input[j]))
+        j++;
+      if (j < input.length && (input[j] === "}" || input[j] === "]")) {
+        i++;
+        continue;
+      }
+    }
+    result.push(ch);
+    i++;
+  }
+  return result.join("");
+}
+function createYYScript(projectYyp, rescName, dir, options) {
+  const dirSplit = dir.split("/");
+  return `{
+  "$GMScript":"v1",
+  "%Name":"${rescName}",
+  "isCompatibility":false,
+  "isDnD":${options?.isDnd ?? false},
+  "name":"${rescName}",
+  "parent":{
+    "name":"${dir !== "" ? dirSplit.pop() : projectYyp.replace(".yyp", "")}",
+    "path":"${dir !== "" ? `folders/${dir}.yy` : `${projectYyp}.yyp`}",
+  },
+  "resourceType":"GMScript",
+  "resourceVersion":"2.0",
+}`;
+}
+function createYYObject(projectYyp, rescName, dir, eventList, options) {
+  const dirSplit = dir.split("/");
+  const eventStr = eventList?.join(`
+`) ?? null;
+  return `{
+  "$GMObject":"",
+  "%Name":"${rescName}",
+  "eventList":[
+    ${eventStr ?? ""}
+  ],
+  "managed":true,
+  "name":"${rescName}",
+  "overriddenProperties":[],
+  "parent":{
+    "name":"${dir !== "" ? dirSplit.pop() : projectYyp.replace(".yyp", "")}",
+    "path":"${dir !== "" ? `folders/${dir}.yy` : `${projectYyp}.yyp`}",
+  },
+  "parentObjectId":null,
+  "persistent":false,
+  "physicsAngularDamping":0.1,
+  "physicsDensity":0.5,
+  "physicsFriction":0.2,
+  "physicsGroup":1,
+  "physicsKinematic":false,
+  "physicsLinearDamping":0.1,
+  "physicsObject":false,
+  "physicsRestitution":0.1,
+  "physicsSensor":false,
+  "physicsShape":1,
+  "physicsShapePoints":[],
+  "physicsStartAwake":true,
+  "properties":[],
+  "resourceType":"GMObject",
+  "resourceVersion":"2.0",
+  "solid":false,
+  "spriteId":null,
+  "spriteMaskId":null,
+  "visible":true,
+}`;
+}
+function parseGMJson(raw) {
+  const validJson = stripTrailingCommas(raw);
+  return JSON.parse(validJson);
+}
+function createGMFolderStr(path3) {
+  const name = path3.split("/").pop();
+  return `    {"$GMFolder":"","%Name":"${name}","folderPath":"folders/${path3}.yy","name":"${name}","resourceType":"GMFolder","resourceVersion":"2.0",},`;
+}
+function createGMResourceStr(type, name) {
+  return `    {"id":{"name":"${name}","path":"${type}/${name}/${name}.yy",},},`;
+}
+function createGMEventStr(eventType, eventNum, options) {
+  return `    {"$GMEvent":"v1","%Name":"",${eventNum !== null ? `"collisionObjectId":${typeof eventNum === "string" ? eventNum : null},` : ""}"eventNum":${typeof eventNum === "number" ? eventNum : 0},"eventType":${eventType},"isDnD":${options?.isDnd ?? false},"name":"","resourceType":"GMEvent","resourceVersion":"2.0",},`;
+}
+async function createGMResource(project, filePath, intgContent, options) {
+  const pathSplit = filePath.split("/");
+  if (filePath.includes("scripts")) {
+    const yyFilePath = filePath.replace(".gml", ".yy");
+    if (!await fileExists(yyFilePath)) {
+      const yyContent = createYYScript(project["%Name"], pathSplit.at(-2), intgContent.dirPath, options);
+      try {
+        await fsRuntime.writeText(yyFilePath, yyContent);
+        return { type: "scripts", name: pathSplit.at(-2), dir: null };
+      } catch (error) {
+        console.error(`Failed to create .yy file for ${filePath}: ${error}`);
+      }
+    }
+  } else if (filePath.includes("objects")) {
+    const yyFilePath = `${pathSplit.slice(0, -1).join("/")}/${pathSplit.at(-2)}.yy`;
+    if (!await fileExists(yyFilePath)) {
+      const yyContent = createYYObject(project["%Name"], pathSplit.at(-2), intgContent.dirPath, intgContent.event ? [createGMEventStr(intgContent.event.type, intgContent.event.type === 4 /* COLLISION */ ? intgContent.event.collObj : intgContent.event.num, options)] : [], options);
+      try {
+        await fsRuntime.writeText(yyFilePath, yyContent);
+        return { type: "objects", name: pathSplit.at(-2), dir: null };
+      } catch (error) {
+        console.error(`Failed to create .yy file for ${filePath}: ${error}`);
+      }
+    } else {
+      const yyFileSplit = (await fsRuntime.readText(yyFilePath)).split(`
+`);
+      const eventStartIdx = yyFileSplit.findIndex((line) => line.includes("eventList"));
+      const eventEndIdx = yyFileSplit.findIndex((line, idx) => idx > eventStartIdx && line.includes("]"));
+      const existsEvents = yyFileSplit.slice(eventStartIdx + 1, eventEndIdx);
+      const typeNum = `${intgContent.event.type}|${intgContent.event.num}`;
+      const dupe = existsEvents.find((line) => {
+        const evNum = line.split('eventNum":')[1]?.split(",")[0];
+        const evType = line.split('eventType":')[1]?.split(",")[0];
+        return `${evType}|${evNum}` === typeNum;
+      });
+      if (!dupe) {
+        const eventStr = createGMEventStr(intgContent.event.type, intgContent.event.type === 4 /* COLLISION */ ? intgContent.event.collObj : intgContent.event.num, options);
+        yyFileSplit.splice(eventEndIdx, 0, eventStr);
+        try {
+          await fsRuntime.writeText(yyFilePath, yyFileSplit.join(`
+`));
+        } catch (error) {
+          console.error(`Failed to modify .yy file for ${filePath}: ${error}`);
+        }
+      }
+    }
+  }
+  return { type: null, name: null, dir: null };
+}
+async function removeGMResource(filePath, scanPath, intgContent) {
+  const pathSplit = filePath.split("/");
+  if (filePath.includes("scripts")) {
+    try {
+      await fsRuntime.delete(filePath);
+      await fsRuntime.delete(filePath.replace(".gml", ".yy"));
+      pathSplit.pop();
+      await deleteDir(pathSplit.join("/"), scanPath);
+      return { type: "scripts", name: pathSplit.at(-1), dir: intgContent.dirPath };
+    } catch (error) {
+      console.error(`Failed to remove resource for ${filePath}: ${error}`);
+    }
+  } else if (filePath.includes("objects")) {
+    try {
+      await fsRuntime.delete(filePath);
+      pathSplit.pop();
+      if (intgContent.isNew) {
+        await deleteDir(pathSplit.join("/"), scanPath);
+        return { type: "objects", name: pathSplit.at(-1), dir: intgContent.dirPath };
+      } else {
+        const yyFilePath = `${pathSplit.join("/")}/${pathSplit.at(-1)}.yy`;
+        const yyFileSplit = (await fsRuntime.readText(yyFilePath)).split(`
+`);
+        const eventStartIdx = yyFileSplit.findIndex((line) => line.includes("eventList"));
+        const eventEndIdx = yyFileSplit.findIndex((line, idx) => idx > eventStartIdx && line.includes("]"));
+        const existsEvents = yyFileSplit.slice(eventStartIdx + 1, eventEndIdx);
+        const typeNum = `${intgContent.event.type}|${intgContent.event.num}`;
+        const evIdx = existsEvents.findIndex((line) => {
+          const evNum = line.split('eventNum":')[1]?.split(",")[0];
+          const evType = line.split('eventType":')[1]?.split(",")[0];
+          return `${evType}|${evNum}` === typeNum;
+        });
+        if (evIdx > -1) {
+          yyFileSplit.splice(eventStartIdx + evIdx + 1, 1);
+          await fsRuntime.writeText(yyFilePath, yyFileSplit.join(`
+`));
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to remove resource for ${filePath}: ${error}`);
+    }
+  }
+  return { type: null, name: null, dir: null };
+}
+async function modifyYyProject(type, projectPath, resource = null, folder = null) {
+  const raw = await fsRuntime.readText(projectPath);
+  const rawLines = raw.split(`
+`);
+  const toAddRescs = resource !== null && !Array.isArray(resource) ? [resource] : resource;
+  const toAddFolders = folder !== null && !Array.isArray(folder) ? [folder] : folder;
+  if (type === "add") {
+    let addedFolderCnt = 0;
+    if (toAddFolders) {
+      let folderStartIdx = rawLines.findIndex((line) => line.includes("Folders"));
+      let folderEndIdx = rawLines.findIndex((line, idx) => idx >= folderStartIdx && line.includes("]"));
+      const existsFolders = folderEndIdx > folderStartIdx ? rawLines.slice(folderStartIdx + 1, folderEndIdx) : [];
+      for (const folderDir of toAddFolders) {
+        const folderSplit = folderDir.split("/");
+        for (let i = 0;i < folderSplit.length; i++) {
+          let name = "";
+          for (let j = 0;j < i + 1; j++) {
+            name += folderSplit[j] + "/";
+          }
+          name = name.slice(0, -1);
+          const dupe = existsFolders.find((line) => line.includes(`"%Name":"${name}"`));
+          if (!dupe) {
+            if (!existsFolders.length) {
+              rawLines[folderStartIdx] = '  "Folders":[';
+              rawLines.splice(folderStartIdx + 1, 0, "  ],");
+              folderEndIdx = folderStartIdx + 1;
+            }
+            rawLines.splice(folderEndIdx + addedFolderCnt, 0, createGMFolderStr(name));
+            addedFolderCnt++;
+          }
+        }
+      }
+    }
+    let addedRescCnt = 0;
+    if (toAddRescs) {
+      const rescStartIdx = rawLines.findIndex((line) => line.includes("resources"));
+      const rescEndIdx = rawLines.findIndex((line, idx) => idx > rescStartIdx && line.includes("]"));
+      const existsRescs = rawLines.slice(rescStartIdx + 1, rescEndIdx);
+      for (const resc of toAddRescs) {
+        const name = resc.split('name":"')[1].split('",')[0];
+        const dupe = existsRescs.find((line) => line.includes(`"name":"${name}"`));
+        if (!dupe) {
+          rawLines.splice(rescEndIdx + addedRescCnt, 0, resc);
+          addedRescCnt++;
+        }
+      }
+    }
+  } else {
+    if (toAddRescs) {
+      const rescStartIdx = rawLines.findIndex((line) => line.includes("resources"));
+      let rescEndIdx = rawLines.findIndex((line, idx) => idx > rescStartIdx && line.includes("]"));
+      for (const resc of toAddRescs) {
+        const [type2, name] = resc.split(",");
+        if (!type2 || !name)
+          continue;
+        const rescIdx = rawLines.findIndex((line, idx) => idx > rescStartIdx && idx < rescEndIdx && line.includes(`name":"${name}`));
+        if (rescIdx > -1) {
+          rawLines.splice(rescIdx, 1);
+          rescEndIdx--;
+        }
+      }
+    }
+  }
+  const res = rawLines.join(`
+`);
+  try {
+    await fsRuntime.writeText(projectPath, res);
+  } catch (error) {
+    console.error(`Failed to modify project: ${error}`);
+  }
+}
+// src/integration/integrate.ts
+async function integrateSourceCodes(genFile, config, projectPath) {
+  const integrations = Object.entries(genFile);
+  if (integrations.length <= 0)
+    return 0;
+  projectPath = normalizePath(resolvePath(projectPath));
+  if (!projectPath.endsWith(".yyp")) {
+    log.error(`Invalid project path: \x1B[32m${projectPath}\x1B[0m. Aborting...`);
+    return null;
+  }
+  const limit = 10;
+  const gmProject = parseGMJson(await fsRuntime.readText(projectPath));
+  const projectPathSplit = projectPath.split("/");
+  const newFolders = [];
+  const newResources = [];
+  let intgCnt = 0;
+  log.debug(`Integrating generated source codes to \x1B[34m${projectPathSplit.pop()?.replace(".yyp", "")}\x1B[0m project...`);
+  for (let i = 0;i < integrations.length; i += limit) {
+    const batch = integrations.slice(i, i + limit);
+    await Promise.all(batch.map(async (intg) => {
+      const [path3, data] = intg;
+      const relPath = path3.split("/").slice(-3).join("/");
+      const isExists = await fileExists(path3);
+      if (isExists) {
+        log.debug(`Updating \x1B[32m${relPath}\x1B[0m...`);
+      } else {
+        log.debug(`File \x1B[32m${relPath}\x1B[0m not found. Creating new resource...`);
+        const { type, name } = await createGMResource(gmProject, path3, data, config.integrationOption);
+        if (type && name) {
+          if (data.dirPath !== "")
+            newFolders.push(data.dirPath);
+          newResources.push(createGMResourceStr(type, name));
+          data.isNew = true;
+        }
+      }
+      for (const rmBody of data.toRemoves) {
+        data.content = data.content.replace(rmBody, "");
+      }
+      data.content = data.content.trim() + `
+`;
+      await fsRuntime.writeText(path3, data.content);
+      intgCnt++;
+    }));
+  }
+  log.info(`All source codes written. Please click \x1B[1mReload\x1B[0m button in the GameMaker IDE to apply changes.`);
+  if (newFolders.length > 0 || newResources.length > 0)
+    await modifyYyProject("add", projectPath, newResources, newFolders);
+  if (!config.acceptAllIntegrations) {
+    console.log("---");
+    log.info(`\x1B[34macceptAllIntegrations\x1B[0m flag is set to \x1B[33mfalse\x1B[0m in the \x1B[32mscaff.config\x1B[0m. Please review the generated source codes before integrating.`);
+    const deleteResources = [];
+    for (const [path3, data] of integrations) {
+      const pathSlice = path3.split("/");
+      const fileName = pathSlice.pop();
+      const relPath2 = pathSlice.slice(-2).join("/");
+      const relPath3 = pathSlice.slice(-3).join("/");
+      if (data.backup) {
+        const restore = !data.event ? await fsRuntime.prompt(`---
+\x1B[35m[INPUT]\x1B[0m  Revert file \x1B[34m${fileName}\x1B[0m from \x1B[32m${relPath2}\x1B[0m? (y/N) -> `) ?? "n" : await fsRuntime.prompt(`---
+\x1B[35m[INPUT]\x1B[0m  Revert \x1B[34m${data.event.name + (data.event.numStr ? `\x1B[0m:\x1B[36m${data.event.numStr}\x1B[34m` : "")} Event\x1B[0m from \x1B[32m${relPath2}\x1B[0m? (y/N) -> `) ?? "n";
+        if (restore.toLowerCase() === "y") {
+          intgCnt--;
+          await fsRuntime.writeText(path3, data.backup);
+          log.debug(`File \x1B[34m${relPath3}\x1B[0m restored to the original source code.`);
+        }
+      } else {
+        const remove = !data.event ? await fsRuntime.prompt(`---
+\x1B[35m[INPUT]\x1B[0m  Remove file \x1B[34m${fileName}\x1B[0m from \x1B[32m${relPath2}\x1B[0m? (y/N) -> `) ?? "n" : await fsRuntime.prompt(`---
+\x1B[35m[INPUT]\x1B[0m  Remove \x1B[34m${data.event.name + (data.event.numStr ? `\x1B[0m:\x1B[36m${data.event.numStr}\x1B[34m` : "")} Event\x1B[0m from \x1B[32m${relPath2}\x1B[0m? (y/N) -> `) ?? "n";
+        if (remove.toLowerCase() === "y") {
+          intgCnt--;
+          const { type, name } = await removeGMResource(path3, projectPathSplit.join("/"), data);
+          if (type && name) {
+            deleteResources.push(`${type},${name},${data.dirPath}`);
+          }
+          log.debug(`File \x1B[34m${relPath3}\x1B[0m removed from the project.`);
+        }
+      }
+    }
+    if (deleteResources.length > 0)
+      await modifyYyProject("remove", projectPath, deleteResources);
+  }
+  console.log("---");
+  if (intgCnt > 0)
+    log.info(`All source codes integrated successfully. Integrated \x1B[32m${intgCnt}\x1B[0m file(s).`);
+  return intgCnt;
+}
+// src/cli/main.ts
+async function main() {
+  const args = process.argv.slice(2);
+  const input = await parseArgs(...args);
+  if (!input)
+    return;
+  switch (input.cmd) {
+    case "generate":
+      log.debug("Getting Scaff config...");
+      const config = await getScaffConfig();
+      const files = await getScaffFiles(resolvePath(config.source));
+      log.debug("Processing files...");
+      const fileGroup = await readAndSplitFiles(files, config);
+      if (!fileGroup) {
+        log.error("Failed to process files. Aborting...");
+        return;
+      }
+      log.debug("Files processed successfully.");
+      log.debug("Getting exported modules...");
+      const module2 = getExportedModules(fileGroup, config);
+      log.debug("Exported modules retrieved successfully.");
+      log.debug("Implementing classes...");
+      const implValid = implementClass(module2, fileGroup, config);
+      if (!implValid)
+        return;
+      log.debug("Classes implemented successfully.");
+      log.debug("Implementing modules...");
+      for (const file of files) {
+        reexportModule(module2, file, config);
+      }
+      const implMods = [];
+      for (const file of files) {
+        const mod = await implementModules(module2, fileGroup, file, config);
+        implMods.push(mod);
+      }
+      if (implMods && implMods.length && implMods.every((modUsage) => modUsage && (modUsage.length === 0 || modUsage.length && modUsage.every((mm) => mm && mm.cmd)))) {
+        log.debug("Modules implemented successfully.");
+      } else {
+        log.error("Failed to implement modules. Aborting...");
+        return;
+      }
+      log.debug("Extracting integration data...");
+      const intgData = fileGroup.generate.reduce((acc, file) => {
+        const data = extractIntegrationData(file, config);
+        if (data)
+          acc.push(...data);
+        return acc;
+      }, []);
+      log.debug("Integration data extracted successfully.");
+      const genFiles = await generateSourceCode(intgData, config, input.projectPath);
+      if (!config.noIntegration && !input.options.noIntegration || input.options.integrate) {
+        log.debug("Integrating source code...");
+        const modified = await integrateSourceCodes(genFiles, config, input.projectPath);
+        if (modified === null) {
+          log.error("Failed to integrate source code. Aborting...");
+          return;
+        } else if (modified === 0) {
+          log.debug("No source code integrated.");
+          console.log("---");
+          log.info("Program executed successfully. Thanks for using ScaffScript!");
+          return;
+        } else
+          log.info("Program executed successfully. Thanks for using ScaffScript!");
+      } else {
+        console.log("---");
+        if (input.options.noIntegration)
+          log.info("\x1B[34m--no-integration\x1B[0m option is set. No source code will be integrated. Thanks for using ScaffScript!");
+        else
+          log.info("\x1B[34mnoIntegration\x1B[0m flag is set to \x1B[33mtrue\x1B[0m in the \x1B[32mscaff.config\x1B[0m. No source code will be integrated. Thanks for using ScaffScript!");
+      }
+      console.log("");
+      break;
+  }
+  console.log("");
+}
+// src/index-node.ts
+main();