typescript-to-lua 1.12.1 → 1.13.0

package/dist/transformation/utils/preceding-statements.d.ts

@@ -1,3 +1,7 @@
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-export declare function transformInPrecedingStatementScope<TReturn extends lua.Statement | lua.Statement[] | lua.Expression | lua.Expression[]>(context: TransformationContext, transformer: () => TReturn): [lua.Statement[], TReturn];
+export interface WithPrecedingStatements<T extends lua.Statement | lua.Statement[] | lua.Expression | lua.Expression[]> {
+    precedingStatements: lua.Statement[];
+    result: T;
+}
+export declare function transformInPrecedingStatementScope<TReturn extends lua.Statement | lua.Statement[] | lua.Expression | lua.Expression[]>(context: TransformationContext, transformer: () => TReturn): WithPrecedingStatements<TReturn>;

package/dist/transformation/utils/preceding-statements.js

@@ -5,7 +5,7 @@ function transformInPrecedingStatementScope(context, transformer) {
     context.pushPrecedingStatements();
     const statementOrStatements = transformer();
     const precedingStatements = context.popPrecedingStatements();
-    return [precedingStatements, statementOrStatements];
+    return { precedingStatements, result: statementOrStatements };
 }
 exports.transformInPrecedingStatementScope = transformInPrecedingStatementScope;
 //# sourceMappingURL=preceding-statements.js.map

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

