@grey-ts/transpiler 1.4.3 → 2.0.0

package/dist/index.js

@@ -2,16 +2,16 @@
 
 // src/index.ts
 import * as fs3 from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // src/transpiler.ts
 import * as fs2 from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import ts14 from "typescript";
 
 // src/nodeHandler.ts
+import * as path from "node:path";
 import ts from "typescript";
-
 class NodeHandler {
   static handlers = new Map;
   static transpileContext;
@@ -29,13 +29,32 @@ class NodeHandler {
     }
     try {
       const result = handler(node, this.transpileContext);
-      return result;
+      const extra = this.transpileContext.extraOutput.get(node);
+      if (!extra)
+        return result;
+      return [
+        ...extra.before ? [extra.before] : [],
+        result,
+        ...extra.after ? [extra.after] : []
+      ].join(`
+`);
     } catch (error) {
       console.error(error);
       this.printLineAndCol(node);
       return ts.isBlock(node.parent) || ts.isSourceFile(node.parent) ? "" : "null";
     }
   }
+  static addExtraOutput(node, before, after) {
+    let extra = this.transpileContext.extraOutput.get(node);
+    if (!extra) {
+      extra = { before: "", after: "" };
+      this.transpileContext.extraOutput.set(node, extra);
+    }
+    if (before)
+      extra.before += before;
+    if (after)
+      extra.after += after;
+  }
   static printLineAndCol(node) {
     const source = node.getSourceFile();
     const lineAndChar = source.getLineAndCharacterOfPosition(node.pos);
@@ -47,6 +66,29 @@ NodeHandler.register(ts.SyntaxKind.InterfaceDeclaration, () => "");
 NodeHandler.register(ts.SyntaxKind.ModuleDeclaration, () => "");
 NodeHandler.register(ts.SyntaxKind.EndOfFileToken, () => "");
 NodeHandler.register(ts.SyntaxKind.EmptyStatement, () => "");
+NodeHandler.register(ts.SyntaxKind.SourceFile, (sourceFile, ctx) => {
+  if (ctx.visitedFiles.has(sourceFile.fileName))
+    return "";
+  ctx.visitedFiles.add(sourceFile.fileName);
+  if (sourceFile.isDeclarationFile)
+    return "";
+  if (program.isSourceFileDefaultLibrary(sourceFile) || program.isSourceFileFromExternalLibrary(sourceFile))
+    return "";
+  const prevFile = ctx.currentFilePath;
+  ctx.currentFilePath = sourceFile.fileName;
+  ctx.currentFolder = path.dirname(sourceFile.fileName);
+  ctx.namedImports[sourceFile.fileName] = {};
+  ctx.namespaceImports[sourceFile.fileName] = new Set;
+  sourceFile.forEachChild((node) => {
+    const result = NodeHandler.handle(node);
+    if (!result)
+      return;
+    ctx.output.push(result);
+  });
+  ctx.currentFilePath = prevFile;
+  ctx.currentFolder = path.dirname(prevFile);
+  return "";
+});
 
 // src/parser.ts
 import ts2 from "typescript";
@@ -57,7 +99,7 @@ var parser_default = parseCode;
 
 // src/utils.ts
 import fs from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 import ts3 from "typescript";
 
 // src/replaceKeywords.ts
@@ -127,7 +169,6 @@ var apiNameMap = {
   "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",
@@ -218,26 +259,11 @@ var apiNameMap = {
   "Object.size": "len",
   "Array.length": "len",
   "Array.shift": "pull",
-  "Array.push": "push_many"
+  "Array.push": "push_many",
+  "Map.size": "data.len",
+  "Set.size": "data.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",
-  "console.log": "print",
-  "console.clear": "clear_screen",
   "String.prototype": "string",
   "Number.prototype": "number",
   "Boolean.prototype": "number",
@@ -263,6 +289,7 @@ var knownOperators = new Set([
   "!==",
   "??",
   "??=",
+  "||=",
   "in",
   "||",
   "<",
@@ -287,13 +314,13 @@ function getOperatorToken(node) {
     return null;
   if (!knownOperators.has(operatorToken))
     throw `Can't handle operator '${operatorToken}' yet`;
-  if (operatorToken == "||")
+  if (operatorToken === "||")
     operatorToken = "or";
-  else if (operatorToken == "&&")
+  else if (operatorToken === "&&")
     operatorToken = "and";
-  else if (operatorToken == "===")
+  else if (operatorToken === "===")
     operatorToken = "==";
-  else if (operatorToken == "!==")
+  else if (operatorToken === "!==")
     operatorToken = "!=";
   return operatorToken;
 }
@@ -315,7 +342,7 @@ function nodeIsFunctionReference(node, type) {
 function asRef(value) {
   if (value[0] === "@")
     return value;
-  return "@" + value;
+  return `@${value}`;
 }
 function getSourceFiles(absPath) {
   if (!fs.existsSync(absPath))
@@ -326,7 +353,7 @@ function getSourceFiles(absPath) {
     const file = filePaths.shift();
     const stat = fs.statSync(file);
     if (stat.isDirectory()) {
-      filePaths.push(...fs.readdirSync(file).map((name) => path.join(file, name)));
+      filePaths.push(...fs.readdirSync(file).map((name) => path2.join(file, name)));
       continue;
     }
     const existing = program.getSourceFile(file);
@@ -340,20 +367,16 @@ function getSourceFiles(absPath) {
   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 !== ts3.TypeFlags.Undefined && t.symbol)?.symbol;
+    let result = original;
+    for (const t of type.types) {
+      result = replaceIdentifier(original, t, propertyName);
+      if (result !== original)
+        return result;
     }
-  } else {
-    symbol = propertyName ? type.getProperty(propertyName) : type.symbol;
+    return result;
   }
+  const symbol = propertyName ? type.getProperty(propertyName) : type.symbol;
   if (!symbol)
     return original;
   const symbolFullName = checker.getFullyQualifiedName(symbol);
@@ -362,7 +385,7 @@ function replaceIdentifier(original, type, propertyName) {
     return original;
   const dotIndex = symbolFullName.lastIndexOf(".");
   const strToReplace = dotIndex !== null ? symbolFullName.slice(dotIndex + 1) : symbolFullName;
-  if (strToReplace != original)
+  if (strToReplace !== original)
     return original;
   return replaceValue;
 }
@@ -376,8 +399,8 @@ function replacePropertyAccess(original, symbol) {
   return replaceValue;
 }
 function findProjectRoot(dir, fileToSearch = "package.json") {
-  while (!fs.existsSync(path.join(dir, fileToSearch))) {
-    const parent = path.dirname(dir);
+  while (!fs.existsSync(path2.join(dir, fileToSearch))) {
+    const parent = path2.dirname(dir);
     if (parent === dir)
       throw new Error(`No ${fileToSearch} found`);
     dir = parent;
@@ -434,7 +457,7 @@ NodeHandler.register(ts5.SyntaxKind.ClassDeclaration, (node) => {
   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)
+  if (extensions?.length && extensions[0].types.length)
     output = `${name} = new ${NodeHandler.handle(extensions[0].types[0].expression)}`;
   const declaredNames = new Set;
   let hasConstructor = false;
@@ -520,7 +543,7 @@ end function`;
 import ts7 from "typescript";
 
 // src/call_transformers/callTransformer.ts
-import path2 from "node:path";
+import path3 from "node:path";
 import ts6 from "typescript";
 class CallTransformer {
   static handlers = new Map;
@@ -529,10 +552,23 @@ class CallTransformer {
       throw `Handler for '${symbolFullName}' was already registered`;
     this.handlers.set(symbolFullName, handler);
   }
-  static handle(symbolFullName, functionName, callArgs, node, ctx) {
+  static handle(type, functionName, callArgs, node, ctx) {
+    let symbolFullName = "";
+    if (type.isUnion()) {
+      let result = null;
+      for (const t of type.types) {
+        const res = CallTransformer.handle(t, functionName, callArgs, node, ctx);
+        result ??= res;
+      }
+      return result;
+    } else if (type.symbol) {
+      symbolFullName = checker.getFullyQualifiedName(type.symbol);
+    }
+    if (!symbolFullName || symbolFullName.startsWith("__")) {
+      const symbol = checker.getSymbolAtLocation(node.expression);
+      symbolFullName = symbol ? checker.getFullyQualifiedName(symbol) : "";
+    }
     if (symbolFullName in extensionFunctions) {
-      if (symbolFullName.startsWith("Math"))
-        utilitiesToInsert.set("create_math", "Math = {}");
       utilitiesToInsert.set(symbolFullName, extensionFunctions[symbolFullName]);
       const params = callArgs.length ? `(${callArgs.join(",")})` : "";
       return `${functionName}${params}`;
@@ -543,41 +579,37 @@ class CallTransformer {
     return handler(functionName, callArgs, node, ctx);
   }
 }
-CallTransformer.register("Number.toString", (name) => {
-  const number = name.slice(0, name.lastIndexOf("."));
-  return `str(${number})`;
-});
 CallTransformer.register("Function.toString", (name) => {
   const func = name.slice(0, name.lastIndexOf("."));
   return `str(@${func})`;
 });
-CallTransformer.register("GreyHack.include", (name, args, node, ctx) => {
+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 = path2.resolve(ctx.currentFolder, fileArg.text);
+  const absPath = path3.resolve(ctx.currentFolder, fileArg.text);
   const sources = getSourceFiles(absPath);
   for (const source of sources) {
-    transpileSourceFile(source, ctx);
+    NodeHandler.handle(source);
   }
   return "";
 });
-CallTransformer.register("GreyHack.isType", (name, args) => {
+CallTransformer.register("GreyHack.isType", (_name, args) => {
   return callUtilFunction("is_type", args.join(","));
 });
-CallTransformer.register("Boolean", (name, args) => {
+CallTransformer.register("Boolean", (_name, args) => {
   if (!args.length)
     return "0";
   return `(not (not ${args[0]}))`;
 });
-CallTransformer.register("Number", (name, args) => {
+CallTransformer.register("Number", (_name, args) => {
   if (!args.length)
     return "0";
   return `str(${args[0]}).val`;
 });
-CallTransformer.register("String", (name, args) => {
+CallTransformer.register("String", (_name, args) => {
   if (!args.length)
     return "";
   return `str(${args[0]})`;
@@ -670,17 +702,12 @@ function handleCallArgs(callNode, ctx) {
 }
 NodeHandler.register(ts7.SyntaxKind.CallExpression, (node, ctx) => {
   const args = handleCallArgs(node, ctx);
-  let name = NodeHandler.handle(node.expression);
+  const 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);
+  const transformed = CallTransformer.handle(type, name, args, node, ctx);
   if (transformed !== null)
     return transformed;
-  if (!args.length)
+  if (!args.length && !ts7.isParenthesizedExpression(node.expression))
     return name;
   return `${name}(${args.join(", ")})`;
 });
@@ -704,7 +731,7 @@ function shouldHaveOuterPrefix(node, operator) {
   const leftSymbol = checker.getSymbolAtLocation(node.left);
   if (!leftSymbol?.valueDeclaration)
     return false;
-  return leftSymbol.valueDeclaration.pos < functionAncestor.pos || leftSymbol.valueDeclaration.pos > functionAncestor.end;
+  return leftSymbol.valueDeclaration.end < functionAncestor.pos || leftSymbol.valueDeclaration.pos > functionAncestor.end;
 }
 function isAssignmentChain(node, operator) {
   if (!assignmentOperators.has(operator))
@@ -715,7 +742,7 @@ function isAssignmentChain(node, operator) {
     return true;
   return false;
 }
-NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node) => {
+NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node, ctx) => {
   let operatorToken = getOperatorToken(node.operatorToken) || node.operatorToken.getText();
   if (isAssignmentChain(node, operatorToken))
     throw `Assignment chaining is not supported`;
@@ -740,7 +767,7 @@ NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node) => {
   }
   let left = NodeHandler.handle(node.left);
   if (shouldHaveOuterPrefix(node, operatorToken))
-    left = "outer." + left;
+    left = `outer.${left}`;
   if (nodeIsFunctionReference(node.left))
     left = asRef(left);
   if (operatorToken === "or" && ts7.hasOnlyExpressionInitializer(node.parent)) {
@@ -752,7 +779,15 @@ NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node) => {
     case "??":
       return callUtilFunction("nullish_coalescing_op", left, right);
     case "??=":
-      return `${left} = ${callUtilFunction("nullish_coalescing_op", left, right)}`;
+    case "||=": {
+      const util = operatorToken === "??=" ? "nullish_coalescing_op" : "or_op";
+      ctx.forceSafeAccess = true;
+      let leftSafe = NodeHandler.handle(node.left);
+      ctx.forceSafeAccess = false;
+      if (nodeIsFunctionReference(node.left))
+        leftSafe = asRef(leftSafe);
+      return `${left} = ${callUtilFunction(util, leftSafe, right)}`;
+    }
     case "in":
       return `${right}.hasIndex(${left})`;
     case "&":
@@ -906,7 +941,7 @@ NodeHandler.register(ts8.SyntaxKind.Block, (node) => {
   const output = node.statements.map((val) => {
     let statement = NodeHandler.handle(val);
     statement = statement.split(`
-`).filter((s) => !!s).map((line) => "\t" + line).join(`
+`).filter((s) => !!s).map((line) => `	${line}`).join(`
 `);
     return statement;
   }).filter((s) => !!s).join(`
@@ -928,7 +963,13 @@ 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;
+    const mainNode = ts8.findAncestor(node.parent, (n) => n.parent && (ts8.isBlock(n.parent) || ts8.isSourceFile(n.parent)));
+    if (!mainNode) {
+      return `@${createAnonFunction(body, params).name}`;
+    }
+    const anon = createAnonFunction(body, params, false);
+    NodeHandler.addExtraOutput(mainNode, anon.str, null);
+    return `@${anon.name}`;
   }
   if (ts8.hasOnlyExpressionInitializer(node.parent) || ts8.isBinaryExpression(node.parent) || ts8.isReturnStatement(node.parent)) {
     return `function(${params.join(", ")})
@@ -949,20 +990,15 @@ NodeHandler.register(ts9.SyntaxKind.Identifier, (node, ctx) => {
   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);
+  name = replaceIdentifier(node.text, type);
+  const symbolFullName = type.symbol ? checker.getFullyQualifiedName(type.symbol) : "";
+  if (symbolFullName in globalObjects) {
+    utilitiesToInsert.set(symbolFullName, globalObjects[symbolFullName]);
   }
-  if (ctx.namedImports[ctx.currentFilePath]?.[name]) {
+  if (ctx.namedImports[ctx.currentFilePath] && Object.hasOwn(ctx.namedImports[ctx.currentFilePath], name)) {
     name = ctx.namedImports[ctx.currentFilePath][name];
   }
-  if (ts9.isCallOrNewExpression(node.parent) && node != node.parent.expression) {
+  if (ts9.isCallOrNewExpression(node.parent) && node !== node.parent.expression) {
     if (nodeIsFunctionReference(node, type))
       name = asRef(name);
   }
@@ -1009,35 +1045,23 @@ NodeHandler.register(ts9.SyntaxKind.RegularExpressionLiteral, (node) => {
 });
 
 // src/visitors/imports.ts
-import path3 from "node:path";
+import path4 from "node:path";
 import ts10 from "typescript";
-function importFile(filePath, ctx, returnResult) {
-  let srcPath = path3.resolve(ctx.currentFolder, filePath);
-  if (!path3.extname(srcPath))
+function importFile(filePath, ctx) {
+  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);
+  return NodeHandler.handle(source);
 }
 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(`
-`);
+    return importFile(moduleName, ctx);
   }
   if (node.importClause.phaseModifier)
     return "";
@@ -1061,37 +1085,38 @@ NodeHandler.register(ts10.SyntaxKind.ImportDeclaration, (node, ctx) => {
 
 // src/visitors/objects.ts
 import ts11 from "typescript";
-function shouldGetSafely(node) {
+function shouldGetSafely(node, ctx) {
   if (ts11.isNonNullExpression(node.parent))
     return false;
+  const callParent = ts11.findAncestor(node, (n) => n.parent && ts11.isCallExpression(n.parent) && n.parent.expression === n);
+  if (callParent)
+    return false;
+  if (ctx.forceSafeAccess)
+    return true;
   if (valueIsBeingAssignedToNode(node))
     return false;
-  if (ts11.isPropertyAccessExpression(node)) {
-    const rightType = checker.getTypeAtLocation(node.name);
-    if (!rightType.isUnion())
-      return !!node.questionDotToken;
-    const hasUndefined = rightType.types.some((t) => t.flags === ts11.TypeFlags.Undefined);
-    if (!hasUndefined)
-      return false;
-    if (!ts11.isCallExpression(node.parent))
-      return true;
-    if (node.parent.arguments.length)
-      return false;
-  } else {
+  if (ts11.isElementAccessExpression(node)) {
     if (ts11.isNumericLiteral(node.argumentExpression) && !node.questionDotToken)
       return false;
+    return true;
   }
+  const type = checker.getTypeAtLocation(node);
+  if (!type.isUnion())
+    return !!node.questionDotToken;
+  const hasNullish = type.types.some((t) => t.flags === ts11.TypeFlags.Undefined || ts11.TypeFlags.Null);
+  if (!hasNullish)
+    return false;
   return true;
 }
 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;
-  if (shouldGetSafely(node))
+  if (shouldGetSafely(node, ctx))
     return callUtilFunction("get_property", left, `"${right}"`);
+  const nodeSymbol = checker.getSymbolAtLocation(node);
   let output = `${left}.${right}`;
   output = replacePropertyAccess(output, nodeSymbol);
   if (nodeIsFunctionReference(node))
@@ -1107,7 +1132,7 @@ NodeHandler.register(ts11.SyntaxKind.ElementAccessExpression, (node, ctx) => {
   } else {
     right = NodeHandler.handle(node.argumentExpression);
   }
-  if (shouldGetSafely(node)) {
+  if (shouldGetSafely(node, ctx)) {
     return callUtilFunction("get_property", left, `${right}`);
   }
   return `${left}[${right}]`;
@@ -1124,7 +1149,7 @@ function handleObjectLiteralExpression(node, ctx, currObj, outObjects, funcs) {
   function pushObj() {
     if (!currObj?.length)
       return "";
-    const res = currObj.filter((s) => s != "").join(",");
+    const res = currObj.filter((s) => s !== "").join(",");
     if (res) {
       outObjects?.push(`{ ${res} }`);
     }
@@ -1170,8 +1195,8 @@ function handleObjectLiteralExpression(node, ctx, currObj, outObjects, funcs) {
       throw "You can't have method declarations inside an object that is not being assigned to a variable";
     }
     output += `
-` + funcs.map((func) => `${objectName}.${func}`).join(`
-`);
+${funcs.map((func) => `${objectName}.${func}`).join(`
+`)}`;
   }
   return output;
 }
@@ -1209,7 +1234,7 @@ NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
     ].join(`
 `);
   }
-  const incrementedStateVarName = "state_" + (Date.now() * Math.random()).toFixed(0).slice(0, 6);
+  const incrementedStateVarName = `state_${(Date.now() * Math.random()).toFixed(0).slice(0, 6)}`;
   const output = [
     `${incrementedStateVarName} = 1`,
     `${initializer}`,
@@ -1290,7 +1315,7 @@ else
 end if`;
   return output;
 });
-NodeHandler.register(ts12.SyntaxKind.WhileStatement, (node, ctx) => {
+NodeHandler.register(ts12.SyntaxKind.WhileStatement, (node) => {
   const expression = NodeHandler.handle(node.expression);
   const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
@@ -1301,7 +1326,7 @@ NodeHandler.register(ts12.SyntaxKind.WhileStatement, (node, ctx) => {
   ].join(`
 `);
 });
-NodeHandler.register(ts12.SyntaxKind.DoStatement, (node, ctx) => {
+NodeHandler.register(ts12.SyntaxKind.DoStatement, (node) => {
   const expression = NodeHandler.handle(node.expression);
   const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
@@ -1314,7 +1339,7 @@ NodeHandler.register(ts12.SyntaxKind.DoStatement, (node, ctx) => {
   ].join(`
 `);
 });
-NodeHandler.register(ts12.SyntaxKind.ContinueStatement, (node) => {
+NodeHandler.register(ts12.SyntaxKind.ContinueStatement, (_node) => {
   return "continue";
 });
 NodeHandler.register(ts12.SyntaxKind.BreakStatement, (node) => {
@@ -1342,7 +1367,7 @@ ${NodeHandler.handle(node.statement)}`;
 
 // src/visitors/variables.ts
 import ts13 from "typescript";
-function handleVariableDeclaration(node, ctx) {
+function handleVariableDeclaration(node) {
   const left = NodeHandler.handle(node.name);
   const initializerType = node.initializer ? checker.getTypeAtLocation(node.initializer) : undefined;
   if (ts13.isPropertyDeclaration(node) && initializerType?.flags === ts13.TypeFlags.Object && !node.modifiers?.some((mod) => mod.kind === ts13.SyntaxKind.StaticKeyword) && !ts13.isFunctionLike(node.initializer)) {
@@ -1350,16 +1375,16 @@ function handleVariableDeclaration(node, ctx) {
 Initialize them in the constructor instead`);
   }
   let right = node.initializer ? NodeHandler.handle(node.initializer) || "null" : "null";
-  if (right != "null" && nodeIsFunctionReference(node.initializer, initializerType)) {
+  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.VariableDeclarationList, (node) => {
+  return node.declarations.map((decl) => handleVariableDeclaration(decl)).join(`
 `);
 });
-NodeHandler.register(ts13.SyntaxKind.VariableStatement, (node, ctx) => {
+NodeHandler.register(ts13.SyntaxKind.VariableStatement, (node) => {
   if (node.modifiers?.some((modifier) => modifier.kind === ts13.SyntaxKind.DeclareKeyword))
     return "";
   return NodeHandler.handle(node.declarationList);
@@ -1370,7 +1395,7 @@ NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
   const members = [];
   function addMember(name, initializer) {
     members.push(`${name}: ${initializer}`);
-    if (isNaN(+initializer))
+    if (Number.isNaN(+initializer))
       return;
     members.push(`${initializer}: ${name}`);
   }
@@ -1392,51 +1417,42 @@ NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
   return `${node.name.text} = { ${members.join(", ")} }`;
 });
 
-// src/call_transformers/array.ts
-CallTransformer.register("Array.slice", (name, args) => {
-  return name.slice(0, name.lastIndexOf(".")) + `[${args[0] ?? ""}:${args[1] ?? ""}]`;
-});
-CallTransformer.register("Array.toString", (name) => {
-  const arrayName = name.slice(0, name.lastIndexOf("."));
-  return `str(${arrayName})`;
-});
-
 // src/call_transformers/object.ts
-CallTransformer.register("ObjectConstructor.hasOwn", (name, args) => {
+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) => {
+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) => {
+CallTransformer.register("ObjectConstructor.keys", (_name, args) => {
   return `${args[0]}.indexes`;
 });
-CallTransformer.register("ObjectConstructor.values", (name, args) => {
+CallTransformer.register("ObjectConstructor.values", (_name, args) => {
   return `${args[0]}.values`;
 });
-CallTransformer.register("ObjectConstructor.sum", (name, args) => {
+CallTransformer.register("ObjectConstructor.sum", (_name, args) => {
   return `${args[0]}.sum`;
 });
-CallTransformer.register("ObjectConstructor.shuffle", (name, args) => {
+CallTransformer.register("ObjectConstructor.shuffle", (_name, args) => {
   return `${args[0]}.shuffle`;
 });
-CallTransformer.register("ObjectConstructor.replace", (name, args) => {
+CallTransformer.register("ObjectConstructor.replace", (_name, args) => {
   return `${args[0]}.replace(${args.slice(1).join(",")})`;
 });
-CallTransformer.register("ObjectConstructor.remove", (name, args) => {
+CallTransformer.register("ObjectConstructor.remove", (_name, args) => {
   return `${args[0]}.remove(${args[1]})`;
 });
-CallTransformer.register("ObjectConstructor.shift", (name, args) => {
+CallTransformer.register("ObjectConstructor.shift", (_name, args) => {
   return `${args[0]}.pull`;
 });
-CallTransformer.register("ObjectConstructor.size", (name, args) => {
+CallTransformer.register("ObjectConstructor.size", (_name, args) => {
   return `${args[0]}.len`;
 });
-CallTransformer.register("ObjectConstructor.indexOf", (name, args) => {
+CallTransformer.register("ObjectConstructor.indexOf", (_name, args) => {
   return `${args[0]}.indexOf(${args[1]})`;
 });
 CallTransformer.register("Object.toString", (name) => {
@@ -1444,14 +1460,6 @@ CallTransformer.register("Object.toString", (name) => {
   return `str(${objectName})`;
 });
 
-// src/call_transformers/string.ts
-CallTransformer.register("String.slice", (name, args) => {
-  return name.slice(0, name.lastIndexOf(".")) + `[${args[0] ?? ""}:${args[1] ?? ""}]`;
-});
-CallTransformer.register("String.toString", (name) => {
-  return name.slice(0, name.lastIndexOf("."));
-});
-
 // src/transpiler.ts
 var program;
 var checker;
@@ -1594,6 +1602,12 @@ var extensionFunctions = {
     "end function"
   ].join(`
 `),
+  "Array.toString": `list.toString = function
+	return str(self)
+end function`,
+  "Array.slice": `list.slice = function(a, b)
+	return self[a:b]
+end function`,
   "String.startsWith": [
     "string.startsWith = function(search, pos = 0)",
     "\tif pos < 0 then pos = 0",
@@ -1636,6 +1650,12 @@ var extensionFunctions = {
     "end function"
   ].join(`
 `),
+  "String.toString": `string.toString = function
+	return str(self)
+end function`,
+  "String.slice": `string.slice = function(a, b)
+	return self[a:b]
+end function`,
   "Number.toFixed": [
     "number.toFixed = function(digits = 0)",
     "\tdigits = floor(digits)",
@@ -1657,23 +1677,120 @@ var extensionFunctions = {
     "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",
+  "Number.toString": `number.toString = function
+	return str(self)
+end function`,
+  "Function.toString": `funcRef.toString = function
+	return str(@self)
+end function`
+};
+var globalObjects = {
+  MapConstructor: [
+    "Map = {}",
+    "Map.constructor = function(entries)",
+    "\tself.data = {}",
+    "\tif not entries then return self",
+    "\tfor entry in entries",
+    "\t\tself.data[entry[0]] = entry[1]",
     "\tend for",
-    "\treturn curr_min",
+    "\treturn self",
+    "end function",
+    "Map.clear = function",
+    "\tfor key in self.data.indexes",
+    "\t\tself.data.remove(@key)",
+    "\tend for",
+    "end function",
+    "Map.delete = function(key)",
+    "\treturn self.data.remove(key)",
+    "end function",
+    "Map.forEach = function(callback)",
+    "\tfor item in self.data",
+    "\t\tcallback(@item.value, @item.key, self)",
+    "\tend for",
+    "end function",
+    "Map.get = function(key)",
+    "\tif not self.data.hasIndex(@key) then retun null",
+    "\treturn self.data[@key]",
+    "end function",
+    "Map.has = function(key)",
+    "\treturn self.data.hasIndex(@key)",
+    "end function",
+    "Map.set = function(key, value)",
+    "\tself.data[@key] = @value",
+    "\treturn self",
+    "end function",
+    "Map.entries = function",
+    "\tentries = []",
+    "\tfor item in self.data",
+    "\t\tentries.push([@item.key, @item.value])",
+    "\tend for",
+    "\treturn entries",
+    "end function",
+    "Map.keys = function",
+    "\treturn self.data.indexes",
+    "end function",
+    "Map.values = function",
+    "\treturn self.data.values",
+    "end function"
+  ].join(`
+`),
+  SetConstructor: [
+    "Set = {}",
+    "Set.constructor = function(values)",
+    "\tself.data = {}",
+    "\tif not values then return self",
+    "\tfor v in values",
+    "\t\tself.data[@v] = 1",
+    "\tend for",
+    "\treturn self",
+    "end function",
+    "Set.add = function(value)",
+    "\tself.data[@value] = 1",
+    "\treturn self",
+    "end function",
+    "Set.clear = function",
+    "\tfor key in self.data.indexes",
+    "\t\tself.data.remove(@key)",
+    "\tend for",
+    "end function",
+    "Set.delete = function(key)",
+    "\treturn self.data.remove(key)",
+    "end function",
+    "Set.forEach = function(callback)",
+    "\tfor key in self.data.indexes",
+    "\t\tcallback(@key, self)",
+    "\tend for",
+    "end function",
+    "Set.has = function(key)",
+    "\treturn self.data.hasIndex(@key)",
+    "end function",
+    "Set.values = function",
+    "\treturn self.data.indexes",
     "end function"
   ].join(`
 `),
-  "Math.max": [
+  Math: [
+    'Math = { "PI": @pi, "abs": @abs, "acos": @acos, "asin": @asin, "atan": @atan, "ceil": @ceil, "floor": @floor, "cos": @cos, "sin": @sin, "tan": @tan, "sqrt": @sqrt, "sign": @sign, "round": @round, "random": @rnd, "log": @log }',
     "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",
+    "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(`
+`),
+  Console: [
+    'console = { "clear": @clear_screen }',
+    "console.log = function(data)",
+    '\tprint(data.join(", "))',
     "end function"
   ].join(`
 `)
@@ -1743,50 +1860,57 @@ var utilFunctions = {
   ].join(`
 `),
   nullish_coalescing_op: `nullish_coalescing_op = function(left, right)
-	if left == null then return @right
+	if @left == null then return @right
 	return @left
 end function`,
   or_op: `or_op = function(left, right)
-	if not left then return @right
+	if not @left then return @right
 	return @left
 end function`,
   is_type: `is_type = function(value, type)
-	return typeof(value) == type
+	return typeof(@value) == type
 end function`,
   conditional_expr: `conditional_expr = function(cond, when_true, when_false)
-	if cond then return when_true
-	return when_false
+	if cond then return @when_true
+	return @when_false
 end function`
 };
-function createAnonFunction(body, params) {
+var anonFunctionsCreated = 0;
+function createAnonFunction(body, params, insertToUtils = true) {
   const defaultParams = new Array(3).fill(0).map((_, i) => `param${i}`);
-  const nextName = `func_${utilitiesToInsert.size}`;
+  const nextName = `func_${anonFunctionsCreated}`;
   const paramString = Object.assign(defaultParams, params).join(",");
   const result = `${nextName} = function(${paramString})
 ${body}
 end function`;
-  utilitiesToInsert.set(nextName, result);
+  anonFunctionsCreated++;
+  if (insertToUtils)
+    utilitiesToInsert.set(nextName, result);
   return { name: nextName, str: result };
 }
-function transpileProgram(entryFileRelativePath) {
-  const ctx = {
-    currentFolder: "",
-    currentFilePath: path4.resolve(process.cwd(), entryFileRelativePath),
+function createContext(currentFileName = "file.ts") {
+  return {
+    currentFolder: process.cwd(),
+    currentFilePath: path5.resolve(process.cwd(), currentFileName),
     namedImports: {},
     namespaceImports: {},
-    visitedFiles: {},
-    output: []
+    visitedFiles: new Set,
+    output: [],
+    extraOutput: new Map
   };
+}
+function transpileProgram(entryFileRelativePath) {
+  const ctx = createContext(entryFileRelativePath);
   NodeHandler.transpileContext = ctx;
-  ctx.currentFolder = path4.dirname(ctx.currentFilePath);
+  ctx.currentFolder = path5.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 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));
+  const parsed = ts14.parseJsonConfigFileContent(res.config, ts14.sys, path5.dirname(tsconfigPath));
   if (!parsed.options.types)
     parsed.options.types = [];
   if (!parsed.options.types.includes("@grey-ts/types")) {
@@ -1805,7 +1929,7 @@ function transpileProgram(entryFileRelativePath) {
     console.error(`Error: failed to find '${ctx.currentFilePath}' from the included sources`);
     process.exit(1);
   }
-  transpileSourceFile(entry, ctx);
+  NodeHandler.handle(entry);
   if (utilitiesToInsert.size) {
     ctx.output.unshift(...utilitiesToInsert.values());
     utilitiesToInsert.clear();
@@ -1813,34 +1937,6 @@ function transpileProgram(entryFileRelativePath) {
   console.log(`Transpiling took ${Date.now() - start} ms`);
   return ctx.output;
 }
-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 = 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);
-  });
-  ctx.currentFilePath = prevFile;
-  ctx.currentFolder = path4.dirname(prevFile);
-  return output.join(`
-`);
-}
 
 // src/index.ts
 var noMoreFlags = false;
@@ -1872,7 +1968,7 @@ function createOutputFile(fileIndex, basename, content) {
   if (fileIndex > 0)
     basename = `${basename}-${fileIndex}`;
   const outFileName = args.length > 1 ? args[1] : `${basename}.src`;
-  const outFilePath = path5.join(outDirPath, outFileName);
+  const outFilePath = path6.join(outDirPath, outFileName);
   fs3.writeFileSync(outFilePath, content);
 }
 if (command === "transpile") {
@@ -1881,7 +1977,7 @@ if (command === "transpile") {
     process.exit(2);
   }
   const entryFile = args[0];
-  const basename = path5.basename(entryFile, ".ts");
+  const basename = path6.basename(entryFile, ".ts");
   const transpiledStatements = transpileProgram(entryFile);
   if (flags.includes("--print") || flags.includes("-p")) {
     console.log(transpiledStatements.join(`
@@ -1899,7 +1995,7 @@ if (command === "transpile") {
       content = "";
       continue;
     }
-    content += statement + `
+    content += `${statement}
 `;
   }
   if (content.length)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grey-ts/transpiler",
-	"version": "1.4.3",
+	"version": "2.0.0",
 	"description": "Transpiles TypeScript into GreyScript",
 	"author": "Okka",
 	"module": "src/index.ts",
@@ -31,14 +31,15 @@
 	],
 	"scripts": {
 		"prepare": "bun run build",
-		"build": "bun run scripts/build.ts"
+		"build": "bun test --only-failures && bun run scripts/build.ts"
 	},
 	"devDependencies": {
-		"@types/bun": "latest",
-		"@grey-ts/types": "latest"
+		"@biomejs/biome": "2.3.14",
+		"@grey-ts/types": "^3.0.0",
+		"@types/bun": "latest"
 	},
 	"peerDependencies": {
-		"typescript": "^5",
+		"typescript": "^5.9.3",
 		"@grey-ts/types": "^2.2.0"
 	}
 }