typescript-to-lua 0.42.0 → 1.1.1

package/dist/transformation/visitors/call.js

@@ -46,7 +46,7 @@ function transformSpreadableExpressionsIntoArrayConcatArguments(context, express
             lastChunk.push(expression);
         }
     }
-    return chunks.map(chunk => lua_ast_1.wrapInTable(...chunk.map(expression => context.transformExpression(expression))));
+    return chunks.map(chunk => (0, lua_ast_1.wrapInTable)(...chunk.map(expression => context.transformExpression(expression))));
 }
 function flattenSpreadExpressions(context, expressions) {
     const [preSpreadExpressions, postSpreadExpressions] = getExpressionsBeforeAndAfterFirstSpread(expressions);
@@ -61,7 +61,7 @@ function flattenSpreadExpressions(context, expressions) {
     }
     // Use Array.concat and unpack the result of that as the last Expression
     const concatArguments = transformSpreadableExpressionsIntoArrayConcatArguments(context, postSpreadExpressions);
-    const lastExpression = lua_ast_1.createUnpackCall(context, lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArrayConcat, undefined, ...concatArguments));
+    const lastExpression = (0, lua_ast_1.createUnpackCall)(context, (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArrayConcat, undefined, ...concatArguments));
     return [...transformedPreSpreadExpressions, lastExpression];
 }
 exports.flattenSpreadExpressions = flattenSpreadExpressions;
@@ -77,7 +77,7 @@ function transformArguments(context, params, signature, callContext) {
             const paramType = context.checker.getTypeAtLocation(param);
             if (signatureParameter.valueDeclaration !== undefined) {
                 const signatureType = context.checker.getTypeAtLocation(signatureParameter.valueDeclaration);
-                assignment_validation_1.validateAssignment(context, param, paramType, signatureType, signatureParameter.name);
+                (0, assignment_validation_1.validateAssignment)(context, param, paramType, signatureType, signatureParameter.name);
             }
         }
     }
