typescript-to-lua 1.0.1 → 1.1.0

package/dist/transformation/builtins/number.js

@@ -8,30 +8,30 @@ const call_1 = require("../visitors/call");
 function transformNumberPrototypeCall(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 "toString":
             return params.length === 0
                 ? lua.createCallExpression(lua.createIdentifier("tostring"), [caller], node)
-                : lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.NumberToString, node, caller, ...params);
+                : (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.NumberToString, node, caller, ...params);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "number", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "number", expressionName));
     }
 }
 exports.transformNumberPrototypeCall = transformNumberPrototypeCall;
 function transformNumberConstructorCall(context, expression) {
     const method = expression.expression;
-    const parameters = call_1.transformArguments(context, expression.arguments);
+    const parameters = (0, call_1.transformArguments)(context, expression.arguments);
     const methodName = method.name.text;
     switch (methodName) {
         case "isNaN":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.NumberIsNaN, expression, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.NumberIsNaN, expression, ...parameters);
         case "isFinite":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.NumberIsFinite, expression, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.NumberIsFinite, expression, ...parameters);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(method.name, "Number", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Number", methodName));
     }
 }
 exports.transformNumberConstructorCall = transformNumberConstructorCall;

package/dist/transformation/builtins/object.js

@@ -7,27 +7,27 @@ const lualib_1 = require("../utils/lualib");
 const call_1 = require("../visitors/call");
 function transformObjectConstructorCall(context, expression) {
     const method = expression.expression;
-    const args = call_1.transformArguments(context, expression.arguments);
+    const args = (0, call_1.transformArguments)(context, expression.arguments);
     const methodName = method.name.text;
     switch (methodName) {
         case "assign":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectAssign, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectAssign, expression, ...args);
         case "defineProperty":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectDefineProperty, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectDefineProperty, expression, ...args);
         case "entries":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectEntries, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectEntries, expression, ...args);
         case "fromEntries":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectFromEntries, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectFromEntries, expression, ...args);
         case "getOwnPropertyDescriptor":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptor, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptor, expression, ...args);
         case "getOwnPropertyDescriptors":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptors, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectGetOwnPropertyDescriptors, expression, ...args);
         case "keys":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectKeys, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectKeys, expression, ...args);
         case "values":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectValues, expression, ...args);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectValues, expression, ...args);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(method.name, "Object", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Object", methodName));
     }
 }
 exports.transformObjectConstructorCall = transformObjectConstructorCall;
@@ -41,7 +41,7 @@ function transformObjectPrototypeCall(context, node) {
             return lua.createCallExpression(toStringIdentifier, [context.transformExpression(expression.expression)], node);
         case "hasOwnProperty":
             const expr = context.transformExpression(expression.expression);
-            const parameters = call_1.transformArguments(context, node.arguments, signature);
+            const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
             const rawGetIdentifier = lua.createIdentifier("rawget");
             const rawGetCall = lua.createCallExpression(rawGetIdentifier, [expr, ...parameters]);
             return lua.createBinaryExpression(rawGetCall, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator, node);

package/dist/transformation/builtins/promise.js

@@ -8,7 +8,7 @@ const typescript_1 = require("../utils/typescript");
 const call_1 = require("../visitors/call");
 function isPromiseClass(context, node) {
     const type = context.checker.getTypeAtLocation(node);
-    return typescript_1.isStandardLibraryType(context, type, undefined) && node.text === "Promise";
+    return (0, typescript_1.isStandardLibraryType)(context, type, undefined) && node.text === "Promise";
 }
 exports.isPromiseClass = isPromiseClass;
 function createPromiseIdentifier(original) {
@@ -18,25 +18,25 @@ exports.createPromiseIdentifier = createPromiseIdentifier;
 function transformPromiseConstructorCall(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 "all":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.PromiseAll, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseAll, node, ...params);
         case "allSettled":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.PromiseAllSettled, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseAllSettled, node, ...params);
         case "any":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.PromiseAny, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseAny, node, ...params);
         case "race":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.PromiseRace, node, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.PromiseRace, node, ...params);
         case "resolve":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Promise);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
             return lua.createCallExpression(createStaticPromiseFunctionAccessor("resolve", expression), params, node);
         case "reject":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Promise);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
             return lua.createCallExpression(createStaticPromiseFunctionAccessor("reject", expression), params, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "Promise", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "Promise", expressionName));
     }
 }
 exports.transformPromiseConstructorCall = transformPromiseConstructorCall;

