typescript-to-lua 0.41.2 → 1.1.0

package/dist/transformation/visitors/binary-expression/bit.js

@@ -31,7 +31,7 @@ function transformBitOperatorToLuaOperator(context, node, operator) {
         case ts.SyntaxKind.LessThanLessThanToken:
             return lua.SyntaxKind.BitwiseLeftShiftOperator;
         case ts.SyntaxKind.GreaterThanGreaterThanToken:
-            context.diagnostics.push(diagnostics_1.unsupportedRightShiftOperator(node));
+            context.diagnostics.push((0, diagnostics_1.unsupportedRightShiftOperator)(node));
         case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
             return lua.SyntaxKind.BitwiseRightShiftOperator;
     }
@@ -40,7 +40,7 @@ function transformBinaryBitOperation(context, node, left, right, operator) {
     switch (context.luaTarget) {
         case CompilerOptions_1.LuaTarget.Universal:
         case CompilerOptions_1.LuaTarget.Lua51:
-            context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "Bitwise operations", CompilerOptions_1.LuaTarget.Lua51));
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Bitwise operations", CompilerOptions_1.LuaTarget.Lua51));
         case CompilerOptions_1.LuaTarget.LuaJIT:
             return transformBinaryBitLibOperation(node, left, right, operator, "bit");
         case CompilerOptions_1.LuaTarget.Lua52:
@@ -58,7 +58,7 @@ function transformUnaryBitLibOperation(node, expression, operator, lib) {
             bitFunction = "bnot";
             break;
         default:
-            utils_1.assertNever(operator);
+            (0, utils_1.assertNever)(operator);
     }
     return lua.createCallExpression(lua.createTableIndexExpression(lua.createIdentifier(lib), lua.createStringLiteral(bitFunction)), [expression], node);
 }