@@ -72,7 +72,7 @@ function transformAssignmentWithRightPrecedingStatements(context, lhs, right, ri
 }
 exports.transformAssignmentWithRightPrecedingStatements = transformAssignmentWithRightPrecedingStatements;
 function transformDestructuredAssignmentExpression(context, expression) {
-    let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+    let { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
     context.addPrecedingStatements(rightPrecedingStatements);
     if ((0, multi_1.isMultiReturnCall)(context, expression.right)) {
         right = (0, lua_ast_1.wrapInTable)(right);
@@ -96,7 +96,7 @@ function transformAssignmentExpression(context, expression) {
         return result;
     }
     if (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) {
-        const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        const { precedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
         const left = transformAssignmentLeftHandSideExpression(context, expression.left, precedingStatements.length > 0);
         context.addPrecedingStatements(precedingStatements);
         const rightExpr = (0, expression_list_1.moveToPrecedingTemp)(context, right, expression.right);
@@ -156,7 +156,7 @@ function transformAssignmentStatement(context, expression) {
         return statements;
     }
     else {
-        const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
+        const { precedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
         return transformAssignmentWithRightPrecedingStatements(context, expression.left, right, precedingStatements);
     }
 }

package/dist/transformation/visitors/binary-expression/compound.d.ts

@@ -4,13 +4,6 @@ import { TransformationContext } from "../../context";
 type CompoundAssignmentToken = ts.SyntaxKind.BarToken | ts.SyntaxKind.PlusToken | ts.SyntaxKind.CaretToken | ts.SyntaxKind.MinusToken | ts.SyntaxKind.SlashToken | ts.SyntaxKind.PercentToken | ts.SyntaxKind.AsteriskToken | ts.SyntaxKind.AmpersandToken | ts.SyntaxKind.AsteriskAsteriskToken | ts.SyntaxKind.LessThanLessThanToken | ts.SyntaxKind.GreaterThanGreaterThanToken | ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.QuestionQuestionToken;
 export declare const isCompoundAssignmentToken: (token: ts.BinaryOperator) => token is ts.CompoundAssignmentOperator;
 export declare const unwrapCompoundAssignmentToken: (token: ts.CompoundAssignmentOperator) => CompoundAssignmentToken;
-export declare function transformCompoundAssignment(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): {
-    statements: lua.Statement[];
-    result: lua.Identifier;
-} | {
-    statements: lua.Statement[];
-    result: lua.TableIndexExpression;
-};
 export declare function transformCompoundAssignmentExpression(context: TransformationContext, expression: ts.Expression, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken, isPostfix: boolean): lua.Expression;
 export declare function transformCompoundAssignmentStatement(context: TransformationContext, node: ts.Node, lhs: ts.Expression, rhs: ts.Expression, operator: CompoundAssignmentToken): lua.Statement[];
 export {};

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

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCompoundAssignmentStatement = exports.transformCompoundAssignmentExpression = exports.transformCompoundAssignment = exports.unwrapCompoundAssignmentToken = exports.isCompoundAssignmentToken = void 0;
+exports.transformCompoundAssignmentStatement = exports.transformCompoundAssignmentExpression = exports.unwrapCompoundAssignmentToken = exports.isCompoundAssignmentToken = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
 const preceding_statements_1 = require("../../utils/preceding-statements");
 const index_1 = require("./index");
 const assignments_1 = require("./assignments");
+const destructuring_assignments_1 = require("./destructuring-assignments");
+const lualib_1 = require("../../utils/lualib");
 function isLuaExpressionWithSideEffect(expression) {
     return !(lua.isLiteral(expression) || lua.isIdentifier(expression));
 }
@@ -37,8 +39,12 @@ exports.isCompoundAssignmentToken = isCompoundAssignmentToken;
 const unwrapCompoundAssignmentToken = (token) => compoundToAssignmentTokens[token];
 exports.unwrapCompoundAssignmentToken = unwrapCompoundAssignmentToken;
 function transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix) {
+    if ((0, destructuring_assignments_1.isArrayLength)(context, lhs)) {
+        const { precedingStatements, result: lengthSetterStatement } = transformCompoundLengthSetter(context, expression, lhs, rhs, operator);
+        return { precedingStatements, result: lengthSetterStatement.expression };
+    }
     const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    const [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
+    const { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
     if (lua.isTableIndexExpression(left)) {
         // Complex property/element accesses need to cache object/index expressions to avoid repeating side-effects
         // local __obj, __index = ${objExpression}, ${indexExpression};
@@ -52,17 +58,17 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
             // ____obj[____index] = ____tmp ${replacementOperator} ${right};
             // return ____tmp
             const tmpDeclaration = lua.createVariableDeclarationStatement(tmp, accessExpression);
-            const [precedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, tmp, right, rightPrecedingStatements, operator, expression);
+            const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, tmp, right, rightPrecedingStatements, operator, expression);
             const assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
             return {
-                statements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
+                precedingStatements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
                 result: tmp,
             };
         }
         else {
             if (isSetterSkippingCompoundAssignmentOperator(operator)) {
                 return {
-                    statements: [
+                    precedingStatements: [
                         objAndIndexDeclaration,
                         ...transformSetterSkippingCompoundAssignment(accessExpression, operator, right, rightPrecedingStatements),
                     ],
@@ -72,11 +78,11 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
             // local ____tmp = ____obj[____index] ${replacementOperator} ${right};
             // ____obj[____index] = ____tmp;
             // return ____tmp
-            const [precedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, expression);
+            const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, expression);
             const tmpDeclaration = lua.createVariableDeclarationStatement(tmp, operatorExpression);
             const assignStatement = lua.createAssignmentStatement(accessExpression, tmp);
             return {
-                statements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
+                precedingStatements: [objAndIndexDeclaration, ...precedingStatements, tmpDeclaration, assignStatement],
                 result: tmp,
             };
         }
@@ -88,36 +94,42 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
         // return ____tmp
         const tmpIdentifier = context.createTempNameForLuaExpression(left);
         const tmpDeclaration = lua.createVariableDeclarationStatement(tmpIdentifier, left);
-        const [precedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, tmpIdentifier, right, rightPrecedingStatements, operator, expression);
+        const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, tmpIdentifier, right, rightPrecedingStatements, operator, expression);
         const assignStatements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements);
-        return { statements: [tmpDeclaration, ...precedingStatements, ...assignStatements], result: tmpIdentifier };
+        return {
+            precedingStatements: [tmpDeclaration, ...precedingStatements, ...assignStatements],
+            result: tmpIdentifier,
+        };
     }
     else {
         if (rightPrecedingStatements.length > 0 && isSetterSkippingCompoundAssignmentOperator(operator)) {
             return {
-                statements: transformSetterSkippingCompoundAssignment(left, operator, right, rightPrecedingStatements),
+                precedingStatements: transformSetterSkippingCompoundAssignment(left, operator, right, rightPrecedingStatements),
                 result: left,
             };
         }
         // Simple expressions
         // ${left} = ${left} ${operator} ${right}
-        const [precedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, expression);
+        const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, expression);
         const statements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, precedingStatements);
-        return { statements, result: left };
+        return { precedingStatements: statements, result: left };
     }
 }
-exports.transformCompoundAssignment = transformCompoundAssignment;
 function transformCompoundAssignmentExpression(context, expression, 
 // TODO: Change type to ts.LeftHandSideExpression?
 lhs, rhs, operator, isPostfix) {
-    const { statements, result } = transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix);
-    context.addPrecedingStatements(statements);
+    const { precedingStatements, result } = transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix);
+    context.addPrecedingStatements(precedingStatements);
     return result;
 }
 exports.transformCompoundAssignmentExpression = transformCompoundAssignmentExpression;
 function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator) {
+    if ((0, destructuring_assignments_1.isArrayLength)(context, lhs)) {
+        const { precedingStatements, result: lengthSetterStatement } = transformCompoundLengthSetter(context, node, lhs, rhs, operator);
+        return [...precedingStatements, lengthSetterStatement];
+    }
     const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
-    let [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
+    const { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
     if (lua.isTableIndexExpression(left) && shouldCacheTableIndexExpressions(left, rightPrecedingStatements)) {
         // Complex property/element accesses need to cache object/index expressions to avoid repeating side-effects
         // local __obj, __index = ${objExpression}, ${indexExpression};
@@ -132,10 +144,9 @@ function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator)
                 ...transformSetterSkippingCompoundAssignment(accessExpression, operator, right, rightPrecedingStatements, node),
             ];
         }
-        let operatorExpression;
-        [rightPrecedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, node);
+        const { precedingStatements: rightPrecedingStatements2, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, accessExpression, right, rightPrecedingStatements, operator, node);
         const assignStatement = lua.createAssignmentStatement(accessExpression, operatorExpression);
-        return [objAndIndexDeclaration, ...rightPrecedingStatements, assignStatement];
+        return [objAndIndexDeclaration, ...rightPrecedingStatements2, assignStatement];
     }
     else {
         if (isSetterSkippingCompoundAssignmentOperator(operator)) {
@@ -143,9 +154,8 @@ function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator)
         }
         // Simple statements
         // ${left} = ${left} ${replacementOperator} ${right}
-        let operatorExpression;
-        [rightPrecedingStatements, operatorExpression] = (0, index_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, node);
-        return (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements);
+        const { precedingStatements: rightPrecedingStatements2, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, node);
+        return (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements2);
     }
 }
 exports.transformCompoundAssignmentStatement = transformCompoundAssignmentStatement;
