typescript-to-lua 1.0.1 → 1.1.0

package/dist/lualib/lualib_bundle.lua

@@ -498,19 +498,35 @@ function __TS__AsyncAwaiter(generator)
     return __TS__New(
         __TS__Promise,
         function(____, resolve, reject)
-            local asyncCoroutine, adopt, fulfilled, step
+            local adopt, fulfilled, rejected, step, asyncCoroutine
             function adopt(self, value)
                 return ((__TS__InstanceOf(value, __TS__Promise) and (function() return value end)) or (function() return __TS__Promise.resolve(value) end))()
             end
             function fulfilled(self, value)
-                local success, resultOrError = coroutine.resume(asyncCoroutine, value)
+                local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine, value)
                 if success then
-                    step(_G, resultOrError)
+                    step(_G, resultOrError, errorOrErrorHandler)
                 else
                     reject(_G, resultOrError)
                 end
             end
-            function step(self, result)
+            function rejected(self, handler)
+                if handler then
+                    return function(____, value)
+                        local success, valueOrError = pcall(handler, value)
+                        if success then
+                            step(_G, valueOrError, handler)
+                        else
+                            reject(_G, valueOrError)
+                        end
+                    end
+                else
+                    return function(____, value)
+                        reject(_G, value)
+                    end
+                end
+            end
+            function step(self, result, errorHandler)
                 if coroutine.status(asyncCoroutine) == "dead" then
                     resolve(_G, result)
                 else
@@ -519,23 +535,23 @@ function __TS__AsyncAwaiter(generator)
                         return ____self["then"](
                             ____self,
                             fulfilled,
-                            function(____, reason) return reject(_G, reason) end
+                            rejected(_G, errorHandler)
                         )
                     end)()
                 end
             end
             asyncCoroutine = coroutine.create(generator)
-            local success, resultOrError = coroutine.resume(asyncCoroutine)
+            local success, errorOrErrorHandler, resultOrError = coroutine.resume(asyncCoroutine)
             if success then
-                step(_G, resultOrError)
+                step(_G, resultOrError, errorOrErrorHandler)
             else
-                reject(_G, resultOrError)
+                reject(_G, errorOrErrorHandler)
             end
         end
     )
 end
-function __TS__Await(thing)
-    return coroutine.yield(thing)
+function __TS__Await(errorHandler, thing)
+    return coroutine.yield(errorHandler, thing)
 end
 
 function __TS__Class(self)
@@ -1417,7 +1433,10 @@ function __TS__Promise.prototype.____constructor(self, executor)
     self.rejectedCallbacks = {}
     self.finallyCallbacks = {}
     do