@@ -66,7 +66,7 @@ function transformUnaryBitOperation(context, node, expression, operator) {
     switch (context.luaTarget) {
         case CompilerOptions_1.LuaTarget.Universal:
         case CompilerOptions_1.LuaTarget.Lua51:
-            context.diagnostics.push(diagnostics_1.unsupportedForTarget(node, "Bitwise operations", CompilerOptions_1.LuaTarget.Lua51));
+            context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(node, "Bitwise operations", CompilerOptions_1.LuaTarget.Lua51));
         case CompilerOptions_1.LuaTarget.LuaJIT:
             return transformUnaryBitLibOperation(node, expression, operator, "bit");
         case CompilerOptions_1.LuaTarget.Lua52:

package/dist/transformation/visitors/binary-expression/compound.js

@@ -11,9 +11,9 @@ const assignments_1 = require("./assignments");
 // If expression is property/element access with possible effects from being evaluated, returns separated object and index expressions.
 function parseAccessExpressionWithEvaluationEffects(context, node) {
     if (ts.isElementAccessExpression(node) &&
-        (typescript_1.isExpressionWithEvaluationEffect(node.expression) || typescript_1.isExpressionWithEvaluationEffect(node.argumentExpression))) {
+        ((0, typescript_1.isExpressionWithEvaluationEffect)(node.expression) || (0, typescript_1.isExpressionWithEvaluationEffect)(node.argumentExpression))) {
         const type = context.checker.getTypeAtLocation(node.expression);
-        if (typescript_1.isArrayType(context, type)) {
+        if ((0, typescript_1.isArrayType)(context, type)) {
             // Offset arrays by one
             const oneLit = ts.factory.createNumericLiteral("1");
             const exp = ts.factory.createParenthesizedExpression(node.argumentExpression);
@@ -24,7 +24,7 @@ function parseAccessExpressionWithEvaluationEffects(context, node) {
             return [node.expression, node.argumentExpression];
         }
     }
-    else if (ts.isPropertyAccessExpression(node) && typescript_1.isExpressionWithEvaluationEffect(node.expression)) {
+    else if (ts.isPropertyAccessExpression(node) && (0, typescript_1.isExpressionWithEvaluationEffect)(node.expression)) {
         return [node.expression, ts.factory.createStringLiteral(node.name.text)];
     }
     return [];
@@ -52,7 +52,7 @@ exports.isCompoundAssignmentToken = isCompoundAssignmentToken;
 const unwrapCompoundAssignmentToken = (token) => compoundToAssignmentTokens[token];
 exports.unwrapCompoundAssignmentToken = unwrapCompoundAssignmentToken;
 function transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix) {
-    const left = utils_1.cast(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
+    const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
     const right = context.transformExpression(rhs);
     const [objExpression, indexExpression] = parseAccessExpressionWithEvaluationEffects(context, lhs);
     if (objExpression && indexExpression) {
@@ -69,13 +69,13 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
             // local ____tmp = ____obj[____index];
             // ____obj[____index] = ____tmp ${replacementOperator} ${right};
             tmpDeclaration = lua.createVariableDeclarationStatement(tmp, accessExpression);
-            const operatorExpression = binary_expression_1.transformBinaryOperation(context, tmp, right, operator, expression);
+            const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, tmp, right, operator, expression);
             assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
         }
         else {
             // local ____tmp = ____obj[____index] ${replacementOperator} ${right};
             // ____obj[____index] = ____tmp;
-            const operatorExpression = binary_expression_1.transformBinaryOperation(context, accessExpression, right, operator, expression);
+            const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, accessExpression, right, operator, expression);
             tmpDeclaration = lua.createVariableDeclarationStatement(tmp, operatorExpression);
             assignStatement = lua.createAssignmentStatement(accessExpression, tmp);
         }
@@ -89,8 +89,8 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
         // return ____tmp
         const tmpIdentifier = lua.createIdentifier("____tmp");
         const tmpDeclaration = lua.createVariableDeclarationStatement(tmpIdentifier, left);
-        const operatorExpression = binary_expression_1.transformBinaryOperation(context, tmpIdentifier, right, operator, expression);
-        const assignStatements = assignments_1.transformAssignment(context, lhs, operatorExpression);
+        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, tmpIdentifier, right, operator, expression);
+        const assignStatements = (0, assignments_1.transformAssignment)(context, lhs, operatorExpression);
         return { statements: [tmpDeclaration, ...assignStatements], result: tmpIdentifier };
     }
     else if (ts.isPropertyAccessExpression(lhs) || ts.isElementAccessExpression(lhs)) {
@@ -99,9 +99,9 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
         // ${left} = ____tmp;
         // return ____tmp
         const tmpIdentifier = lua.createIdentifier("____tmp");
-        const operatorExpression = binary_expression_1.transformBinaryOperation(context, left, right, operator, expression);
+        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, left, right, operator, expression);
         const tmpDeclaration = lua.createVariableDeclarationStatement(tmpIdentifier, operatorExpression);
-        const assignStatements = assignments_1.transformAssignment(context, lhs, tmpIdentifier);
+        const assignStatements = (0, assignments_1.transformAssignment)(context, lhs, tmpIdentifier);
         if (isSetterSkippingCompoundAssignmentOperator(operator)) {
             const statements = [
                 tmpDeclaration,
@@ -114,8 +114,8 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
     else {
         // Simple expressions
         // ${left} = ${right}; return ${right}
-        const operatorExpression = binary_expression_1.transformBinaryOperation(context, left, right, operator, expression);
-        const statements = assignments_1.transformAssignment(context, lhs, operatorExpression);
+        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, left, right, operator, expression);
+        const statements = (0, assignments_1.transformAssignment)(context, lhs, operatorExpression);
         return { statements, result: left };
     }
 }
@@ -123,11 +123,11 @@ exports.transformCompoundAssignment = transformCompoundAssignment;
 function transformCompoundAssignmentExpression(context, expression, 
 // TODO: Change type to ts.LeftHandSideExpression?
 lhs, rhs, operator, isPostfix) {
-    return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix), expression);
+    return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix), expression);
 }
 exports.transformCompoundAssignmentExpression = transformCompoundAssignmentExpression;
 function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator) {
-    const left = utils_1.cast(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
+    const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
     const right = context.transformExpression(rhs);
     const [objExpression, indexExpression] = parseAccessExpressionWithEvaluationEffects(context, lhs);
     if (objExpression && indexExpression) {
@@ -144,7 +144,7 @@ function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator)
                 ...transformSetterSkippingCompoundAssignment(context, accessExpression, operator, rhs, node),
             ];
         }
-        const operatorExpression = binary_expression_1.transformBinaryOperation(context, accessExpression, right, operator, node);
+        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, accessExpression, right, operator, node);
         const assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
         return [objAndIndexDeclaration, assignStatement];
     }