@@ -174,4 +184,12 @@ function transformSetterSkippingCompoundAssignment(lhs, operator, right, rightPr
         lua.createIfStatement(condition, lua.createBlock([...rightPrecedingStatements, lua.createAssignmentStatement(lhs, right, node)]), undefined, node),
     ];
 }
+function transformCompoundLengthSetter(context, node, lhs, rhs, operator) {
+    const { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
+    const table = context.transformExpression(lhs.expression);
+    const lengthExpression = lua.createUnaryExpression(table, lua.SyntaxKind.LengthOperator, lhs);
+    const { precedingStatements, result: operatorExpression } = (0, index_1.transformBinaryOperation)(context, lengthExpression, right, rightPrecedingStatements, operator, node);
+    const arrayLengthAssignment = lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySetLength, node, table, operatorExpression));
+    return { precedingStatements, result: arrayLengthAssignment };
+}
 //# sourceMappingURL=compound.js.map

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

@@ -52,7 +52,7 @@ function transformArrayLiteralAssignmentPattern(context, node, root, rightHasPre
                 const assignedVariable = context.createTempNameForLuaExpression(indexedRoot);
                 const assignedVariableDeclaration = lua.createVariableDeclarationStatement(assignedVariable, indexedRoot);
                 const nilCondition = lua.createBinaryExpression(assignedVariable, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator);
-                const [defaultPrecedingStatements, defaultAssignmentStatements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.left, context.transformExpression(element.right)));
+                const { precedingStatements: defaultPrecedingStatements, result: defaultAssignmentStatements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.left, context.transformExpression(element.right)));
                 // Keep preceding statements inside if block
                 defaultAssignmentStatements.unshift(...defaultPrecedingStatements);
                 const elseAssignmentStatements = (0, assignments_1.transformAssignment)(context, element.left, assignedVariable);
@@ -63,7 +63,7 @@ function transformArrayLiteralAssignmentPattern(context, node, root, rightHasPre
             case ts.SyntaxKind.Identifier:
             case ts.SyntaxKind.PropertyAccessExpression:
             case ts.SyntaxKind.ElementAccessExpression:
-                const [precedingStatements, statements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element, indexedRoot, rightHasPrecedingStatements));
+                const { precedingStatements, result: statements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element, indexedRoot, rightHasPrecedingStatements));
                 return [...precedingStatements, ...statements]; // Keep preceding statements in order
             case ts.SyntaxKind.SpreadElement:
                 if (index !== node.elements.length - 1) {
@@ -71,7 +71,7 @@ function transformArrayLiteralAssignmentPattern(context, node, root, rightHasPre
                     return [];
                 }
                 const restElements = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, undefined, root, lua.createNumericLiteral(index));
-                const [spreadPrecedingStatements, spreadStatements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.expression, restElements, rightHasPrecedingStatements));
+                const { precedingStatements: spreadPrecedingStatements, result: spreadStatements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, assignments_1.transformAssignment)(context, element.expression, restElements, rightHasPrecedingStatements));
                 return [...spreadPrecedingStatements, ...spreadStatements]; // Keep preceding statements in order
             case ts.SyntaxKind.OmittedExpression:
                 return [];
@@ -146,12 +146,12 @@ function transformPropertyAssignment(context, node, root, rightHasPrecedingState
             // Access expressions need their table and index expressions cached to preserve execution order
             const left = (0, utils_1.cast)(context.transformExpression(node.initializer.left), lua.isTableIndexExpression);
             const rightExpression = node.initializer.right;
-            const [defaultPrecedingStatements, defaultExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rightExpression));
+            const { precedingStatements: defaultPrecedingStatements, result: defaultExpression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rightExpression));
             const tableTemp = context.createTempNameForLuaExpression(left.table);
             const indexTemp = context.createTempNameForLuaExpression(left.index);
             const tempsDeclaration = lua.createVariableDeclarationStatement([tableTemp, indexTemp], [left.table, left.index]);
             // obj[index] = extractingExpression ?? defaultExpression
-            const [rightPrecedingStatements, rhs] = (0, _1.transformBinaryOperation)(context, extractingExpression, defaultExpression, defaultPrecedingStatements, ts.SyntaxKind.QuestionQuestionToken, node.initializer);
+            const { precedingStatements: rightPrecedingStatements, result: rhs } = (0, _1.transformBinaryOperation)(context, extractingExpression, defaultExpression, defaultPrecedingStatements, ts.SyntaxKind.QuestionQuestionToken, node.initializer);
             const assignStatement = lua.createAssignmentStatement(lua.createTableIndexExpression(tableTemp, indexTemp), rhs);
             destructureAssignmentStatements = [tempsDeclaration, ...rightPrecedingStatements, assignStatement];
         }

package/dist/transformation/visitors/binary-expression/index.d.ts

@@ -2,10 +2,11 @@ import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../../context";
 import { BitOperator } from "./bit";
+import { WithPrecedingStatements } from "../../utils/preceding-statements";
 type ShortCircuitOperator = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
 type SimpleOperator = ts.AdditiveOperatorOrHigher | Exclude<ts.RelationalOperator, ts.SyntaxKind.InstanceOfKeyword | ts.SyntaxKind.InKeyword> | ts.EqualityOperator | ts.LogicalOperator;
