@grey-ts/transpiler 1.1.2 → 1.3.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) {
@@ -44,6 +44,7 @@ class NodeHandler {
 }
 NodeHandler.register(ts.SyntaxKind.TypeAliasDeclaration, () => "");
 NodeHandler.register(ts.SyntaxKind.InterfaceDeclaration, () => "");
+NodeHandler.register(ts.SyntaxKind.ModuleDeclaration, () => "");
 NodeHandler.register(ts.SyntaxKind.EndOfFileToken, () => "");
 NodeHandler.register(ts.SyntaxKind.EmptyStatement, () => "");
 
@@ -214,9 +215,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",
@@ -383,7 +386,7 @@ function findProjectRoot(dir, fileToSearch = "package.json") {
   return dir;
 }
 function callUtilFunction(functionName, ...params) {
-  calledUtilFunctions.add(functionName);
+  utilitiesToInsert.set(functionName, utilFunctions[functionName]);
   return `${functionName}(${params.join(", ")})`;
 }
 
@@ -507,6 +510,13 @@ class CallTransformer {
     this.handlers.set(symbolFullName, handler);
   }
   static handle(symbolFullName, functionName, callArgs, node, ctx) {
+    if (symbolFullName in utilFunctions) {
+      if (symbolFullName.startsWith("Math"))
+        utilitiesToInsert.set("create_math", "Math = {}");
+      utilitiesToInsert.set(symbolFullName, utilFunctions[symbolFullName]);
+      const params = callArgs.length ? `(${callArgs.join(",")})` : "";
+      return `${functionName}${params}`;
+    }
     const handler = this.handlers.get(symbolFullName);
     if (!handler)
       return null;
@@ -521,12 +531,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 "";
@@ -770,8 +774,8 @@ 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 (name === "is_type" && !utilitiesToInsert.has("is_type")) {
+    utilitiesToInsert.set("is_type", utilFunctions["is_type"]);
   }
   if (!args.length)
     return name;
@@ -971,13 +975,26 @@ NodeHandler.register(ts8.SyntaxKind.AsExpression, (node) => {
   return NodeHandler.handle(node.expression);
 });
 NodeHandler.register(ts8.SyntaxKind.DeleteExpression, (node) => {
-  if (!ts8.isPropertyAccessExpression(node.expression))
-    throw `Cant handle delete expression for ${ts8.SyntaxKind[node.expression.kind]}`;
-  const pnode = node.expression;
-  const left = NodeHandler.handle(pnode.expression);
-  const leftType = checker.getTypeAtLocation(pnode.expression);
-  const right = replaceIdentifier(NodeHandler.handle(pnode.name), leftType, pnode.name.text);
-  return `${left}.remove(${right})`;
+  if (ts8.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)) {
+    const pnode = node.expression;
+    const left = NodeHandler.handle(pnode.expression);
+    let right;
+    if (ts8.isStringLiteral(pnode.argumentExpression)) {
+      const leftType = checker.getTypeAtLocation(pnode.expression);
+      right = `"${replaceIdentifier(pnode.argumentExpression.text, leftType, pnode.argumentExpression.text)}"`;
+    } else {
+      right = NodeHandler.handle(pnode.argumentExpression);
+    }
+    return `${left}.remove(${right})`;
+  }
+  throw `Cant handle delete expression for ${ts8.SyntaxKind[node.expression.kind]}`;
 });
 
 // src/visitors/functions.ts
@@ -1166,11 +1183,13 @@ NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
     }
     return false;
   }
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   if (!hasContinue(node)) {
     return [
       `${initializer}`,
       `while ${condition}`,
       `	${statement.trimStart()}`,
+      ...labelIf ? [labelIf] : [],
       `	${incrementor}`,
       `end while`
     ].join(`
@@ -1187,6 +1206,7 @@ NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
     `	end if`,
     `	${incrementedStateVarName} = 0`,
     `	${statement.trimStart()}`,
+    ...labelIf ? [labelIf] : [],
     `	${incrementor}`,
     `	${incrementedStateVarName} = 1`,
     `end while`
@@ -1203,9 +1223,14 @@ NodeHandler.register(ts12.SyntaxKind.ForOfStatement, (node) => {
   }
   const varName = NodeHandler.handle(node.initializer.declarations[0].name);
   const objToLoop = NodeHandler.handle(node.expression);
-  return `for ${varName} in ${objToLoop}
-${NodeHandler.handle(node.statement)}
-end for`;
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  return [
+    `for ${varName} in ${objToLoop}`,
+    `${NodeHandler.handle(node.statement)}`,
+    ...labelIf ? [labelIf] : [],
+    `end for`
+  ].join(`
+`);
 });
 NodeHandler.register(ts12.SyntaxKind.ForInStatement, (node) => {
   if (!ts12.isVariableDeclarationList(node.initializer)) {
@@ -1216,9 +1241,14 @@ NodeHandler.register(ts12.SyntaxKind.ForInStatement, (node) => {
   }
   const varName = NodeHandler.handle(node.initializer.declarations[0].name);
   const objToLoop = NodeHandler.handle(node.expression);
-  return `for ${varName} in ${objToLoop}.indexes
-${NodeHandler.handle(node.statement)}
-end for`;
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  return [
+    `for ${varName} in ${objToLoop}.indexes`,
+    `${NodeHandler.handle(node.statement)}`,
+    ...labelIf ? [labelIf] : [],
+    `end for`
+  ].join(`
+`);
 });
 NodeHandler.register(ts12.SyntaxKind.IfStatement, (node) => {
   const condition = NodeHandler.handle(node.expression);
@@ -1248,20 +1278,24 @@ end if`;
 });
 NodeHandler.register(ts12.SyntaxKind.WhileStatement, (node, ctx) => {
   const expression = NodeHandler.handle(node.expression);
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
     `while ${expression}`,
     `	${NodeHandler.handle(node.statement).trimStart()}`,
+    ...labelIf ? [labelIf] : [],
     `end while`
   ].join(`
 `);
 });
 NodeHandler.register(ts12.SyntaxKind.DoStatement, (node, ctx) => {
   const expression = NodeHandler.handle(node.expression);
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
     `did_once = 0`,
     `while not did_once or ${expression}`,
     `	did_once = 1`,
     `	${NodeHandler.handle(node.statement).trimStart()}`,
+    ...labelIf ? [labelIf] : [],
     `end while`
   ].join(`
 `);
@@ -1270,6 +1304,12 @@ NodeHandler.register(ts12.SyntaxKind.ContinueStatement, (node) => {
   return "continue";
 });
 NodeHandler.register(ts12.SyntaxKind.BreakStatement, (node) => {
+  if (node.label) {
+    if (!ts12.isBlock(node.parent))
+      throw "A break statement with a label must be in a block";
+    return `${NodeHandler.handle(node.label)}Broke = 1
+break`;
+  }
   return "break";
 });
 NodeHandler.register(ts12.SyntaxKind.ReturnStatement, (node) => {
@@ -1281,6 +1321,10 @@ NodeHandler.register(ts12.SyntaxKind.ReturnStatement, (node) => {
   }
   return `return ${NodeHandler.handle(node.expression)}`;
 });
+NodeHandler.register(ts12.SyntaxKind.LabeledStatement, (node) => {
+  return `${NodeHandler.handle(node.label)}Broke = 0
+${NodeHandler.handle(node.statement)}`;
+});
 
 // src/visitors/variables.ts
 import ts13 from "typescript";
@@ -1309,71 +1353,39 @@ NodeHandler.register(ts13.SyntaxKind.VariableStatement, (node, ctx) => {
 NodeHandler.register(ts13.SyntaxKind.VariableDeclaration, handleVariableDeclaration);
 NodeHandler.register(ts13.SyntaxKind.PropertyDeclaration, handleVariableDeclaration);
 NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
-  const members = node.members.map((member, index) => {
-    const name = NodeHandler.handle(member.name);
+  const members = [];
+  function addMember(name, initializer) {
+    members.push(`${name}: ${initializer}`);
+    if (isNaN(+initializer))
+      return;
+    members.push(`${initializer}: ${name}`);
+  }
+  node.members.forEach((member, index) => {
+    let name = NodeHandler.handle(member.name);
+    if (!ts13.isStringLiteral(member.name))
+      name = `"${name}"`;
     if (member.initializer) {
-      return `${name}: ${NodeHandler.handle(member.initializer)}`;
+      addMember(name, NodeHandler.handle(member.initializer));
+      return;
     }
     const type = checker.getTypeAtLocation(member);
     if ("value" in type) {
-      return `${name}: ${type.value}`;
+      addMember(name, String(type.value));
+      return;
     }
-    return `${name}: ${index}`;
+    addMember(name, index.toString());
   });
   return `${node.name.text} = { ${members.join(", ")} }`;
 });
 
 // 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) => {
@@ -1419,21 +1431,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] ?? ""}]`;
 });
@@ -1444,132 +1441,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",
@@ -1577,58 +1510,123 @@ 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)",
+  "Array.reverse": [
+    "list.old_reverse = @list.reverse",
+    "list.reverse = function",
+    "\tself.old_reverse",
+    "\treturn self",
+    "end function"
+  ].join(`
+`),
+  "Array.includes": [
+    "list.includes = function(value, pos = 0)",
+    "\tindex = self.indexOf(value)",
+    "\tif index == null then return false",
     "\tif pos < 0 then pos = 0",
-    "\treturn str.indexOf(search) == pos",
+    "\treturn index >= pos",
     "end function"
   ].join(`
 `),
-  str_ends_with: [
-    "str_ends_with = function(str, search, pos = null)",
-    "\tif pos == null then pos = str.len",
+  "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(`
+`),
+  "String.startsWith": [
+    "string.startsWith = function(search, pos = 0)",
     "\tif pos < 0 then pos = 0",
-    "\treturn str.indexOf(search) + search.len == pos",
+    "\treturn self.indexOf(search) == pos",
     "end function"
   ].join(`
 `),
-  str_repeat: [
-    "str_repeat = function(str, count = 0)",
-    '\tif count <= 0 then return ""',
-    "\tif count == 1 then return str",
-    "\tout = str",
-    "\tfor i in range(count-2)",
-    "\t\tout = out + str",
-    "\tend for",
-    "\treturn out",
+  "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 false",
+    "\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(`
+`),
+  "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)",
+  "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",
@@ -1637,8 +1635,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",
@@ -1646,6 +1644,71 @@ 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(`
 `),
   nullish_coalescing_op: `nullish_coalescing_op = function(left, right)
 	if left == null then return @right
@@ -1662,16 +1725,17 @@ end function`,
   conditional_expr: `conditional_expr = function(cond, when_true, when_false)
 	if cond then return when_true
 	return when_false
-end function`
+end function`,
+  ...extensionFunctions
 };
 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) {
@@ -1712,15 +1776,9 @@ 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(`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grey-ts/transpiler",
-	"version": "1.1.2",
+	"version": "1.3.0",
 	"description": "Transpiles TypeScript into GreyScript",
 	"author": "Okka",
 	"module": "src/index.ts",
@@ -40,6 +40,6 @@
 		"typescript": "^5"
 	},
 	"dependencies": {
-		"@grey-ts/types": "^2.0.1"
+		"@grey-ts/types": "^2.1.0"
 	}
 }