package/dist/transformation/builtins/string.js

@@ -13,35 +13,37 @@ function createStringCall(methodName, tsOriginal, ...params) {
 function transformStringPrototypeCall(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 "replace":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringReplace, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringReplace, node, caller, ...params);
+        case "replaceAll":
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringReplaceAll, node, caller, ...params);
         case "concat":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringConcat, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringConcat, node, caller, ...params);
         case "indexOf": {
             const stringExpression = createStringCall("find", node, caller, params[0], params[1]
                 ? // string.find handles negative indexes by making it relative to string end, but for indexOf it's the same as 0
-                    lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("math"), lua.createStringLiteral("max")), [lua_ast_1.addToNumericExpression(params[1], 1), lua.createNumericLiteral(1)])
+                    lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("math"), lua.createStringLiteral("max")), [(0, lua_ast_1.addToNumericExpression)(params[1], 1), lua.createNumericLiteral(1)])
                 : lua.createNilLiteral(), lua.createBooleanLiteral(true));
             return lua.createBinaryExpression(lua.createBinaryExpression(stringExpression, lua.createNumericLiteral(0), lua.SyntaxKind.OrOperator), lua.createNumericLiteral(1), lua.SyntaxKind.SubtractionOperator, node);
         }
         case "substr":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSubstr, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSubstr, node, caller, ...params);
         case "substring":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSubstring, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSubstring, node, caller, ...params);
         case "slice": {
-            const literalArg1 = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalArg1 = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             if (params[0] && literalArg1 !== undefined) {
                 let stringSubArgs = [
-                    lua_ast_1.addToNumericExpression(params[0], literalArg1 < 0 ? 0 : 1),
+                    (0, lua_ast_1.addToNumericExpression)(params[0], literalArg1 < 0 ? 0 : 1),
                 ];
                 if (params[1]) {
-                    const literalArg2 = lua_ast_1.getNumberLiteralValue(params[1]);
+                    const literalArg2 = (0, lua_ast_1.getNumberLiteralValue)(params[1]);
                     if (literalArg2 !== undefined) {
-                        stringSubArgs.push(lua_ast_1.addToNumericExpression(params[1], literalArg2 < 0 ? -1 : 0));
+                        stringSubArgs.push((0, lua_ast_1.addToNumericExpression)(params[1], literalArg2 < 0 ? -1 : 0));
                     }
                     else {
                         stringSubArgs = undefined;
@@ -52,69 +54,69 @@ function transformStringPrototypeCall(context, node) {
                     return createStringCall("sub", node, caller, ...stringSubArgs);
                 }
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSlice, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSlice, node, caller, ...params);
         }
         case "toLowerCase":
             return createStringCall("lower", node, caller);
         case "toUpperCase":
             return createStringCall("upper", node, caller);
         case "trim":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrim, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrim, node, caller);
         case "trimEnd":
         case "trimRight":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrimEnd, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrimEnd, node, caller);
         case "trimStart":
         case "trimLeft":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringTrimStart, node, caller);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringTrimStart, node, caller);
         case "split":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringSplit, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringSplit, node, caller, ...params);
         case "charAt": {
-            const literalValue = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalValue = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             // Inline string.sub call if we know that parameter is pure and isn't negative
             if (literalValue !== undefined && literalValue >= 0) {
-                const firstParamPlusOne = lua_ast_1.addToNumericExpression(params[0], 1);
+                const firstParamPlusOne = (0, lua_ast_1.addToNumericExpression)(params[0], 1);
                 return createStringCall("sub", node, caller, firstParamPlusOne, firstParamPlusOne);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringCharAt, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringCharAt, node, caller, ...params);
         }
         case "charCodeAt": {
-            const literalValue = lua_ast_1.getNumberLiteralValue(params[0]);
+            const literalValue = (0, lua_ast_1.getNumberLiteralValue)(params[0]);
             // Inline string.sub call if we know that parameter is pure and isn't negative
             if (literalValue !== undefined && literalValue >= 0) {
-                return lua.createBinaryExpression(createStringCall("byte", node, caller, lua_ast_1.addToNumericExpression(params[0], 1)), lua_ast_1.createNaN(), lua.SyntaxKind.OrOperator);
+                return lua.createBinaryExpression(createStringCall("byte", node, caller, (0, lua_ast_1.addToNumericExpression)(params[0], 1)), (0, lua_ast_1.createNaN)(), lua.SyntaxKind.OrOperator);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringCharCodeAt, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringCharCodeAt, node, caller, ...params);
         }
         case "startsWith":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringStartsWith, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringStartsWith, node, caller, ...params);
         case "endsWith":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringEndsWith, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringEndsWith, node, caller, ...params);
         case "includes":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringIncludes, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringIncludes, node, caller, ...params);
         case "repeat":
             const math = lua.createIdentifier("math");
             const floor = lua.createStringLiteral("floor");
             const parameter = lua.createCallExpression(lua.createTableIndexExpression(math, floor), [params[0]]);
             return createStringCall("rep", node, caller, parameter);
         case "padStart":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringPadStart, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadStart, node, caller, ...params);
         case "padEnd":
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "string", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "string", expressionName));
     }
 }
 exports.transformStringPrototypeCall = transformStringPrototypeCall;
 function transformStringConstructorCall(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 "fromCharCode":
             return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier("string"), lua.createStringLiteral("char")), params, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(expression.name, "String", expressionName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(expression.name, "String", expressionName));
     }
 }
 exports.transformStringConstructorCall = transformStringConstructorCall;