-export declare function createShortCircuitBinaryExpressionPrecedingStatements(context: TransformationContext, lhs: lua.Expression, rhs: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: ShortCircuitOperator, node?: ts.BinaryExpression): [lua.Statement[], lua.Expression];
-export declare function transformBinaryOperation(context: TransformationContext, left: lua.Expression, right: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: BitOperator | SimpleOperator | ts.SyntaxKind.QuestionQuestionToken, node: ts.Node): [lua.Statement[], lua.Expression];
+export declare function createShortCircuitBinaryExpressionPrecedingStatements(context: TransformationContext, lhs: lua.Expression, rhs: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: ShortCircuitOperator, node?: ts.BinaryExpression): WithPrecedingStatements<lua.Expression>;
+export declare function transformBinaryOperation(context: TransformationContext, left: lua.Expression, right: lua.Expression, rightPrecedingStatements: lua.Statement[], operator: BitOperator | SimpleOperator | ts.SyntaxKind.QuestionQuestionToken, node: ts.Node): WithPrecedingStatements<lua.Expression>;
 export declare const transformBinaryExpression: FunctionVisitor<ts.BinaryExpression>;
 export declare function transformBinaryExpressionStatement(context: TransformationContext, node: ts.ExpressionStatement): lua.Statement[] | lua.Statement | undefined;
 export {};

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

@@ -78,23 +78,23 @@ function createShortCircuitBinaryExpressionPrecedingStatements(context, lhs, rhs
             break;
     }
     const ifStatement = lua.createIfStatement(condition, lua.createBlock([...rightPrecedingStatements, lua.createAssignmentStatement(conditionIdentifier, rhs)]), undefined, node === null || node === void 0 ? void 0 : node.left);
-    return [[assignmentStatement, ifStatement], conditionIdentifier];
+    return { precedingStatements: [assignmentStatement, ifStatement], result: conditionIdentifier };
 }
 exports.createShortCircuitBinaryExpressionPrecedingStatements = createShortCircuitBinaryExpressionPrecedingStatements;
 function transformShortCircuitBinaryExpression(context, node, operator) {
     const lhs = context.transformExpression(node.left);
-    const [rightPrecedingStatements, rhs] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
-    return transformBinaryOperation(context, lhs, rhs, rightPrecedingStatements, operator, node);
+    const { precedingStatements, result } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
+    return transformBinaryOperation(context, lhs, result, precedingStatements, operator, node);
 }
 function transformBinaryOperation(context, left, right, rightPrecedingStatements, operator, node) {
     if (rightPrecedingStatements.length > 0 && isShortCircuitOperator(operator)) {
         (0, utils_1.assert)(ts.isBinaryExpression(node));
         return createShortCircuitBinaryExpressionPrecedingStatements(context, left, right, rightPrecedingStatements, operator, node);
     }
-    return [
-        rightPrecedingStatements,
-        transformBinaryOperationWithNoPrecedingStatements(context, left, right, operator, node),
-    ];
+    return {
+        precedingStatements: rightPrecedingStatements,
+        result: transformBinaryOperationWithNoPrecedingStatements(context, left, right, operator, node),
+    };
 }
 exports.transformBinaryOperation = transformBinaryOperation;
 const transformBinaryExpression = (node, context) => {
@@ -127,7 +127,7 @@ const transformBinaryExpression = (node, context) => {
         }
         case ts.SyntaxKind.CommaToken: {
             const statements = context.transformStatements(ts.factory.createExpressionStatement(node.left));
-            const [precedingStatements, result] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
+            const { precedingStatements, result } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
             statements.push(...precedingStatements);
             context.addPrecedingStatements(statements);
             return result;
@@ -135,14 +135,13 @@ const transformBinaryExpression = (node, context) => {
         case ts.SyntaxKind.QuestionQuestionToken:
         case ts.SyntaxKind.AmpersandAmpersandToken:
         case ts.SyntaxKind.BarBarToken: {
-            const [precedingStatements, result] = transformShortCircuitBinaryExpression(context, node, operator);
+            const { precedingStatements, result } = transformShortCircuitBinaryExpression(context, node, operator);
             context.addPrecedingStatements(precedingStatements);
             return result;
         }
     }
-    let [precedingStatements, [lhs, rhs]] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.transformOrderedExpressions)(context, [node.left, node.right]));
-    let result;
-    [precedingStatements, result] = transformBinaryOperation(context, lhs, rhs, precedingStatements, operator, node);
+    const { precedingStatements: orderedExpressionPrecedingStatements, result: [lhs, rhs], } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.transformOrderedExpressions)(context, [node.left, node.right]));
+    const { precedingStatements, result } = transformBinaryOperation(context, lhs, rhs, orderedExpressionPrecedingStatements, operator, node);
     context.addPrecedingStatements(precedingStatements);
     return result;
 };
@@ -174,7 +173,7 @@ function transformNullishCoalescingOperationNoPrecedingStatements(context, node,
     // Check if we can take a shortcut to 'lhs or rhs' if the left-hand side cannot be 'false'.
     if ((0, typescript_1.canBeFalsyWhenNotNull)(context, lhsType)) {
         // reuse logic from case with preceding statements
-        const [precedingStatements, result] = createShortCircuitBinaryExpressionPrecedingStatements(context, transformedLeft, transformedRight, [], ts.SyntaxKind.QuestionQuestionToken, node);
+        const { precedingStatements, result } = createShortCircuitBinaryExpressionPrecedingStatements(context, transformedLeft, transformedRight, [], ts.SyntaxKind.QuestionQuestionToken, node);
         context.addPrecedingStatements(precedingStatements);
         return result;
     }

package/dist/transformation/visitors/call.js

@@ -55,7 +55,7 @@ function transformCallWithArguments(context, callExpression, transformedArgument
     return [call, transformedArguments];
 }
 function transformCallAndArguments(context, callExpression, params, signature, callContext) {
-    const [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, params, signature, callContext));
+    const { precedingStatements: argPrecedingStatements, result: transformedArguments } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, params, signature, callContext));
     return transformCallWithArguments(context, callExpression, transformedArguments, argPrecedingStatements);
 }
 exports.transformCallAndArguments = transformCallAndArguments;