@@ -89,7 +89,7 @@ function transformElementAccessCall(context, left, args, signature) {
     // Cache left-side if it has effects
     // (function() local ____self = context; return ____self[argument](parameters); end)()
     const argument = ts.isElementAccessExpression(left)
-        ? access_1.transformElementAccessArgument(context, left)
+        ? (0, access_1.transformElementAccessArgument)(context, left)
         : lua.createStringLiteral(left.name.text);
     const selfIdentifier = lua.createIdentifier("____self");
     const callContext = context.transformExpression(left.expression);
@@ -100,19 +100,20 @@ function transformElementAccessCall(context, left, args, signature) {
 }
 function transformContextualCallExpression(context, node, args, signature) {
     const left = ts.isCallExpression(node) ? node.expression : node.tag;
-    if (ts.isPropertyAccessExpression(left) && ts.isIdentifier(left.name) && safe_names_1.isValidLuaIdentifier(left.name.text)) {
+    if (ts.isPropertyAccessExpression(left) && ts.isIdentifier(left.name) && (0, safe_names_1.isValidLuaIdentifier)(left.name.text)) {
         // table:name()
         const table = context.transformExpression(left.expression);
         if (ts.isOptionalChain(node)) {
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalMethodCall, node, table, lua.createStringLiteral(left.name.text, left.name), ...transformArguments(context, args, signature));
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalMethodCall, node, table, lua.createStringLiteral(left.name.text, left.name), lua.createBooleanLiteral(node.questionDotToken !== undefined), // Require method is present if no ?.() call
+            ...transformArguments(context, args, signature));
         }
         else {
             return lua.createMethodCallExpression(table, lua.createIdentifier(left.name.text, left.name), transformArguments(context, args, signature), node);
         }
     }
     else if (ts.isElementAccessExpression(left) || ts.isPropertyAccessExpression(left)) {
-        if (typescript_1.isExpressionWithEvaluationEffect(left.expression)) {
-            return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => transformElementAccessCall(context, left, args, signature), node);
+        if ((0, typescript_1.isExpressionWithEvaluationEffect)(left.expression)) {
+            return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => transformElementAccessCall(context, left, args, signature), node);
         }
         else {
             const callContext = context.transformExpression(left.expression);
@@ -140,7 +141,7 @@ function transformPropertyCall(context, node) {
         return lua.createCallExpression(context.transformExpression(node.expression), parameters);
     }
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    if (!signatureDeclaration || function_context_1.getDeclarationContextType(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
+    if (!signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
         // table:name()
         return transformContextualCallExpression(context, node, node.arguments, signature);
     }
@@ -149,7 +150,7 @@ function transformPropertyCall(context, node) {
         const callPath = context.transformExpression(node.expression);
         const parameters = transformArguments(context, node.arguments, signature);
         if (ts.isOptionalChain(node)) {
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, callPath, ...parameters);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, callPath, ...parameters);
         }
         else {
             return lua.createCallExpression(callPath, parameters, node);
@@ -159,7 +160,7 @@ function transformPropertyCall(context, node) {
 function transformElementCall(context, node) {
     const signature = context.checker.getResolvedSignature(node);
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
-    if (!signatureDeclaration || function_context_1.getDeclarationContextType(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
+    if (!signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void) {
         // A contextual parameter must be given to this call expression
         return transformContextualCallExpression(context, node, node.arguments, signature);
     }
@@ -171,38 +172,41 @@ function transformElementCall(context, node) {
     }
 }
 const transformCallExpression = (node, context) => {
-    const wrapResultInTable = multi_1.isMultiReturnCall(context, node) && multi_1.shouldMultiReturnCallBeWrapped(context, node);
+    const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
     const wrapResultInOptional = ts.isOptionalChain(node);
-    const builtinResult = builtins_1.transformBuiltinCallExpression(context, node);
+    const builtinResult = (0, builtins_1.transformBuiltinCallExpression)(context, node);
     if (builtinResult) {
-        return wrapResultInTable ? lua_ast_1.wrapInTable(builtinResult) : builtinResult;
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinResult) : builtinResult;
     }
-    if (operators_1.isOperatorMapping(context, node)) {
-        return operators_1.transformOperatorMappingExpression(context, node);
+    if ((0, annotations_1.isTupleReturnCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
     }
-    if (table_1.isTableDeleteCall(context, node)) {
-        context.diagnostics.push(diagnostics_1.invalidTableDeleteExpression(node));
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => ({ statements: table_1.transformTableDeleteExpression(context, node), result: lua.createNilLiteral() }), node);
+    if ((0, operators_1.isOperatorMapping)(context, node)) {
+        return (0, operators_1.transformOperatorMappingExpression)(context, node);
     }
-    if (table_1.isTableGetCall(context, node)) {
-        return table_1.transformTableGetExpression(context, node);
+    if ((0, table_1.isTableDeleteCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.invalidTableDeleteExpression)(node));
+        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => ({ statements: (0, table_1.transformTableDeleteExpression)(context, node), result: lua.createNilLiteral() }), node);
     }
-    if (table_1.isTableHasCall(context, node)) {
-        return table_1.transformTableHasExpression(context, node);
+    if ((0, table_1.isTableGetCall)(context, node)) {
+        return (0, table_1.transformTableGetExpression)(context, node);
     }
-    if (table_1.isTableSetCall(context, node)) {
-        context.diagnostics.push(diagnostics_1.invalidTableSetExpression(node));
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => ({ statements: table_1.transformTableSetExpression(context, node), result: lua.createNilLiteral() }), node);
+    if ((0, table_1.isTableHasCall)(context, node)) {
+        return (0, table_1.transformTableHasExpression)(context, node);
+    }
+    if ((0, table_1.isTableSetCall)(context, node)) {
+        context.diagnostics.push((0, diagnostics_1.invalidTableSetExpression)(node));
+        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => ({ statements: (0, table_1.transformTableSetExpression)(context, node), result: lua.createNilLiteral() }), node);
     }
     if (ts.isPropertyAccessExpression(node.expression)) {
         const ownerType = context.checker.getTypeAtLocation(node.expression.expression);
-        const annotations = annotations_1.getTypeAnnotations(ownerType);
+        const annotations = (0, annotations_1.getTypeAnnotations)(ownerType);
         if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-            context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.LuaTable));
+            context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
         }
         const result = transformPropertyCall(context, node);
         // transformPropertyCall already wraps optional so no need to do so here
-        return wrapResultInTable ? lua_ast_1.wrapInTable(result) : result;
+        return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
     if (ts.isElementAccessExpression(node.expression)) {
         const result = transformElementCall(context, node);
@@ -217,7 +221,7 @@ const transformCallExpression = (node, context) => {
     const callPath = context.transformExpression(node.expression);
     const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
     let parameters = [];
-    if (signatureDeclaration && function_context_1.getDeclarationContextType(context, signatureDeclaration) === function_context_1.ContextType.Void) {
+    if (signatureDeclaration && (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) === function_context_1.ContextType.Void) {
         parameters = transformArguments(context, node.arguments, signature);
     }
     else {
@@ -230,14 +234,15 @@ const transformCallExpression = (node, context) => {
 exports.transformCallExpression = transformCallExpression;
 function wrapIfRequired(context, shouldWrapInTable, shouldWrapOptional, call, node) {
     const wrappedOptional = shouldWrapOptional ? wrapOptionalCall(context, call, node) : call;
-    return shouldWrapInTable ? lua_ast_1.wrapInTable(wrappedOptional) : wrappedOptional;
+    return shouldWrapInTable ? (0, lua_ast_1.wrapInTable)(wrappedOptional) : wrappedOptional;
 }
 function wrapOptionalCall(context, call, node) {
     if (lua.isMethodCallExpression(call)) {
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalMethodCall, node, call.prefixExpression, lua.createStringLiteral(call.name.text), ...call.params);
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalMethodCall, node, call.prefixExpression, lua.createStringLiteral(call.name.text), lua.createBooleanLiteral(node.questionDotToken !== undefined), // Require method is present if no ?.() call
+        ...call.params);
     }
     else {
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, call.expression, ...call.params);
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.OptionalFunctionCall, node, call.expression, ...call.params);
     }
 }
 //# sourceMappingURL=call.js.map

package/dist/transformation/visitors/class/decorators.js

@@ -9,9 +9,9 @@ const lualib_1 = require("../../utils/lualib");
 function transformDecoratorExpression(context, decorator) {
     const expression = decorator.expression;
     const type = context.checker.getTypeAtLocation(expression);
-    const callContext = function_context_1.getFunctionContextType(context, type);
+    const callContext = (0, function_context_1.getFunctionContextType)(context, type);
     if (callContext === function_context_1.ContextType.Void) {
-        context.diagnostics.push(diagnostics_1.decoratorInvalidContext(decorator));
+        context.diagnostics.push((0, diagnostics_1.decoratorInvalidContext)(decorator));
     }
     return context.transformExpression(expression);
 }
@@ -26,7 +26,7 @@ function createDecoratingExpression(context, kind, decorators, targetTableName,
             kind === ts.SyntaxKind.SetAccessor;
         trailingExpressions.push(isMethodOrAccessor ? lua.createBooleanLiteral(true) : lua.createNilLiteral());
     }
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.Decorate, undefined, ...trailingExpressions);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Decorate, undefined, ...trailingExpressions);
 }
 exports.createDecoratingExpression = createDecoratingExpression;
 //# sourceMappingURL=decorators.js.map

package/dist/transformation/visitors/class/index.js

@@ -21,8 +21,8 @@ const setup_1 = require("./setup");
 const utils_2 = require("./utils");
 const transformClassDeclaration = (declaration, context) => {
     // If declaration is a default export, transform to export variable assignment instead
-    if (export_1.hasDefaultExportModifier(declaration)) {
-        const left = export_1.createExportedIdentifier(context, export_1.createDefaultExportIdentifier(declaration));
+    if ((0, export_1.hasDefaultExportModifier)(declaration)) {
+        const left = (0, export_1.createDefaultExportExpression)(declaration);
         const right = transformClassAsExpression(declaration, context);
         return [lua.createAssignmentStatement(left, right, declaration)];
     }
@@ -30,12 +30,12 @@ const transformClassDeclaration = (declaration, context) => {
     return statements;
 };
 exports.transformClassDeclaration = transformClassDeclaration;
-const transformThisExpression = node => lua_ast_1.createSelfIdentifier(node);
+const transformThisExpression = node => (0, lua_ast_1.createSelfIdentifier)(node);
 exports.transformThisExpression = transformThisExpression;
 function transformClassAsExpression(expression, context) {
-    return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => {
+    return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => {
         const { statements, name } = transformClassLikeDeclaration(expression, context);
-        return { statements: lua_ast_1.unwrapVisitorResult(statements), result: name };
+        return { statements: (0, lua_ast_1.unwrapVisitorResult)(statements), result: name };
     }, expression);
 }
 exports.transformClassAsExpression = transformClassAsExpression;
@@ -46,52 +46,52 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         className = nameOverride;
     }
     else if (classDeclaration.name !== undefined) {
-        className = identifier_1.transformIdentifier(context, classDeclaration.name);
+        className = (0, identifier_1.transformIdentifier)(context, classDeclaration.name);
     }
     else {
         // TypeScript error
         className = lua.createAnonymousIdentifier();
     }
-    const annotations = annotations_1.getTypeAnnotations(context.checker.getTypeAtLocation(classDeclaration));
+    const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(classDeclaration));
     if (annotations.has(annotations_1.AnnotationKind.Extension)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(classDeclaration, annotations_1.AnnotationKind.Extension));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(classDeclaration, annotations_1.AnnotationKind.Extension));
     }
     if (annotations.has(annotations_1.AnnotationKind.MetaExtension)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(classDeclaration, annotations_1.AnnotationKind.MetaExtension));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(classDeclaration, annotations_1.AnnotationKind.MetaExtension));
     }
     // Get type that is extended