-        local ____try, e = pcall(
+        local function ____catch(e)
+            self:reject(e)
+        end
+        local ____try, ____hasReturned = pcall(
             function()
                 executor(
                     _G,
@@ -1427,7 +1446,7 @@ function __TS__Promise.prototype.____constructor(self, executor)
             end
         )
         if not ____try then
-            self:reject(e)
+            ____hasReturned, ____returnValue = ____catch(____hasReturned)
         end
     end
 end
@@ -1456,10 +1475,12 @@ __TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
     local promise = ____.promise
     local resolve = ____.resolve
     local reject = ____.reject
+    local isFulfilled = self.state == __TS__PromiseState.Fulfilled
+    local isRejected = self.state == __TS__PromiseState.Rejected
     if onFulfilled then
         local internalCallback = self:createPromiseResolvingCallback(onFulfilled, resolve, reject)
         __TS__ArrayPush(self.fulfilledCallbacks, internalCallback)
-        if self.state == __TS__PromiseState.Fulfilled then
+        if isFulfilled then
             internalCallback(_G, self.value)
         end
     else
@@ -1471,10 +1492,16 @@ __TS__Promise.prototype["then"] = function(self, onFulfilled, onRejected)
     if onRejected then
         local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
         __TS__ArrayPush(self.rejectedCallbacks, internalCallback)
-        if self.state == __TS__PromiseState.Rejected then
+        if isRejected then
             internalCallback(_G, self.rejectionReason)
         end
     end
+    if isFulfilled then
+        resolve(_G, self.value)
+    end
+    if isRejected then
+        reject(_G, self.rejectionReason)
+    end
     return promise
 end
 function __TS__Promise.prototype.catch(self, onRejected)
@@ -1516,7 +1543,10 @@ end
 function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve, reject)
     return function(____, value)
         do
-            local ____try, e = pcall(
+            local function ____catch(e)
+                reject(_G, e)
+            end
+            local ____try, ____hasReturned = pcall(
                 function()
                     self:handleCallbackData(
                         f(_G, value),
@@ -1526,7 +1556,7 @@ function __TS__Promise.prototype.createPromiseResolvingCallback(self, f, resolve
                 end
             )
             if not ____try then
-                reject(_G, e)
+                ____hasReturned, ____returnValue = ____catch(____hasReturned)
             end
         end
     end
@@ -1947,16 +1977,26 @@ function __TS__SourceMapTraceBack(fileName, sourceMap)
             if type(trace) ~= "string" then
                 return trace
             end
-            local result = string.gsub(
-                trace,
-                "(%S+).lua:(%d+)",
-                function(file, line)
-                    local fileSourceMap = _G.__TS__sourcemap[file .. ".lua"]
-                    if fileSourceMap and fileSourceMap[line] then
-                        return (file .. ".ts:") .. tostring(fileSourceMap[line])
+            local function replacer(____, file, srcFile, line)
+                local fileSourceMap = _G.__TS__sourcemap[file]
+                if fileSourceMap and fileSourceMap[line] then
+                    local data = fileSourceMap[line]
+                    if type(data) == "number" then
+                        return (srcFile .. ":") .. tostring(data)
                     end
-                    return (file .. ".lua:") .. line
+                    return (tostring(data.file) .. ":") .. tostring(data.line)
                 end
+                return (file .. ":") .. line
+            end
+            local result = string.gsub(
+                trace,
+                "(%S+)%.lua:(%d+)",
+                function(file, line) return replacer(_G, file .. ".lua", file .. ".ts", line) end
+            )
+            result = string.gsub(
+                result,
+                "(%[string \"[^\"]+\"%]):(%d+)",
+                function(file, line) return replacer(_G, file, "unknown", line) end
             )
             return result
         end
@@ -2082,20 +2122,51 @@ function __TS__StringPadStart(self, maxLength, fillString)
 end
 
 function __TS__StringReplace(source, searchValue, replaceValue)
-    searchValue = string.gsub(searchValue, "[%%%(%)%.%+%-%*%?%[%^%$]", "%%%1")
+    local startPos, endPos = string.find(source, searchValue, nil, true)
+    if not startPos then
+        return source
+    end
+    local sub = string.sub
+    local before = sub(source, 1, startPos - 1)
+    local replacement = (((type(replaceValue) == "string") and (function() return replaceValue end)) or (function() return replaceValue(_G, searchValue, startPos - 1, source) end))()
+    local after = sub(source, endPos + 1)
+    return (before .. replacement) .. after
+end
+
+function __TS__StringReplaceAll(source, searchValue, replaceValue)
+    local replacer
     if type(replaceValue) == "string" then
-        replaceValue = string.gsub(replaceValue, "%%", "%%%%")
-        local result = string.gsub(source, searchValue, replaceValue, 1)
-        return result
+        replacer = function() return replaceValue end
     else
-        local result = string.gsub(
-            source,
-            searchValue,
-            function(match) return replaceValue(_G, match) end,
-            1
-        )
-        return result
+        replacer = replaceValue
+    end
+    local parts = {}
+    local partsIndex = 1
+    local sub = string.sub
+    if #searchValue == 0 then
+        parts[1] = replacer(_G, "", 0, source)
+        partsIndex = 2
+        for i = 1, #source do
+            parts[partsIndex] = sub(source, i, i)
+            parts[partsIndex + 1] = replacer(_G, "", i, source)
+            partsIndex = partsIndex + 2
+        end
+    else
+        local find = string.find
+        local currentPos = 1
+        while true do
+            local startPos, endPos = find(source, searchValue, currentPos, true)
+            if not startPos then
+                break
+            end
+            parts[partsIndex] = sub(source, currentPos, startPos - 1)
+            parts[partsIndex + 1] = replacer(_G, searchValue, startPos - 1, source)
+            partsIndex = partsIndex + 2
+            currentPos = endPos + 1
+        end
+        parts[partsIndex] = sub(source, currentPos)
     end
+    return table.concat(parts)
 end
 
 function __TS__StringSlice(self, start, ____end)

package/dist/transformation/builtins/array.js

@@ -9,69 +9,69 @@ const typescript_1 = require("../utils/typescript");
 function transformArrayConstructorCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "isArray":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayIsArray, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayIsArray, node, ...params);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "Array", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Array", expressionName));
     }
 }
 exports.transformArrayConstructorCall = transformArrayConstructorCall;
 function transformArrayPrototypeCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const caller = context.transformExpression(expression.expression);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "concat":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayConcat, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayConcat, node, caller, ...params);
         case "entries":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayEntries, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayEntries, node, caller);
         case "push":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayPush, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayPush, node, caller, ...params);
         case "reverse":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayReverse, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayReverse, node, caller);
         case "shift":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayShift, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayShift, node, caller);
         case "unshift":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayUnshift, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayUnshift, node, caller, ...params);
         case "sort":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySort, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySort, node, caller, ...params);
         case "pop":
             return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("remove")), [caller], node);
         case "forEach":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayForEach, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayForEach, node, caller, ...params);
         case "find":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFind, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFind, node, caller, ...params);
         case "findIndex":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFindIndex, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFindIndex, node, caller, ...params);
         case "includes":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayIncludes, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayIncludes, node, caller, ...params);
         case "indexOf":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayIndexOf, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayIndexOf, node, caller, ...params);
         case "map":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayMap, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayMap, node, caller, ...params);
         case "filter":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFilter, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFilter, node, caller, ...params);
         case "reduce":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayReduce, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayReduce, node, caller, ...params);
         case "reduceRight":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayReduceRight, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayReduceRight, node, caller, ...params);
         case "some":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySome, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySome, node, caller, ...params);
         case "every":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayEvery, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayEvery, node, caller, ...params);
         case "slice":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySlice, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, node, caller, ...params);
         case "splice":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySplice, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySplice, node, caller, ...params);
         case "join":
             const callerType = context.checker.getTypeAtLocation(expression.expression);
             const elementType = context.checker.getElementTypeOfArrayType(callerType);
