typescript-to-lua 0.42.0 → 1.1.1

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

@@ -18,33 +18,33 @@ const diagnostics_1 = require("../../utils/diagnostics");
 function transformAssignmentLeftHandSideExpression(context, node) {
     const symbol = context.checker.getSymbolAtLocation(node);
     const left = context.transformExpression(node);
-    return lua.isIdentifier(left) && symbol && export_1.isSymbolExported(context, symbol)
-        ? export_1.createExportedIdentifier(context, left)
-        : utils_1.cast(left, lua.isAssignmentLeftHandSideExpression);
+    return lua.isIdentifier(left) && symbol && (0, export_1.isSymbolExported)(context, symbol)
+        ? (0, export_1.createExportedIdentifier)(context, left)
+        : (0, utils_1.cast)(left, lua.isAssignmentLeftHandSideExpression);
 }
 exports.transformAssignmentLeftHandSideExpression = transformAssignmentLeftHandSideExpression;
 function transformAssignment(context, 
 // TODO: Change type to ts.LeftHandSideExpression?
 lhs, right, parent) {
     if (ts.isOptionalChain(lhs)) {
-        context.diagnostics.push(diagnostics_1.notAllowedOptionalAssignment(lhs));
+        context.diagnostics.push((0, diagnostics_1.notAllowedOptionalAssignment)(lhs));
         return [];
     }
-    if (destructuring_assignments_1.isArrayLength(context, lhs)) {
-        const arrayLengthAssignment = lua.createExpressionStatement(lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySetLength, parent, context.transformExpression(lhs.expression), right));
+    if ((0, destructuring_assignments_1.isArrayLength)(context, lhs)) {
+        const arrayLengthAssignment = lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, parent, context.transformExpression(lhs.expression), right));
         return [arrayLengthAssignment];
     }
     const symbol = ts.isShorthandPropertyAssignment(lhs.parent)
         ? context.checker.getShorthandAssignmentValueSymbol(lhs.parent)
         : context.checker.getSymbolAtLocation(lhs);
-    const dependentSymbols = symbol ? export_1.getDependenciesOfSymbol(context, symbol) : [];
+    const dependentSymbols = symbol ? (0, export_1.getDependenciesOfSymbol)(context, symbol) : [];
     const left = transformAssignmentLeftHandSideExpression(context, lhs);
     const rootAssignment = lua.createAssignmentStatement(left, right, lhs.parent);
     return [
         rootAssignment,
         ...dependentSymbols.map(symbol => {
             const [left] = rootAssignment.left;
-            const identifierToAssign = export_1.createExportedIdentifier(context, lua.createIdentifier(symbol.name));
+            const identifierToAssign = (0, export_1.createExportedIdentifier)(context, lua.createIdentifier(symbol.name));
             return lua.createAssignmentStatement(identifierToAssign, left);
         }),
     ];
@@ -53,12 +53,12 @@ exports.transformAssignment = transformAssignment;
 function transformDestructuredAssignmentExpression(context, expression) {
     const rootIdentifier = lua.createAnonymousIdentifier(expression.left);
     let right = context.transformExpression(expression.right);
-    if (multi_1.isMultiReturnCall(context, expression.right)) {
-        right = lua_ast_1.wrapInTable(right);
+    if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
+        right = (0, lua_ast_1.wrapInTable)(right);
     }
     const statements = [
         lua.createVariableDeclarationStatement(rootIdentifier, right),
-        ...destructuring_assignments_1.transformDestructuringAssignment(context, expression, rootIdentifier),
+        ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier),
     ];
     return { statements, result: rootIdentifier };
 }
@@ -66,13 +66,13 @@ function transformAssignmentExpression(context, expression) {
     // Validate assignment
     const rightType = context.checker.getTypeAtLocation(expression.right);
     const leftType = context.checker.getTypeAtLocation(expression.left);
-    assignment_validation_1.validateAssignment(context, expression.right, rightType, leftType);
-    if (destructuring_assignments_1.isArrayLength(context, expression.left)) {
+    (0, assignment_validation_1.validateAssignment)(context, expression.right, rightType, leftType);
+    if ((0, destructuring_assignments_1.isArrayLength)(context, expression.left)) {
         // array.length = x
-        return lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySetLength, expression, context.transformExpression(expression.left.expression), context.transformExpression(expression.right));
+        return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, expression, context.transformExpression(expression.left.expression), context.transformExpression(expression.right));
     }
-    if (typescript_1.isDestructuringAssignment(expression)) {
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => transformDestructuredAssignmentExpression(context, expression), expression);
+    if ((0, typescript_1.isDestructuringAssignment)(expression)) {
+        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => transformDestructuredAssignmentExpression(context, expression), expression);
     }
     if (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) {
         // Left is property/element access: cache result while maintaining order of evaluation
@@ -90,7 +90,7 @@ function transformAssignmentExpression(context, expression) {
             indexParameter,
             valueParameter,
         ]);