@@ -124,7 +126,7 @@ function transformStringProperty(context, node) {
             const expression = context.transformExpression(node.expression);
             return lua.createUnaryExpression(expression, lua.SyntaxKind.LengthOperator, node);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(node.name, "string", node.name.text));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(node.name, "string", node.name.text));
     }
 }
 exports.transformStringProperty = transformStringProperty;

package/dist/transformation/builtins/symbol.js

@@ -8,17 +8,17 @@ const call_1 = require("../visitors/call");
 function transformSymbolConstructorCall(context, expression) {
     const method = expression.expression;
     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);
     const methodName = method.name.text;
     switch (methodName) {
         case "for":
         case "keyFor":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.SymbolRegistry);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.SymbolRegistry);
             const upperMethodName = methodName[0].toUpperCase() + methodName.slice(1);
             const functionIdentifier = lua.createIdentifier(`__TS__SymbolRegistry${upperMethodName}`);
             return lua.createCallExpression(functionIdentifier, parameters, expression);
         default:
-            context.diagnostics.push(diagnostics_1.unsupportedProperty(method.name, "Symbol", methodName));
+            context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(method.name, "Symbol", methodName));
     }
 }
 exports.transformSymbolConstructorCall = transformSymbolConstructorCall;

package/dist/transformation/context/context.js

@@ -35,13 +35,13 @@ class TransformationContext {
         }
         const nodeVisitors = this.visitorMap.get(node.kind);
         if (!nodeVisitors || nodeVisitors.length === 0) {
-            this.diagnostics.push(diagnostics_1.unsupportedNodeKind(node, node.kind));
+            this.diagnostics.push((0, diagnostics_1.unsupportedNodeKind)(node, node.kind));
             return isExpression ? [lua.createNilLiteral()] : [];
         }
         const previousNodeVisitors = this.currentNodeVisitors;
         this.currentNodeVisitors = [...nodeVisitors];
         const visitor = this.currentNodeVisitors.pop();
-        const result = lua_ast_1.unwrapVisitorResult(visitor.transform(node, this));
+        const result = (0, lua_ast_1.unwrapVisitorResult)(visitor.transform(node, this));
         this.currentNodeVisitors = previousNodeVisitors;
         return result;
     }
@@ -50,7 +50,7 @@ class TransformationContext {
             throw new Error(`There is no super transform for ${ts.SyntaxKind[node.kind]} visitor`);
         }
         const visitor = this.currentNodeVisitors.pop();
-        return lua_ast_1.unwrapVisitorResult(visitor.transform(node, this));
+        return (0, lua_ast_1.unwrapVisitorResult)(visitor.transform(node, this));
     }
     transformExpression(node) {
         const [result] = this.transformNode(node, true);
@@ -67,10 +67,10 @@ class TransformationContext {
         return result;
     }
     transformStatements(node) {
-        return utils_1.castArray(node).flatMap(n => this.transformNode(n));
+        return (0, utils_1.castArray)(node).flatMap(n => this.transformNode(n));
     }
     superTransformStatements(node) {
-        return utils_1.castArray(node).flatMap(n => this.superTransformNode(n));
+        return (0, utils_1.castArray)(node).flatMap(n => this.superTransformNode(n));
     }
 }
 exports.TransformationContext = TransformationContext;