-            if (elementType && (typescript_1.isStringType(context, elementType) || typescript_1.isNumberType(context, elementType))) {
+            if (elementType && ((0, typescript_1.isStringType)(context, elementType) || (0, typescript_1.isNumberType)(context, elementType))) {
                 const defaultSeparatorLiteral = lua.createStringLiteral(",");
                 const parameters = [
                     caller,
@@ -81,13 +81,13 @@ function transformArrayPrototypeCall(context, node) {
                 ];
                 return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("table"), lua.createStringLiteral("concat")), parameters, node);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayJoin, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayJoin, node, caller, ...params);
         case "flat":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFlat, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFlat, node, caller, ...params);
         case "flatMap":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayFlatMap, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayFlatMap, node, caller, ...params);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "array", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "array", expressionName));
     }
 }
 exports.transformArrayPrototypeCall = transformArrayPrototypeCall;

package/dist/transformation/builtins/console.js

@@ -10,7 +10,7 @@ function transformConsoleCall(context, expression) {
     const method = expression.expression;
     const methodName = method.name.text;
     const signature = context.checker.getResolvedSignature(expression);
-    const parameters = call_1.transformArguments(context, expression.arguments, signature);
+    const parameters = (0, call_1.transformArguments)(context, expression.arguments, signature);
     switch (methodName) {
         case "error":
         case "info":
@@ -42,7 +42,7 @@ function transformConsoleCall(context, expression) {
             const debugTracebackCall = lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("debug"), lua.createStringLiteral("traceback")), parameters);
             return lua.createCallExpression(lua.createIdentifier("print"), [debugTracebackCall]);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(method.name, "console", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "console", methodName));
     }
 }
 exports.transformConsoleCall = transformConsoleCall;