@@ -155,8 +155,8 @@ function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator)
         }
         // Simple statements
         // ${left} = ${left} ${replacementOperator} ${right}
-        const operatorExpression = binary_expression_1.transformBinaryOperation(context, left, right, operator, node);
-        return assignments_1.transformAssignment(context, lhs, operatorExpression);
+        const operatorExpression = (0, binary_expression_1.transformBinaryOperation)(context, left, right, operator, node);
+        return (0, assignments_1.transformAssignment)(context, lhs, operatorExpression);
     }
 }
 exports.transformCompoundAssignmentStatement = transformCompoundAssignmentStatement;
@@ -178,7 +178,7 @@ function transformSetterSkippingCompoundAssignment(context, lhs, operator, rhs,
         condition = lua.createBinaryExpression(lhs, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
     }
     else {
-        utils_1.assertNever(operator);
+        (0, utils_1.assertNever)(operator);
     }
     // if condition then lhs = rhs end
     return [

package/dist/transformation/visitors/binary-expression/destructuring-assignments.js

@@ -13,7 +13,7 @@ function isArrayLength(context, expression) {
         return false;
     }
     const type = context.checker.getTypeAtLocation(expression.expression);
-    if (!typescript_1.isArrayType(context, type)) {
+    if (!(0, typescript_1.isArrayType)(context, type)) {
         return false;
     }
     const name = ts.isPropertyAccessExpression(expression)
@@ -49,8 +49,8 @@ function transformArrayLiteralAssignmentPattern(context, node, root) {
                 const assignedVariable = lua.createIdentifier("____bindingAssignmentValue");
                 const assignedVariableDeclaration = lua.createVariableDeclarationStatement(assignedVariable, indexedRoot);
                 const nilCondition = lua.createBinaryExpression(assignedVariable, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-                const defaultAssignmentStatements = assignments_1.transformAssignment(context, element.left, context.transformExpression(element.right));
-                const elseAssignmentStatements = assignments_1.transformAssignment(context, element.left, assignedVariable);
+                const defaultAssignmentStatements = (0, assignments_1.transformAssignment)(context, element.left, context.transformExpression(element.right));
+                const elseAssignmentStatements = (0, assignments_1.transformAssignment)(context, element.left, assignedVariable);
                 const ifBlock = lua.createBlock(defaultAssignmentStatements);
                 const elseBlock = lua.createBlock(elseAssignmentStatements);
                 const ifStatement = lua.createIfStatement(nilCondition, ifBlock, elseBlock, node);
@@ -58,14 +58,14 @@ function transformArrayLiteralAssignmentPattern(context, node, root) {
             case ts.SyntaxKind.Identifier:
             case ts.SyntaxKind.PropertyAccessExpression:
             case ts.SyntaxKind.ElementAccessExpression:
-                return assignments_1.transformAssignment(context, element, indexedRoot);
+                return (0, assignments_1.transformAssignment)(context, element, indexedRoot);
             case ts.SyntaxKind.SpreadElement:
                 if (index !== node.elements.length - 1) {
                     // TypeScript error
                     return [];
                 }
-                const restElements = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySlice, undefined, root, lua.createNumericLiteral(index));
-                return assignments_1.transformAssignment(context, element.expression, restElements);
+                const restElements = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, undefined, root, lua.createNumericLiteral(index));
+                return (0, assignments_1.transformAssignment)(context, element.expression, restElements);
             case ts.SyntaxKind.OmittedExpression:
                 return [];
             default:
@@ -93,23 +93,23 @@ function transformObjectLiteralAssignmentPattern(context, node, root) {
                 // TypeScript error
                 break;
             default:
-                utils_1.assertNever(property);
+                (0, utils_1.assertNever)(property);
         }
     }
     return result;
 }
 function transformShorthandPropertyAssignment(context, node, root) {
     const result = [];
-    const assignmentVariableName = assignments_1.transformAssignmentLeftHandSideExpression(context, node.name);
+    const assignmentVariableName = (0, assignments_1.transformAssignmentLeftHandSideExpression)(context, node.name);
     const extractionIndex = lua.createStringLiteral(node.name.text);
-    const variableExtractionAssignmentStatements = assignments_1.transformAssignment(context, node.name, lua.createTableIndexExpression(root, extractionIndex));
+    const variableExtractionAssignmentStatements = (0, assignments_1.transformAssignment)(context, node.name, lua.createTableIndexExpression(root, extractionIndex));
     result.push(...variableExtractionAssignmentStatements);
     const defaultInitializer = node.objectAssignmentInitializer
         ? context.transformExpression(node.objectAssignmentInitializer)
         : undefined;
     if (defaultInitializer) {
         const nilCondition = lua.createBinaryExpression(assignmentVariableName, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-        const assignmentStatements = assignments_1.transformAssignment(context, node.name, defaultInitializer);
+        const assignmentStatements = (0, assignments_1.transformAssignment)(context, node.name, defaultInitializer);
         const ifBlock = lua.createBlock(assignmentStatements);
         result.push(lua.createIfStatement(nilCondition, ifBlock, undefined, node));
     }
@@ -117,8 +117,8 @@ function transformShorthandPropertyAssignment(context, node, root) {
 }
 function transformPropertyAssignment(context, node, root) {
     const result = [];
-    if (typescript_1.isAssignmentPattern(node.initializer)) {
-        const propertyAccessString = literal_1.transformPropertyName(context, node.name);
+    if ((0, typescript_1.isAssignmentPattern)(node.initializer)) {
+        const propertyAccessString = (0, literal_1.transformPropertyName)(context, node.name);
         const newRootAccess = lua.createTableIndexExpression(root, propertyAccessString);
         if (ts.isObjectLiteralExpression(node.initializer)) {
             return transformObjectLiteralAssignmentPattern(context, node.initializer, newRootAccess);
@@ -128,14 +128,14 @@ function transformPropertyAssignment(context, node, root) {
         }
     }
     const leftExpression = ts.isBinaryExpression(node.initializer) ? node.initializer.left : node.initializer;
-    const variableToExtract = literal_1.transformPropertyName(context, node.name);
+    const variableToExtract = (0, literal_1.transformPropertyName)(context, node.name);
     const extractingExpression = lua.createTableIndexExpression(root, variableToExtract);
-    const destructureAssignmentStatements = assignments_1.transformAssignment(context, leftExpression, extractingExpression);
+    const destructureAssignmentStatements = (0, assignments_1.transformAssignment)(context, leftExpression, extractingExpression);
     result.push(...destructureAssignmentStatements);
     if (ts.isBinaryExpression(node.initializer)) {
         const assignmentLeftHandSide = context.transformExpression(node.initializer.left);
         const nilCondition = lua.createBinaryExpression(assignmentLeftHandSide, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-        const ifBlock = lua.createBlock(assignments_1.transformAssignmentStatement(context, node.initializer));
+        const ifBlock = lua.createBlock((0, assignments_1.transformAssignmentStatement)(context, node.initializer));
         result.push(lua.createIfStatement(nilCondition, ifBlock, undefined, node));
     }
     return result;
@@ -152,7 +152,7 @@ function transformSpreadAssignment(context, node, root, properties) {
             usedProperties.push(lua.createTableFieldExpression(lua.createBooleanLiteral(true), name));
         }
     }
-    const extractingExpression = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectRest, undefined, root, lua.createTableExpression(usedProperties));
-    return assignments_1.transformAssignment(context, node.expression, extractingExpression);
+    const extractingExpression = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectRest, undefined, root, lua.createTableExpression(usedProperties));
+    return (0, assignments_1.transformAssignment)(context, node.expression, extractingExpression);
 }
 //# sourceMappingURL=destructuring-assignments.js.map

package/dist/transformation/visitors/binary-expression/index.js

@@ -31,11 +31,11 @@ const simpleOperatorsToLua = {
     [ts.SyntaxKind.ExclamationEqualsEqualsToken]: lua.SyntaxKind.InequalityOperator,
 };
 function transformBinaryOperation(context, left, right, operator, node) {
-    if (bit_1.isBitOperator(operator)) {
-        return bit_1.transformBinaryBitOperation(context, node, left, right, operator);
+    if ((0, bit_1.isBitOperator)(operator)) {
+        return (0, bit_1.transformBinaryBitOperation)(context, node, left, right, operator);
     }
     if (operator === ts.SyntaxKind.QuestionQuestionToken) {
-        utils_1.assert(ts.isBinaryExpression(node));
+        (0, utils_1.assert)(ts.isBinaryExpression(node));
         return transformNullishCoalescingExpression(context, node, left, right);
     }
     let luaOperator = simpleOperatorsToLua[operator];
@@ -43,9 +43,11 @@ function transformBinaryOperation(context, left, right, operator, node) {
     if (operator === ts.SyntaxKind.PlusToken && ts.isBinaryExpression(node)) {
         const typeLeft = context.checker.getTypeAtLocation(node.left);
         const typeRight = context.checker.getTypeAtLocation(node.right);
-        if (typescript_1.isStringType(context, typeLeft) || typescript_1.isStringType(context, typeRight)) {
-            left = lua_ast_1.wrapInToStringForConcat(left);
-            right = lua_ast_1.wrapInToStringForConcat(right);
+        const isLeftString = (0, typescript_1.isStringType)(context, typeLeft);
+        const isRightString = (0, typescript_1.isStringType)(context, typeRight);
+        if (isLeftString || isRightString) {
+            left = isLeftString ? left : (0, lua_ast_1.wrapInToStringForConcat)(left);
+            right = isRightString ? right : (0, lua_ast_1.wrapInToStringForConcat)(right);
             luaOperator = lua.SyntaxKind.ConcatOperator;
         }
     }
@@ -54,17 +56,17 @@ function transformBinaryOperation(context, left, right, operator, node) {
 exports.transformBinaryOperation = transformBinaryOperation;
 const transformBinaryExpression = (node, context) => {
     const operator = node.operatorToken.kind;
-    const typeOfResult = typeof_1.transformTypeOfBinaryExpression(context, node);
+    const typeOfResult = (0, typeof_1.transformTypeOfBinaryExpression)(context, node);
     if (typeOfResult) {
         return typeOfResult;
     }
-    if (compound_1.isCompoundAssignmentToken(operator)) {
-        const token = compound_1.unwrapCompoundAssignmentToken(operator);
-        return compound_1.transformCompoundAssignmentExpression(context, node, node.left, node.right, token, false);
+    if ((0, compound_1.isCompoundAssignmentToken)(operator)) {
+        const token = (0, compound_1.unwrapCompoundAssignmentToken)(operator);
+        return (0, compound_1.transformCompoundAssignmentExpression)(context, node, node.left, node.right, token, false);
     }
     switch (operator) {
         case ts.SyntaxKind.EqualsToken:
-            return assignments_1.transformAssignmentExpression(context, node);
+            return (0, assignments_1.transformAssignmentExpression)(context, node);
         case ts.SyntaxKind.InKeyword: {
             const lhs = context.transformExpression(node.left);
             const rhs = context.transformExpression(node.right);
@@ -75,13 +77,13 @@ const transformBinaryExpression = (node, context) => {
             const lhs = context.transformExpression(node.left);
             const rhs = context.transformExpression(node.right);
             const rhsType = context.checker.getTypeAtLocation(node.right);
-            if (typescript_1.isStandardLibraryType(context, rhsType, "ObjectConstructor")) {
-                return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.InstanceOfObject, node, lhs);
+            if ((0, typescript_1.isStandardLibraryType)(context, rhsType, "ObjectConstructor")) {
+                return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.InstanceOfObject, node, lhs);
             }
-            return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.InstanceOf, node, lhs, rhs);
+            return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.InstanceOf, node, lhs, rhs);
         }
         case ts.SyntaxKind.CommaToken: {
-            return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => ({
+            return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => ({
                 statements: context.transformStatements(ts.factory.createExpressionStatement(node.left)),
                 result: context.transformExpression(node.right),
             }), node);
@@ -96,13 +98,13 @@ function transformBinaryExpressionStatement(context, node) {
     if (!ts.isBinaryExpression(expression))
         return;
     const operator = expression.operatorToken.kind;
-    if (compound_1.isCompoundAssignmentToken(operator)) {
+    if ((0, compound_1.isCompoundAssignmentToken)(operator)) {
         // +=, -=, etc...
-        const token = compound_1.unwrapCompoundAssignmentToken(operator);
-        return compound_1.transformCompoundAssignmentStatement(context, expression, expression.left, expression.right, token);
+        const token = (0, compound_1.unwrapCompoundAssignmentToken)(operator);
+        return (0, compound_1.transformCompoundAssignmentStatement)(context, expression, expression.left, expression.right, token);
     }
     else if (operator === ts.SyntaxKind.EqualsToken) {
-        return assignments_1.transformAssignmentStatement(context, expression);
+        return (0, assignments_1.transformAssignmentStatement)(context, expression);
     }
     else if (operator === ts.SyntaxKind.CommaToken) {
         const statements = [
@@ -118,7 +120,7 @@ function transformNullishCoalescingExpression(context, node, transformedLeft, tr
     // Check if we can take a shortcut to 'lhs or rhs' if the left-hand side cannot be 'false'.
     const typeCanBeFalse = (type) => (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Boolean)) !== 0 ||
         (type.flags & ts.TypeFlags.BooleanLiteral & ts.TypeFlags.PossiblyFalsy) !== 0;
-    if (typescript_1.typeCanSatisfy(context, lhsType, typeCanBeFalse)) {
+    if ((0, typescript_1.typeCanSatisfy)(context, lhsType, typeCanBeFalse)) {
         // lhs can be false, transform to IIFE
         const lhsIdentifier = lua.createIdentifier("____lhs");
         const nilComparison = lua.createBinaryExpression(lua.cloneIdentifier(lhsIdentifier), lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);

package/dist/transformation/visitors/block.js

@@ -9,16 +9,16 @@ function transformBlockOrStatement(context, statement) {
 }
 exports.transformBlockOrStatement = transformBlockOrStatement;
 function transformScopeBlock(context, node, scopeType) {
-    scope_1.pushScope(context, scopeType);
-    const statements = scope_1.performHoisting(context, context.transformStatements(node.statements));
-    const scope = scope_1.popScope(context);
+    (0, scope_1.pushScope)(context, scopeType);
+    const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
+    const scope = (0, scope_1.popScope)(context);
     return [lua.createBlock(statements, node), scope];
 }
 exports.transformScopeBlock = transformScopeBlock;
 const transformBlock = (node, context) => {
-    scope_1.pushScope(context, scope_1.ScopeType.Block);
-    const statements = scope_1.performHoisting(context, context.transformStatements(node.statements));
-    scope_1.popScope(context);
+    (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+    const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
+    (0, scope_1.popScope)(context);
     return lua.createDoStatement(statements, node);
 };
 exports.transformBlock = transformBlock;

package/dist/transformation/visitors/break-continue.js

@@ -6,21 +6,16 @@ const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const scope_1 = require("../utils/scope");
 const transformBreakStatement = (breakStatement, context) => {
-    const breakableScope = scope_1.findScope(context, scope_1.ScopeType.Loop | scope_1.ScopeType.Switch);
-    if ((breakableScope === null || breakableScope === void 0 ? void 0 : breakableScope.type) === scope_1.ScopeType.Switch) {
-        return lua.createGotoStatement(`____switch${breakableScope.id}_end`);
-    }
-    else {
-        return lua.createBreakStatement(breakStatement);
-    }
+    void context;
+    return lua.createBreakStatement(breakStatement);
 };
 exports.transformBreakStatement = transformBreakStatement;
 const transformContinueStatement = (statement, context) => {
     var _a;
     if (context.luaTarget === CompilerOptions_1.LuaTarget.Universal || context.luaTarget === CompilerOptions_1.LuaTarget.Lua51) {
-        context.diagnostics.push(diagnostics_1.unsupportedForTarget(statement, "Continue statement", CompilerOptions_1.LuaTarget.Lua51));
+        context.diagnostics.push((0, diagnostics_1.unsupportedForTarget)(statement, "Continue statement", CompilerOptions_1.LuaTarget.Lua51));
     }
-    const scope = scope_1.findScope(context, scope_1.ScopeType.Loop);
+    const scope = (0, scope_1.findScope)(context, scope_1.ScopeType.Loop);
     if (scope) {
         scope.loopContinued = true;
     }

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,43 +172,41 @@ function transformElementCall(context, node) {
     }
 }
 const transformCallExpression = (node, context) => {
-    const isTupleReturn = annotations_1.isTupleReturnCall(context, node);
-    const isTupleReturnForward = node.parent && ts.isReturnStatement(node.parent) && annotations_1.isInTupleReturnFunction(context, node);
-    const isInSpread = node.parent && ts.isSpreadElement(node.parent);
-    const returnValueIsUsed = node.parent && !ts.isExpressionStatement(node.parent);
-    const wrapTupleReturn = isTupleReturn && !isTupleReturnForward && !typescript_1.isInDestructingAssignment(node) && !isInSpread && returnValueIsUsed;
-    const wrapResultInTable = wrapTupleReturn || 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);
@@ -222,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 {
@@ -235,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