package/dist/transformation/index.js

@@ -12,7 +12,7 @@ function createVisitorMap(customVisitors) {
             if (!visitor)
                 continue;
             const syntaxKind = Number(syntaxKindKey);
-            const nodeVisitors = utils_1.getOrUpdate(visitorMap, syntaxKind, () => []);
+            const nodeVisitors = (0, utils_1.getOrUpdate)(visitorMap, syntaxKind, () => []);
             const objectVisitor = typeof visitor === "function" ? { transform: visitor, priority } : visitor;
             nodeVisitors.push(objectVisitor);
         }

package/dist/transformation/utils/annotations.d.ts

@@ -14,9 +14,7 @@ export declare enum AnnotationKind {
     NoSelf = "noSelf",
     NoSelfInFile = "noSelfInFile",
     Vararg = "vararg",
-    ForRange = "forRange",
-    Jsx = "jsx",
-    JsxFrag = "jsxFrag"
+    ForRange = "forRange"
 }
 export interface Annotation {
     kind: AnnotationKind;

package/dist/transformation/utils/annotations.js

@@ -18,8 +18,6 @@ var AnnotationKind;
     AnnotationKind["NoSelfInFile"] = "noSelfInFile";
     AnnotationKind["Vararg"] = "vararg";
     AnnotationKind["ForRange"] = "forRange";
-    AnnotationKind["Jsx"] = "jsx";
-    AnnotationKind["JsxFrag"] = "jsxFrag";
 })(AnnotationKind = exports.AnnotationKind || (exports.AnnotationKind = {}));
 function createAnnotation(name, args) {
     const kind = Object.values(AnnotationKind).find(k => k.toLowerCase() === name.toLowerCase());

package/dist/transformation/utils/assignment-validation.js

@@ -16,7 +16,7 @@ function validateAssignment(context, node, fromType, toType, toName) {
         return;
     }
     // Use cache to avoid repeating check for same types (protects against infinite loop in recursive types)
-    const fromTypeCache = utils_1.getOrUpdate(typeValidationCache, fromType, () => new Set());
+    const fromTypeCache = (0, utils_1.getOrUpdate)(typeValidationCache, fromType, () => new Set());
     if (fromTypeCache.has(toType))
         return;
     fromTypeCache.add(toType);
@@ -40,7 +40,8 @@ function validateAssignment(context, node, fromType, toType, toName) {
         }
     }
     if ((toType.flags & ts.TypeFlags.Object) !== 0 &&
-        (toType.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0 &&
+        (ts.isTypeLiteralNode(toTypeNode) ||
+            (toType.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0) &&
         toType.symbol &&
         toType.symbol.members &&
         fromType.symbol &&
@@ -61,15 +62,15 @@ function validateAssignment(context, node, fromType, toType, toName) {
 }
 exports.validateAssignment = validateAssignment;
 function validateFunctionAssignment(context, node, fromType, toType, toName) {
-    const fromContext = function_context_1.getFunctionContextType(context, fromType);
-    const toContext = function_context_1.getFunctionContextType(context, toType);
+    const fromContext = (0, function_context_1.getFunctionContextType)(context, fromType);
+    const toContext = (0, function_context_1.getFunctionContextType)(context, toType);
     if (fromContext === function_context_1.ContextType.Mixed || toContext === function_context_1.ContextType.Mixed) {
-        context.diagnostics.push(diagnostics_1.unsupportedOverloadAssignment(node, toName));
+        context.diagnostics.push((0, diagnostics_1.unsupportedOverloadAssignment)(node, toName));
     }
     else if (fromContext !== toContext && fromContext !== function_context_1.ContextType.None && toContext !== function_context_1.ContextType.None) {
         context.diagnostics.push(toContext === function_context_1.ContextType.Void
-            ? diagnostics_1.unsupportedNoSelfFunctionConversion(node, toName)
-            : diagnostics_1.unsupportedSelfFunctionConversion(node, toName));
+            ? (0, diagnostics_1.unsupportedNoSelfFunctionConversion)(node, toName)
+            : (0, diagnostics_1.unsupportedSelfFunctionConversion)(node, toName));
     }
 }
 //# sourceMappingURL=assignment-validation.js.map

package/dist/transformation/utils/diagnostics.js

@@ -4,10 +4,10 @@ exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = expo
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const utils_1 = require("../../utils");
-const createDiagnosticFactory = (category, message) => utils_1.createSerialDiagnosticFactory((node, ...args) => ({
-    file: node.getSourceFile(),
-    start: node.getStart(),
-    length: node.getWidth(),
+const createDiagnosticFactory = (category, message) => (0, utils_1.createSerialDiagnosticFactory)((node, ...args) => ({
+    file: ts.getOriginalNode(node).getSourceFile(),
+    start: ts.getOriginalNode(node).getStart(),
+    length: ts.getOriginalNode(node).getWidth(),
     messageText: typeof message === "string" ? message : message(...args),
     category,
 }));

package/dist/transformation/utils/export.js

@@ -25,7 +25,7 @@ function getExportedSymbolDeclaration(symbol) {
 exports.getExportedSymbolDeclaration = getExportedSymbolDeclaration;
 function getSymbolFromIdentifier(context, identifier) {
     if (identifier.symbolId !== undefined) {
-        const symbolInfo = symbols_1.getSymbolInfo(context, identifier.symbolId);
+        const symbolInfo = (0, symbols_1.getSymbolInfo)(context, identifier.symbolId);
         if (symbolInfo !== undefined) {
             return symbolInfo.symbol;
         }
@@ -48,7 +48,7 @@ function getSymbolExportScope(context, symbol) {
     if (!exportedDeclaration) {
         return undefined;
     }
-    const scope = typescript_1.findFirstNodeAbove(exportedDeclaration, (n) => ts.isSourceFile(n) || ts.isModuleDeclaration(n));
+    const scope = (0, typescript_1.findFirstNodeAbove)(exportedDeclaration, (n) => ts.isSourceFile(n) || ts.isModuleDeclaration(n));
     if (!scope) {
         return undefined;
     }
@@ -98,8 +98,8 @@ function createExportedIdentifier(context, identifier, exportScope) {
         return identifier;
     }
     const exportTable = exportScope && ts.isModuleDeclaration(exportScope)
-        ? namespace_1.createModuleLocalNameIdentifier(context, exportScope)
-        : lua_ast_1.createExportsIdentifier();
+        ? (0, namespace_1.createModuleLocalNameIdentifier)(context, exportScope)
+        : (0, lua_ast_1.createExportsIdentifier)();
     return lua.createTableIndexExpression(exportTable, lua.createStringLiteral(identifier.text));
 }
 exports.createExportedIdentifier = createExportedIdentifier;

package/dist/transformation/utils/function-context.js

@@ -12,14 +12,14 @@ var ContextType;
     ContextType[ContextType["Mixed"] = 3] = "Mixed";
 })(ContextType = exports.ContextType || (exports.ContextType = {}));
 function hasNoSelfAncestor(declaration) {
-    const scopeDeclaration = typescript_1.findFirstNodeAbove(declaration, (node) => ts.isSourceFile(node) || ts.isModuleDeclaration(node));
+    const scopeDeclaration = (0, typescript_1.findFirstNodeAbove)(declaration, (node) => ts.isSourceFile(node) || ts.isModuleDeclaration(node));
     if (!scopeDeclaration) {
         return false;
     }
     else if (ts.isSourceFile(scopeDeclaration)) {
-        return annotations_1.getFileAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelfInFile);
+        return (0, annotations_1.getFileAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelfInFile);
     }
-    else if (annotations_1.getNodeAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+    else if ((0, annotations_1.getNodeAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
         return true;
     }
     else {
@@ -38,7 +38,7 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
             : ContextType.NonVoid;
     }
     // noSelf declaration on function signature
-    if (annotations_1.getNodeAnnotations(signatureDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+    if ((0, annotations_1.getNodeAnnotations)(signatureDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
         return ContextType.Void;
     }
     if (ts.isMethodSignature(signatureDeclaration) ||
@@ -48,11 +48,11 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
         (signatureDeclaration.parent && ts.isPropertyDeclaration(signatureDeclaration.parent)) ||
         (signatureDeclaration.parent && ts.isPropertySignature(signatureDeclaration.parent))) {
         // Class/interface methods only respect @noSelf on their parent
-        const scopeDeclaration = typescript_1.findFirstNodeAbove(signatureDeclaration, (n) => ts.isClassDeclaration(n) || ts.isClassExpression(n) || ts.isInterfaceDeclaration(n));
+        const scopeDeclaration = (0, typescript_1.findFirstNodeAbove)(signatureDeclaration, (n) => ts.isClassDeclaration(n) || ts.isClassExpression(n) || ts.isInterfaceDeclaration(n));
         if (scopeDeclaration === undefined) {
             return ContextType.NonVoid;
         }
-        if (annotations_1.getNodeAnnotations(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
+        if ((0, annotations_1.getNodeAnnotations)(scopeDeclaration).has(annotations_1.AnnotationKind.NoSelf)) {
             return ContextType.Void;
         }
         return ContextType.NonVoid;
@@ -98,10 +98,10 @@ function getSignatureDeclarations(context, signatures) {
         else if ((ts.isFunctionExpression(signatureDeclaration) || ts.isArrowFunction(signatureDeclaration)) &&
             !getExplicitThisParameter(signatureDeclaration)) {
             // Infer type of function expressions/arrow functions
-            inferredType = typescript_1.inferAssignedType(context, signatureDeclaration);
+            inferredType = (0, typescript_1.inferAssignedType)(context, signatureDeclaration);
         }
         if (inferredType) {
-            const inferredSignatures = typescript_1.getAllCallSignatures(inferredType);
+            const inferredSignatures = (0, typescript_1.getAllCallSignatures)(inferredType);
             if (inferredSignatures.length > 0) {
                 return inferredSignatures.map(s => s.getDeclaration());
             }

package/dist/transformation/utils/lua-ast.js

@@ -10,7 +10,7 @@ const scope_1 = require("./scope");
 const lualib_1 = require("./lualib");
 const LuaLib_1 = require("../../LuaLib");
 function unwrapVisitorResult(result) {
-    return result === undefined ? [] : utils_1.castArray(result);
+    return result === undefined ? [] : (0, utils_1.castArray)(result);
 }
 exports.unwrapVisitorResult = unwrapVisitorResult;
 function createSelfIdentifier(tsOriginal) {
@@ -58,7 +58,7 @@ exports.getNumberLiteralValue = getNumberLiteralValue;
 // Prefer use of transformToImmediatelyInvokedFunctionExpression to maintain correct scope. If you use this directly,
 // ensure you push/pop a function scope appropriately to avoid incorrect vararg optimization.
 function createImmediatelyInvokedFunctionExpression(statements, result, tsOriginal) {
-    const body = [...statements, lua.createReturnStatement(utils_1.castArray(result))];
+    const body = [...statements, lua.createReturnStatement((0, utils_1.castArray)(result))];
     const flags = statements.length === 0 ? lua.FunctionExpressionFlags.Inline : lua.FunctionExpressionFlags.None;
     const iife = lua.createFunctionExpression(lua.createBlock(body), undefined, undefined, flags);
     return lua.createCallExpression(iife, [], tsOriginal);
@@ -66,7 +66,7 @@ function createImmediatelyInvokedFunctionExpression(statements, result, tsOrigin
 exports.createImmediatelyInvokedFunctionExpression = createImmediatelyInvokedFunctionExpression;
 function createUnpackCall(context, expression, tsOriginal) {
     if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal) {
-        return lualib_1.transformLuaLibFunction(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
+        return (0, lualib_1.transformLuaLibFunction)(context, LuaLib_1.LuaLibFeature.Unpack, tsOriginal, expression);
     }
     const unpack = context.luaTarget === CompilerOptions_1.LuaTarget.Lua51 || context.luaTarget === CompilerOptions_1.LuaTarget.LuaJIT
         ? lua.createIdentifier("unpack")
@@ -91,8 +91,8 @@ exports.wrapInToStringForConcat = wrapInToStringForConcat;
 function createHoistableVariableDeclarationStatement(context, identifier, initializer, tsOriginal) {
     const declaration = lua.createVariableDeclarationStatement(identifier, initializer, tsOriginal);
     if (identifier.symbolId !== undefined) {
-        const scope = scope_1.peekScope(context);
-        utils_1.assert(scope.type !== scope_1.ScopeType.Switch);
+        const scope = (0, scope_1.peekScope)(context);
+        (0, utils_1.assert)(scope.type !== scope_1.ScopeType.Switch);
         if (!scope.variableDeclarations) {
             scope.variableDeclarations = [];
         }
@@ -106,32 +106,32 @@ function hasMultipleReferences(scope, identifiers) {
     if (!scopeSymbols) {
         return false;
     }
-    const referenceLists = utils_1.castArray(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
+    const referenceLists = (0, utils_1.castArray)(identifiers).map(i => i.symbolId && scopeSymbols.get(i.symbolId));
     return referenceLists.some(symbolRefs => symbolRefs && symbolRefs.length > 1);
 }
 function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal, overrideExportScope) {
     let declaration;
     let assignment;
     const isFunctionDeclaration = tsOriginal !== undefined && ts.isFunctionDeclaration(tsOriginal);
-    const identifiers = utils_1.castArray(lhs);
+    const identifiers = (0, utils_1.castArray)(lhs);
     if (identifiers.length === 0) {
         return [];
     }
-    const exportScope = overrideExportScope !== null && overrideExportScope !== void 0 ? overrideExportScope : export_1.getIdentifierExportScope(context, identifiers[0]);
+    const exportScope = overrideExportScope !== null && overrideExportScope !== void 0 ? overrideExportScope : (0, export_1.getIdentifierExportScope)(context, identifiers[0]);
     if (exportScope) {
         // exported
         if (!rhs) {
             return [];
         }
         else {
-            assignment = lua.createAssignmentStatement(identifiers.map(identifier => export_1.createExportedIdentifier(context, identifier, exportScope)), rhs, tsOriginal);
+            assignment = lua.createAssignmentStatement(identifiers.map(identifier => (0, export_1.createExportedIdentifier)(context, identifier, exportScope)), rhs, tsOriginal);
         }
     }
     else {
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         const isTopLevelVariable = scope.type === scope_1.ScopeType.File;
         if (context.isModule || !isTopLevelVariable) {
-            if (scope.type === scope_1.ScopeType.Switch || (!isFunctionDeclaration && hasMultipleReferences(scope, lhs))) {
+            if (!isFunctionDeclaration && hasMultipleReferences(scope, lhs)) {
                 // Split declaration and assignment of identifiers that reference themselves in their declaration
                 declaration = lua.createVariableDeclarationStatement(lhs, undefined, tsOriginal);
                 if (rhs) {
@@ -141,13 +141,12 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
             else {
                 declaration = lua.createVariableDeclarationStatement(lhs, rhs, tsOriginal);
             }
-            // Remember local variable declarations for hoisting later
-            if (!scope.variableDeclarations) {
-                scope.variableDeclarations = [];
-            }
-            scope.variableDeclarations.push(declaration);
-            if (scope.type === scope_1.ScopeType.Switch) {
-                declaration = undefined;
+            if (!isFunctionDeclaration) {
+                // Remember local variable declarations for hoisting later
+                if (!scope.variableDeclarations) {
+                    scope.variableDeclarations = [];
+                }
+                scope.variableDeclarations.push(declaration);
             }
         }
         else if (rhs) {
@@ -161,7 +160,7 @@ function createLocalOrExportedOrGlobalDeclaration(context, lhs, rhs, tsOriginal,
     if (isFunctionDeclaration) {
         // Remember function definitions for hoisting later
         const functionSymbolId = lhs.symbolId;
-        const scope = scope_1.peekScope(context);
+        const scope = (0, scope_1.peekScope)(context);
         if (functionSymbolId && scope.functionDefinitions) {
             const definitions = scope.functionDefinitions.get(functionSymbolId);
             if (definitions) {

package/dist/transformation/utils/lualib.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "LuaLibFeature", { enumerable: true, get: functio
 const utils_1 = require("../../utils");
 const luaLibFeatures = new WeakMap();
 function getUsedLuaLibFeatures(context) {
-    return utils_1.getOrUpdate(luaLibFeatures, context, () => new Set());
+    return (0, utils_1.getOrUpdate)(luaLibFeatures, context, () => new Set());
 }
 exports.getUsedLuaLibFeatures = getUsedLuaLibFeatures;
 function importLuaLibFeature(context, feature) {