@grey-ts/transpiler 0.3.0 → 0.3.2

package/dist/index.js

@@ -6,20 +6,58 @@ import path5 from "node:path";
 
 // src/transpiler.ts
 import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import ts3 from "typescript";
+import * as path4 from "node:path";
+import ts14 from "typescript";
 
-// src/parser.ts
+// src/nodeHandler.ts
 import ts from "typescript";
+
+class NodeHandler {
+  static handlers = new Map;
+  static transpileContext;
+  static register(kind, handler) {
+    if (this.handlers.has(kind))
+      throw `${ts.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 ${ts.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(ts.SyntaxKind.TypeAliasDeclaration, () => "");
+NodeHandler.register(ts.SyntaxKind.InterfaceDeclaration, () => "");
+NodeHandler.register(ts.SyntaxKind.EndOfFileToken, () => "");
+NodeHandler.register(ts.SyntaxKind.EmptyStatement, () => "");
+
+// src/parser.ts
+import ts2 from "typescript";
 function parseCode(fileName, code) {
-  return ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  return ts2.createSourceFile(fileName, code, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
 }
 var parser_default = parseCode;
 
 // src/utils.ts
 import fs from "node:fs";
 import path from "node:path";
-import ts2 from "typescript";
+import ts3 from "typescript";
 
 // src/replaceKeywords.ts
 var apiNameMap = {
@@ -240,7 +278,7 @@ var knownOperators = new Set([
   "instanceof"
 ]);
 function getOperatorToken(node) {
-  let operatorToken = ts2.tokenToString(node.kind);
+  let operatorToken = ts3.tokenToString(node.kind);
   if (!operatorToken)
     return null;
   if (!knownOperators.has(operatorToken))
@@ -261,9 +299,9 @@ function transformString(value) {
   return value;
 }
 function nodeIsFunctionReference(node, type) {
-  if (ts2.isCallOrNewExpression(node) || ts2.isCallOrNewExpression(node.parent) && node === node.parent.expression)
+  if (ts3.isCallOrNewExpression(node) || ts3.isCallOrNewExpression(node.parent) && node === node.parent.expression)
     return false;
-  if (ts2.isFunctionLike(node))
+  if (ts3.isFunctionLike(node))
     return false;
   type ??= checker.getTypeAtLocation(node);
   if (!type.getCallSignatures().length)
@@ -307,7 +345,7 @@ function replaceIdentifier(original, type, propertyName) {
           break;
       }
     } else {
-      symbol = type.types.find((t) => t.flags !== ts2.TypeFlags.Undefined && t.symbol)?.symbol;
+      symbol = type.types.find((t) => t.flags !== ts3.TypeFlags.Undefined && t.symbol)?.symbol;
     }
   } else {
     symbol = propertyName ? type.getProperty(propertyName) : type.symbol;
@@ -347,443 +385,96 @@ function callUtilFunction(functionName, ...params) {
   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";
+// 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)}`;
     }
   }