package/dist/transformation/builtins/function.js

@@ -11,22 +11,22 @@ const call_1 = require("../visitors/call");
 function transformFunctionPrototypeCall(context, node) {
     const expression = node.expression;
     const callerType = context.checker.getTypeAtLocation(expression.expression);
-    if (function_context_1.getFunctionContextType(context, callerType) === function_context_1.ContextType.Void) {
-        context.diagnostics.push(diagnostics_1.unsupportedSelfFunctionConversion(node));
+    if ((0, function_context_1.getFunctionContextType)(context, callerType) === function_context_1.ContextType.Void) {
+        context.diagnostics.push((0, diagnostics_1.unsupportedSelfFunctionConversion)(node));
     }
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const caller = context.transformExpression(expression.expression);
     const expressionName = expression.name.text;
     switch (expressionName) {
         case "apply":
-            return lua.createCallExpression(caller, [params[0], lua_ast_1.createUnpackCall(context, params[1], node.arguments[1])], node);
+            return lua.createCallExpression(caller, [params[0], (0, lua_ast_1.createUnpackCall)(context, params[1], node.arguments[1])], node);
         case "bind":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.FunctionBind, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.FunctionBind, node, caller, ...params);
         case "call":
             return lua.createCallExpression(caller, params, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "function", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "function", expressionName));
     }
 }
 exports.transformFunctionPrototypeCall = transformFunctionPrototypeCall;
@@ -34,17 +34,17 @@ function transformFunctionProperty(context, node) {
     switch (node.name.text) {
         case "length":
             if (context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 || context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
-                context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "function.length", CompilerOptions_1.LuaTarget.Lua51));
+                context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "function.length", CompilerOptions_1.LuaTarget.Lua51));
             }
             // debug.getinfo(fn)
             const getInfoCall = lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("debug"), lua.createStringLiteral("getinfo")), [context.transformExpression(node.expression)]);
             const nparams = lua.createTableIndexExpression(getInfoCall, lua.createStringLiteral("nparams"));
-            const contextType = function_context_1.getFunctionContextType(context, context.checker.getTypeAtLocation(node.expression));
+            const contextType = (0, function_context_1.getFunctionContextType)(context, context.checker.getTypeAtLocation(node.expression));
             return contextType === function_context_1.ContextType.NonVoid
                 ? lua.createBinaryExpression(nparams, lua.createNumericLiteral(1), lua.SyntaxKind.SubtractionOperator)
                 : nparams;
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(node.name, "function", node.name.text));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node.name, "function", node.name.text));
     }
 }
 exports.transformFunctionProperty = transformFunctionProperty;

package/dist/transformation/builtins/global.js

@@ -6,24 +6,24 @@ const typescript_1 = require("../utils/typescript");
 const call_1 = require("../visitors/call");
 function transformGlobalCall(context, node) {
     const signature = context.checker.getResolvedSignature(node);
-    const parameters = call_1.transformArguments(context, node.arguments, signature);
+    const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
     const expressionType = context.checker.getTypeAtLocation(node.expression);
     const name = expressionType.symbol.name;
     switch (name) {
         case "SymbolConstructor":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Symbol, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Symbol, node, ...parameters);
         case "NumberConstructor":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Number, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, node, ...parameters);
         case "isNaN":
         case "isFinite":
-            const numberParameters = typescript_1.isNumberType(context, expressionType)
+            const numberParameters = (0, typescript_1.isNumberType)(context, expressionType)
                 ? parameters