-        scope_1.pushScope(context, scope_1.ScopeType.Function);
+        (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
         const objExpression = context.transformExpression(expression.left.expression);
         let indexExpression;
         if (ts.isPropertyAccessExpression(expression.left)) {
@@ -99,14 +99,14 @@ function transformAssignmentExpression(context, expression) {
         }
         else {
             // Element access
-            indexExpression = access_1.transformElementAccessArgument(context, expression.left);
+            indexExpression = (0, access_1.transformElementAccessArgument)(context, expression.left);
         }
         const args = [objExpression, indexExpression, context.transformExpression(expression.right)];
-        scope_1.popScope(context);
+        (0, scope_1.popScope)(context);
         return lua.createCallExpression(iife, args, expression);
     }
     else {
-        return transform_1.transformToImmediatelyInvokedFunctionExpression(context, () => {
+        return (0, transform_1.transformToImmediatelyInvokedFunctionExpression)(context, () => {
             // Simple assignment
             // (function() ${left} = ${right}; return ${left} end)()
             const left = context.transformExpression(expression.left);
@@ -119,7 +119,7 @@ function transformAssignmentExpression(context, expression) {
 exports.transformAssignmentExpression = transformAssignmentExpression;
 const canBeTransformedToLuaAssignmentStatement = (context, node) => ts.isArrayLiteralExpression(node.left) &&
     node.left.elements.every(element => {
-        if (destructuring_assignments_1.isArrayLength(context, element)) {
+        if ((0, destructuring_assignments_1.isArrayLength)(context, element)) {
             return false;
         }
         if (ts.isPropertyAccessExpression(element) || ts.isElementAccessExpression(element)) {
@@ -128,7 +128,7 @@ const canBeTransformedToLuaAssignmentStatement = (context, node) => ts.isArrayLi
         if (ts.isIdentifier(element)) {
             const symbol = context.checker.getSymbolAtLocation(element);
             if (symbol) {
-                const aliases = export_1.getDependenciesOfSymbol(context, symbol);
+                const aliases = (0, export_1.getDependenciesOfSymbol)(context, symbol);
                 return aliases.length === 0;
             }
         }
@@ -137,28 +137,28 @@ function transformAssignmentStatement(context, expression) {
     // Validate assignment
     const rightType = context.checker.getTypeAtLocation(expression.right);
     const leftType = context.checker.getTypeAtLocation(expression.left);
-    assignment_validation_1.validateAssignment(context, expression.right, rightType, leftType);
-    if (typescript_1.isDestructuringAssignment(expression)) {
+    (0, assignment_validation_1.validateAssignment)(context, expression.right, rightType, leftType);
+    if ((0, typescript_1.isDestructuringAssignment)(expression)) {
         if (canBeTransformedToLuaAssignmentStatement(context, expression)) {
             const rightType = context.checker.getTypeAtLocation(expression.right);
             let right = context.transformExpression(expression.right);
             if (ts.isArrayLiteralExpression(expression.right)) {
                 right = expression.right.elements.map(e => context.transformExpression(e));
             }
-            else if (!multi_1.isMultiReturnCall(context, expression.right) && typescript_1.isArrayType(context, rightType)) {
-                right = lua_ast_1.createUnpackCall(context, right, expression.right);
+            else if (!(0, multi_1.isMultiReturnCall)(context, expression.right) && (0, typescript_1.isArrayType)(context, rightType)) {
+                right = (0, lua_ast_1.createUnpackCall)(context, right, expression.right);
             }
             const left = expression.left.elements.map(e => transformAssignmentLeftHandSideExpression(context, e));
             return [lua.createAssignmentStatement(left, right, expression)];
         }
         let right = context.transformExpression(expression.right);
-        if (multi_1.isMultiReturnCall(context, expression.right)) {
-            right = lua_ast_1.wrapInTable(right);
+        if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
+            right = (0, lua_ast_1.wrapInTable)(right);
         }
         const rootIdentifier = lua.createAnonymousIdentifier(expression.left);
         return [
             lua.createVariableDeclarationStatement(rootIdentifier, right),
-            ...destructuring_assignments_1.transformDestructuringAssignment(context, expression, rootIdentifier),
+            ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier),
         ];
     }
     else {

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,11 +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);
-        const isLeftString = typescript_1.isStringType(context, typeLeft);
-        const isRightString = typescript_1.isStringType(context, typeRight);
+        const isLeftString = (0, typescript_1.isStringType)(context, typeLeft);
+        const isRightString = (0, typescript_1.isStringType)(context, typeRight);
         if (isLeftString || isRightString) {
-            left = isLeftString ? left : lua_ast_1.wrapInToStringForConcat(left);
-            right = isRightString ? right : lua_ast_1.wrapInToStringForConcat(right);
+            left = isLeftString ? left : (0, lua_ast_1.wrapInToStringForConcat)(left);
+            right = isRightString ? right : (0, lua_ast_1.wrapInToStringForConcat)(right);
             luaOperator = lua.SyntaxKind.ConcatOperator;
         }
     }
@@ -56,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);
@@ -77,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);
@@ -98,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 = [
@@ -120,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;
     }