-    const extendedTypeNode = utils_2.getExtendedNode(context, classDeclaration);
-    const extendedType = utils_2.getExtendedType(context, classDeclaration);
-    const superInfo = utils_1.getOrUpdate(classSuperInfos, context, () => []);
+    const extendedTypeNode = (0, utils_2.getExtendedNode)(context, classDeclaration);
+    const extendedType = (0, utils_2.getExtendedType)(context, classDeclaration);
+    const superInfo = (0, utils_1.getOrUpdate)(classSuperInfos, context, () => []);
     superInfo.push({ className, extendedTypeNode });
     if (extendedType) {
-        new_1.checkForLuaLibType(context, extendedType);
+        (0, new_1.checkForLuaLibType)(context, extendedType);
     }
     // Get all properties with value
     const properties = classDeclaration.members.filter(ts.isPropertyDeclaration).filter(member => member.initializer);
     // Divide properties into static and non-static
-    const instanceFields = properties.filter(prop => !utils_2.isStaticNode(prop));
+    const instanceFields = properties.filter(prop => !(0, utils_2.isStaticNode)(prop));
     const result = [];
     let localClassName;
-    if (safe_names_1.isUnsafeName(className.text)) {
-        localClassName = lua.createIdentifier(safe_names_1.createSafeName(className.text), undefined, className.symbolId, className.text);
+    if ((0, safe_names_1.isUnsafeName)(className.text)) {
+        localClassName = lua.createIdentifier((0, safe_names_1.createSafeName)(className.text), undefined, className.symbolId, className.text);
         lua.setNodePosition(localClassName, className);
     }
     else {
         localClassName = className;
     }
-    result.push(...setup_1.createClassSetup(context, classDeclaration, className, localClassName, extendedType));
+    result.push(...(0, setup_1.createClassSetup)(context, classDeclaration, className, localClassName, extendedType));
     // Find first constructor with body
     const constructor = classDeclaration.members.find((n) => ts.isConstructorDeclaration(n) && n.body !== undefined);
     if (constructor) {
         // Add constructor plus initialization of instance fields
-        const constructorResult = constructor_1.transformConstructorDeclaration(context, constructor, localClassName, instanceFields, classDeclaration);
+        const constructorResult = (0, constructor_1.transformConstructorDeclaration)(context, constructor, localClassName, instanceFields, classDeclaration);
         if (constructorResult)
             result.push(constructorResult);
     }
     else if (!extendedType) {
         // Generate a constructor if none was defined in a base class
-        const constructorResult = constructor_1.transformConstructorDeclaration(context, ts.factory.createConstructorDeclaration([], [], [], ts.factory.createBlock([], true)), localClassName, instanceFields, classDeclaration);
+        const constructorResult = (0, constructor_1.transformConstructorDeclaration)(context, ts.factory.createConstructorDeclaration([], [], [], ts.factory.createBlock([], true)), localClassName, instanceFields, classDeclaration);
         if (constructorResult)
             result.push(constructorResult);
     }
@@ -100,11 +100,11 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         // localClassName.prototype.____constructor = function(self, ...)
         //     baseClassName.prototype.____constructor(self, ...)
         //     ...
-        const constructorBody = fields_1.transformClassInstanceFields(context, instanceFields);
-        const superCall = lua.createExpressionStatement(lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), [lua_ast_1.createSelfIdentifier(), lua.createDotsLiteral()]));
+        const constructorBody = (0, fields_1.transformClassInstanceFields)(context, instanceFields);
+        const superCall = lua.createExpressionStatement(lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), [(0, lua_ast_1.createSelfIdentifier)(), lua.createDotsLiteral()]));
         constructorBody.unshift(superCall);
