@grey-ts/transpiler 1.2.0 → 1.4.0

package/dist/index.js

@@ -25,7 +25,7 @@ class NodeHandler {
     if (!handler) {
       console.log(`Unsupported syntax ${ts.SyntaxKind[node.kind]} (kind ${node.kind}) was not transpiled: ${node.getText()}`);
       this.printLineAndCol(node);
-      return "null";
+      return ts.isBlock(node.parent) || ts.isSourceFile(node.parent) ? "" : "null";
     }
     try {
       const result = handler(node, this.transpileContext);
@@ -33,7 +33,7 @@ class NodeHandler {
     } catch (error) {
       console.error(error);
       this.printLineAndCol(node);
-      return "null";
+      return ts.isBlock(node.parent) || ts.isSourceFile(node.parent) ? "" : "null";
     }
   }
   static printLineAndCol(node) {
@@ -149,7 +149,6 @@ var apiNameMap = {
   "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",
@@ -215,9 +214,11 @@ var apiNameMap = {
   "String.length": "len",
   "String.toLowerCase": "lower",
   "String.toUpperCase": "upper",
+  "String.repeat": "repeatSelf",
   "Object.size": "len",
   "Array.length": "len",
-  "Array.shift": "pull"
+  "Array.shift": "pull",
+  "Array.push": "push_many"
 };
 var propertyAccessReplacements = {
   "Math.PI": "pi",
@@ -384,9 +385,28 @@ function findProjectRoot(dir, fileToSearch = "package.json") {
   return dir;
 }
 function callUtilFunction(functionName, ...params) {
-  calledUtilFunctions.add(functionName);
+  utilitiesToInsert.set(functionName, utilFunctions[functionName]);
   return `${functionName}(${params.join(", ")})`;
 }
+var assignmentOperators = new Set([
+  "=",
+  "??=",
+  "||=",
+  "-=",
+  "+="
+]);
+function valueIsBeingAssignedToNode(node) {
+  if (ts3.hasOnlyExpressionInitializer(node.parent) && node === node.parent.name)
+    return true;
+  const assignAncestor = ts3.findAncestor(node, (ancestor) => {
+    if (ancestor.parent && ts3.isBinaryExpression(ancestor.parent) && ancestor === ancestor.parent.left) {
+      const token = ts3.tokenToString(ancestor.parent.operatorToken.kind) || ancestor.parent.operatorToken.getText();
+      return assignmentOperators.has(token);
+    }
+    return false;
+  });
+  return !!assignAncestor;
+}
 
 // src/visitors/assignments.ts
 import ts4 from "typescript";
@@ -495,7 +515,7 @@ end function`;
 });
 
 // src/visitors/expressions.ts
-import ts8 from "typescript";
+import ts7 from "typescript";
 
 // src/call_transformers/callTransformer.ts
 import path2 from "node:path";
@@ -508,6 +528,13 @@ class CallTransformer {
     this.handlers.set(symbolFullName, handler);
   }
   static handle(symbolFullName, functionName, callArgs, node, ctx) {
+    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}`;
+    }
     const handler = this.handlers.get(symbolFullName);
     if (!handler)
       return null;
@@ -522,12 +549,6 @@ CallTransformer.register("Function.toString", (name) => {
   const func = name.slice(0, name.lastIndexOf("."));
   return `str(@${func})`;
 });
-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("GreyHack.include", (name, args, node, ctx) => {
   if (!node.arguments.length)
     return "";
@@ -541,6 +562,9 @@ CallTransformer.register("GreyHack.include", (name, args, node, ctx) => {
   }
   return "";
 });
+CallTransformer.register("GreyHack.isType", (name, args) => {
+  return callUtilFunction("is_type", args.join(","));
+});
 CallTransformer.register("Boolean", (name, args) => {
   if (!args.length)
     return "0";
@@ -557,129 +581,12 @@ CallTransformer.register("String", (name, args) => {
   return `str(${args[0]})`;
 });
 
-// src/visitors/objects.ts
-import ts7 from "typescript";
-var assignmentOperators = new Set([
-  "=",
-  "??=",
-  "||=",
-  "-=",
-  "+="
-]);
-function valueIsBeingAssignedToNode(node) {
-  const assignAncestor = ts7.findAncestor(node, (ancestor) => {
-    if (ancestor.parent && ts7.isBinaryExpression(ancestor.parent) && ancestor === ancestor.parent.left) {
-      const token = ts7.tokenToString(ancestor.parent.operatorToken.kind) || ancestor.parent.operatorToken.getText();
-      return assignmentOperators.has(token);
-    }
-    return false;
-  });
-  return !!assignAncestor;
-}
-NodeHandler.register(ts7.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 && !ts7.isNonNullExpression(node.parent);
-  const rightType = checker.getTypeAtLocation(node.name);
-  if (rightType.isUnion()) {
-    const hasUndefined = rightType.types.some((t) => t.flags === ts7.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(ts7.SyntaxKind.ElementAccessExpression, (node, ctx) => {
-  const left = NodeHandler.handle(node.expression);
-  let right;
-  if (ts7.isStringLiteral(node.argumentExpression)) {
-    const leftType = checker.getTypeAtLocation(node.expression);
-    right = `"${replaceIdentifier(node.argumentExpression.text, leftType, node.argumentExpression.text)}"`;
-  } else {
-    right = NodeHandler.handle(node.argumentExpression);
-  }
-  if (!valueIsBeingAssignedToNode(node) && !ts7.isNumericLiteral(node.argumentExpression)) {
-    return callUtilFunction("get_property", left, `${right}`);
-  }
-  return `${left}[${right}]`;
-});
-function handleObjectLiteralExpression(node, ctx, currObj, outObjects, funcs) {
-  currObj ??= [];
-  outObjects ??= [];
-  funcs ??= [];
-  const objectName = ts7.hasOnlyExpressionInitializer(node.parent) ? NodeHandler.handle(node.parent.name) : ts7.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 (ts7.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 (ts7.isPropertyAssignment(item) && ts7.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 (ts7.isSpreadAssignment(item)) {
-      if (ts7.isObjectLiteralExpression(item.expression)) {
-        handleObjectLiteralExpression(item.expression, ctx, currObj, outObjects);
-        continue;
-      }
-      if (ts7.isIdentifier(item.expression)) {
-        pushObj();
-        outObjects.push(NodeHandler.handle(item.expression));
-        continue;
-      }
-      if (ts7.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(ts7.SyntaxKind.ObjectLiteralExpression, handleObjectLiteralExpression);
-
 // src/visitors/expressions.ts
 function hasRestParam(params) {
   if (!params.length)
     return false;
   const lastParam = params[params.length - 1];
-  return !!(lastParam.valueDeclaration && ts8.isParameter(lastParam.valueDeclaration) && lastParam.valueDeclaration.dotDotDotToken);
+  return !!(lastParam.valueDeclaration && ts7.isParameter(lastParam.valueDeclaration) && lastParam.valueDeclaration.dotDotDotToken);
 }
 function handleCallArgs(callNode, ctx) {
   const args = callNode.arguments;
@@ -703,11 +610,11 @@ function handleCallArgs(callNode, ctx) {
     }
   }
   for (const arg of args) {
-    if (!ts8.isSpreadElement(arg)) {
+    if (!ts7.isSpreadElement(arg)) {
       pushArgs(false, NodeHandler.handle(arg));
       continue;
     }
-    if (ts8.isArrayLiteralExpression(arg.expression)) {
+    if (ts7.isArrayLiteralExpression(arg.expression)) {
       const arrayItems = [];
       const outArrs = [];
       handleArrayLiteralExpression(arg.expression, ctx, arrayItems, outArrs);
@@ -759,7 +666,7 @@ function handleCallArgs(callNode, ctx) {
     result.push("[]");
   return result;
 }
-NodeHandler.register(ts8.SyntaxKind.CallExpression, (node, ctx) => {
+NodeHandler.register(ts7.SyntaxKind.CallExpression, (node, ctx) => {
   const args = handleCallArgs(node, ctx);
   let name = NodeHandler.handle(node.expression);
   const type = checker.getTypeAtLocation(node.expression);
@@ -771,14 +678,11 @@ NodeHandler.register(ts8.SyntaxKind.CallExpression, (node, ctx) => {
   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(ts8.SyntaxKind.NewExpression, (node, ctx) => {
+NodeHandler.register(ts7.SyntaxKind.NewExpression, (node, ctx) => {
   const args = handleCallArgs(node, ctx);
   let output = `(new ${NodeHandler.handle(node.expression)}).constructor`;
   if (args.length)
@@ -788,12 +692,12 @@ NodeHandler.register(ts8.SyntaxKind.NewExpression, (node, ctx) => {
 function shouldHaveOuterPrefix(node, operator) {
   if (!assignmentOperators.has(operator))
     return false;
-  if (!ts8.isIdentifier(node.left))
+  if (!ts7.isIdentifier(node.left))
     return false;
-  const functionAncestor = ts8.findAncestor(node.parent, (n) => ts8.isFunctionLike(n));
+  const functionAncestor = ts7.findAncestor(node.parent, (n) => ts7.isFunctionLike(n));
   if (!functionAncestor)
     return false;
-  if (!ts8.findAncestor(functionAncestor.parent, (n) => ts8.isFunctionLike(n)))
+  if (!ts7.findAncestor(functionAncestor.parent, (n) => ts7.isFunctionLike(n)))
     return false;
   const leftSymbol = checker.getSymbolAtLocation(node.left);
   if (!leftSymbol?.valueDeclaration)
@@ -803,26 +707,26 @@ function shouldHaveOuterPrefix(node, operator) {
 function isAssignmentChain(node, operator) {
   if (!assignmentOperators.has(operator))
     return false;
-  if (ts8.isBinaryExpression(node.right) && assignmentOperators.has(ts8.tokenToString(node.right.operatorToken.kind) || ""))
+  if (ts7.isBinaryExpression(node.right) && assignmentOperators.has(ts7.tokenToString(node.right.operatorToken.kind) || ""))
     return true;
-  if (ts8.hasOnlyExpressionInitializer(node.parent))
+  if (ts7.hasOnlyExpressionInitializer(node.parent))
     return true;
   return false;
 }
-NodeHandler.register(ts8.SyntaxKind.BinaryExpression, (node) => {
+NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node) => {
   let operatorToken = getOperatorToken(node.operatorToken) || node.operatorToken.getText();
   if (isAssignmentChain(node, operatorToken))
     throw `Assignment chaining is not supported`;
   let right = NodeHandler.handle(node.right);
   if (nodeIsFunctionReference(node.right))
     right = asRef(right);
-  if (ts8.isPropertyAccessExpression(node.left)) {
+  if (ts7.isPropertyAccessExpression(node.left)) {
     const leftType = checker.getTypeAtLocation(node.left.expression);
     const symbol = leftType.getProperty(node.left.name.text);
-    if (symbol?.declarations?.some((decl) => ts8.isSetAccessor(decl))) {
+    if (symbol?.declarations?.some((decl) => ts7.isSetAccessor(decl))) {
       const objName = NodeHandler.handle(node.left.expression);
       const key = node.left.name.text;
-      if (operatorToken !== "=" && symbol.declarations.some((decl) => ts8.isGetAccessor(decl)))
+      if (operatorToken !== "=" && symbol.declarations.some((decl) => ts7.isGetAccessor(decl)))
         throw `Can't handle '${operatorToken}' because '${objName}' doesn't have a getter '${key}'`;
       if (operatorToken === "+=" || operatorToken === "-=") {
         right = `${objName}.${key} ${operatorToken[0]} ${right}`;
@@ -837,22 +741,12 @@ NodeHandler.register(ts8.SyntaxKind.BinaryExpression, (node) => {
     left = "outer." + left;
   if (nodeIsFunctionReference(node.left))
     left = asRef(left);
-  if (operatorToken === "or" && ts8.hasOnlyExpressionInitializer(node.parent)) {
+  if (operatorToken === "or" && ts7.hasOnlyExpressionInitializer(node.parent)) {
     return callUtilFunction("or_op", left, right);
   }
-  if (operatorToken === "instanceof") {
-    const rightSymbol = checker.getSymbolAtLocation(node.right);
-    const classIdMember = rightSymbol?.members?.get(ts8.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})`;
-  }
   switch (operatorToken) {
+    case "instanceof":
+      return callUtilFunction("instance_of", left, right);
     case "??":
       return callUtilFunction("nullish_coalescing_op", left, right);
     case "??=":
@@ -879,41 +773,44 @@ NodeHandler.register(ts8.SyntaxKind.BinaryExpression, (node) => {
     operatorToken = "^";
   return `${left} ${operatorToken} ${right}`;
 });
-NodeHandler.register(ts8.SyntaxKind.ParenthesizedExpression, (node) => {
+NodeHandler.register(ts7.SyntaxKind.ParenthesizedExpression, (node) => {
   return `(${NodeHandler.handle(node.expression)})`;
 });
 function handleUnaryExpression(node) {
   const operand = NodeHandler.handle(node.operand);
-  const operator = ts8.tokenToString(node.operator);
-  if (operator === "++")
-    return `${operand} = ${operand} + 1`;
-  if (operator === "--")
-    return `${operand} = ${operand} - 1`;
-  if (operator === "!") {
-    if (ts8.isPrefixUnaryExpression(node.parent) && ts8.tokenToString(node.parent.operator) === "!") {
-      return `(not ${operand})`;
-    }
-    return `not ${operand}`;
-  }
-  if (operator === "-")
-    return `-${operand}`;
-  if (operator === "+")
-    return `str(${operand}).val()`;
-  if (operator === "~")
-    return `bitwise("~", ${operand})`;
-  throw `Couldn't handle this UnaryExpression: ${node.getText()}`;
+  const operator = ts7.tokenToString(node.operator);
+  switch (operator) {
+    case "++":
+    case "--":
+      if (ts7.hasOnlyExpressionInitializer(node.parent) || ts7.isBinaryExpression(node.parent))
+        throw `Operator ${operator} is not supported for this kind of expression yet`;
+      return `${operand} = ${operand} ${operator[0]} 1`;
+    case "!":
+      if (ts7.isPrefixUnaryExpression(node.parent) && ts7.tokenToString(node.parent.operator) === "!") {
+        return `(not ${operand})`;
+      }
+      return `not ${operand}`;
+    case "-":
+      return `-${operand}`;
+    case "+":
+      return `str(${operand}).val`;
+    case "~":
+      return `bitwise("~", ${operand})`;
+    default:
+      throw `Couldn't handle this UnaryExpression: ${node.getText()}`;
+  }
 }
-NodeHandler.register(ts8.SyntaxKind.PrefixUnaryExpression, handleUnaryExpression);
-NodeHandler.register(ts8.SyntaxKind.PostfixUnaryExpression, handleUnaryExpression);
+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 (!ts8.isSpreadElement(item)) {
+    if (!ts7.isSpreadElement(item)) {
       itemStrings.push(NodeHandler.handle(item));
       continue;
     }
-    if (ts8.isArrayLiteralExpression(item.expression)) {
+    if (ts7.isArrayLiteralExpression(item.expression)) {
       handleArrayLiteralExpression(item.expression, ctx, itemStrings, out);
       continue;
     }
@@ -923,14 +820,14 @@ function handleArrayLiteralExpression(node, ctx, itemStrings, out) {
     }
     out.push(NodeHandler.handle(item.expression));
   }
-  if ((!out.length || itemStrings.length) && !ts8.isSpreadElement(node.parent)) {
+  if ((!out.length || itemStrings.length) && !ts7.isSpreadElement(node.parent)) {
     out.push(`[${itemStrings.join(",")}]`);
     itemStrings.length = 0;
   }
   return out.join(" + ");
 }
-NodeHandler.register(ts8.SyntaxKind.ArrayLiteralExpression, handleArrayLiteralExpression);
-NodeHandler.register(ts8.SyntaxKind.TemplateExpression, (node) => {
+NodeHandler.register(ts7.SyntaxKind.ArrayLiteralExpression, handleArrayLiteralExpression);
+NodeHandler.register(ts7.SyntaxKind.TemplateExpression, (node) => {
   const head = NodeHandler.handle(node.head);
   const strings = [
     ...head ? [`"${head}"`] : [],
@@ -939,22 +836,22 @@ NodeHandler.register(ts8.SyntaxKind.TemplateExpression, (node) => {
   const output = strings.join(" + ");
   return output;
 });
-NodeHandler.register(ts8.SyntaxKind.TemplateHead, (node) => {
+NodeHandler.register(ts7.SyntaxKind.TemplateHead, (node) => {
   return transformString(node.text);
 });
-NodeHandler.register(ts8.SyntaxKind.TemplateSpan, (node) => {
+NodeHandler.register(ts7.SyntaxKind.TemplateSpan, (node) => {
   let output = NodeHandler.handle(node.expression);
-  if (ts8.isBinaryExpression(node.expression))
+  if (ts7.isBinaryExpression(node.expression))
     output = `str(${output})`;
   if (node.literal.text)
     output += ` + "${transformString(node.literal.text)}"`;
   return output;
 });
-NodeHandler.register(ts8.SyntaxKind.NoSubstitutionTemplateLiteral, (node) => {
+NodeHandler.register(ts7.SyntaxKind.NoSubstitutionTemplateLiteral, (node) => {
   return `"${transformString(node.text)}"`;
 });
-NodeHandler.register(ts8.SyntaxKind.ConditionalExpression, (node) => {
-  if (ts8.isCallExpression(node.whenTrue) || ts8.isCallExpression(node.whenFalse)) {
+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);
@@ -962,28 +859,28 @@ NodeHandler.register(ts8.SyntaxKind.ConditionalExpression, (node) => {
   const whenFalse = NodeHandler.handle(node.whenFalse);
   return callUtilFunction("conditional_expr", condition, whenTrue, whenFalse);
 });
-NodeHandler.register(ts8.SyntaxKind.ExpressionStatement, (node) => {
+NodeHandler.register(ts7.SyntaxKind.ExpressionStatement, (node) => {
   return NodeHandler.handle(node.expression);
 });
-NodeHandler.register(ts8.SyntaxKind.NonNullExpression, (node) => {
+NodeHandler.register(ts7.SyntaxKind.NonNullExpression, (node) => {
   return NodeHandler.handle(node.expression);
 });
-NodeHandler.register(ts8.SyntaxKind.AsExpression, (node) => {
+NodeHandler.register(ts7.SyntaxKind.AsExpression, (node) => {
   return NodeHandler.handle(node.expression);
 });
-NodeHandler.register(ts8.SyntaxKind.DeleteExpression, (node) => {
-  if (ts8.isPropertyAccessExpression(node.expression)) {
+NodeHandler.register(ts7.SyntaxKind.DeleteExpression, (node) => {
+  if (ts7.isPropertyAccessExpression(node.expression)) {
     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}")`;
   }
-  if (ts8.isElementAccessExpression(node.expression)) {
+  if (ts7.isElementAccessExpression(node.expression)) {
     const pnode = node.expression;
     const left = NodeHandler.handle(pnode.expression);
     let right;
-    if (ts8.isStringLiteral(pnode.argumentExpression)) {
+    if (ts7.isStringLiteral(pnode.argumentExpression)) {
       const leftType = checker.getTypeAtLocation(pnode.expression);
       right = `"${replaceIdentifier(pnode.argumentExpression.text, leftType, pnode.argumentExpression.text)}"`;
     } else {
@@ -991,11 +888,11 @@ NodeHandler.register(ts8.SyntaxKind.DeleteExpression, (node) => {
     }
     return `${left}.remove(${right})`;
   }
-  throw `Cant handle delete expression for ${ts8.SyntaxKind[node.expression.kind]}`;
+  throw `Cant handle delete expression for ${ts7.SyntaxKind[node.expression.kind]}`;
 });
 
 // src/visitors/functions.ts
-import ts9 from "typescript";
+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) : "";
@@ -1003,7 +900,7 @@ function transpileFunctionBody(node) {
 ${body}
 end function`;
 }
-NodeHandler.register(ts9.SyntaxKind.Block, (node) => {
+NodeHandler.register(ts8.SyntaxKind.Block, (node) => {
   const output = node.statements.map((val) => {
     let statement = NodeHandler.handle(val);
     statement = statement.split(`
@@ -1014,38 +911,38 @@ NodeHandler.register(ts9.SyntaxKind.Block, (node) => {
 `);
   return output;
 });
-NodeHandler.register(ts9.SyntaxKind.MethodDeclaration, (node) => {
+NodeHandler.register(ts8.SyntaxKind.MethodDeclaration, (node) => {
   return `${NodeHandler.handle(node.name)} = ${transpileFunctionBody(node)}`;
 });
-NodeHandler.register(ts9.SyntaxKind.FunctionDeclaration, (node) => {
+NodeHandler.register(ts8.SyntaxKind.FunctionDeclaration, (node) => {
   if (!node.body)
     return "";
-  if (node.modifiers?.some((m) => m.kind === ts9.SyntaxKind.DeclareKeyword))
+  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(ts9.SyntaxKind.ArrowFunction, (node) => {
+NodeHandler.register(ts8.SyntaxKind.ArrowFunction, (node) => {
   const params = node.parameters.map((param) => NodeHandler.handle(param));
-  const body = ts9.isBlock(node.body) ? NodeHandler.handle(node.body) : `	return ${NodeHandler.handle(node.body)}`;
-  if (ts9.isCallOrNewExpression(node.parent) || ts9.isParenthesizedExpression(node.parent)) {
+  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 (ts9.hasOnlyExpressionInitializer(node.parent) || ts9.isBinaryExpression(node.parent) || ts9.isReturnStatement(node.parent)) {
+  if (ts8.hasOnlyExpressionInitializer(node.parent) || ts8.isBinaryExpression(node.parent) || ts8.isReturnStatement(node.parent)) {
     return `function(${params.join(", ")})
 ${body}
 end function`;
   }
-  const kind = ts9.SyntaxKind[node.parent.kind];
+  const kind = ts8.SyntaxKind[node.parent.kind];
   throw `This kind of arrow function is not yet supported (parent: ${kind} (${node.parent.kind}))`;
 });
-NodeHandler.register(ts9.SyntaxKind.FunctionExpression, (node) => {
+NodeHandler.register(ts8.SyntaxKind.FunctionExpression, (node) => {
   return transpileFunctionBody(node);
 });
 
 // src/visitors/identifiers.ts
-import ts10 from "typescript";
-NodeHandler.register(ts10.SyntaxKind.Identifier, (node, ctx) => {
+import ts9 from "typescript";
+NodeHandler.register(ts9.SyntaxKind.Identifier, (node, ctx) => {
   const type = checker.getTypeAtLocation(node);
   let name = node.text;
   if (name === "undefined")
@@ -1063,31 +960,31 @@ NodeHandler.register(ts10.SyntaxKind.Identifier, (node, ctx) => {
   if (ctx.namedImports[ctx.currentFilePath]?.[name]) {
     name = ctx.namedImports[ctx.currentFilePath][name];
   }
-  if (ts10.isCallOrNewExpression(node.parent) && node != node.parent.expression) {
+  if (ts9.isCallOrNewExpression(node.parent) && node != node.parent.expression) {
     if (nodeIsFunctionReference(node, type))
       name = asRef(name);
   }
   return name;
 });
-NodeHandler.register(ts10.SyntaxKind.Parameter, (node) => {
+NodeHandler.register(ts9.SyntaxKind.Parameter, (node) => {
   const name = NodeHandler.handle(node.name);
   if (!node.initializer)
     return name;
   const initializer = NodeHandler.handle(node.initializer);
   const initializerType = checker.getTypeAtLocation(node.initializer);
-  if (initializerType.flags === ts10.TypeFlags.Object) {
+  if (initializerType.flags === ts9.TypeFlags.Object) {
     throw `You can't initialize parameter '${name}' with an Array or an Object as that won't work in GreyScript and it would be null`;
   }
   return `${name} = ${initializer}`;
 });
-NodeHandler.register(ts10.SyntaxKind.NumericLiteral, (node) => node.text);
-NodeHandler.register(ts10.SyntaxKind.StringLiteral, (node) => `"${transformString(node.text)}"`);
-NodeHandler.register(ts10.SyntaxKind.NullKeyword, () => "null");
-NodeHandler.register(ts10.SyntaxKind.UndefinedKeyword, () => "null");
-NodeHandler.register(ts10.SyntaxKind.FalseKeyword, () => "0");
-NodeHandler.register(ts10.SyntaxKind.TrueKeyword, () => "1");
-NodeHandler.register(ts10.SyntaxKind.ThisKeyword, (node) => {
-  const propDeclarationAncestor = ts10.findAncestor(node.parent, (n) => ts10.isPropertyDeclaration(n));
+NodeHandler.register(ts9.SyntaxKind.NumericLiteral, (node) => node.text);
+NodeHandler.register(ts9.SyntaxKind.StringLiteral, (node) => `"${transformString(node.text)}"`);
+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.ThisKeyword, (node) => {
+  const propDeclarationAncestor = ts9.findAncestor(node.parent, (n) => ts9.isPropertyDeclaration(n));
   if (propDeclarationAncestor) {
     if (!propDeclarationAncestor.parent.name)
       throw `Can't handle this 'this' keyword becuase the class doesn't have a name and it's needed for this case`;
@@ -1095,12 +992,12 @@ NodeHandler.register(ts10.SyntaxKind.ThisKeyword, (node) => {
   }
   return "self";
 });
-NodeHandler.register(ts10.SyntaxKind.SuperKeyword, (node) => {
-  if (ts10.isPropertyAccessExpression(node.parent) || ts10.isElementAccessExpression(node.parent))
+NodeHandler.register(ts9.SyntaxKind.SuperKeyword, (node) => {
+  if (ts9.isPropertyAccessExpression(node.parent) || ts9.isElementAccessExpression(node.parent))
     return "super";
   return "super.constructor";
 });
-NodeHandler.register(ts10.SyntaxKind.RegularExpressionLiteral, (node) => {
+NodeHandler.register(ts9.SyntaxKind.RegularExpressionLiteral, (node) => {
   const start = node.text.indexOf("/") + 1;
   const end = node.text.lastIndexOf("/");
   const flags = node.text.slice(end + 1);
@@ -1111,7 +1008,7 @@ NodeHandler.register(ts10.SyntaxKind.RegularExpressionLiteral, (node) => {
 
 // src/visitors/imports.ts
 import path3 from "node:path";
-import ts11 from "typescript";
+import ts10 from "typescript";
 function importFile(filePath, ctx, returnResult) {
   let srcPath = path3.resolve(ctx.currentFolder, filePath);
   if (!path3.extname(srcPath))
@@ -1123,7 +1020,7 @@ function importFile(filePath, ctx, returnResult) {
   }
   return transpileSourceFile(source, ctx, returnResult);
 }
-NodeHandler.register(ts11.SyntaxKind.ImportDeclaration, (node, ctx) => {
+NodeHandler.register(ts10.SyntaxKind.ImportDeclaration, (node, ctx) => {
   if (!node.importClause) {
     const moduleName = node.moduleSpecifier.text;
     const transpiledFile = importFile(moduleName, ctx, true);
@@ -1146,7 +1043,7 @@ NodeHandler.register(ts11.SyntaxKind.ImportDeclaration, (node, ctx) => {
     throw `Can't import default exports yet (imported as ${node.importClause.name.text})`;
   const bindings = node.importClause.namedBindings;
   if (bindings) {
-    if (ts11.isNamespaceImport(bindings)) {
+    if (ts10.isNamespaceImport(bindings)) {
       ctx.namespaceImports[ctx.currentFilePath]?.add(bindings.name.text);
     } else {
       bindings.elements.forEach((el) => {
@@ -1160,6 +1057,109 @@ NodeHandler.register(ts11.SyntaxKind.ImportDeclaration, (node, ctx) => {
   return importFile(moduleSpecifier, ctx);
 });
 
+// src/visitors/objects.ts
+import ts11 from "typescript";
+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);
+  }
+  if (!valueIsBeingAssignedToNode(node) && !ts11.isNumericLiteral(node.argumentExpression)) {
+    return callUtilFunction("get_property", left, `${right}`);
+  }
+  return `${left}[${right}]`;
+});
+function handleObjectLiteralExpression(node, ctx, currObj, outObjects, funcs) {
+  currObj ??= [];
+  outObjects ??= [];
+  funcs ??= [];
+  let objectName = "";
+  if (ts11.hasOnlyExpressionInitializer(node.parent))
+    objectName = NodeHandler.handle(node.parent.name);
+  else if (ts11.isBinaryExpression(node.parent) && node === node.parent.right)
+    objectName = 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)) {
+      funcs.push(NodeHandler.handle(item));
+      continue;
+    }
+    if (ts11.isPropertyAssignment(item) && ts11.isFunctionLike(item.initializer)) {
+      funcs.push(`${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) {
+    if (ts11.isPropertyAssignment(node.parent) || !objectName) {
+      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(`
+`);
+  }
+  return output;
+}
+NodeHandler.register(ts11.SyntaxKind.ObjectLiteralExpression, handleObjectLiteralExpression);
+
 // src/visitors/statements.ts
 import ts12 from "typescript";
 NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
@@ -1376,56 +1376,13 @@ NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
 });
 
 // src/call_transformers/array.ts
-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("Array.slice", (name, args) => {
   return name.slice(0, name.lastIndexOf(".")) + `[${args[0] ?? ""}:${args[1] ?? ""}]`;
 });
-CallTransformer.register("Array.push", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_push", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
-CallTransformer.register("Array.unshift", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_unshift", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
 CallTransformer.register("Array.toString", (name) => {
   const arrayName = name.slice(0, name.lastIndexOf("."));
   return `str(${arrayName})`;
 });
-CallTransformer.register("Array.reverse", (name) => {
-  return callUtilFunction("array_reverse", name.slice(0, name.lastIndexOf(".")));
-});
 
 // src/call_transformers/object.ts
 CallTransformer.register("ObjectConstructor.hasOwn", (name, args) => {
@@ -1471,21 +1428,6 @@ CallTransformer.register("Object.toString", (name) => {
 });
 
 // src/call_transformers/string.ts
-CallTransformer.register("String.startsWith", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("str_starts_with", name.slice(0, name.lastIndexOf(".")), ...args);
-});
-CallTransformer.register("String.endsWith", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("str_ends_with", name.slice(0, name.lastIndexOf(".")), ...args);
-});
-CallTransformer.register("String.repeat", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("str_repeat", name.slice(0, name.lastIndexOf(".")), ...args);
-});
 CallTransformer.register("String.slice", (name, args) => {
   return name.slice(0, name.lastIndexOf(".")) + `[${args[0] ?? ""}:${args[1] ?? ""}]`;
 });
@@ -1496,132 +1438,68 @@ CallTransformer.register("String.toString", (name) => {
 // 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\tres = obj[key]",
-    '\t\t\tif typeof(@res) == "function" and str(@res)[8:][1:-1].indexOf("self") == 0 then return res(obj)',
-    "\t\t\treturn obj[key]",
-    "\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)",
+var utilitiesToInsert = new Map;
+var extensionFunctions = {
+  "Array.map": [
+    "list.map = function(callback)",
     "\tindex = 0",
     "\tout = []",
-    "\tfor item in array",
-    "\t\tout.push(callback(item, index, array))",
+    "\tfor item in self",
+    "\t\tout.push(callback(item, index, self))",
     "\t\tindex = index + 1",
     "\tend for",
     "\treturn out",
     "end function"
   ].join(`
 `),
-  array_filter: [
-    "array_filter = function(array, predicate)",
+  "Array.filter": [
+    "list.filter = function(predicate)",
     "\tindex = 0",
     "\tout = []",
-    "\tfor item in array",
-    "\t\tif predicate(item, index, array) then out.push(item)",
+    "\tfor item in self",
+    "\t\tif predicate(item, index, self) then out.push(item)",
     "\t\tindex = index + 1",
     "\tend for",
     "\treturn out",
     "end function"
   ].join(`
 `),
-  array_find: [
-    "array_find = function(array, predicate)",
+  "Array.find": [
+    "list.find = function(predicate)",
     "\tindex = 0",
-    "\tfor item in array",
-    "\t\tif predicate(item, index, array) then return item",
+    "\tfor item in self",
+    "\t\tif predicate(item, index, self) then return item",
     "\t\tindex = index + 1",
     "\tend for",
     "\treturn null",
     "end function"
   ].join(`
 `),
-  array_some: [
-    "array_some = function(array, predicate)",
+  "Array.some": [
+    "list.some = function(predicate)",
     "\tindex = 0",
-    "\tfor item in array",
-    "\t\tif predicate(item, index, array) then return 1",
+    "\tfor item in self",
+    "\t\tif predicate(item, index, self) then return 1",
     "\t\tindex = index + 1",
     "\tend for",
     "\treturn 0",
     "end function"
   ].join(`
 `),
-  array_every: [
-    "array_every = function(array, predicate)",
+  "Array.every": [
+    "list.every = function(predicate)",
     "\tindex = 0",
-    "\tfor item in array",
-    "\t\tif not predicate(item, index, array) then return 0",
+    "\tfor item in self",
+    "\t\tif not predicate(item, index, self) then return 0",
     "\t\tindex = index + 1",
     "\tend for",
     "\treturn 1",
     "end function"
   ].join(`
 `),
-  array_concat: [
-    "array_concat = function(target, items)",
-    "\tout = target[0:]",
+  "Array.concat": [
+    "list.concat = function(items)",
+    "\tout = self[0:]",
     "\tfor item in items",
     "\t\tif item isa list then out = out + item else out.push(item)",
     "\tend for",
@@ -1629,58 +1507,141 @@ var utilFunctions2 = {
     "end function"
   ].join(`
 `),
-  array_push: [
-    "array_push = function(target, items)",
+  "Array.push": [
+    "list.push_many = function(items)",
     "\tfor item in items[:]",
-    "\t\ttarget.push(@item)",
+    "\t\tself.push(@item)",
     "\tend for",
-    "\treturn target.len",
+    "\treturn self.len",
     "end function"
   ].join(`
 `),
-  array_unshift: [
-    "array_unshift = function(target, items)",
-    "\tif not items.len then return target.len",
+  "Array.unshift": [
+    "list.unshift = function(items)",
+    "\tif not items.len then return self.len",
     "\tfor i in range(items.len-1)",
-    "\t\ttarget.insert(0, @items[i])",
+    "\t\tself.insert(0, items[i])",
     "\tend for",
-    "\treturn target.len",
+    "\treturn self.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",
+  "Array.reverse": [
+    "list.old_reverse = @list.reverse",
+    "list.reverse = function",
+    "\tself.old_reverse",
+    "\treturn self",
     "end function"
   ].join(`
 `),
-  str_ends_with: [
-    "str_ends_with = function(str, search, pos = null)",
-    "\tif pos == null then pos = str.len",
+  "Array.includes": [
+    "list.includes = function(value, pos = 0)",
+    "\tindex = self.indexOf(value)",
+    "\tif index == null then return 0",
     "\tif pos < 0 then pos = 0",
-    "\treturn str.indexOf(search) + search.len == pos",
+    "\treturn index >= 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",
+  "Array.splice": [
+    "list.splice = function(start, count)",
+    "\tdeleted = []",
+    "\tif start < 0 then start = self.len + start",
+    "\tif start < 0 then start = 0",
+    "\tif count == null then count = self.len - start",
+    "\tif count <= 0 then return deleted",
+    "\twhile deleted.len < count",
+    "\t\tif not self.hasIndex(start) then return deleted",
+    "\t\tdeleted.push(self[start])",
+    "\t\tself.remove(start)",
+    "\tend while",
+    "\treturn deleted",
+    "end function"
+  ].join(`
+`),
+  "Array.fill": [
+    "list.fill = function(value, start, endI)",
+    "\tlen = self.len",
+    "\tif not len then return self",
+    "\tif start == null then start = 0",
+    "\tif endI == null then endI = len - 1",
+    "\tif start < 0 then start = len + start",
+    "\tif start < 0 then start = 0",
+    "\tif endI < 0 then endI = len + endI",
+    "\tif endI < 0 then endI = 0",
+    "\tfor i in range(start, endI-1, 1)",
+    "\t\tif i >= len then break",
+    "\t\tself[i] = value",
     "\tend for",
-    "\treturn out",
+    "\treturn self",
+    "end function"
+  ].join(`
+`),
+  "String.startsWith": [
+    "string.startsWith = function(search, pos = 0)",
+    "\tif pos < 0 then pos = 0",
+    "\treturn self.indexOf(search) == pos",
+    "end function"
+  ].join(`
+`),
+  "String.endsWith": [
+    "string.endsWith = function(search, pos = null)",
+    "\tif pos == null then pos = self.len",
+    "\tif pos < 0 then pos = 0",
+    "\treturn self.indexOf(search) + search.len == pos",
+    "end function"
+  ].join(`
+`),
+  "String.repeat": [
+    "string.repeatSelf = function(count = 0)",
+    "\treturn self * count",
+    "end function"
+  ].join(`
+`),
+  "String.includes": [
+    "string.includes = function(search, pos = 0)",
+    "\tindex = self.indexOf(search)",
+    "\tif index == null then return 0",
+    "\tif pos < 0 then pos = 0",
+    "\treturn index >= pos",
+    "end function"
+  ].join(`
+`),
+  "String.trimStart": [
+    "string.trimStart = function()",
+    '\treturn self.replace("^\\s+", "")',
+    "end function"
+  ].join(`
+`),
+  "String.trimEnd": [
+    "string.trimEnd = function()",
+    '\treturn self.replace("\\s+$", "")',
     "end function"
   ].join(`
 `),
-  math_min: [
-    "math_min = function(numbers)",
+  "Number.toFixed": [
+    "number.toFixed = function(digits = 0)",
+    "\tdigits = floor(digits)",
+    "\tif digits <= 0 then return str(round(self))",
+    "\tvalue = self",
+    "\tvalue = value * (10 ^ digits)",
+    "\tvalue = round(value)",
+    "\tvalue = value / (10 ^ digits)",
+    "\t",
+    "\tstr_value = str(value)",
+    '\tdot_index = str_value.indexOf(".")',
+    "\tif dot_index == null then",
+    '\t\tstr_value = str_value + "." + ("0" * digits)',
+    "\telse if str_value[dot_index + 1:].len < digits then",
+    "\t\trepeat_count = digits - str_value[dot_index + 1:].len",
+    '\t\tstr_value = str_value + ("0" * repeat_count)',
+    "\tend if",
+    "\treturn str_value",
+    "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",
@@ -1689,8 +1650,8 @@ end function`,
     "end function"
   ].join(`
 `),
-  math_max: [
-    "math_max = function(numbers)",
+  "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",
@@ -1698,6 +1659,83 @@ end function`,
     "\treturn curr_max",
     "end function"
   ].join(`
+`)
+};
+var utilFunctions = {
+  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\tres = obj[key]",
+    '\t\t\tif typeof(@res) == "function" and str(@res)[8:][1:-1].indexOf("self") == 0 then return res(obj)',
+    "\t\t\treturn obj[key]",
+    "\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(`
+`),
+  instance_of: [
+    "instance_of = function(obj, class)",
+    '\tif not obj.hasIndex("__isa") then return 0',
+    "\tisaobj = obj",
+    '\twhile isaobj.hasIndex("__isa")',
+    '\t\tif isaobj["__isa"] == class then return 1',
+    '\t\tisaobj = isaobj["__isa"]',
+    "\tend while",
+    "\treturn 0",
+    "end function"
+  ].join(`
 `),
   nullish_coalescing_op: `nullish_coalescing_op = function(left, right)
 	if left == null then return @right
@@ -1708,8 +1746,7 @@ end function`,
 	return @left
 end function`,
   is_type: `is_type = function(value, type)
-	if typeof(value) == type then return 1
-	return 0
+	return typeof(value) == type
 end function`,
   conditional_expr: `conditional_expr = function(cond, when_true, when_false)
 	if cond then return when_true
@@ -1718,12 +1755,12 @@ end function`
 };
 function createAnonFunction(body, params) {
   const defaultParams = new Array(3).fill(0).map((_, i) => `param${i}`);
-  const nextName = `func_${anonFunctions.size}`;
+  const nextName = `func_${utilitiesToInsert.size}`;
   const paramString = Object.assign(defaultParams, params).join(",");
   const result = `${nextName} = function(${paramString})
 ${body}
 end function`;
-  anonFunctions.set(nextName, result);
+  utilitiesToInsert.set(nextName, result);
   return { name: nextName, str: result };
 }
 function transpileProgram(entryFileRelativePath) {
@@ -1764,19 +1801,12 @@ function transpileProgram(entryFileRelativePath) {
     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();
+  if (utilitiesToInsert.size) {
+    ctx.output.unshift(...utilitiesToInsert.values());
+    utilitiesToInsert.clear();
   }
   console.log(`Transpiling took ${Date.now() - start} ms`);
-  return ctx.output.join(`
-`);
+  return ctx.output;
 }
 function transpileSourceFile(sourceFile, ctx, returnResult) {
   if (ctx.visitedFiles[sourceFile.fileName])
@@ -1828,27 +1858,54 @@ for (let i = 2;i < process.argv.length; i++) {
     args.push(arg);
 }
 var root = findProjectRoot(process.cwd());
+var outDirPath = `${root}/out`;
 if (!command) {
   console.error("No command specified.");
   process.exit(2);
 }
+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);
+  fs3.writeFileSync(outFilePath, content);
+}
 if (command === "transpile") {
   if (!args.length) {
     console.error("No entry file specified.");
     process.exit(2);
   }
   const entryFile = args[0];
-  const output = transpileProgram(entryFile);
+  const basename = path5.basename(entryFile, ".ts");
+  const transpiledStatements = transpileProgram(entryFile);
   if (flags.includes("--print") || flags.includes("-p")) {
-    console.log(output);
+    console.log(transpiledStatements.join(`
+`));
     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);
+  let content = "";
+  const fileContents = [];
+  while (transpiledStatements.length) {
+    const statement = transpiledStatements.shift();
+    if (content.length + statement.length > 155000 && content.length) {
+      fileContents.push(content);
+      content = "";
+      continue;
+    }
+    content += statement + `
+`;
+  }
+  if (content.length)
+    fileContents.push(content);
+  for (let i = 0;i < fileContents.length; i++) {
+    if (i + 1 < fileContents.length) {
+      const nextFileName = `${basename}-${i + 1}.src`;
+      fileContents[i] += `import_code("${nextFileName}")`;
+    }
+    createOutputFile(i, basename, fileContents[i]);
+  }
 } else {
   console.log(`Invalid command: ${command}`);
   process.exit(127);