@@ -82,7 +82,7 @@ function transformContextualCallExpression(context, node, args, signature) {
         return (0, optional_chaining_1.transformOptionalChain)(context, node);
     }
     const left = ts.isCallExpression(node) ? getCalledExpression(node) : node.tag;
-    let [argPrecedingStatements, transformedArguments] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
+    let { precedingStatements: argPrecedingStatements, result: transformedArguments } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformArguments(context, args, signature));
     if (ts.isPropertyAccessExpression(left) &&
         ts.isIdentifier(left.name) &&
         (0, safe_names_1.isValidLuaIdentifier)(left.name.text, context.options) &&

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

@@ -20,7 +20,7 @@ const transformClassDeclaration = (declaration, context) => {
     // If declaration is a default export, transform to export variable assignment instead
     if ((0, export_1.hasDefaultExportModifier)(declaration)) {
         // Class declaration including assignment to ____exports.default are in preceding statements
-        const [precedingStatements] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        const { precedingStatements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
             transformClassAsExpression(declaration, context);
             return [];
         });

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

@@ -22,7 +22,7 @@ exports.createPropertyDecoratingExpression = createPropertyDecoratingExpression;
 function transformClassInstanceFields(context, instanceFields) {
     const statements = [];
     for (const f of instanceFields) {
-        const [precedingStatements, statement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        const { precedingStatements, result: statement } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
             // Get identifier
             const fieldName = (0, literal_1.transformPropertyName)(context, f.name);
             const value = f.initializer ? context.transformExpression(f.initializer) : undefined;

package/dist/transformation/visitors/conditional.js

@@ -10,12 +10,12 @@ const typescript_1 = require("../utils/typescript");
 const diagnostics_1 = require("../utils/diagnostics");
 function transformProtectedConditionalExpression(context, expression, condition, whenTrue, whenFalse) {
     const tempVar = context.createTempNameForNode(expression.condition);
-    const trueStatements = whenTrue[0].concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenTrue[1], expression.whenTrue));
-    const falseStatements = whenFalse[0].concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenFalse[1], expression.whenFalse));
+    const trueStatements = whenTrue.precedingStatements.concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenTrue.result, expression.whenTrue));
+    const falseStatements = whenFalse.precedingStatements.concat(lua.createAssignmentStatement(lua.cloneIdentifier(tempVar), whenFalse.result, expression.whenFalse));
     context.addPrecedingStatements([
         lua.createVariableDeclarationStatement(tempVar, undefined, expression.condition),
-        ...condition[0],
-        lua.createIfStatement(condition[1], lua.createBlock(trueStatements, expression.whenTrue), lua.createBlock(falseStatements, expression.whenFalse), expression),
+        ...condition.precedingStatements,
+        lua.createIfStatement(condition.result, lua.createBlock(trueStatements, expression.whenTrue), lua.createBlock(falseStatements, expression.whenFalse), expression),
     ]);
     return lua.cloneIdentifier(tempVar);
 }
@@ -25,15 +25,15 @@ const transformConditionalExpression = (expression, context) => {
     const condition = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.condition));
     const whenTrue = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.whenTrue));
     const whenFalse = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.whenFalse));