-        const constructorFunction = lua.createFunctionExpression(lua.createBlock(constructorBody), [lua_ast_1.createSelfIdentifier()], lua.createDotsLiteral(), lua.FunctionExpressionFlags.Declaration);
-        result.push(lua.createAssignmentStatement(constructor_1.createConstructorName(localClassName), constructorFunction, classDeclaration));
+        const constructorFunction = lua.createFunctionExpression(lua.createBlock(constructorBody), [(0, lua_ast_1.createSelfIdentifier)()], lua.createDotsLiteral(), lua.FunctionExpressionFlags.Declaration);
+        result.push(lua.createAssignmentStatement((0, constructor_1.createConstructorName)(localClassName), constructorFunction, classDeclaration));
     }
     // Transform accessors
     for (const member of classDeclaration.members) {
@@ -113,7 +113,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         const accessors = context.resolver.getAllAccessorDeclarations(member);
         if (accessors.firstAccessor !== member)
             continue;
-        const accessorsResult = accessors_1.transformAccessorDeclarations(context, accessors, localClassName);
+        const accessorsResult = (0, accessors_1.transformAccessorDeclarations)(context, accessors, localClassName);
         if (accessorsResult) {
             result.push(accessorsResult);
         }
@@ -121,27 +121,27 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
     const decorationStatements = [];
     for (const member of classDeclaration.members) {
         if (ts.isAccessor(member)) {
-            const expression = fields_1.createPropertyDecoratingExpression(context, member, localClassName);
+            const expression = (0, fields_1.createPropertyDecoratingExpression)(context, member, localClassName);
             if (expression)
                 decorationStatements.push(lua.createExpressionStatement(expression));
         }
         else if (ts.isMethodDeclaration(member)) {
-            const statement = method_1.transformMethodDeclaration(context, member, localClassName);
+            const statement = (0, method_1.transformMethodDeclaration)(context, member, localClassName);
             if (statement)
                 result.push(statement);
             if (member.body) {
-                const statement = method_1.createMethodDecoratingExpression(context, member, localClassName);
+                const statement = (0, method_1.createMethodDecoratingExpression)(context, member, localClassName);
                 if (statement)
                     decorationStatements.push(statement);
             }
         }
         else if (ts.isPropertyDeclaration(member)) {
-            if (utils_2.isStaticNode(member)) {
-                const statement = fields_1.transformStaticPropertyDeclaration(context, member, localClassName);
+            if ((0, utils_2.isStaticNode)(member)) {
+                const statement = (0, fields_1.transformStaticPropertyDeclaration)(context, member, localClassName);
                 if (statement)
                     decorationStatements.push(statement);
             }
-            const expression = fields_1.createPropertyDecoratingExpression(context, member, localClassName);
+            const expression = (0, fields_1.createPropertyDecoratingExpression)(context, member, localClassName);
             if (expression)
                 decorationStatements.push(lua.createExpressionStatement(expression));
         }
@@ -149,15 +149,22 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
     result.push(...decorationStatements);
     // Decorate the class
     if (classDeclaration.decorators) {
-        const decoratingExpression = decorators_1.createDecoratingExpression(context, classDeclaration.kind, classDeclaration.decorators.map(d => decorators_1.transformDecoratorExpression(context, d)), localClassName);
+        const decoratingExpression = (0, decorators_1.createDecoratingExpression)(context, classDeclaration.kind, classDeclaration.decorators.map(d => (0, decorators_1.transformDecoratorExpression)(context, d)), localClassName);
         const decoratingStatement = lua.createAssignmentStatement(localClassName, decoratingExpression);
         result.push(decoratingStatement);
+        if ((0, export_1.hasExportModifier)(classDeclaration)) {
+            const exportExpression = (0, export_1.hasDefaultExportModifier)(classDeclaration)
+                ? (0, export_1.createDefaultExportExpression)(classDeclaration)
+                : (0, export_1.createExportedIdentifier)(context, className);
+            const classAssignment = lua.createAssignmentStatement(exportExpression, localClassName);
+            result.push(classAssignment);
+        }
     }
     superInfo.pop();
     return { statements: result, name: className };
 }
 const transformSuperExpression = (expression, context) => {
-    const superInfos = utils_1.getOrUpdate(classSuperInfos, context, () => []);
+    const superInfos = (0, utils_1.getOrUpdate)(classSuperInfos, context, () => []);
     const superInfo = superInfos[superInfos.length - 1];
     if (!superInfo)
         return lua.createAnonymousIdentifier(expression);
@@ -167,9 +174,9 @@ const transformSuperExpression = (expression, context) => {
     let baseClassName;
     if (extendsExpression && ts.isIdentifier(extendsExpression)) {
         const symbol = context.checker.getSymbolAtLocation(extendsExpression);
-        if (symbol && !export_1.isSymbolExported(context, symbol)) {
+        if (symbol && !(0, export_1.isSymbolExported)(context, symbol)) {
             // Use "baseClassName" if base is a simple identifier
-            baseClassName = identifier_1.transformIdentifier(context, extendsExpression);
+            baseClassName = (0, identifier_1.transformIdentifier)(context, extendsExpression);
         }
     }
     if (!baseClassName) {

package/dist/transformation/visitors/class/members/accessors.js

@@ -9,12 +9,12 @@ const literal_1 = require("../../literal");
 const utils_1 = require("../utils");
 const constructor_1 = require("./constructor");
 function transformAccessor(context, node) {
-    const [params, dot, restParam] = function_1.transformParameters(context, node.parameters, lua_ast_1.createSelfIdentifier());
-    const body = node.body ? function_1.transformFunctionBody(context, node.parameters, node.body, restParam)[0] : [];
+    const [params, dot, restParam] = (0, function_1.transformParameters)(context, node.parameters, (0, lua_ast_1.createSelfIdentifier)());
+    const body = node.body ? (0, function_1.transformFunctionBody)(context, node.parameters, node.body, restParam)[0] : [];
     return lua.createFunctionExpression(lua.createBlock(body), params, dot, lua.FunctionExpressionFlags.Declaration);
 }
 function transformAccessorDeclarations(context, { firstAccessor, getAccessor, setAccessor }, className) {
-    const propertyName = literal_1.transformPropertyName(context, firstAccessor.name);
+    const propertyName = (0, literal_1.transformPropertyName)(context, firstAccessor.name);
     const descriptor = lua.createTableExpression([]);
     if (getAccessor) {
         const getterFunction = transformAccessor(context, getAccessor);
@@ -24,13 +24,13 @@ function transformAccessorDeclarations(context, { firstAccessor, getAccessor, se
         const setterFunction = transformAccessor(context, setAccessor);
         descriptor.fields.push(lua.createTableFieldExpression(setterFunction, lua.createStringLiteral("set")));
     }
-    const isStatic = utils_1.isStaticNode(firstAccessor);
-    const target = isStatic ? lua.cloneIdentifier(className) : constructor_1.createPrototypeName(className);
+    const isStatic = (0, utils_1.isStaticNode)(firstAccessor);
+    const target = isStatic ? lua.cloneIdentifier(className) : (0, constructor_1.createPrototypeName)(className);
     const feature = isStatic ? lualib_1.LuaLibFeature.ObjectDefineProperty : lualib_1.LuaLibFeature.SetDescriptor;
     const parameters = [target, propertyName, descriptor];
     if (!isStatic)
         parameters.push(lua.createBooleanLiteral(true));
-    const call = lualib_1.transformLuaLibFunction(context, feature, undefined, ...parameters);
+    const call = (0, lualib_1.transformLuaLibFunction)(context, feature, undefined, ...parameters);
     return lua.createExpressionStatement(call);
 }
 exports.transformAccessorDeclarations = transformAccessorDeclarations;

package/dist/transformation/visitors/class/members/constructor.js

@@ -22,14 +22,14 @@ function transformConstructorDeclaration(context, statement, className, instance
         return undefined;
     }
     // Transform body
-    const scope = scope_1.pushScope(context, scope_1.ScopeType.Function);
-    const body = function_1.transformFunctionBodyContent(context, statement.body);
-    const [params, dotsLiteral, restParamName] = function_1.transformParameters(context, statement.parameters, lua_ast_1.createSelfIdentifier());
+    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
+    const body = (0, function_1.transformFunctionBodyContent)(context, statement.body);
+    const [params, dotsLiteral, restParamName] = (0, function_1.transformParameters)(context, statement.parameters, (0, lua_ast_1.createSelfIdentifier)());
     // Make sure default parameters are assigned before fields are initialized
-    const bodyWithFieldInitializers = function_1.transformFunctionBodyHeader(context, scope, statement.parameters, restParamName);
+    const bodyWithFieldInitializers = (0, function_1.transformFunctionBodyHeader)(context, scope, statement.parameters, restParamName);
     // Check for field declarations in constructor
     const constructorFieldsDeclarations = statement.parameters.filter(p => p.modifiers !== undefined);
-    const classInstanceFields = fields_1.transformClassInstanceFields(context, instanceFields);
+    const classInstanceFields = (0, fields_1.transformClassInstanceFields)(context, instanceFields);
     // If there are field initializers and the first statement is a super call,
     // move super call between default assignments and initializers
     if ((constructorFieldsDeclarations.length > 0 || classInstanceFields.length > 0) &&
@@ -49,7 +49,7 @@ function transformConstructorDeclaration(context, statement, className, instance
     for (const declaration of constructorFieldsDeclarations) {
         if (ts.isIdentifier(declaration.name)) {
             // self.declarationName = declarationName
-            const assignment = lua.createAssignmentStatement(lua.createTableIndexExpression(lua_ast_1.createSelfIdentifier(), lua.createStringLiteral(declaration.name.text)), identifier_1.transformIdentifier(context, declaration.name));
+            const assignment = lua.createAssignmentStatement(lua.createTableIndexExpression((0, lua_ast_1.createSelfIdentifier)(), lua.createStringLiteral(declaration.name.text)), (0, identifier_1.transformIdentifier)(context, declaration.name));
             bodyWithFieldInitializers.push(assignment);
         }
         // else { TypeScript error: A parameter property may not be declared using a binding pattern }
@@ -58,7 +58,7 @@ function transformConstructorDeclaration(context, statement, className, instance
     bodyWithFieldInitializers.push(...body);
     const block = lua.createBlock(bodyWithFieldInitializers);
     const constructorWasGenerated = statement.pos === -1;
-    scope_1.popScope(context);
+    (0, scope_1.popScope)(context);
     return lua.createAssignmentStatement(createConstructorName(className), lua.createFunctionExpression(block, params, dotsLiteral, lua.FunctionExpressionFlags.Declaration), constructorWasGenerated ? classDeclaration : statement);
 }
 exports.transformConstructorDeclaration = transformConstructorDeclaration;

package/dist/transformation/visitors/class/members/fields.js

@@ -9,19 +9,19 @@ const method_1 = require("./method");
 function createPropertyDecoratingExpression(context, node, className) {
     if (!node.decorators)
         return;
-    const propertyName = literal_1.transformPropertyName(context, node.name);
-    const propertyOwnerTable = method_1.transformMemberExpressionOwnerName(node, className);
-    return decorators_1.createDecoratingExpression(context, node.kind, node.decorators.map(d => decorators_1.transformDecoratorExpression(context, d)), propertyOwnerTable, propertyName);
+    const propertyName = (0, literal_1.transformPropertyName)(context, node.name);
+    const propertyOwnerTable = (0, method_1.transformMemberExpressionOwnerName)(node, className);
+    return (0, decorators_1.createDecoratingExpression)(context, node.kind, node.decorators.map(d => (0, decorators_1.transformDecoratorExpression)(context, d)), propertyOwnerTable, propertyName);
 }
 exports.createPropertyDecoratingExpression = createPropertyDecoratingExpression;
 function transformClassInstanceFields(context, instanceFields) {
     const statements = [];
     for (const f of instanceFields) {
         // Get identifier
-        const fieldName = literal_1.transformPropertyName(context, f.name);
+        const fieldName = (0, literal_1.transformPropertyName)(context, f.name);
         const value = f.initializer ? context.transformExpression(f.initializer) : undefined;
         // self[fieldName]
-        const selfIndex = lua.createTableIndexExpression(lua_ast_1.createSelfIdentifier(), fieldName);
+        const selfIndex = lua.createTableIndexExpression((0, lua_ast_1.createSelfIdentifier)(), fieldName);
         // self[fieldName] = value
         const assignClassField = lua.createAssignmentStatement(selfIndex, value, f);
         statements.push(assignClassField);
@@ -32,7 +32,7 @@ exports.transformClassInstanceFields = transformClassInstanceFields;
 function transformStaticPropertyDeclaration(context, field, className) {
     if (!field.initializer)
         return;
-    const fieldName = literal_1.transformPropertyName(context, field.name);
+    const fieldName = (0, literal_1.transformPropertyName)(context, field.name);
     const value = context.transformExpression(field.initializer);
     const classField = lua.createTableIndexExpression(lua.cloneIdentifier(className), fieldName);
     return lua.createAssignmentStatement(classField, value);

package/dist/transformation/visitors/class/members/method.js

@@ -10,11 +10,11 @@ const constructor_1 = require("./constructor");
 const lualib_1 = require("../../../utils/lualib");
 const utils_2 = require("../../../../utils");
 function transformMemberExpressionOwnerName(node, className) {
-    return utils_1.isStaticNode(node) ? lua.cloneIdentifier(className) : constructor_1.createPrototypeName(className);
+    return (0, utils_1.isStaticNode)(node) ? lua.cloneIdentifier(className) : (0, constructor_1.createPrototypeName)(className);
 }
 exports.transformMemberExpressionOwnerName = transformMemberExpressionOwnerName;
 function transformMethodName(context, node) {
-    const methodName = literal_1.transformPropertyName(context, node.name);
+    const methodName = (0, literal_1.transformPropertyName)(context, node.name);
     if (lua.isStringLiteral(methodName) && methodName.value === "toString") {
         return lua.createStringLiteral("__tostring", node.name);
     }
@@ -27,7 +27,7 @@ function transformMethodDeclaration(context, node, className) {
         return;
     const methodTable = transformMemberExpressionOwnerName(node, className);
     const methodName = transformMethodName(context, node);
-    const [functionExpression] = function_1.transformFunctionToExpression(context, node);
+    const [functionExpression] = (0, function_1.transformFunctionToExpression)(context, node);
     return lua.createAssignmentStatement(lua.createTableIndexExpression(methodTable, methodName), functionExpression, node);
 }
 exports.transformMethodDeclaration = transformMethodDeclaration;
@@ -38,12 +38,12 @@ function createMethodDecoratingExpression(context, node, className) {
     const parameterDecorators = node.parameters
         .flatMap((parameter, index) => {
         var _a;
-        return (_a = parameter.decorators) === null || _a === void 0 ? void 0 : _a.map(decorator => lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.DecorateParam, node, lua.createNumericLiteral(index), decorators_1.transformDecoratorExpression(context, decorator)));
+        return (_a = parameter.decorators) === null || _a === void 0 ? void 0 : _a.map(decorator => (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.DecorateParam, node, lua.createNumericLiteral(index), (0, decorators_1.transformDecoratorExpression)(context, decorator)));
     })
         .filter(utils_2.isNonNull);
-    const methodDecorators = (_b = (_a = node.decorators) === null || _a === void 0 ? void 0 : _a.map(d => decorators_1.transformDecoratorExpression(context, d))) !== null && _b !== void 0 ? _b : [];
+    const methodDecorators = (_b = (_a = node.decorators) === null || _a === void 0 ? void 0 : _a.map(d => (0, decorators_1.transformDecoratorExpression)(context, d))) !== null && _b !== void 0 ? _b : [];
     if (methodDecorators.length > 0 || parameterDecorators.length > 0) {
-        const decorateMethod = decorators_1.createDecoratingExpression(context, node.kind, [...methodDecorators, ...parameterDecorators], methodTable, methodName);
+        const decorateMethod = (0, decorators_1.createDecoratingExpression)(context, node.kind, [...methodDecorators, ...parameterDecorators], methodTable, methodName);
         return lua.createExpressionStatement(decorateMethod);
     }
 }

package/dist/transformation/visitors/class/new.js

@@ -28,49 +28,49 @@ function checkForLuaLibType(context, type) {
     const name = context.checker.getFullyQualifiedName(type.symbol);
     switch (name) {
         case "Map":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Map);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Map);
             return;
         case "Set":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Set);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Set);
             return;
         case "WeakMap":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.WeakMap);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.WeakMap);
             return;
         case "WeakSet":
-            lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.WeakSet);
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.WeakSet);
             return;
     }
     if (builtinErrorTypeNames.has(name)) {
-        lualib_1.importLuaLibFeature(context, lualib_1.LuaLibFeature.Error);
+        (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Error);
     }
 }
 exports.checkForLuaLibType = checkForLuaLibType;
 const transformNewExpression = (node, context) => {
     var _a;
     const type = context.checker.getTypeAtLocation(node);
-    const annotations = annotations_1.getTypeAnnotations(type);
+    const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-        context.diagnostics.push(diagnostics_1.annotationRemoved(node, annotations_1.AnnotationKind.LuaTable));
+        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
     }
-    if (table_1.isTableNewCall(context, node)) {
+    if ((0, table_1.isTableNewCall)(context, node)) {
         return lua.createTableExpression(undefined, node);
     }
-    const name = context.transformExpression(node.expression);
     const signature = context.checker.getResolvedSignature(node);
     const params = node.arguments
-        ? call_1.transformArguments(context, node.arguments, signature)
+        ? (0, call_1.transformArguments)(context, node.arguments, signature)
         : [lua.createBooleanLiteral(true)];
     checkForLuaLibType(context, type);
+    const name = context.transformExpression(node.expression);
     const customConstructorAnnotation = annotations.get(annotations_1.AnnotationKind.CustomConstructor);
     if (customConstructorAnnotation) {
         if (customConstructorAnnotation.args.length === 1) {
-            return lua.createCallExpression(lua.createIdentifier(customConstructorAnnotation.args[0]), call_1.transformArguments(context, (_a = node.arguments) !== null && _a !== void 0 ? _a : []), node);
+            return lua.createCallExpression(lua.createIdentifier(customConstructorAnnotation.args[0]), (0, call_1.transformArguments)(context, (_a = node.arguments) !== null && _a !== void 0 ? _a : []), node);
         }
         else {
-            context.diagnostics.push(diagnostics_1.annotationInvalidArgumentCount(node, annotations_1.AnnotationKind.CustomConstructor, customConstructorAnnotation.args.length, 1));
+            context.diagnostics.push((0, diagnostics_1.annotationInvalidArgumentCount)(node, annotations_1.AnnotationKind.CustomConstructor, customConstructorAnnotation.args.length, 1));
         }
     }
-    return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.New, node, name, ...params);
+    return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.New, node, name, ...params);
 };
 exports.transformNewExpression = transformNewExpression;
 //# sourceMappingURL=new.js.map