-                : [lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Number, undefined, ...parameters)];
-            return lualib_1.transformLuaLibFunction(context, name === "isNaN" ? lualib_1.LuaLibFeature.NumberIsNaN : lualib_1.LuaLibFeature.NumberIsFinite, node, ...numberParameters);
+                : [(0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, undefined, ...parameters)];
+            return (0, lualib_1.transformLuaLibFunction)(context, name === "isNaN" ? lualib_1.LuaLibFeature.NumberIsNaN : lualib_1.LuaLibFeature.NumberIsFinite, node, ...numberParameters);
         case "parseFloat":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ParseFloat, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ParseFloat, node, ...parameters);
         case "parseInt":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ParseInt, node, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ParseInt, node, ...parameters);
     }
 }
 exports.transformGlobalCall = transformGlobalCall;

package/dist/transformation/builtins/index.js

@@ -21,31 +21,31 @@ const string_1 = require("./string");
 const symbol_1 = require("./symbol");
 function transformBuiltinPropertyAccessExpression(context, node) {
     const ownerType = context.checker.getTypeAtLocation(node.expression);
-    if (typescript_1.isStringType(context, ownerType)) {
-        return string_1.transformStringProperty(context, node);
+    if ((0, typescript_1.isStringType)(context, ownerType)) {
+        return (0, string_1.transformStringProperty)(context, node);
     }
-    if (typescript_1.isArrayType(context, ownerType)) {
-        return array_1.transformArrayProperty(context, node);
+    if ((0, typescript_1.isArrayType)(context, ownerType)) {
+        return (0, array_1.transformArrayProperty)(context, node);
     }
-    if (typescript_1.isFunctionType(context, ownerType)) {
-        return function_1.transformFunctionProperty(context, node);
+    if ((0, typescript_1.isFunctionType)(context, ownerType)) {
+        return (0, function_1.transformFunctionProperty)(context, node);
     }
-    if (ts.isIdentifier(node.expression) && typescript_1.isStandardLibraryType(context, ownerType, undefined)) {
+    if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
         switch (node.expression.text) {
             case "Math":
-                return math_1.transformMathProperty(context, node);
+                return (0, math_1.transformMathProperty)(context, node);
             case "Symbol":
-                lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Symbol);
+                (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Symbol);
         }
     }
 }
 exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAccessExpression;
 function transformBuiltinCallExpression(context, node) {
     const expressionType = context.checker.getTypeAtLocation(node.expression);
-    if (ts.isIdentifier(node.expression) && typescript_1.isStandardLibraryType(context, expressionType, undefined)) {
+    if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, expressionType, undefined)) {
         // TODO:
-        new_1.checkForLuaLibType(context, expressionType);
-        const result = global_1.transformGlobalCall(context, node);
+        (0, new_1.checkForLuaLibType)(context, expressionType);
+        const result = (0, global_1.transformGlobalCall)(context, node);
         if (result) {
             return result;
         }
@@ -53,43 +53,43 @@ function transformBuiltinCallExpression(context, node) {
     if (!ts.isPropertyAccessExpression(node.expression)) {
         return;
     }
-    utils_1.assume(node);
+    (0, utils_1.assume)(node);
     // If the function being called is of type owner.func, get the type of owner
     const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
-    if (typescript_1.isStandardLibraryType(context, ownerType, undefined)) {
+    if ((0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
         const symbol = ownerType.getSymbol();
         switch (symbol === null || symbol === void 0 ? void 0 : symbol.name) {
             case "ArrayConstructor":
-                return array_1.transformArrayConstructorCall(context, node);
+                return (0, array_1.transformArrayConstructorCall)(context, node);
             case "Console":
-                return console_1.transformConsoleCall(context, node);
+                return (0, console_1.transformConsoleCall)(context, node);
             case "Math":
-                return math_1.transformMathCall(context, node);
+                return (0, math_1.transformMathCall)(context, node);
             case "StringConstructor":
-                return string_1.transformStringConstructorCall(context, node);
+                return (0, string_1.transformStringConstructorCall)(context, node);
             case "ObjectConstructor":
-                return object_1.transformObjectConstructorCall(context, node);
+                return (0, object_1.transformObjectConstructorCall)(context, node);
             case "SymbolConstructor":
-                return symbol_1.transformSymbolConstructorCall(context, node);
+                return (0, symbol_1.transformSymbolConstructorCall)(context, node);
             case "NumberConstructor":
-                return number_1.transformNumberConstructorCall(context, node);
+                return (0, number_1.transformNumberConstructorCall)(context, node);
             case "PromiseConstructor":
-                return promise_1.transformPromiseConstructorCall(context, node);
+                return (0, promise_1.transformPromiseConstructorCall)(context, node);
         }
     }
-    if (typescript_1.isStringType(context, ownerType) && typescript_1.hasStandardLibrarySignature(context, node)) {
-        return string_1.transformStringPrototypeCall(context, node);
+    if ((0, typescript_1.isStringType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        return (0, string_1.transformStringPrototypeCall)(context, node);
     }
-    if (typescript_1.isNumberType(context, ownerType) && typescript_1.hasStandardLibrarySignature(context, node)) {
-        return number_1.transformNumberPrototypeCall(context, node);
+    if ((0, typescript_1.isNumberType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        return (0, number_1.transformNumberPrototypeCall)(context, node);
     }
-    if (typescript_1.isArrayType(context, ownerType) && typescript_1.hasStandardLibrarySignature(context, node)) {
-        return array_1.transformArrayPrototypeCall(context, node);
+    if ((0, typescript_1.isArrayType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        return (0, array_1.transformArrayPrototypeCall)(context, node);
     }
-    if (typescript_1.isFunctionType(context, ownerType) && typescript_1.hasStandardLibrarySignature(context, node)) {
-        return function_1.transformFunctionPrototypeCall(context, node);
+    if ((0, typescript_1.isFunctionType)(context, ownerType) && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
+        return (0, function_1.transformFunctionPrototypeCall)(context, node);
     }
-    const objectResult = object_1.transformObjectPrototypeCall(context, node);
+    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node);
     if (objectResult) {
         return objectResult;
     }
@@ -98,13 +98,13 @@ exports.transformBuiltinCallExpression = transformBuiltinCallExpression;
 function transformBuiltinIdentifierExpression(context, node) {
     switch (node.text) {
         case "NaN":
-            return lua_ast_1.createNaN(node);
+            return (0, lua_ast_1.createNaN)(node);
         case "Infinity":
             const math = lua.createIdentifier("math");
             const huge = lua.createStringLiteral("huge");
             return lua.createTableIndexExpression(math, huge, node);
         case "globalThis":
-            return lua.createIdentifier("_G", node, symbols_1.getIdentifierSymbolId(context, node), "globalThis");
+            return lua.createIdentifier("_G", node, (0, symbols_1.getIdentifierSymbolId)(context, node), "globalThis");
     }
 }
 exports.transformBuiltinIdentifierExpression = transformBuiltinIdentifierExpression;

package/dist/transformation/builtins/math.js

@@ -22,14 +22,14 @@ function transformMathProperty(context, node) {
         case "SQRT2":
             return lua.createNumericLiteral(Math[name], node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(node.name, "Math", name));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node.name, "Math", name));
     }
 }
 exports.transformMathProperty = transformMathProperty;
 function transformMathCall(context, node) {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
-    const params = call_1.transformArguments(context, node.arguments, signature);
+    const params = (0, call_1.transformArguments)(context, node.arguments, signature);
     const math = lua.createIdentifier("math");
     const expressionName = expression.name.text;
     switch (expressionName) {
@@ -37,7 +37,7 @@ function transformMathCall(context, node) {
         // Otherwise: math.atan2(y, x)
         case "atan2": {
             if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
-                return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.MathAtan2, node, ...params);
+                return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.MathAtan2, node, ...params);
             }
             const method = lua.createStringLiteral(context.luaTarget === CompilerOptions_1.LuaTarget.Lua53 ? "atan" : "atan2");
             return lua.createCallExpression(lua.createTableIndexExpression(math, method), params, node);
@@ -84,7 +84,7 @@ function transformMathCall(context, node) {
             return lua.createCallExpression(lua.createTableIndexExpression(math, method), params, node);
         }
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "Math", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Math", expressionName));
     }
 }
 exports.transformMathCall = transformMathCall;