-    if (whenTrue[0].length > 0 ||
-        whenFalse[0].length > 0 ||
+    if (whenTrue.precedingStatements.length > 0 ||
+        whenFalse.precedingStatements.length > 0 ||
         (0, typescript_1.canBeFalsy)(context, context.checker.getTypeAtLocation(expression.whenTrue))) {
         return transformProtectedConditionalExpression(context, expression, condition, whenTrue, whenFalse);
     }
     // condition and v1 or v2
-    context.addPrecedingStatements(condition[0]);
-    const conditionAnd = lua.createBinaryExpression(condition[1], whenTrue[1], lua.SyntaxKind.AndOperator);
-    return lua.createBinaryExpression(conditionAnd, whenFalse[1], lua.SyntaxKind.OrOperator, expression);
+    context.addPrecedingStatements(condition.precedingStatements);
+    const conditionAnd = lua.createBinaryExpression(condition.result, whenTrue.result, lua.SyntaxKind.AndOperator);
+    return lua.createBinaryExpression(conditionAnd, whenFalse.result, lua.SyntaxKind.OrOperator, expression);
 };
 exports.transformConditionalExpression = transformConditionalExpression;
 function transformIfStatement(statement, context) {
@@ -47,7 +47,7 @@ function transformIfStatement(statement, context) {
     if (statement.elseStatement) {
         if (ts.isIfStatement(statement.elseStatement)) {
             const tsElseStatement = statement.elseStatement;
-            const [precedingStatements, elseStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformIfStatement(tsElseStatement, context));
+            const { precedingStatements, result: elseStatement } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => transformIfStatement(tsElseStatement, context));
             // If else-if condition generates preceding statements, we can't use elseif, we have to break it down:
             // if conditionA then
             //     ...

package/dist/transformation/visitors/expression-list.js

@@ -34,7 +34,7 @@ function transformExpressions(context, expressions) {
     const transformedExpressions = [];
     let lastPrecedingStatementsIndex = -1;
     for (let i = 0; i < expressions.length; ++i) {
-        const [expressionPrecedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expressions[i]));
+        const { precedingStatements: expressionPrecedingStatements, result: expression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expressions[i]));
         transformedExpressions.push(expression);
         if (expressionPrecedingStatements.length > 0) {
             lastPrecedingStatementsIndex = i;

package/dist/transformation/visitors/function.js

@@ -69,7 +69,7 @@ function isFunctionTypeWithProperties(context, functionType) {
 exports.isFunctionTypeWithProperties = isFunctionTypeWithProperties;
 function transformFunctionBodyContent(context, body) {
     if (!ts.isBlock(body)) {
-        const [precedingStatements, returnStatement] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, return_1.transformExpressionBodyToReturnStatement)(context, body));
+        const { precedingStatements, result: returnStatement } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, return_1.transformExpressionBodyToReturnStatement)(context, body));
         return [...precedingStatements, returnStatement];
     }
     const bodyStatements = (0, scope_1.performHoisting)(context, context.transformStatements(body.statements));
@@ -90,7 +90,7 @@ function transformFunctionBodyHeader(context, bodyScope, parameters, spreadIdent
             }
             // Binding pattern
             const name = declaration.name;
-            const [precedingStatements, bindings] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, name, identifier));
+            const { precedingStatements, result: bindings } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, name, identifier));
             bindingPatternDeclarations.push(...precedingStatements, ...bindings);
         }
         else if (declaration.initializer !== undefined) {

package/dist/transformation/visitors/loops/do-while.js

@@ -9,7 +9,7 @@ const transformWhileStatement = (statement, context) => {
     // Check if we need to add diagnostic about Lua truthiness
     (0, conditional_1.checkOnlyTruthyCondition)(statement.expression, context);
     const body = (0, utils_1.transformLoopBody)(context, statement);
-    let [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
+    let { precedingStatements: conditionPrecedingStatements, result: condition } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
     // If condition has preceding statements, ensure they are executed every iteration by using the form:
     //
     // while true do
@@ -31,7 +31,7 @@ const transformDoStatement = (statement, context) => {
     // Check if we need to add diagnostic about Lua truthiness
     (0, conditional_1.checkOnlyTruthyCondition)(statement.expression, context);
     const body = lua.createDoStatement((0, utils_1.transformLoopBody)(context, statement));
-    let [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, utils_1.invertCondition)(context.transformExpression(statement.expression)));
+    let { precedingStatements: conditionPrecedingStatements, result: condition } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, utils_1.invertCondition)(context.transformExpression(statement.expression)));
     // If condition has preceding statements, ensure they are executed every iteration by using the form:
     //
     // repeat

package/dist/transformation/visitors/loops/for.js

@@ -21,9 +21,9 @@ const transformForStatement = (statement, context) => {
     const body = (0, utils_1.transformLoopBody)(context, statement);
     let condition;
     if (statement.condition) {
-        let conditionPrecedingStatements;
         const tsCondition = statement.condition;
-        [conditionPrecedingStatements, condition] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsCondition));
+        const { precedingStatements: conditionPrecedingStatements, result } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsCondition));
+        condition = result;
         // If condition has preceding statements, ensure they are executed every iteration by using the form:
         //
         // while true do

package/dist/transformation/visitors/loops/utils.js

