@grey-ts/transpiler 0.1.0

package/dist/index.js

@@ -0,0 +1,1572 @@
+#!/usr/bin/env -S node --no-warnings --no-deprecation
+
+// src/index.ts
+import * as fs3 from "node:fs";
+import path5 from "node:path";
+
+// src/transpiler.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import ts3 from "typescript";
+
+// src/parser.ts
+import ts from "typescript";
+function parseCode(fileName, code) {
+  return ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+var parser_default = parseCode;
+
+// src/utils.ts
+import fs from "node:fs";
+import path from "node:path";
+import ts2 from "typescript";
+
+// src/replaceKeywords.ts
+var apiNameMap = {
+  "GreyHack.AptClient.addRepo": "add_repo",
+  "GreyHack.AptClient.checkUpgrade": "check_upgrade",
+  "GreyHack.AptClient.delRepo": "del_repo",
+  "GreyHack.BlockChain.amountMined": "amount_mined",
+  "GreyHack.BlockChain.coinPrice": "coin_price",
+  "GreyHack.BlockChain.createWallet": "create_wallet",
+  "GreyHack.BlockChain.deleteCoin": "delete_coin",
+  "GreyHack.BlockChain.getCoin": "get_coin",
+  "GreyHack.BlockChain.getCoinName": "get_coin_name",
+  "GreyHack.BlockChain.loginWallet": "login_wallet",
+  "GreyHack.BlockChain.showHistory": "show_history",
+  "GreyHack.Coin.createSubWallet": "create_subwallet",
+  "GreyHack.Coin.getAddress": "get_address",
+  "GreyHack.Coin.getCycleMining": "get_cycle_mining",
+  "GreyHack.Coin.getMinedCoins": "get_mined_coins",
+  "GreyHack.Coin.getReward": "get_reward",
+  "GreyHack.Coin.getSubwallet": "get_subwallet",
+  "GreyHack.Coin.getSubwallets": "get_subwallets",
+  "GreyHack.Coin.resetPassword": "reset_password",
+  "GreyHack.Coin.setAddress": "set_address",
+  "GreyHack.Coin.setCycleMining": "set_cycle_mining",
+  "GreyHack.Coin.setReward": "set_reward",
+  "GreyHack.BaseComputer.file": "File",
+  "GreyHack.Computer.activeNetCard": "active_net_card",
+  "GreyHack.Computer.changePassword": "change_password",
+  "GreyHack.Computer.closeProgram": "close_program",
+  "GreyHack.Computer.connectEthernet": "connect_ethernet",
+  "GreyHack.Computer.connectWifi": "connect_wifi",
+  "GreyHack.BaseComputer.createFolder": "create_folder",
+  "GreyHack.Computer.createGroup": "create_group",
+  "GreyHack.Computer.createUser": "create_user",
+  "GreyHack.Computer.deleteGroup": "delete_group",
+  "GreyHack.Computer.deleteUser": "delete_user",
+  "GreyHack.BaseComputer.getName": "get_name",
+  "GreyHack.Computer.getPorts": "get_ports",
+  "GreyHack.Computer.isNetworkActive": "is_network_active",
+  "GreyHack.Computer.localIp": "local_ip",
+  "GreyHack.Computer.networkDevices": "network_devices",
+  "GreyHack.Computer.networkGateway": "network_gateway",
+  "GreyHack.Computer.publicIp": "public_ip",
+  "GreyHack.Computer.showProcs": "show_procs",
+  "GreyHack.Computer.wifiNetworks": "wifi_networks",
+  "GreyHack.Crypto.isEncrypted": "is_encrypted",
+  "GreyHack.Crypto.smtpUserList": "smtp_user_list",
+  "GreyHack.Ctfevent.getCreatorName": "get_creator_name",
+  "GreyHack.Ctfevent.getDescription": "get_description",
+  "GreyHack.Ctfevent.getMailContent": "get_mail_content",
+  "GreyHack.Ctfevent.getTemplate": "get_template",
+  "GreyHack.Ctfevent.playerSuccess": "player_success",
+  "GreyHack.DebugLibrary.applyPatch": "apply_patch",
+  "GreyHack.DebugLibrary.unitTesting": "unit_testing",
+  "GreyHack.File.allowImport": "allow_import",
+  "GreyHack.File.getContent": "get_content",
+  "GreyHack.File.getFiles": "get_files",
+  "GreyHack.File.getFolders": "get_folders",
+  "GreyHack.FtpFile.getFiles": "get_files",
+  "GreyHack.FtpFile.getFolders": "get_folders",
+  "GreyHack.BaseFile.hasPermission": "has_permission",
+  "GreyHack.BaseFile.isBinary": "is_binary",
+  "GreyHack.BaseFile.isFolder": "is_folder",
+  "GreyHack.BaseFile.isSymlink": "is_symlink",
+  "GreyHack.File.setContent": "set_content",
+  "GreyHack.File.setGroup": "set_group",
+  "GreyHack.File.setOwner": "set_owner",
+  "GreyHack.activeUser": "active_user",
+  "GreyHack.clearScreen": "clear_screen",
+  "GreyHack.commandInfo": "command_info",
+  "GreyHack.currentDate": "current_date",
+  "GreyHack.currentPath": "current_path",
+  "GreyHack.formatColumns": "format_columns",
+  "GreyHack.getAbsPath": "get_abs_path",
+  "GreyHack.getCtf": "get_ctf",
+  "GreyHack.getCustomObject": "get_custom_object",
+  "GreyHack.getRouter": "get_router",
+  "GreyHack.getShell": "get_shell",
+  "GreyHack.getSwitch": "get_switch",
+  "GreyHack.homeDir": "home_dir",
+  "GreyHack.importCode": "import_code",
+  "GreyHack.includeLib": "include_lib",
+  "GreyHack.isLanIp": "is_lan_ip",
+  "GreyHack.isValidIp": "is_valid_ip",
+  "GreyHack.launchPath": "launch_path",
+  "GreyHack.mailLogin": "mail_login",
+  "GreyHack.parentPath": "parent_path",
+  "GreyHack.programPath": "program_path",
+  "GreyHack.resetCtfPassword": "reset_ctf_password",
+  "GreyHack.getType": "typeof",
+  "GreyHack.isType": "is_type",
+  "GreyHack.userBankNumber": "user_bank_number",
+  "GreyHack.userInput": "user_input",
+  "GreyHack.userMailAddress": "user_mail_address",
+  "GreyHack.MetaLib.debugTools": "debug_tools",
+  "GreyHack.MetaLib.isPatched": "is_patched",
+  "GreyHack.MetaLib.libName": "lib_name",
+  "GreyHack.Metaxploit.netUse": "net_use",
+  "GreyHack.Metaxploit.rshellClient": "rshell_client",
+  "GreyHack.Metaxploit.rshellServer": "rshell_server",
+  "GreyHack.Metaxploit.scanAddress": "scan_address",
+  "GreyHack.NetSession.dumpLib": "dump_lib",
+  "GreyHack.NetSession.floodConnection": "flood_connection",
+  "GreyHack.NetSession.getNumConnGateway": "get_num_conn_gateway",
+  "GreyHack.NetSession.getNumPortforward": "get_num_portforward",
+  "GreyHack.NetSession.getNumUsers": "get_num_users",
+  "GreyHack.NetSession.isAnyActiveUser": "is_any_active_user",
+  "GreyHack.NetSession.isRootActiveUser": "is_root_active_user",
+  "GreyHack.Port.getLanIp": "get_lan_ip",
+  "GreyHack.Port.isClosed": "is_closed",
+  "GreyHack.Port.portNumber": "port_number",
+  "GreyHack.Router.bssidName": "bssid_name",
+  "GreyHack.Router.devicePorts": "device_ports",
+  "GreyHack.Router.devicesLanIp": "devices_lan_ip",
+  "GreyHack.Router.essidName": "essid_name",
+  "GreyHack.Router.firewallRules": "firewall_rules",
+  "GreyHack.Router.kernelVersion": "kernel_version",
+  "GreyHack.Router.localIp": "local_ip",
+  "GreyHack.Router.pingPort": "ping_port",
+  "GreyHack.Router.portInfo": "port_info",
+  "GreyHack.Router.publicIp": "public_ip",
+  "GreyHack.Router.usedPorts": "used_ports",
+  "GreyHack.Service.installService": "install_service",
+  "GreyHack.Service.startService": "start_service",
+  "GreyHack.Service.stopService": "stop_service",
+  "GreyHack.Shell.connectService": "connect_service",
+  "GreyHack.Shell.hostComputer": "host_computer",
+  "GreyHack.Shell.startTerminal": "start_terminal",
+  "GreyHack.SmartAppliance.overrideSettings": "override_settings",
+  "GreyHack.SmartAppliance.setAlarm": "set_alarm",
+  "GreyHack.SubWallet.checkPassword": "check_password",
+  "GreyHack.SubWallet.getBalance": "get_balance",
+  "GreyHack.SubWallet.getInfo": "get_info",
+  "GreyHack.SubWallet.getUser": "get_user",
+  "GreyHack.SubWallet.lastTransaction": "last_transaction",
+  "GreyHack.SubWallet.setInfo": "set_info",
+  "GreyHack.SubWallet.walletUsername": "wallet_username",
+  "GreyHack.TrafficNet.cameraLinkSystem": "camera_link_system",
+  "GreyHack.TrafficNet.getCredentialsInfo": "get_credentials_info",
+  "GreyHack.TrafficNet.locateVehicle": "locate_vehicle",
+  "GreyHack.Wallet.buyCoin": "buy_coin",
+  "GreyHack.Wallet.cancelPendingTrade": "cancel_pending_trade",
+  "GreyHack.Wallet.getBalance": "get_balance",
+  "GreyHack.Wallet.getGlobalOffers": "get_global_offers",
+  "GreyHack.Wallet.getPendingTrade": "get_pending_trade",
+  "GreyHack.Wallet.getPin": "get_pin",
+  "GreyHack.Wallet.listCoins": "list_coins",
+  "GreyHack.Wallet.listGlobalCoins": "list_global_coins",
+  "GreyHack.Wallet.resetPassword": "reset_password",
+  "GreyHack.Wallet.sellCoin": "sell_coin",
+  "GreyHack.Wallet.showNodes": "show_nodes",
+  "String.isMatch": "is_match",
+  "String.toInt": "to_int",
+  "String.length": "len",
+  "Object.size": "len",
+  "Array.length": "len"
+};
+var propertyAccessReplacements = {
+  "Math.PI": "pi",
+  "Math.abs": "abs",
+  "Math.acos": "acos",
+  "Math.asin": "asin",
+  "Math.atan": "atan",
+  "Math.ceil": "ceil",
+  "Math.floor": "floor",
+  "Math.cos": "cos",
+  "Math.sin": "sin",
+  "Math.tan": "tan",
+  "Math.sqrt": "sqrt",
+  "Math.sign": "sign",
+  "Math.round": "round",
+  "Math.random": "rnd",
+  "Math.log": "log",
+  "String.prototype": "string",
+  "Number.prototype": "number",
+  "Object.prototype": "map",
+  "Array.prototype": "list",
+  "Function.prototype": "funcRef"
+};
+
+// src/utils.ts
+var knownOperators = new Set([
+  "=",
+  "+",
+  "+=",
+  "-",
+  "-=",
+  "++",
+  "--",
+  "**",
+  "&&",
+  "==",
+  "===",
+  "!=",
+  "!==",
+  "??",
+  "??=",
+  "in",
+  "||",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "*",
+  "/",
+  "%",
+  "~",
+  "&",
+  "|",
+  "^",
+  "<<",
+  ">>",
+  ">>>",
+  "instanceof"
+]);
+function getOperatorToken(node) {
+  let operatorToken = ts2.tokenToString(node.kind);
+  if (!operatorToken)
+    return null;
+  if (!knownOperators.has(operatorToken))
+    throw `Can't handle operator '${operatorToken}' yet`;
+  if (operatorToken == "||")
+    operatorToken = "or";
+  else if (operatorToken == "&&")
+    operatorToken = "and";
+  else if (operatorToken == "===")
+    operatorToken = "==";
+  else if (operatorToken == "!==")
+    operatorToken = "!=";
+  return operatorToken;
+}
+function transformString(value) {
+  value = value.replaceAll('"', '""').replaceAll(`
+`, ` \\n`);
+  return value;
+}
+function nodeIsFunctionReference(node, type) {
+  if (ts2.isCallOrNewExpression(node) || ts2.isCallOrNewExpression(node.parent) && node === node.parent.expression)
+    return false;
+  if (ts2.isFunctionLike(node))
+    return false;
+  type ??= checker.getTypeAtLocation(node);
+  if (!type.getCallSignatures().length)
+    return false;
+  return true;
+}
+function asRef(value) {
+  if (value[0] === "@")
+    return value;
+  return "@" + value;
+}
+function getSourceFiles(absPath) {
+  if (!fs.existsSync(absPath))
+    throw new Error(`File ${absPath} doesn't exist`);
+  const output = [];
+  const filePaths = [absPath];
+  while (filePaths.length) {
+    const file = filePaths.shift();
+    const stat = fs.statSync(file);
+    if (stat.isDirectory()) {
+      filePaths.push(...fs.readdirSync(file).map((name) => path.join(file, name)));
+      continue;
+    }
+    const existing = program.getSourceFile(file);
+    if (existing) {
+      output.push(existing);
+      continue;
+    }
+    const source = parser_default(file, fs.readFileSync(file, { encoding: "utf-8" }));
+    output.push(source);
+  }
+  return output;
+}
+function replaceIdentifier(original, type, propertyName) {
+  let symbol;
+  if (type.isUnion()) {
+    if (propertyName) {
+      for (const t of type.types) {
+        symbol = t.getProperty(propertyName);
+        if (symbol)
+          break;
+      }
+    } else {
+      symbol = type.types.find((t) => t.flags !== ts2.TypeFlags.Undefined && t.symbol)?.symbol;
+    }
+  } else {
+    symbol = propertyName ? type.getProperty(propertyName) : type.symbol;
+  }
+  if (!symbol)
+    return original;
+  const symbolFullName = checker.getFullyQualifiedName(symbol);
+  const replaceValue = apiNameMap[symbolFullName];
+  if (!replaceValue)
+    return original;
+  const dotIndex = symbolFullName.lastIndexOf(".");
+  const strToReplace = dotIndex !== null ? symbolFullName.slice(dotIndex + 1) : symbolFullName;
+  if (strToReplace != original)
+    return original;
+  return replaceValue;
+}
+function replacePropertyAccess(original, symbol) {
+  if (!symbol)
+    return original;
+  const symbolFullName = checker.getFullyQualifiedName(symbol);
+  const replaceValue = propertyAccessReplacements[symbolFullName];
+  if (!replaceValue || original !== symbolFullName)
+    return original;
+  return replaceValue;
+}
+function findProjectRoot(dir, fileToSearch = "package.json") {
+  while (!fs.existsSync(path.join(dir, fileToSearch))) {
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      throw new Error(`No ${fileToSearch} found`);
+    dir = parent;
+  }
+  return dir;
+}
+function callUtilFunction(functionName, ...params) {
+  calledUtilFunctions.add(functionName);
+  return `${functionName}(${params.join(", ")})`;
+}
+
+// src/transpiler.ts
+class NodeHandler {
+  static handlers = new Map;
+  static transpileContext;
+  static register(kind, handler) {
+    if (this.handlers.has(kind))
+      throw `${ts3.SyntaxKind[kind]} (${kind}) is already registered`;
+    this.handlers.set(kind, handler);
+  }
+  static handle(node) {
+    const handler = this.handlers.get(node.kind);
+    if (!handler) {
+      console.log(`Unsupported syntax ${ts3.SyntaxKind[node.kind]} (kind ${node.kind}) was not transpiled: ${node.getText()}`);
+      this.printLineAndCol(node);
+      return "null";
+    }
+    try {
+      const result = handler(node, this.transpileContext);
+      return result;
+    } catch (error) {
+      console.error(error);
+      this.printLineAndCol(node);
+      return "null";
+    }
+  }
+  static printLineAndCol(node) {
+    const source = node.getSourceFile();
+    const lineAndChar = source.getLineAndCharacterOfPosition(node.pos);
+    console.log(`At ${source.fileName}: line ${lineAndChar.line + 1}, col ${lineAndChar.character + 1}`);
+  }
+}
+NodeHandler.register(ts3.SyntaxKind.TypeAliasDeclaration, () => "");
+NodeHandler.register(ts3.SyntaxKind.InterfaceDeclaration, () => "");
+NodeHandler.register(ts3.SyntaxKind.EndOfFileToken, () => "");
+NodeHandler.register(ts3.SyntaxKind.EmptyStatement, () => "");
+var program;
+var checker;
+var anonFunctions = new Map;
+var calledUtilFunctions = new Set;
+var utilFunctions2 = {
+  get_property: [
+    "get_property = function(obj, key)",
+    "\tif not obj then return null",
+    "\tif obj.hasIndex(key) then return obj[key]",
+    "\tisaobj = obj",
+    '\twhile isaobj.hasIndex("__isa")',
+    '\t\tisaobj = obj["__isa"]',
+    "\t\tif isaobj.hasIndex(key) then",
+    "\t\t\tval = obj[key]",
+    "\t\t\treturn val",
+    "\t\tend if",
+    "\tend while",
+    "\treturn null",
+    "end function"
+  ].join(`
+`),
+  assign_objects: [
+    "assign_objects = function(target, source1, source2, source3)",
+    "\tassign_to_list = function(target, source)",
+    "\t\tif source isa list then",
+    "\t\t\tfor i in range(0, source.len - 1, 1)",
+    "\t\t\t\tif target.len <= i then target.push(null)",
+    "\t\t\t\ttarget[i] = source[i]",
+    "\t\t\tend for",
+    "\t\telse if source isa map then",
+    "\t\t\tfor item in source",
+    "\t\t\t\tkey = str(item.key).to_int",
+    "\t\t\t\tif key isa number then target[key] = item.value",
+    "\t\t\tend for",
+    "\t\tend if",
+    "\t\treturn target",
+    "\tend function",
+    "\tcounter = 0",
+    "\tassign_object = function(target, source)",
+    "\t\tif target isa list then return assign_to_list(target, source)",
+    "\t\tif source isa list then",
+    "\t\t\tfor i in range(0, source.len - 1, 1)",
+    "\t\t\t\ttarget[str(i)] = source[i]",
+    "\t\t\tend for",
+    "\t\telse if source isa map then",
+    "\t\t\tfor item in source",
+    "\t\t\t\ttarget[item.key] = item.value",
+    "\t\t\tend for",
+    "\t\telse",
+    "\t\t\ttarget[str(outer.counter)] = source",
+    "\t\t\touter.counter = outer.counter + 1",
+    "\t\tend if",
+    "\tend function",
+    "\tif source1 isa list then",
+    "\t\tif target isa list then return assign_to_list(target, source1)",
+    "\t\tfor source in source1",
+    "\t\t\tassign_object(target, source)",
+    "\t\tend for",
+    "\t\treturn target",
+    "\tend if",
+    "\tif source1 then assign_object(target, source1)",
+    "\tif source2 then assign_object(target, source2)",
+    "\tif source3 then assign_object(target, source3)",
+    "\treturn target",
+    "end function"
+  ].join(`
+`),
+  array_map: [
+    "array_map = function(array, callback)",
+    "\tindex = 0",
+    "\tout = []",
+    "\tfor item in array",
+    "\t\tout.push(callback(item, index, array))",
+    "\t\tindex = index + 1",
+    "\tend for",
+    "\treturn out",
+    "end function"
+  ].join(`
+`),
+  array_filter: [
+    "array_filter = function(array, predicate)",
+    "\tindex = 0",
+    "\tout = []",
+    "\tfor item in array",
+    "\t\tif predicate(item, index, array) then out.push(item)",
+    "\t\tindex = index + 1",
+    "\tend for",
+    "\treturn out",
+    "end function"
+  ].join(`
+`),
+  array_find: [
+    "array_find = function(array, predicate)",
+    "\tindex = 0",
+    "\tfor item in array",
+    "\t\tif predicate(item, index, array) then return item",
+    "\t\tindex = index + 1",
+    "\tend for",
+    "\treturn null",
+    "end function"
+  ].join(`
+`),
+  array_some: [
+    "array_some = function(array, predicate)",
+    "\tindex = 0",
+    "\tfor item in array",
+    "\t\tif predicate(item, index, array) then return 1",
+    "\t\tindex = index + 1",
+    "\tend for",
+    "\treturn 0",
+    "end function"
+  ].join(`
+`),
+  array_every: [
+    "array_every = function(array, predicate)",
+    "\tindex = 0",
+    "\tfor item in array",
+    "\t\tif not predicate(item, index, array) then return 0",
+    "\t\tindex = index + 1",
+    "\tend for",
+    "\treturn 1",
+    "end function"
+  ].join(`
+`),
+  array_concat: [
+    "array_concat = function(target, items)",
+    "\tout = target[0:]",
+    "\tfor item in items",
+    "\t\tif item isa list then out = out + item else out.push(item)",
+    "\tend for",
+    "\treturn out",
+    "end function"
+  ].join(`
+`),
+  math_min: [
+    "math_min = function(numbers)",
+    "\tcurr_min = null",
+    "\tfor num in numbers",
+    "\t\tif curr_min == null or num < curr_min then curr_min = num",
+    "\tend for",
+    "\treturn curr_min",
+    "end function"
+  ].join(`
+`),
+  math_max: [
+    "math_max = function(numbers)",
+    "\tcurr_max = null",
+    "\tfor num in numbers",
+    "\t\tif curr_max == null or num > curr_max then curr_max = num",
+    "\tend for",
+    "\treturn curr_max",
+    "end function"
+  ].join(`
+`),
+  nullish_coalescing_op: `nullish_coalescing_op = function(left, right)
+	if left == null then return @right
+	return @left
+end function`,
+  or_op: `or_op = function(left, right)
+	if not left then return @right
+	return @left
+end function`,
+  is_type: `is_type = function(value, type)
+	if typeof(value) == type then return 1
+	return 0
+end function`,
+  conditional_expr: `conditional_expr = function(cond, when_true, when_false)
+	if cond then return when_true
+	return when_false
+end function`
+};
+function createAnonFunction(body, params) {
+  const defaultParams = new Array(3).fill(0).map((_, i) => `param${i}`);
+  const nextName = `func_${anonFunctions.size}`;
+  const paramString = Object.assign(defaultParams, params).join(",");
+  const result = `${nextName} = function(${paramString})
+${body}
+end function`;
+  anonFunctions.set(nextName, result);
+  return { name: nextName, str: result };
+}
+function transpileProgram(entryFileRelativePath) {
+  const ctx = {
+    currentFolder: "",
+    currentFilePath: path2.resolve(process.cwd(), entryFileRelativePath),
+    namedImports: {},
+    namespaceImports: {},
+    visitedFiles: {},
+    output: []
+  };
+  NodeHandler.transpileContext = ctx;
+  ctx.currentFolder = path2.dirname(ctx.currentFilePath);
+  if (!fs2.existsSync(ctx.currentFilePath)) {
+    console.error(`Error: file '${ctx.currentFilePath}' doesn't exist`);
+    process.exit(1);
+  }
+  let start = Date.now();
+  const tsconfigPath = findProjectRoot(process.cwd(), "tsconfig.json") + "/tsconfig.json";
+  const res = ts3.readConfigFile(tsconfigPath, ts3.sys.readFile);
+  const parsed = ts3.parseJsonConfigFileContent(res.config, ts3.sys, path2.dirname(tsconfigPath));
+  if (!parsed.options.types)
+    parsed.options.types = [];
+  if (!parsed.options.types.includes("@grey-ts/types")) {
+    parsed.options.types.push("@grey-ts/types");
+  }
+  parsed.options.noLib = true;
+  program = ts3.createProgram({
+    rootNames: parsed.fileNames,
+    options: parsed.options
+  });
+  console.log(`Program creation took ${Date.now() - start} ms`);
+  start = Date.now();
+  checker = program.getTypeChecker();
+  const entry = program.getSourceFile(ctx.currentFilePath);
+  if (!entry) {
+    console.error(`Error: failed to find '${ctx.currentFilePath}' from the included sources`);
+    process.exit(1);
+  }
+  transpileSourceFile(entry, ctx);
+  if (anonFunctions.size) {
+    for (const declaration of anonFunctions.values())
+      ctx.output.unshift(declaration);
+    anonFunctions.clear();
+  }
+  if (calledUtilFunctions.size) {
+    for (const call of calledUtilFunctions.keys())
+      ctx.output.unshift(utilFunctions2[call]);
+    calledUtilFunctions.clear();
+  }
+  console.log(`Transpiling took ${Date.now() - start} ms`);
+  return ctx.output.join(`
+`);
+}
+function transpileSourceFile(sourceFile, ctx, returnResult) {
+  if (ctx.visitedFiles[sourceFile.fileName])
+    return "";
+  ctx.visitedFiles[sourceFile.fileName] = true;
+  if (sourceFile.isDeclarationFile)
+    return "";
+  if (program.isSourceFileDefaultLibrary(sourceFile) || program.isSourceFileFromExternalLibrary(sourceFile))
+    return "";
+  const prevFile = ctx.currentFilePath;
+  ctx.currentFilePath = sourceFile.fileName;
+  ctx.currentFolder = path2.dirname(sourceFile.fileName);
+  ctx.namedImports[sourceFile.fileName] = {};
+  ctx.namespaceImports[sourceFile.fileName] = new Set;
+  const output = [];
+  sourceFile.forEachChild((node) => {
+    const result = NodeHandler.handle(node);
+    if (!result)
+      return;
+    if (!returnResult)
+      ctx.output.push(result);
+    else
+      output.push(result);
+  });
+  ctx.currentFilePath = prevFile;
+  ctx.currentFolder = path2.dirname(prevFile);
+  return output.join(`
+`);
+}
+
+// src/visitors/assignments.ts
+import ts4 from "typescript";
+NodeHandler.register(ts4.SyntaxKind.PropertyAssignment, (node) => {
+  let right = NodeHandler.handle(node.initializer);
+  if (nodeIsFunctionReference(node.initializer))
+    right = asRef(right);
+  if (ts4.isNumericLiteral(node.name) || ts4.isStringLiteral(node.name) || ts4.isComputedPropertyName(node.name))
+    return `${NodeHandler.handle(node.name)}: ${right}`;
+  return `"${NodeHandler.handle(node.name)}": ${right}`;
+});
+NodeHandler.register(ts4.SyntaxKind.ShorthandPropertyAssignment, (node) => {
+  const name = NodeHandler.handle(node.name);
+  return `"${name}": ${nodeIsFunctionReference(node.name) ? asRef(name) : name}`;
+});
+NodeHandler.register(ts4.SyntaxKind.ComputedPropertyName, (node) => {
+  return NodeHandler.handle(node.expression);
+});
+
+// src/visitors/classes.ts
+import ts5 from "typescript";
+NodeHandler.register(ts5.SyntaxKind.ClassDeclaration, (node) => {
+  if (node.modifiers?.some((m) => m.kind === ts5.SyntaxKind.DeclareKeyword))
+    return "";
+  const name = node.name ? node.name.text : "anon";
+  const extensions = node.heritageClauses?.filter((h) => h.token === ts5.SyntaxKind.ExtendsKeyword);
+  let output = `${name} = {}`;
+  if (extensions && extensions.length && extensions[0].types.length)
+    output = `${name} = new ${NodeHandler.handle(extensions[0].types[0].expression)}`;
+  for (const member of node.members) {
+    if (ts5.isMethodDeclaration(member) || ts5.isConstructorDeclaration(member)) {
+      if (!member.body)
+        continue;
+      output += `
+${name}.${NodeHandler.handle(member)}`;
+    } else if (ts5.isPropertyDeclaration(member)) {
+      output += `
+${name}.${NodeHandler.handle(member)}`;
+    } else {
+      output += `
+${name}.${NodeHandler.handle(member)}`;
+    }
+  }
+  return output;
+});
+NodeHandler.register(ts5.SyntaxKind.Constructor, (node) => {
+  if (!node.body)
+    return "";
+  const params = node.parameters.map((param) => NodeHandler.handle(param)).join(", ");
+  const body = NodeHandler.handle(node.body);
+  return `constructor = function(${params})
+${body}
+	return self
+end function`;
+});
+NodeHandler.register(ts5.SyntaxKind.GetAccessor, (node) => {
+  if (!node.body)
+    return "";
+  const body = NodeHandler.handle(node.body);
+  return `${NodeHandler.handle(node.name)} = function
+${body}
+end function`;
+});
+NodeHandler.register(ts5.SyntaxKind.SetAccessor, (node) => {
+  if (!node.body)
+    return "";
+  const body = NodeHandler.handle(node.body);
+  const params = node.parameters.map((param) => NodeHandler.handle(param));
+  return `${NodeHandler.handle(node.name)} = function(${params.join(", ")})
+${body}
+end function`;
+});
+
+// src/visitors/expressions.ts
+import ts7 from "typescript";
+
+// src/callTransformer.ts
+import path3 from "node:path";
+import ts6 from "typescript";
+class CallTransformer {
+  static handlers = new Map;
+  static register(symbolFullName, handler) {
+    if (this.handlers.has(symbolFullName))
+      throw `Handler for '${symbolFullName}' was already registered`;
+    this.handlers.set(symbolFullName, handler);
+  }
+  static handle(symbolFullName, functionName, callArgs, node, ctx) {
+    const handler = this.handlers.get(symbolFullName);
+    if (!handler)
+      return null;
+    return handler(functionName, callArgs, node, ctx);
+  }
+}
+CallTransformer.register("Array.concat", (name, args) => {
+  const dotI = name.lastIndexOf(".");
+  const arrayName = name.slice(0, dotI);
+  return callUtilFunction("array_concat", arrayName, args.join(","));
+});
+CallTransformer.register("Array.map", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_map", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.filter", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_filter", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.find", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_find", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.some", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_some", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.every", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_every", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Math.min", (name, args) => {
+  return callUtilFunction("math_min", `${args.join(",")}`);
+});
+CallTransformer.register("Math.max", (name, args) => {
+  return callUtilFunction("math_max", `${args.join(",")}`);
+});
+CallTransformer.register("ObjectConstructor.hasOwn", (name, args) => {
+  if (args.length < 2)
+    throw "Invalid argument count";
+  return `${args[0]}.hasIndex(${args[1]})`;
+});
+CallTransformer.register("ObjectConstructor.assign", (name, args) => {
+  if (args.length < 2)
+    throw "Invalid argument count";
+  return callUtilFunction("assign_objects", args.join(","));
+});
+CallTransformer.register("ObjectConstructor.keys", (name, args) => {
+  return `${args[0]}.indexes`;
+});
+CallTransformer.register("GreyHack.include", (name, args, node, ctx) => {
+  if (!node.arguments.length)
+    return "";
+  const fileArg = node.arguments[0];
+  if (!ts6.isStringLiteralLike(fileArg))
+    throw "You can't include variables";
+  const absPath = path3.resolve(ctx.currentFolder, fileArg.text);
+  const sources = getSourceFiles(absPath);
+  for (const source of sources) {
+    transpileSourceFile(source, ctx);
+  }
+  return "";
+});
+
+// src/visitors/expressions.ts
+function hasRestParam(params) {
+  if (!params.length)
+    return false;
+  const lastParam = params[params.length - 1];
+  return !!(lastParam.valueDeclaration && ts7.isParameter(lastParam.valueDeclaration) && lastParam.valueDeclaration.dotDotDotToken);
+}
+function handleCallArgs(callNode, ctx) {
+  const args = callNode.arguments;
+  if (!args)
+    return [];
+  const result = [];
+  const restItems = [];
+  const restArrays = [];
+  const params = checker.getResolvedSignature(callNode)?.parameters || [];
+  const hasRestParameter = hasRestParam(params);
+  const nonRestParamCount = params.length - Number(hasRestParameter);
+  let remainingRequired = nonRestParamCount;
+  function pushArgs(...items) {
+    for (const item of items) {
+      if (remainingRequired > 0) {
+        result.push(item);
+        remainingRequired--;
+        continue;
+      }
+      restItems.push(item);
+    }
+  }
+  for (const arg of args) {
+    if (!ts7.isSpreadElement(arg)) {
+      pushArgs(NodeHandler.handle(arg));
+      continue;
+    }
+    if (ts7.isArrayLiteralExpression(arg.expression)) {
+      const arrayItems = [];
+      const outArrs = [];
+      handleArrayLiteralExpression(arg.expression, ctx, arrayItems, outArrs);
+      if (outArrs.length > 1)
+        throw "The transpiler can't handle it yet if there are nested spread elements as parameters";
+      pushArgs(...arrayItems);
+      continue;
+    }
+    const arrayName = NodeHandler.handle(arg.expression);
+    if (remainingRequired > 0) {
+      for (let i = 0;i < remainingRequired; i++) {
+        result.push(`${arrayName}[${i}]`);
+      }
+      if (hasRestParameter)
+        restArrays.push(`${arrayName}[${remainingRequired}:]`);
+      remainingRequired = 0;
+      continue;
+    }
+    if (restItems.length) {
+      restArrays.push(`[${restItems.join(",")}]`);
+      restItems.length = 0;
+    }
+    restArrays.push(arrayName);
+  }
+  if (restItems.length) {
+    if (remainingRequired > 0 || !hasRestParameter) {
+      result.push(...restItems);
+    } else {
+      const processedItems = [];
+      for (const item of restItems) {
+        if (item[0] !== "[") {
+          processedItems.push(item);
+          continue;
+        }
+        if (processedItems.length) {
+          restArrays.push(`[${processedItems.join(",")}]`);
+          processedItems.length = 0;
+        }
+        restArrays.push(item);
+      }
+      if (processedItems.length)
+        restArrays.push(`[${processedItems.join(",")}]`);
+    }
+  }
+  if (restArrays.length) {
+    result.push(restArrays.join(" + "));
+  }
+  return result;
+}
+NodeHandler.register(ts7.SyntaxKind.CallExpression, (node, ctx) => {
+  const args = handleCallArgs(node, ctx);
+  let name = NodeHandler.handle(node.expression);
+  const type = checker.getTypeAtLocation(node.expression);
+  let symbolFullName = type.symbol ? checker.getFullyQualifiedName(type.symbol) : "";
+  if (!symbolFullName || symbolFullName.startsWith("__")) {
+    const symbol = checker.getSymbolAtLocation(node.expression);
+    symbolFullName = symbol ? checker.getFullyQualifiedName(symbol) : "";
+  }
+  const transformed = CallTransformer.handle(symbolFullName, name, args, node, ctx);
+  if (transformed !== null)
+    return transformed;
+  if (name === "is_type" && !calledUtilFunctions.has("is_type")) {
+    calledUtilFunctions.add("is_type");
+  }
+  if (!args.length)
+    return name;
+  return `${name}(${args.join(", ")})`;
+});
+NodeHandler.register(ts7.SyntaxKind.NewExpression, (node, ctx) => {
+  const args = handleCallArgs(node, ctx);
+  let output = `(new ${NodeHandler.handle(node.expression)}).constructor`;
+  if (args.length)
+    output += `(${args.join(",")})`;
+  return output;
+});
+NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node) => {
+  let operatorToken = getOperatorToken(node.operatorToken) || node.operatorToken.getText();
+  if (operatorToken === "=" && ts7.isBinaryExpression(node.right) && node.right.operatorToken.kind === ts7.SyntaxKind.EqualsToken) {
+    throw "Assignment chaining is not supported";
+  }
+  let right = NodeHandler.handle(node.right);
+  if (nodeIsFunctionReference(node.right))
+    right = asRef(right);
+  if (ts7.isPropertyAccessExpression(node.left)) {
+    const leftType = checker.getTypeAtLocation(node.left.expression);
+    const symbol = leftType.getProperty(node.left.name.text);
+    if (symbol?.declarations && ts7.isSetAccessor(symbol.declarations[0])) {
+      if (operatorToken != "=") {
+        throw "Set accessor can only work with = operator for now.";
+      }
+      return `${NodeHandler.handle(node.left.expression)}.${node.left.name.text}(${right})`;
+    }
+  }
+  let left = NodeHandler.handle(node.left);
+  if (nodeIsFunctionReference(node.left))
+    left = asRef(left);
+  if (operatorToken === "or" && (ts7.isVariableDeclaration(node.parent) || ts7.isPropertyAssignment(node.parent))) {
+    return callUtilFunction("or_op", left, right);
+  }
+  if (operatorToken === "instanceof") {
+    const rightSymbol = checker.getSymbolAtLocation(node.right);
+    const classIdMember = rightSymbol?.members?.get(ts7.escapeLeadingUnderscores("classID"));
+    if (!classIdMember) {
+      throw `Can't handle this 'instanceof' operator because '${right}' doesn't have a 'classID' member, which is needed in GreyScript to check a type`;
+    }
+    const declaration = classIdMember.valueDeclaration;
+    if (!declaration || !("initializer" in declaration) || !declaration.initializer) {
+      throw `The 'classID' property of '${right}' isn't initialized`;
+    }
+    return `${left}.classID == typeof(${right})`;
+  }
+  if (operatorToken === "??") {
+    return callUtilFunction("nullish_coalescing_op", left, right);
+  } else if (operatorToken === "??=") {
+    return `${left} = ${callUtilFunction("nullish_coalescing_op", left, right)}`;
+  } else if (operatorToken === "in") {
+    return `${right}.hasIndex(${left})`;
+  } else if (operatorToken === "&") {
+    return `bitwise("&", ${left}, ${right})`;
+  } else if (operatorToken === "|") {
+    return `bitwise("|", ${left}, ${right})`;
+  } else if (operatorToken === "^") {
+    return `bitwise("^", ${left}, ${right})`;
+  } else if (operatorToken === "<<") {
+    return `bitwise("<<", ${left}, ${right})`;
+  } else if (operatorToken === ">>") {
+    return `bitwise(">>", ${left}, ${right})`;
+  } else if (operatorToken === ">>>") {
+    return `bitwise(">>>", ${left}, ${right})`;
+  }
+  if (operatorToken == "+=" || operatorToken == "-=")
+    return `${left} = ${left} ${operatorToken[0]} ${right}`;
+  if (operatorToken === "**")
+    operatorToken = "^";
+  return `${left} ${operatorToken} ${right}`;
+});
+NodeHandler.register(ts7.SyntaxKind.ParenthesizedExpression, (node) => {
+  return `(${NodeHandler.handle(node.expression)})`;
+});
+function handleUnaryExpression(node) {
+  const operand = NodeHandler.handle(node.operand);
+  const operator = ts7.tokenToString(node.operator);
+  if (operator === "++")
+    return `${operand} = ${operand} + 1`;
+  if (operator === "--")
+    return `${operand} = ${operand} - 1`;
+  if (operator === "!") {
+    if (ts7.isPrefixUnaryExpression(node.parent) && ts7.tokenToString(node.parent.operator) === "!") {
+      return `(not ${operand})`;
+    }
+    return `not ${operand}`;
+  }
+  if (operator === "-")
+    return `-${operand}`;
+  if (operator === "+")
+    return `${operand}.val()`;
+  if (operator === "~")
+    return `bitwise("~", ${operand})`;
+  throw `Couldn't handle this UnaryExpression: ${node.getText()}`;
+}
+NodeHandler.register(ts7.SyntaxKind.PrefixUnaryExpression, handleUnaryExpression);
+NodeHandler.register(ts7.SyntaxKind.PostfixUnaryExpression, handleUnaryExpression);
+function handleArrayLiteralExpression(node, ctx, itemStrings, out) {
+  itemStrings ??= [];
+  out ??= [];
+  for (const item of node.elements) {
+    if (!ts7.isSpreadElement(item)) {
+      itemStrings.push(NodeHandler.handle(item));
+      continue;
+    }
+    if (ts7.isArrayLiteralExpression(item.expression)) {
+      handleArrayLiteralExpression(item.expression, ctx, itemStrings, out);
+      continue;
+    }
+    if (itemStrings.length) {
+      out.push(`[${itemStrings.join(",")}]`);
+      itemStrings.length = 0;
+    }
+    out.push(NodeHandler.handle(item.expression));
+  }
+  if ((!out.length || itemStrings.length) && !ts7.isSpreadElement(node.parent)) {
+    out.push(`[${itemStrings.join(",")}]`);
+    itemStrings.length = 0;
+  }
+  return out.join(" + ");
+}
+NodeHandler.register(ts7.SyntaxKind.ArrayLiteralExpression, handleArrayLiteralExpression);
+NodeHandler.register(ts7.SyntaxKind.TemplateExpression, (node) => {
+  const head = NodeHandler.handle(node.head);
+  const strings = [
+    ...head ? [`"${head}"`] : [],
+    ...node.templateSpans.map((span) => NodeHandler.handle(span))
+  ];
+  const output = strings.join(" + ");
+  return output;
+});
+NodeHandler.register(ts7.SyntaxKind.TemplateHead, (node) => {
+  return transformString(node.text);
+});
+NodeHandler.register(ts7.SyntaxKind.TemplateSpan, (node) => {
+  let output = NodeHandler.handle(node.expression);
+  if (ts7.isBinaryExpression(node.expression))
+    output = `str(${output})`;
+  if (node.literal.text)
+    output += ` + "${transformString(node.literal.text)}"`;
+  return output;
+});
+NodeHandler.register(ts7.SyntaxKind.NoSubstitutionTemplateLiteral, (node) => {
+  return `"${transformString(node.text)}"`;
+});
+NodeHandler.register(ts7.SyntaxKind.ConditionalExpression, (node) => {
+  if (ts7.isCallExpression(node.whenTrue) || ts7.isCallExpression(node.whenFalse)) {
+    throw "Call expressions are not supported inside conditional expressions yet";
+  }
+  const condition = NodeHandler.handle(node.condition);
+  const whenTrue = NodeHandler.handle(node.whenTrue);
+  const whenFalse = NodeHandler.handle(node.whenFalse);
+  return callUtilFunction("conditional_expr", condition, whenTrue, whenFalse);
+});
+NodeHandler.register(ts7.SyntaxKind.ExpressionStatement, (node) => {
+  return NodeHandler.handle(node.expression);
+});
+NodeHandler.register(ts7.SyntaxKind.NonNullExpression, (node) => {
+  return NodeHandler.handle(node.expression);
+});
+NodeHandler.register(ts7.SyntaxKind.AsExpression, (node) => {
+  return NodeHandler.handle(node.expression);
+});
+NodeHandler.register(ts7.SyntaxKind.DeleteExpression, (node) => {
+  if (!ts7.isPropertyAccessExpression(node.expression))
+    throw `Cant handle delete expression for ${ts7.SyntaxKind[node.expression.kind]}`;
+  const pnode = node.expression;
+  const left = NodeHandler.handle(pnode.expression);
+  const leftType = checker.getTypeAtLocation(pnode.expression);
+  const right = replaceIdentifier(NodeHandler.handle(pnode.name), leftType, pnode.name.text);
+  return `${left}.remove(${right})`;
+});
+
+// src/visitors/functions.ts
+import ts8 from "typescript";
+function transpileFunctionBody(node) {
+  const params = node.parameters.map((param) => NodeHandler.handle(param)).join(", ");
+  const body = node.body ? NodeHandler.handle(node.body) : "";
+  return `function(${params})
+${body}
+end function`;
+}
+NodeHandler.register(ts8.SyntaxKind.Block, (node) => {
+  const output = node.statements.map((val) => {
+    let statement = NodeHandler.handle(val);
+    statement = statement.split(`
+`).map((line) => "\t" + line).join(`
+`);
+    return statement;
+  }).join(`
+`);
+  return output;
+});
+NodeHandler.register(ts8.SyntaxKind.MethodDeclaration, (node) => {
+  return `${NodeHandler.handle(node.name)} = ${transpileFunctionBody(node)}`;
+});
+NodeHandler.register(ts8.SyntaxKind.FunctionDeclaration, (node) => {
+  if (!node.body)
+    return "";
+  if (node.modifiers?.some((m) => m.kind === ts8.SyntaxKind.DeclareKeyword))
+    return "";
+  const name = node.name ? node.name.text : "anon";
+  return `${name} = ${transpileFunctionBody(node)}`;
+});
+NodeHandler.register(ts8.SyntaxKind.ArrowFunction, (node) => {
+  const params = node.parameters.map((param) => NodeHandler.handle(param));
+  const body = ts8.isBlock(node.body) ? NodeHandler.handle(node.body) : `	return ${NodeHandler.handle(node.body)}`;
+  if (ts8.isCallOrNewExpression(node.parent) || ts8.isParenthesizedExpression(node.parent)) {
+    return "@" + createAnonFunction(body, params).name;
+  }
+  if (ts8.isPropertyAssignment(node.parent) || ts8.isVariableDeclaration(node.parent) || ts8.isBinaryExpression(node.parent) || ts8.isReturnStatement(node.parent)) {
+    return `function(${params.join(", ")})
+${body}
+end function`;
+  }
+  const kind = ts8.SyntaxKind[node.parent.kind];
+  throw `This kind of arrow function is not yet supported (parent: ${kind} (${node.parent.kind}))`;
+});
+NodeHandler.register(ts8.SyntaxKind.FunctionExpression, (node) => {
+  return transpileFunctionBody(node);
+});
+
+// src/visitors/identifiers.ts
+import ts9 from "typescript";
+NodeHandler.register(ts9.SyntaxKind.Identifier, (node, ctx) => {
+  const type = checker.getTypeAtLocation(node);
+  let name = node.text;
+  if (name === "undefined")
+    return "null";
+  if (type.isUnion()) {
+    const original = node.text;
+    for (const t of type.types) {
+      name = replaceIdentifier(node.text, t);
+      if (name != original)
+        break;
+    }
+  } else {
+    name = replaceIdentifier(node.text, type);
+  }
+  if (ctx.namedImports[ctx.currentFilePath]?.[name]) {
+    name = ctx.namedImports[ctx.currentFilePath][name];
+  }
+  if (ts9.isCallOrNewExpression(node.parent) && node != node.parent.expression) {
+    if (nodeIsFunctionReference(node, type))
+      name = asRef(name);
+  }
+  return name;
+});
+NodeHandler.register(ts9.SyntaxKind.Parameter, (node) => {
+  const name = NodeHandler.handle(node.name);
+  if (!node.initializer)
+    return name;
+  return `${name} = ${NodeHandler.handle(node.initializer)}`;
+});
+NodeHandler.register(ts9.SyntaxKind.NumericLiteral, (node) => node.text);
+NodeHandler.register(ts9.SyntaxKind.StringLiteral, (node) => `"${transformString(node.text)}"`);
+NodeHandler.register(ts9.SyntaxKind.ThisKeyword, () => "self");
+NodeHandler.register(ts9.SyntaxKind.NullKeyword, () => "null");
+NodeHandler.register(ts9.SyntaxKind.UndefinedKeyword, () => "null");
+NodeHandler.register(ts9.SyntaxKind.FalseKeyword, () => "0");
+NodeHandler.register(ts9.SyntaxKind.TrueKeyword, () => "1");
+NodeHandler.register(ts9.SyntaxKind.SuperKeyword, (node) => {
+  if (ts9.isPropertyAccessExpression(node.parent))
+    return "super";
+  return "super.constructor";
+});
+NodeHandler.register(ts9.SyntaxKind.RegularExpressionLiteral, (node) => {
+  const start = node.text.indexOf("/") + 1;
+  const end = node.text.lastIndexOf("/");
+  const flags = node.text.slice(end + 1);
+  if (flags)
+    throw "Regex flags are not supported yet";
+  return `"${node.text.slice(start, end)}"`;
+});
+
+// src/visitors/imports.ts
+import path4 from "node:path";
+import ts10 from "typescript";
+function importFile(filePath, ctx, returnResult) {
+  let srcPath = path4.resolve(ctx.currentFolder, filePath);
+  if (!path4.extname(srcPath))
+    srcPath += ".ts";
+  const source = program.getSourceFile(srcPath);
+  if (!source) {
+    console.error(`Failed to find source ${srcPath}`);
+    return "";
+  }
+  return transpileSourceFile(source, ctx, returnResult);
+}
+NodeHandler.register(ts10.SyntaxKind.ImportDeclaration, (node, ctx) => {
+  if (!node.importClause) {
+    const moduleName = node.moduleSpecifier.text;
+    const transpiledFile = importFile(moduleName, ctx, true);
+    if (!transpiledFile)
+      return "";
+    const rndName = "func_" + (Date.now() * Math.random()).toString().slice(0, 6);
+    return [
+      `${rndName} = function`,
+      transpiledFile.split(`
+`).map((line) => "\t" + line).join(`
+`),
+      "end function",
+      `${rndName}()`
+    ].join(`
+`);
+  }
+  if (node.importClause.phaseModifier)
+    return "";
+  if (node.importClause.name)
+    throw `Can't import default exports yet (imported as ${node.importClause.name.text})`;
+  const bindings = node.importClause.namedBindings;
+  if (bindings) {
+    if (ts10.isNamespaceImport(bindings)) {
+      ctx.namespaceImports[ctx.currentFilePath]?.add(bindings.name.text);
+    } else {
+      bindings.elements.forEach((el) => {
+        if (!el.propertyName || el.isTypeOnly)
+          return;
+        ctx.namedImports[ctx.currentFilePath][el.name.text] = el.propertyName.text;
+      });
+    }
+  }
+  const moduleSpecifier = node.moduleSpecifier.text;
+  return importFile(moduleSpecifier, ctx);
+});
+
+// src/visitors/objects.ts
+import ts11 from "typescript";
+var assignmentOperators = new Set([
+  "=",
+  "??=",
+  "||=",
+  "-=",
+  "+="
+]);
+function valueIsBeingAssignedToNode(node) {
+  const assignAncestor = ts11.findAncestor(node, (ancestor) => {
+    if (ancestor.parent && ts11.isBinaryExpression(ancestor.parent) && ancestor === ancestor.parent.left) {
+      const token = ts11.tokenToString(ancestor.parent.operatorToken.kind) || ancestor.parent.operatorToken.getText();
+      return assignmentOperators.has(token);
+    }
+    return false;
+  });
+  return !!assignAncestor;
+}
+NodeHandler.register(ts11.SyntaxKind.PropertyAccessExpression, (node, ctx) => {
+  const left = NodeHandler.handle(node.expression);
+  let right = NodeHandler.handle(node.name);
+  right = replaceIdentifier(right, checker.getTypeAtLocation(node.expression), right);
+  const nodeSymbol = checker.getSymbolAtLocation(node);
+  if (ctx.namespaceImports[ctx.currentFilePath]?.has(left))
+    return right;
+  let getSafely = !!node.questionDotToken && !ts11.isNonNullExpression(node.parent);
+  const rightType = checker.getTypeAtLocation(node.name);
+  if (rightType.isUnion()) {
+    const hasUndefined = rightType.types.some((t) => t.flags === ts11.TypeFlags.Undefined);
+    if (hasUndefined)
+      getSafely = true;
+  }
+  if (!valueIsBeingAssignedToNode(node) && getSafely)
+    return callUtilFunction("get_property", left, `"${right}"`);
+  let output = `${left}.${right}`;
+  output = replacePropertyAccess(output, nodeSymbol);
+  if (nodeIsFunctionReference(node))
+    output = asRef(output);
+  return output;
+});
+NodeHandler.register(ts11.SyntaxKind.ElementAccessExpression, (node, ctx) => {
+  const left = NodeHandler.handle(node.expression);
+  let right;
+  if (ts11.isStringLiteral(node.argumentExpression)) {
+    const leftType = checker.getTypeAtLocation(node.expression);
+    right = `"${replaceIdentifier(node.argumentExpression.text, leftType, node.argumentExpression.text)}"`;
+  } else {
+    right = NodeHandler.handle(node.argumentExpression);
+  }
+  const asd = ts11.findAncestor(node, (ancestor) => {
+    if (ancestor.parent && ts11.isBinaryExpression(ancestor.parent) && ancestor === ancestor.parent.left) {
+      const token = ts11.tokenToString(ancestor.parent.operatorToken.kind) || ancestor.parent.operatorToken.getText();
+      return assignmentOperators.has(token);
+    }
+    return false;
+  });
+  if (!asd && !ts11.isNumericLiteral(node.argumentExpression)) {
+    return callUtilFunction("get_property", left, `${right}`);
+  }
+  return `${left}[${right}]`;
+});
+function handleObjectLiteralExpression(node, ctx, currObj, outObjects, funcs) {
+  currObj ??= [];
+  outObjects ??= [];
+  funcs ??= [];
+  const objectName = ts11.isVariableDeclaration(node.parent) ? NodeHandler.handle(node.parent.name) : ts11.isBinaryExpression(node.parent) && node === node.parent.right ? NodeHandler.handle(node.parent.left) : "";
+  function pushObj() {
+    if (!currObj?.length)
+      return "";
+    const res = currObj.filter((s) => s != "").join(",");
+    if (res) {
+      outObjects?.push(`{ ${res} }`);
+    }
+    currObj.length = 0;
+    return res;
+  }
+  for (const item of node.properties) {
+    if (ts11.isFunctionLike(item)) {
+      if (!objectName)
+        throw "You can't have method declarations inside an object that is not being assigned to a variable";
+      funcs.push(`${objectName}.${NodeHandler.handle(item)}`);
+      continue;
+    }
+    if (ts11.isPropertyAssignment(item) && ts11.isFunctionLike(item.initializer)) {
+      if (!objectName)
+        throw "You can't have method declarations inside an object that is not being assigned to a variable";
+      funcs.push(`${objectName}.${NodeHandler.handle(item.name)} = ${NodeHandler.handle(item.initializer)}`);
+      continue;
+    }
+    if (ts11.isSpreadAssignment(item)) {
+      if (ts11.isObjectLiteralExpression(item.expression)) {
+        handleObjectLiteralExpression(item.expression, ctx, currObj, outObjects);
+        continue;
+      }
+      if (ts11.isIdentifier(item.expression)) {
+        pushObj();
+        outObjects.push(NodeHandler.handle(item.expression));
+        continue;
+      }
+      if (ts11.isArrayLiteralExpression(item.expression)) {
+        pushObj();
+        outObjects.push(NodeHandler.handle(item.expression));
+        continue;
+      }
+    }
+    currObj.push(NodeHandler.handle(item));
+  }
+  pushObj();
+  if (!outObjects.length)
+    outObjects.push("{}");
+  let output = outObjects[0];
+  if (outObjects.length > 1) {
+    output = callUtilFunction("assign_objects", output, `[${outObjects.slice(1).join(",")}]`);
+  }
+  if (funcs.length) {
+    output += `
+` + funcs.join(`
+`);
+  }
+  return output;
+}
+NodeHandler.register(ts11.SyntaxKind.ObjectLiteralExpression, handleObjectLiteralExpression);
+
+// src/visitors/statements.ts
+import ts12 from "typescript";
+NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
+  if (!node.condition || !node.initializer || !node.incrementor) {
+    throw "Can't transpile this type of for loop.";
+  }
+  const initializer = NodeHandler.handle(node.initializer);
+  const condition = NodeHandler.handle(node.condition);
+  const incrementor = NodeHandler.handle(node.incrementor);
+  const statement = NodeHandler.handle(node.statement);
+  function hasContinue(n) {
+    if (n.getChildren().some((child) => {
+      if (ts12.isContinueStatement(child))
+        return true;
+      return hasContinue(child);
+    })) {
+      return true;
+    }
+    return false;
+  }
+  if (!hasContinue(node)) {
+    return [
+      `${initializer}`,
+      `while ${condition}`,
+      `	${statement.trimStart()}`,
+      `	${incrementor}`,
+      `end while`
+    ].join(`
+`);
+  }
+  const incrementedStateVarName = "state_" + (Date.now() * Math.random()).toFixed(0).slice(0, 6);
+  const output = [
+    `${incrementedStateVarName} = 1`,
+    `${initializer}`,
+    `while ${condition}`,
+    `	if not ${incrementedStateVarName} then`,
+    `		${incrementor}`,
+    `		if not ${condition} then break`,
+    `	end if`,
+    `	${incrementedStateVarName} = 0`,
+    `	${statement.trimStart()}`,
+    `	${incrementor}`,
+    `	${incrementedStateVarName} = 1`,
+    `end while`
+  ].join(`
+`);
+  return output;
+});
+NodeHandler.register(ts12.SyntaxKind.ForOfStatement, (node) => {
+  if (!ts12.isVariableDeclarationList(node.initializer)) {
+    throw `Can't handle this 'for of' statement as '${NodeHandler.handle(node.initializer)}' is not initialized there`;
+  }
+  if (node.initializer.declarations.length > 1) {
+    throw "Can't have more than 1 variable declarations in a 'for of' statement";
+  }
+  const varName = NodeHandler.handle(node.initializer.declarations[0].name);
+  const objToLoop = NodeHandler.handle(node.expression);
+  return `for ${varName} in ${objToLoop}
+${NodeHandler.handle(node.statement)}
+end for`;
+});
+NodeHandler.register(ts12.SyntaxKind.ForInStatement, (node) => {
+  if (!ts12.isVariableDeclarationList(node.initializer)) {
+    throw `Can't handle this 'for in' statement as '${NodeHandler.handle(node.initializer)}' is not initialized there`;
+  }
+  if (node.initializer.declarations.length > 1) {
+    throw "Can't have more than 1 variable declarations in a 'for in' statement";
+  }
+  const varName = NodeHandler.handle(node.initializer.declarations[0].name);
+  const objToLoop = NodeHandler.handle(node.expression);
+  return `for ${varName} in ${objToLoop}.indexes
+${NodeHandler.handle(node.statement)}
+end for`;
+});
+NodeHandler.register(ts12.SyntaxKind.IfStatement, (node) => {
+  const condition = NodeHandler.handle(node.expression);
+  const thenStatement = NodeHandler.handle(node.thenStatement);
+  if (!ts12.isBlock(node.thenStatement) && !ts12.isIfStatement(node.thenStatement) && !ts12.isIfStatement(node.parent)) {
+    if (!node.elseStatement)
+      return `if ${condition} then ${thenStatement}`;
+    else if (!ts12.isBlock(node.elseStatement) && !ts12.isIfStatement(node.elseStatement))
+      return `if ${condition} then ${thenStatement} else ${NodeHandler.handle(node.elseStatement)}`;
+  }
+  let output = `if ${condition} then
+	${thenStatement.trimStart()}`;
+  if (node.elseStatement) {
+    if (ts12.isIfStatement(node.elseStatement)) {
+      output += `
+else ${NodeHandler.handle(node.elseStatement)}`;
+      return output;
+    } else {
+      output += `
+else
+	${NodeHandler.handle(node.elseStatement).trimStart()}`;
+    }
+  }
+  output += `
+end if`;
+  return output;
+});
+NodeHandler.register(ts12.SyntaxKind.WhileStatement, (node, ctx) => {
+  const expression = NodeHandler.handle(node.expression);
+  return [
+    `while ${expression}`,
+    `	${NodeHandler.handle(node.statement).trimStart()}`,
+    `end while`
+  ].join(`
+`);
+});
+NodeHandler.register(ts12.SyntaxKind.DoStatement, (node, ctx) => {
+  const expression = NodeHandler.handle(node.expression);
+  return [
+    `did_once = 0`,
+    `while not did_once or ${expression}`,
+    `	did_once = 1`,
+    `	${NodeHandler.handle(node.statement).trimStart()}`,
+    `end while`
+  ].join(`
+`);
+});
+NodeHandler.register(ts12.SyntaxKind.ContinueStatement, (node) => {
+  return "continue";
+});
+NodeHandler.register(ts12.SyntaxKind.BreakStatement, (node) => {
+  return "break";
+});
+NodeHandler.register(ts12.SyntaxKind.ReturnStatement, (node) => {
+  if (!node.expression) {
+    if (ts12.findAncestor(node, (n) => ts12.isConstructorDeclaration(n)) && !ts12.findAncestor(node, (n) => ts12.isFunctionLike(n))) {
+      return "return self";
+    }
+    return "return";
+  }
+  return `return ${NodeHandler.handle(node.expression)}`;
+});
+
+// src/visitors/variables.ts
+import ts13 from "typescript";
+function handleVariableDeclaration(node, ctx) {
+  const left = NodeHandler.handle(node.name);
+  const initializerType = node.initializer ? checker.getTypeAtLocation(node.initializer) : undefined;
+  if (ts13.isPropertyDeclaration(node) && initializerType?.flags === ts13.TypeFlags.Object) {
+    console.warn(`You shouldn't initialize '${left}' with an Array or an Object because in GreyScript, every instantiation refers to the same '${left}' variable.
+Initialize them in the constructor instead`);
+  }
+  let right = node.initializer ? NodeHandler.handle(node.initializer) || "null" : "null";
+  if (right != "null" && nodeIsFunctionReference(node.initializer, initializerType)) {
+    right = asRef(right);
+  }
+  return `${left} = ${right}`;
+}
+NodeHandler.register(ts13.SyntaxKind.VariableDeclarationList, (node, ctx) => {
+  return node.declarations.map((decl) => handleVariableDeclaration(decl, ctx)).join(`
+`);
+});
+NodeHandler.register(ts13.SyntaxKind.VariableStatement, (node, ctx) => {
+  if (node.modifiers?.some((modifier) => modifier.kind === ts13.SyntaxKind.DeclareKeyword))
+    return "";
+  return NodeHandler.handle(node.declarationList);
+});
+NodeHandler.register(ts13.SyntaxKind.VariableDeclaration, handleVariableDeclaration);
+NodeHandler.register(ts13.SyntaxKind.PropertyDeclaration, handleVariableDeclaration);
+NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
+  const members = node.members.map((member, index) => {
+    const name = NodeHandler.handle(member.name);
+    if (member.initializer) {
+      return `${name}: ${NodeHandler.handle(member.initializer)}`;
+    }
+    const type = checker.getTypeAtLocation(member);
+    if ("value" in type) {
+      return `${name}: ${type.value}`;
+    }
+    return `${name}: ${index}`;
+  });
+  return `${node.name.text} = { ${members.join(", ")} }`;
+});
+
+// src/index.ts
+var noMoreFlags = false;
+var command = "";
+var flags = [];
+var args = [];
+for (let i = 2;i < process.argv.length; i++) {
+  const arg = process.argv[i];
+  if (arg === "--") {
+    noMoreFlags = true;
+    continue;
+  }
+  if (!command) {
+    command = arg;
+    continue;
+  }
+  if (arg.startsWith("-") && !noMoreFlags)
+    flags.push(arg);
+  else
+    args.push(arg);
+}
+var root = findProjectRoot(process.cwd());
+if (!command) {
+  console.error("No command specified.");
+  process.exit(2);
+}
+if (command === "transpile") {
+  if (!args.length) {
+    console.error("No entry file specified.");
+    process.exit(2);
+  }
+  const entryFile = args[0];
+  const output = transpileProgram(entryFile);
+  if (flags.includes("--print") || flags.includes("-p")) {
+    console.log(output);
+    process.exit(0);
+  }
+  const outDirPath = `${root}/out`;
+  if (!fs3.existsSync(outDirPath))
+    fs3.mkdirSync(outDirPath);
+  const outFileName = args.length > 1 ? args[1] : `${path5.basename(entryFile).replace(".ts", ".src")}`;
+  const outFilePath = path5.join(outDirPath, outFileName);
+  fs3.writeFileSync(outFilePath, output);
+} else {
+  console.log(`Invalid command: ${command}`);
+  process.exit(127);
+}
+export {
+  transpileProgram
+};