-  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(`
-`),
-  array_push: [
-    "array_push = function(target, items)",
-    "\tfor item in items",
-    "\t\ttarget.push(item)",
-    "\tend for",
-    "\treturn target.len",
-    "end function"
-  ].join(`
-`),
-  array_unshift: [
-    "array_unshift = function(target, items)",
-    "\tif not items.len then return target.len",
-    "\tfor i in range(items.len-1)",
-    "\t\ttarget.insert(0, items[i])",
-    "\tend for",
-    "\treturn target.len",
-    "end function"
-  ].join(`
-`),
-  array_reverse: `array_reverse = function(arr)
-	arr.reverse
-	return arr
-end function`,
-  str_starts_with: [
-    "str_starts_with = function(str, search, pos = 0)",
-    "\tif pos < 0 then pos = 0",
-    "\treturn str.indexOf(search) == pos",
-    "end function"
-  ].join(`
-`),
-  str_ends_with: [
-    "str_ends_with = function(str, search, pos = null)",
-    "\tif pos == null then pos = str.len",
-    "\tif pos < 0 then pos = 0",
-    "\treturn str.indexOf(search) + search.len == pos",
-    "end function"
-  ].join(`
-`),
-  str_repeat: [
-    "str_repeat = function(str, count = 0)",
-    '\tif count <= 0 then return ""',
-    "\tif count == 1 then return str",
-    "\tout = str",
-    "\tfor i in range(count-2)",
-    "\t\tout = out + str",
-    "\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 `set_${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);
+  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 `set_${NodeHandler.handle(node.name)} = function(${params.join(", ")})
+${body}
+end function`;
+});
+
+// src/visitors/expressions.ts
+import ts7 from "typescript";
+
+// src/callTransformer.ts
+import path2 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) => {
@@ -897,7 +588,7 @@ CallTransformer.register("GreyHack.include", (name, args, node, ctx) => {
   const fileArg = node.arguments[0];
   if (!ts6.isStringLiteralLike(fileArg))
     throw "You can't include variables";
-  const absPath = path3.resolve(ctx.currentFolder, fileArg.text);
+  const absPath = path2.resolve(ctx.currentFolder, fileArg.text);
   const sources = getSourceFiles(absPath);
   for (const source of sources) {
     transpileSourceFile(source, ctx);
@@ -938,19 +629,19 @@ function handleCallArgs(callNode, ctx) {
   const hasRestParameter = hasRestParam(params);
   const nonRestParamCount = params.length - Number(hasRestParameter);
   let remainingRequired = nonRestParamCount;
-  function pushArgs(...items) {
+  function pushArgs(fromSpread, ...items) {
     for (const item of items) {
       if (remainingRequired > 0) {
         result.push(item);
         remainingRequired--;
         continue;
       }
-      restItems.push(item);
+      restItems.push({ text: item, fromSpread });
     }
   }
   for (const arg of args) {
     if (!ts7.isSpreadElement(arg)) {
-      pushArgs(NodeHandler.handle(arg));
+      pushArgs(false, NodeHandler.handle(arg));
       continue;
     }
     if (ts7.isArrayLiteralExpression(arg.expression)) {
@@ -959,7 +650,7 @@ function handleCallArgs(callNode, ctx) {
       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);
+      pushArgs(true, ...arrayItems);
       continue;
     }
     const arrayName = NodeHandler.handle(arg.expression);
@@ -973,26 +664,26 @@ function handleCallArgs(callNode, ctx) {
       continue;
     }
     if (restItems.length) {
-      restArrays.push(`[${restItems.join(",")}]`);
+      restArrays.push(`[${restItems.map((el) => el.text).join(",")}]`);
       restItems.length = 0;
     }
     restArrays.push(arrayName);
   }
   if (restItems.length) {
     if (remainingRequired > 0 || !hasRestParameter) {
-      result.push(...restItems);
+      result.push(...restItems.map((el) => el.text));
     } else {
       const processedItems = [];
       for (const item of restItems) {
-        if (item[0] !== "[") {
-          processedItems.push(item);
+        if (!item.fromSpread || !item.text.startsWith("[") || !item.text.endsWith("]")) {
+          processedItems.push(item.text);
           continue;
         }
         if (processedItems.length) {
           restArrays.push(`[${processedItems.join(",")}]`);
           processedItems.length = 0;
         }
-        restArrays.push(item);
+        restArrays.push(item.text);
       }
       if (processedItems.length)
         restArrays.push(`[${processedItems.join(",")}]`);
@@ -1115,7 +806,7 @@ function handleUnaryExpression(node) {
   if (operator === "-")
     return `-${operand}`;
   if (operator === "+")
-    return `${operand}.val()`;
+    return `str(${operand}).val()`;
   if (operator === "~")
     return `bitwise("~", ${operand})`;
   throw `Couldn't handle this UnaryExpression: ${node.getText()}`;
@@ -1301,11 +992,11 @@ NodeHandler.register(ts9.SyntaxKind.RegularExpressionLiteral, (node) => {
 });
 
 // src/visitors/imports.ts
-import path4 from "node:path";
+import path3 from "node:path";
 import ts10 from "typescript";
 function importFile(filePath, ctx, returnResult) {
-  let srcPath = path4.resolve(ctx.currentFolder, filePath);
-  if (!path4.extname(srcPath))
+  let srcPath = path3.resolve(ctx.currentFolder, filePath);
+  if (!path3.extname(srcPath))
     srcPath += ".ts";
   const source = program.getSourceFile(srcPath);
   if (!source) {
@@ -1471,186 +1162,499 @@ function handleObjectLiteralExpression(node, ctx, currObj, outObjects, funcs) {
 ` + funcs.join(`
 `);
   }
-  return output;
-}
-NodeHandler.register(ts11.SyntaxKind.ObjectLiteralExpression, handleObjectLiteralExpression);
+  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/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.";
+// 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`);
   }
-  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;
+  let right = node.initializer ? NodeHandler.handle(node.initializer) || "null" : "null";
+  if (right != "null" && nodeIsFunctionReference(node.initializer, initializerType)) {
+    right = asRef(right);
   }
-  if (!hasContinue(node)) {
-    return [
-      `${initializer}`,
-      `while ${condition}`,
-      `	${statement.trimStart()}`,
-      `	${incrementor}`,
-      `end while`
-    ].join(`
+  return `${left} = ${right}`;
+}
+NodeHandler.register(ts13.SyntaxKind.VariableDeclarationList, (node, ctx) => {
+  return node.declarations.map((decl) => handleVariableDeclaration(decl, ctx)).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`
+});
+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/transpiler.ts
+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(`
+`),
+  array_push: [
+    "array_push = function(target, items)",
+    "\tfor item in items[:]",
+    "\t\ttarget.push(@item)",
+    "\tend for",
+    "\treturn target.len",
+    "end function"
+  ].join(`
+`),
+  array_unshift: [
+    "array_unshift = function(target, items)",
+    "\tif not items.len then return target.len",
+    "\tfor i in range(items.len-1)",
+    "\t\ttarget.insert(0, @items[i])",
+    "\tend for",
+    "\treturn target.len",
+    "end function"
+  ].join(`
+`),
+  array_reverse: `array_reverse = function(arr)
+	arr.reverse
+	return arr
+end function`,
+  str_starts_with: [
+    "str_starts_with = function(str, search, pos = 0)",
+    "\tif pos < 0 then pos = 0",
+    "\treturn str.indexOf(search) == pos",
+    "end function"
   ].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";
+`),
+  str_ends_with: [
+    "str_ends_with = function(str, search, pos = null)",
+    "\tif pos == null then pos = str.len",
+    "\tif pos < 0 then pos = 0",
+    "\treturn str.indexOf(search) + search.len == pos",
+    "end function"
+  ].join(`
+`),
+  str_repeat: [
+    "str_repeat = function(str, count = 0)",
+    '\tif count <= 0 then return ""',
+    "\tif count == 1 then return str",
+    "\tout = str",
+    "\tfor i in range(count-2)",
+    "\t\tout = out + str",
+    "\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: path4.resolve(process.cwd(), entryFileRelativePath),
+    namedImports: {},
+    namespaceImports: {},
+    visitedFiles: {},
+    output: []
+  };
+  NodeHandler.transpileContext = ctx;
+  ctx.currentFolder = path4.dirname(ctx.currentFilePath);
+  if (!fs2.existsSync(ctx.currentFilePath)) {
+    console.error(`Error: file '${ctx.currentFilePath}' doesn't exist`);
+    process.exit(1);
   }
-  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`;
+  let start = Date.now();
+  const tsconfigPath = findProjectRoot(process.cwd(), "tsconfig.json") + "/tsconfig.json";
+  const res = ts14.readConfigFile(tsconfigPath, ts14.sys.readFile);
+  const parsed = ts14.parseJsonConfigFileContent(res.config, ts14.sys, path4.dirname(tsconfigPath));
+  if (!parsed.options.types)
+    parsed.options.types = [];
+  if (!parsed.options.types.includes("@grey-ts/types")) {
+    parsed.options.types.push("@grey-ts/types");
   }
-  if (node.initializer.declarations.length > 1) {
-    throw "Can't have more than 1 variable declarations in a 'for in' statement";
+  parsed.options.noLib = true;
+  program = ts14.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);
   }
-  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)}`;
+  transpileSourceFile(entry, ctx);
+  if (anonFunctions.size) {
+    for (const declaration of anonFunctions.values())
+      ctx.output.unshift(declaration);
+    anonFunctions.clear();
   }
-  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()}`;
-    }
+  if (calledUtilFunctions.size) {
+    for (const call of calledUtilFunctions.keys())
+      ctx.output.unshift(utilFunctions2[call]);
+    calledUtilFunctions.clear();
   }
-  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(`
+  console.log(`Transpiling took ${Date.now() - start} ms`);
+  return ctx.output.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))
+function transpileSourceFile(sourceFile, ctx, returnResult) {
+  if (ctx.visitedFiles[sourceFile.fileName])
     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}`;
+  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 = path4.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);
   });
-  return `${node.name.text} = { ${members.join(", ")} }`;
-});
+  ctx.currentFilePath = prevFile;
+  ctx.currentFolder = path4.dirname(prevFile);
+  return output.join(`
+`);
+}
 
 // src/index.ts
 var noMoreFlags = false;