@@ -40,7 +40,7 @@ function transformForInitializer(context, initializer, block) {
         // Declaration of new variable
         const binding = getVariableDeclarationBinding(context, initializer);
         if (ts.isArrayBindingPattern(binding) || ts.isObjectBindingPattern(binding)) {
-            const [precedingStatements, bindings] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, binding, valueVariable));
+            const { precedingStatements, result: bindings } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, variable_declaration_1.transformBindingPattern)(context, binding, valueVariable));
             block.statements.unshift(...precedingStatements, ...bindings);
         }
         else {

package/dist/transformation/visitors/optional-chaining.js

@@ -99,7 +99,7 @@ function transformOptionalChainWithCapture(context, tsNode, thisValueCapture, is
     // transform right expression first to check if thisValue capture is needed
     // capture and return thisValue if requested from outside
     let returnThisValue;
-    const [rightPrecedingStatements, rightExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+    const { precedingStatements: rightPrecedingStatements, result: rightExpression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
         if (!thisValueCapture) {
             return context.transformExpression(tsRightExpression);
         }
@@ -113,7 +113,7 @@ function transformOptionalChainWithCapture(context, tsNode, thisValueCapture, is
     let capturedThisValue;
     const optionalContinuationData = getOptionalContinuationData(tsTemp);
     const rightContextualCall = optionalContinuationData === null || optionalContinuationData === void 0 ? void 0 : optionalContinuationData.contextualCall;
-    const [leftPrecedingStatements, leftExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+    const { precedingStatements: leftPrecedingStatements, result: leftExpression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
         let result;
         if (rightContextualCall) {
             ({ expression: result, thisValue: capturedThisValue } = transformExpressionWithThisValueCapture(context, tsLeftExpression, leftThisValueTemp));

package/dist/transformation/visitors/sourceFile.js

@@ -15,7 +15,7 @@ const transformSourceFileNode = (node, context) => {
         const [statement] = node.statements;
         if (statement) {
             (0, utils_1.assert)(ts.isExpressionStatement(statement));
-            const [precedingStatements, expression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
+            const { precedingStatements, result: expression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(statement.expression));
             statements.push(...precedingStatements);
             statements.push(lua.createReturnStatement([expression]));
         }

package/dist/transformation/visitors/switch.js

@@ -25,18 +25,21 @@ const createOrExpression = (context, left, right, rightPrecedingStatements) => {
         return (0, binary_expression_1.createShortCircuitBinaryExpressionPrecedingStatements)(context, left, right, rightPrecedingStatements, ts.SyntaxKind.BarBarToken);
     }
     else {
-        return [rightPrecedingStatements, lua.createBinaryExpression(left, right, lua.SyntaxKind.OrOperator)];
+        return {
+            precedingStatements: rightPrecedingStatements,
+            result: lua.createBinaryExpression(left, right, lua.SyntaxKind.OrOperator),
+        };
     }
 };
 const coalesceCondition = (condition, conditionPrecedingStatements, switchVariable, expression, context) => {
-    const [precedingStatements, transformedExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression));
+    const { precedingStatements, result: transformedExpression } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression));
     // Coalesce skipped statements
     const comparison = lua.createBinaryExpression(switchVariable, transformedExpression, lua.SyntaxKind.EqualityOperator);
     if (condition) {
         return createOrExpression(context, condition, comparison, precedingStatements);
     }
     // Next condition
-    return [[...conditionPrecedingStatements, ...precedingStatements], comparison];
+    return { precedingStatements: [...conditionPrecedingStatements, ...precedingStatements], result: comparison };
 };
 const transformSwitchStatement = (statement, context) => {
     const scope = context.pushScope(scope_1.ScopeType.Switch);
@@ -77,7 +80,9 @@ const transformSwitchStatement = (statement, context) => {
             }
             // Compute the condition for the if statement
             if (!ts.isDefaultClause(clause)) {
-                [conditionPrecedingStatements, condition] = coalesceCondition(condition, conditionPrecedingStatements, switchVariable, clause.expression, context);
+                const { precedingStatements, result } = coalesceCondition(condition, conditionPrecedingStatements, switchVariable, clause.expression, context);
+                conditionPrecedingStatements = precedingStatements;
+                condition = result;
                 // Skip empty clauses unless final clause (i.e side-effects)
                 if (i !== clauses.length - 1 && clause.statements.length === 0)
                     continue;
@@ -86,7 +91,9 @@ const transformSwitchStatement = (statement, context) => {
                     statements.push(...conditionPrecedingStatements, lua.createVariableDeclarationStatement(conditionVariable, condition));
                 }
                 else {
-                    [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                    const { precedingStatements, result } = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                    conditionPrecedingStatements = precedingStatements;
+                    condition = result;
                     statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
                 }
                 isInitialCondition = false;
@@ -104,7 +111,9 @@ const transformSwitchStatement = (statement, context) => {
                 if (i === clauses.length - 1) {
                     // Evaluate the final condition that we may be skipping
                     if (condition) {
-                        [conditionPrecedingStatements, condition] = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                        const { precedingStatements, result } = createOrExpression(context, conditionVariable, condition, conditionPrecedingStatements);
+                        conditionPrecedingStatements = precedingStatements;
+                        condition = result;
                         statements.push(...conditionPrecedingStatements, lua.createAssignmentStatement(conditionVariable, condition));
                     }
                     continue;

package/dist/transformation/visitors/typeof.js

@@ -43,7 +43,7 @@ function transformTypeOfBinaryExpression(context, node) {
     }
     const innerExpression = context.transformExpression(typeOfExpression.expression);
     const typeCall = lua.createCallExpression(lua.createIdentifier("type"), [innerExpression], typeOfExpression);
-    const [precedingStatements, result] = (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, [], operator, node);
+    const { precedingStatements, result } = (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, [], operator, node);
     context.addPrecedingStatements(precedingStatements);
     return result;
 }

package/dist/transformation/visitors/variable-declaration.js

@@ -61,7 +61,7 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
         const variableName = (0, identifier_1.transformIdentifier)(context, element.name);
         // The field to extract
         const elementName = (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name;
-        const [precedingStatements, propertyName] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, literal_1.transformPropertyName)(context, elementName));
+        const { precedingStatements, result: propertyName } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, literal_1.transformPropertyName)(context, elementName));
         result.push(...precedingStatements); // Keep property's preceding statements in order
         let expression;
         if (element.dotDotDotToken) {
@@ -101,7 +101,7 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
         if (element.initializer) {
             const identifier = (0, export_1.addExportToIdentifier)(context, variableName);
             const tsInitializer = element.initializer;
-            const [initializerPrecedingStatements, initializer] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsInitializer));
+            const { precedingStatements: initializerPrecedingStatements, result: initializer } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsInitializer));
             result.push(lua.createIfStatement(lua.createBinaryExpression(identifier, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator), lua.createBlock([
                 ...initializerPrecedingStatements,
                 lua.createAssignmentStatement(identifier, initializer),
@@ -124,7 +124,7 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
             if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
                 expression = (0, lua_ast_1.wrapInTable)(expression);
             }
-            const [moveStatements, movedExpr] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.moveToPrecedingTemp)(context, expression, initializer));
+            const { precedingStatements: moveStatements, result: movedExpr } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, expression_list_1.moveToPrecedingTemp)(context, expression, initializer));
             statements.push(...moveStatements);
             table = movedExpr;
         }

package/dist/transpilation/output-collector.d.ts

@@ -7,7 +7,7 @@ export interface TranspiledFile {
     declaration?: string;
     declarationMap?: string;
 }
-export declare function createEmitOutputCollector(): {
+export declare function createEmitOutputCollector(luaExtension?: string): {
     writeFile: ts.WriteFileCallback;
     files: TranspiledFile[];
 };

package/dist/transpilation/output-collector.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEmitOutputCollector = void 0;
 const utils_1 = require("../utils");
-function createEmitOutputCollector() {
+function createEmitOutputCollector(luaExtension = ".lua") {
     const files = [];
     const writeFile = (fileName, data, _bom, _onError, sourceFiles = []) => {
         let file = files.find(f => (0, utils_1.intersection)(f.sourceFiles, sourceFiles).length > 0);
@@ -13,10 +13,10 @@ function createEmitOutputCollector() {
         else {
             file.sourceFiles = (0, utils_1.union)(file.sourceFiles, sourceFiles);
         }
-        if (fileName.endsWith(".lua")) {
+        if (fileName.endsWith(luaExtension)) {
             file.lua = data;
         }
-        else if (fileName.endsWith(".lua.map")) {
+        else if (fileName.endsWith(`${luaExtension}.map`)) {
             file.luaSourceMap = data;
         }
         else if (fileName.endsWith(".js")) {

package/dist/transpilation/resolve.js

@@ -15,6 +15,7 @@ const resolver = resolve.ResolverFactory.createResolver({
     enforceExtension: true,
     fileSystem: { ...new resolve.CachedInputFileSystem(fs) },
     useSyncFileSystemCalls: true,
+    conditionNames: ["require", "node", "tstl", "default"],
     symlinks: false, // Do not resolve symlinks to their original paths (that breaks node_modules detection)
 });
 class ResolutionContext {
@@ -40,8 +41,8 @@ class ResolutionContext {
                 // Remove @NoResolution prefix if not building in library mode
                 if (!isBuildModeLibrary(this.program)) {
                     const path = required.requirePath.replace("@NoResolution:", "");
-                    replaceRequireInCode(file, required, path);
-                    replaceRequireInSourceMap(file, required, path);
+                    replaceRequireInCode(file, required, path, this.options.extension);
+                    replaceRequireInSourceMap(file, required, path, this.options.extension);
                 }
                 // Skip
                 continue;
@@ -72,8 +73,8 @@ class ResolutionContext {
         // Figure out resolved require path and dependency output path
         if (shouldRewriteRequires(dependencyPath, this.program)) {
             const resolvedRequire = (0, transpiler_1.getEmitPathRelativeToOutDir)(dependencyPath, this.program);
-            replaceRequireInCode(file, required, resolvedRequire);
-            replaceRequireInSourceMap(file, required, resolvedRequire);
+            replaceRequireInCode(file, required, resolvedRequire, this.options.extension);
+            replaceRequireInSourceMap(file, required, resolvedRequire, this.options.extension);
         }
     }
     processDependency(dependencyPath) {
@@ -96,8 +97,8 @@ class ResolutionContext {
     }
     couldNotResolveImport(required, file) {
         const fallbackRequire = fallbackResolve(required, (0, transpiler_1.getSourceDir)(this.program), path.dirname(file.fileName));
-        replaceRequireInCode(file, required, fallbackRequire);
-        replaceRequireInSourceMap(file, required, fallbackRequire);
+        replaceRequireInCode(file, required, fallbackRequire, this.options.extension);
+        replaceRequireInSourceMap(file, required, fallbackRequire, this.options.extension);
         this.diagnostics.push((0, diagnostics_1.couldNotResolveRequire)(required.requirePath, path.relative((0, transpiler_1.getProjectRoot)(this.program), file.fileName)));
     }
     resolveDependencyPath(requiringFile, dependency) {
@@ -263,19 +264,27 @@ function shouldIncludeDependency(resolvedDependency, program) {
 function isBuildModeLibrary(program) {
     return program.getCompilerOptions().buildMode === CompilerOptions_1.BuildMode.Library;
 }
-function replaceRequireInCode(file, originalRequire, newRequire) {
-    const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
+function replaceRequireInCode(file, originalRequire, newRequire, extension) {
+    const requirePath = requirePathForFile(newRequire, extension);
     file.code = file.code =
         file.code.substring(0, originalRequire.from) +
             `require("${requirePath}")` +
             file.code.substring(originalRequire.to + 1);
 }
-function replaceRequireInSourceMap(file, originalRequire, newRequire) {
-    const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
+function replaceRequireInSourceMap(file, originalRequire, newRequire, extension) {
+    const requirePath = requirePathForFile(newRequire, extension);
     if (file.sourceMapNode) {
         replaceInSourceMap(file.sourceMapNode, file.sourceMapNode, `"${originalRequire.requirePath}"`, `"${requirePath}"`);
     }
 }
+function requirePathForFile(filePath, extension = ".lua") {
+    if (filePath.endsWith(extension)) {
+        return (0, utils_1.formatPathToLuaPath)(filePath.substring(0, filePath.length - extension.length));
+    }
+    else {
+        return (0, utils_1.formatPathToLuaPath)(filePath);
+    }
+}
 function replaceInSourceMap(node, parent, require, resolvedRequire) {
     if ((!node.children || node.children.length === 0) && node.toString() === require) {
         parent.children = [new source_map_1.SourceNode(node.line, node.column, node.source, [resolvedRequire])];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.12.1",
+    "version": "1.13.0",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
     "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",
     "homepage": "https://typescripttolua.github.io/",