typescript-to-lua 1.25.2 → 1.26.0

package/dist/transformation/utils/symbols.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIdentifierSymbolId = exports.trackSymbolReference = exports.getSymbolIdOfSymbol = exports.getSymbolInfo = void 0;
+exports.getSymbolInfo = getSymbolInfo;
+exports.getSymbolIdOfSymbol = getSymbolIdOfSymbol;
+exports.trackSymbolReference = trackSymbolReference;
+exports.getIdentifierSymbolId = getIdentifierSymbolId;
 const spread_1 = require("../visitors/spread");
 const scope_1 = require("./scope");
 function getSymbolInfo(context, symbolId) {
     return context.symbolInfoMap.get(symbolId);
 }
-exports.getSymbolInfo = getSymbolInfo;
 function getSymbolIdOfSymbol(context, symbol) {
     return context.symbolIdMaps.get(symbol);
 }
-exports.getSymbolIdOfSymbol = getSymbolIdOfSymbol;
 function trackSymbolReference(context, symbol, identifier) {
     // Track first time symbols are seen
     let symbolId = context.symbolIdMaps.get(symbol);
@@ -26,11 +27,9 @@ function trackSymbolReference(context, symbol, identifier) {
     }
     return symbolId;
 }
-exports.trackSymbolReference = trackSymbolReference;
 function getIdentifierSymbolId(context, identifier, symbol) {
     if (symbol) {
         return trackSymbolReference(context, symbol, identifier);
     }
 }
-exports.getIdentifierSymbolId = getIdentifierSymbolId;
 //# sourceMappingURL=symbols.js.map

package/dist/transformation/utils/typescript/index.js

@@ -14,7 +14,19 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.isStandardLibraryDeclaration = exports.getFirstDeclarationInFile = exports.expressionResultIsUsed = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
+exports.hasExportEquals = hasExportEquals;
+exports.findFirstNodeAbove = findFirstNodeAbove;
+exports.findFirstNonOuterParent = findFirstNonOuterParent;
+exports.expressionResultIsUsed = expressionResultIsUsed;
+exports.getFirstDeclarationInFile = getFirstDeclarationInFile;
+exports.isStandardLibraryDeclaration = isStandardLibraryDeclaration;
+exports.isStandardLibraryType = isStandardLibraryType;
+exports.hasStandardLibrarySignature = hasStandardLibrarySignature;
+exports.inferAssignedType = inferAssignedType;
+exports.getAllCallSignatures = getAllCallSignatures;
+exports.isExpressionWithEvaluationEffect = isExpressionWithEvaluationEffect;
+exports.getFunctionTypeForCall = getFunctionTypeForCall;
+exports.isConstIdentifier = isConstIdentifier;
 const ts = require("typescript");
 __exportStar(require("./nodes"), exports);
 __exportStar(require("./types"), exports);
@@ -22,7 +34,6 @@ __exportStar(require("./types"), exports);
 function hasExportEquals(sourceFile) {
     return sourceFile.statements.some(node => ts.isExportAssignment(node) && node.isExportEquals);
 }
-exports.hasExportEquals = hasExportEquals;
 /**
  * Search up until finding a node satisfying the callback
  */
@@ -37,7 +48,6 @@ function findFirstNodeAbove(node, callback) {
         }
     }
 }
-exports.findFirstNodeAbove = findFirstNodeAbove;
 function findFirstNonOuterParent(node) {
     let current = ts.getOriginalNode(node).parent;
     while (ts.isOuterExpression(current)) {
@@ -45,18 +55,15 @@ function findFirstNonOuterParent(node) {
     }
     return current;
 }
-exports.findFirstNonOuterParent = findFirstNonOuterParent;
 function expressionResultIsUsed(node) {
     return !ts.isExpressionStatement(findFirstNonOuterParent(node));
 }
-exports.expressionResultIsUsed = expressionResultIsUsed;
 function getFirstDeclarationInFile(symbol, sourceFile) {
     var _a, _b;
     const originalSourceFile = (_a = ts.getParseTreeNode(sourceFile)) !== null && _a !== void 0 ? _a : sourceFile;
     const declarations = ((_b = symbol.getDeclarations()) !== null && _b !== void 0 ? _b : []).filter(d => d.getSourceFile() === originalSourceFile);
     return declarations.length > 0 ? declarations.reduce((p, c) => (p.pos < c.pos ? p : c)) : undefined;
 }
-exports.getFirstDeclarationInFile = getFirstDeclarationInFile;
 function isStandardLibraryDeclaration(context, declaration) {
     var _a;
     const parseTreeNode = (_a = ts.getParseTreeNode(declaration)) !== null && _a !== void 0 ? _a : declaration;
@@ -66,7 +73,6 @@ function isStandardLibraryDeclaration(context, declaration) {
     }
     return context.program.isSourceFileDefaultLibrary(sourceFile);
 }
-exports.isStandardLibraryDeclaration = isStandardLibraryDeclaration;
 function isStandardLibraryType(context, type, name) {
     const symbol = type.getSymbol();
     if (!symbol || (name ? symbol.name !== name : symbol.name === "__type")) {
@@ -79,26 +85,21 @@ function isStandardLibraryType(context, type, name) {
     }
     return isStandardLibraryDeclaration(context, declaration);
 }
-exports.isStandardLibraryType = isStandardLibraryType;
 function hasStandardLibrarySignature(context, callExpression) {
     const signature = context.checker.getResolvedSignature(callExpression);
     return (signature === null || signature === void 0 ? void 0 : signature.declaration) ? isStandardLibraryDeclaration(context, signature.declaration) : false;
 }
-exports.hasStandardLibrarySignature = hasStandardLibrarySignature;
 function inferAssignedType(context, expression) {
     var _a;
     return (_a = context.checker.getContextualType(expression)) !== null && _a !== void 0 ? _a : context.checker.getTypeAtLocation(expression);
 }
-exports.inferAssignedType = inferAssignedType;
 function getAllCallSignatures(type) {
     return type.isUnion() ? type.types.flatMap(getAllCallSignatures) : type.getCallSignatures();
 }
-exports.getAllCallSignatures = getAllCallSignatures;
 // Returns true for expressions that may have effects when evaluated
 function isExpressionWithEvaluationEffect(node) {
     return !(ts.isLiteralExpression(node) || ts.isIdentifier(node) || node.kind === ts.SyntaxKind.ThisKeyword);
 }
-exports.isExpressionWithEvaluationEffect = isExpressionWithEvaluationEffect;
 function getFunctionTypeForCall(context, node) {
     const signature = context.checker.getResolvedSignature(node);
     if (!(signature === null || signature === void 0 ? void 0 : signature.declaration)) {
@@ -110,7 +111,6 @@ function getFunctionTypeForCall(context, node) {
     }
     return context.checker.getTypeFromTypeNode(typeDeclaration.type);
 }
-exports.getFunctionTypeForCall = getFunctionTypeForCall;
 function isConstIdentifier(context, node) {
     let identifier = node;
     if (ts.isComputedPropertyName(identifier)) {
@@ -125,5 +125,4 @@ function isConstIdentifier(context, node) {
     }
     return symbol.declarations.some(d => ts.isVariableDeclarationList(d.parent) && (d.parent.flags & ts.NodeFlags.Const) !== 0);
 }
-exports.isConstIdentifier = isConstIdentifier;
 //# sourceMappingURL=index.js.map

package/dist/transformation/utils/typescript/nodes.js

@@ -1,28 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFirstDeclaration = exports.getSymbolOfNode = exports.isInGeneratorFunction = exports.isInAsyncFunction = exports.isInDestructingAssignment = exports.isAmbientNode = exports.isDestructuringAssignment = exports.isAssignmentPattern = void 0;
+exports.isAssignmentPattern = isAssignmentPattern;
+exports.isDestructuringAssignment = isDestructuringAssignment;
+exports.isAmbientNode = isAmbientNode;
+exports.isInDestructingAssignment = isInDestructingAssignment;
+exports.isInAsyncFunction = isInAsyncFunction;
+exports.isInGeneratorFunction = isInGeneratorFunction;
+exports.getSymbolOfNode = getSymbolOfNode;
+exports.isFirstDeclaration = isFirstDeclaration;
 const ts = require("typescript");
 const _1 = require(".");
 function isAssignmentPattern(node) {
     return ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node);
 }
-exports.isAssignmentPattern = isAssignmentPattern;
 function isDestructuringAssignment(node) {
     return (ts.isBinaryExpression(node) &&
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         isAssignmentPattern(node.left));
 }
-exports.isDestructuringAssignment = isDestructuringAssignment;
 function isAmbientNode(node) {
     return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Ambient) !== 0;
 }
-exports.isAmbientNode = isAmbientNode;
 function isInDestructingAssignment(node) {
     return (node.parent &&
         ((ts.isVariableDeclaration(node.parent) && ts.isArrayBindingPattern(node.parent.name)) ||
             (ts.isBinaryExpression(node.parent) && ts.isArrayLiteralExpression(node.parent.left))));
 }
-exports.isInDestructingAssignment = isInDestructingAssignment;
 function isInAsyncFunction(node) {
     var _a, _b;
     // Check if node is in function declaration with `async`
@@ -37,7 +40,6 @@ function isInAsyncFunction(node) {
         return false;
     }
 }
-exports.isInAsyncFunction = isInAsyncFunction;
 function isInGeneratorFunction(node) {
     // Check if node is in function declaration with `async`
     const declaration = (0, _1.findFirstNodeAbove)(node, ts.isFunctionDeclaration);
@@ -46,7 +48,6 @@ function isInGeneratorFunction(node) {
     }
     return declaration.asteriskToken !== undefined;
 }
-exports.isInGeneratorFunction = isInGeneratorFunction;
 /**
  * Quite hacky, avoid unless absolutely necessary!
  */
@@ -54,10 +55,8 @@ function getSymbolOfNode(context, node) {
     var _a;
     return (_a = node.symbol) !== null && _a !== void 0 ? _a : context.checker.getSymbolAtLocation(node);
 }
-exports.getSymbolOfNode = getSymbolOfNode;
 function isFirstDeclaration(context, node) {
     const symbol = getSymbolOfNode(context, node);
     return symbol ? symbol.valueDeclaration === node : true;
 }
-exports.isFirstDeclaration = isFirstDeclaration;
 //# sourceMappingURL=nodes.js.map

package/dist/transformation/utils/typescript/types.js

@@ -1,6 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isAlwaysArrayType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanHaveSomeOfFlags = exports.typeAlwaysHasSomeOfFlags = void 0;
+exports.typeAlwaysHasSomeOfFlags = typeAlwaysHasSomeOfFlags;
+exports.typeCanHaveSomeOfFlags = typeCanHaveSomeOfFlags;
+exports.isStringType = isStringType;
+exports.isNumberType = isNumberType;
+exports.forTypeOrAnySupertype = forTypeOrAnySupertype;
+exports.isArrayType = isArrayType;
+exports.isAlwaysArrayType = isAlwaysArrayType;
+exports.isFunctionType = isFunctionType;
+exports.canBeFalsy = canBeFalsy;
+exports.canBeFalsyWhenNotNull = canBeFalsyWhenNotNull;
 const ts = require("typescript");
 function typeAlwaysHasSomeOfFlags(context, type, flags) {
     const baseConstraint = context.checker.getBaseConstraintOfType(type);
@@ -18,7 +27,6 @@ function typeAlwaysHasSomeOfFlags(context, type, flags) {
     }
     return false;
 }
-exports.typeAlwaysHasSomeOfFlags = typeAlwaysHasSomeOfFlags;
 function typeCanHaveSomeOfFlags(context, type, flags) {
     const baseConstraint = context.checker.getBaseConstraintOfType(type);
     if (!baseConstraint) {
@@ -40,15 +48,12 @@ function typeCanHaveSomeOfFlags(context, type, flags) {
     }
     return false;
 }
-exports.typeCanHaveSomeOfFlags = typeCanHaveSomeOfFlags;
 function isStringType(context, type) {
     return typeAlwaysHasSomeOfFlags(context, type, ts.TypeFlags.StringLike);
 }
-exports.isStringType = isStringType;
 function isNumberType(context, type) {
     return typeAlwaysHasSomeOfFlags(context, type, ts.TypeFlags.NumberLike);
 }
-exports.isNumberType = isNumberType;
 function isExplicitArrayType(context, type) {
     if (context.checker.isArrayType(type) || context.checker.isTupleType(type))
         return true;
@@ -92,19 +97,15 @@ function forTypeOrAnySupertype(context, type, predicate) {
         return false;
     return baseTypes.some(superType => forTypeOrAnySupertype(context, superType, predicate));
 }
-exports.forTypeOrAnySupertype = forTypeOrAnySupertype;
 function isArrayType(context, type) {
     return forTypeOrAnySupertype(context, type, t => isExplicitArrayType(context, t));
 }
-exports.isArrayType = isArrayType;
 function isAlwaysArrayType(context, type) {
     return forTypeOrAnySupertype(context, type, t => isAlwaysExplicitArrayType(context, t));
 }
-exports.isAlwaysArrayType = isAlwaysArrayType;
 function isFunctionType(type) {
     return type.getCallSignatures().length > 0;
 }
-exports.isFunctionType = isFunctionType;
 function canBeFalsy(context, type) {
     const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
     if (!strictNullChecks && !type.isLiteral())
@@ -119,7 +120,6 @@ function canBeFalsy(context, type) {
         ts.TypeFlags.Null;
     return typeCanHaveSomeOfFlags(context, type, falsyFlags);
 }
-exports.canBeFalsy = canBeFalsy;
 function canBeFalsyWhenNotNull(context, type) {
     const falsyFlags = ts.TypeFlags.Boolean |
         ts.TypeFlags.BooleanLiteral |
@@ -129,5 +129,4 @@ function canBeFalsyWhenNotNull(context, type) {
         ts.TypeFlags.Any;
     return typeCanHaveSomeOfFlags(context, type, falsyFlags);
 }
-exports.canBeFalsyWhenNotNull = canBeFalsyWhenNotNull;
 //# sourceMappingURL=types.js.map

package/dist/transformation/visitors/access.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformQualifiedName = exports.transformPropertyAccessExpressionWithCapture = exports.transformPropertyAccessExpression = exports.transformElementAccessExpressionWithCapture = exports.transformElementAccessExpression = exports.transformElementAccessArgument = void 0;
+exports.transformQualifiedName = exports.transformPropertyAccessExpression = exports.transformElementAccessExpression = void 0;
+exports.transformElementAccessArgument = transformElementAccessArgument;
+exports.transformElementAccessExpressionWithCapture = transformElementAccessExpressionWithCapture;
+exports.transformPropertyAccessExpressionWithCapture = transformPropertyAccessExpressionWithCapture;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
@@ -29,7 +32,6 @@ function transformElementAccessArgument(context, node) {
     const index = context.transformExpression(node.argumentExpression);
     return addOneToArrayAccessArgument(context, node, index);
 }
-exports.transformElementAccessArgument = transformElementAccessArgument;
 const transformElementAccessExpression = (node, context) => transformElementAccessExpressionWithCapture(context, node, undefined).expression;
 exports.transformElementAccessExpression = transformElementAccessExpression;
 function transformElementAccessExpressionWithCapture(context, node, thisValueCapture) {
@@ -73,7 +75,6 @@ function transformElementAccessExpressionWithCapture(context, node, thisValueCap
     }
     return { expression: lua.createTableIndexExpression(table, updatedAccessExpression, node) };
 }
-exports.transformElementAccessExpressionWithCapture = transformElementAccessExpressionWithCapture;
 const transformPropertyAccessExpression = (node, context) => transformPropertyAccessExpressionWithCapture(context, node, undefined).expression;
 exports.transformPropertyAccessExpression = transformPropertyAccessExpression;
 function transformPropertyAccessExpressionWithCapture(context, node, thisValueCapture) {
@@ -145,7 +146,6 @@ function transformPropertyAccessExpressionWithCapture(context, node, thisValueCa
     }
     return { expression: lua.createTableIndexExpression(table, lua.createStringLiteral(property), node) };
 }
-exports.transformPropertyAccessExpressionWithCapture = transformPropertyAccessExpressionWithCapture;
 const transformQualifiedName = (node, context) => {
     const right = lua.createStringLiteral(node.right.text, node.right);
     const left = context.transformExpression(node.left);

package/dist/transformation/visitors/async-await.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapInAsyncAwaiter = exports.isAsyncFunction = exports.transformAwaitExpression = void 0;
+exports.transformAwaitExpression = void 0;
+exports.isAsyncFunction = isAsyncFunction;
+exports.wrapInAsyncAwaiter = wrapInAsyncAwaiter;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
@@ -19,7 +21,6 @@ function isAsyncFunction(declaration) {
     var _a, _b;
     return (_b = (_a = declaration.modifiers) === null || _a === void 0 ? void 0 : _a.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)) !== null && _b !== void 0 ? _b : false;
 }
-exports.isAsyncFunction = isAsyncFunction;
 function wrapInAsyncAwaiter(context, statements, includeResolveParameter = true) {
     (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Await);
     const parameters = includeResolveParameter ? [lua.createIdentifier("____awaiter_resolve")] : [];
@@ -27,5 +28,4 @@ function wrapInAsyncAwaiter(context, statements, includeResolveParameter = true)
         lua.createFunctionExpression(lua.createBlock(statements), parameters),
     ]);
 }
-exports.wrapInAsyncAwaiter = wrapInAsyncAwaiter;
 //# sourceMappingURL=async-await.js.map

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

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformAssignmentStatement = exports.transformAssignmentExpression = exports.transformAssignmentWithRightPrecedingStatements = exports.transformAssignment = exports.transformAssignmentLeftHandSideExpression = void 0;
+exports.transformAssignmentLeftHandSideExpression = transformAssignmentLeftHandSideExpression;
+exports.transformAssignment = transformAssignment;
+exports.transformAssignmentWithRightPrecedingStatements = transformAssignmentWithRightPrecedingStatements;
+exports.transformAssignmentExpression = transformAssignmentExpression;
+exports.transformAssignmentStatement = transformAssignmentStatement;
 const ts = require("typescript");
 const typescript_1 = require("typescript");
 const lua = require("../../../LuaAST");
@@ -43,7 +47,6 @@ function transformAssignmentLeftHandSideExpression(context, node, rightHasPreced
         return lua.createAnonymousIdentifier();
     }
 }
-exports.transformAssignmentLeftHandSideExpression = transformAssignmentLeftHandSideExpression;
 function transformAssignment(context, 
 // TODO: Change type to ts.LeftHandSideExpression?
 lhs, right, rightHasPrecedingStatements, parent) {
@@ -82,14 +85,12 @@ lhs, right, rightHasPrecedingStatements, parent) {
         }),
     ];
 }
-exports.transformAssignment = transformAssignment;
 function transformAssignmentWithRightPrecedingStatements(context, lhs, right, rightPrecedingStatements, parent) {
     return [
         ...rightPrecedingStatements,
         ...transformAssignment(context, lhs, right, rightPrecedingStatements.length > 0, parent),
     ];
 }
-exports.transformAssignmentWithRightPrecedingStatements = transformAssignmentWithRightPrecedingStatements;
 function transformDestructuredAssignmentExpression(context, expression) {
     let { precedingStatements: rightPrecedingStatements, result: right } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
     context.addPrecedingStatements(rightPrecedingStatements);
@@ -131,7 +132,6 @@ function transformAssignmentExpression(context, expression) {
         return left;
     }
 }
-exports.transformAssignmentExpression = transformAssignmentExpression;
 const canBeTransformedToLuaAssignmentStatement = (context, node) => ts.isArrayLiteralExpression(node.left) &&
     node.left.elements.every(element => {
         if ((0, destructuring_assignments_1.isArrayLength)(context, element)) {
@@ -179,5 +179,4 @@ function transformAssignmentStatement(context, expression) {
         return transformAssignmentWithRightPrecedingStatements(context, expression.left, right, precedingStatements);
     }
 }
-exports.transformAssignmentStatement = transformAssignmentStatement;
 //# sourceMappingURL=assignments.js.map

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformUnaryBitOperation = exports.transformBinaryBitOperation = exports.isBitOperator = void 0;
+exports.isBitOperator = void 0;
+exports.transformBinaryBitOperation = transformBinaryBitOperation;
+exports.transformUnaryBitOperation = transformUnaryBitOperation;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../../CompilerOptions");
 const lua = require("../../../LuaAST");
@@ -53,7 +55,6 @@ function transformBinaryBitOperation(context, node, left, right, operator) {
             return lua.createBinaryExpression(left, right, luaOperator, node);
     }
 }
-exports.transformBinaryBitOperation = transformBinaryBitOperation;
 function transformUnaryBitLibOperation(node, expression, operator, lib) {
     let bitFunction;
     switch (operator) {
@@ -80,5 +81,4 @@ function transformUnaryBitOperation(context, node, expression, operator) {
             return lua.createUnaryExpression(expression, operator, node);
     }
 }
-exports.transformUnaryBitOperation = transformUnaryBitOperation;
 //# sourceMappingURL=bit.js.map

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCompoundAssignmentStatement = exports.transformCompoundAssignmentExpression = exports.unwrapCompoundAssignmentToken = exports.isCompoundAssignmentToken = void 0;
+exports.unwrapCompoundAssignmentToken = exports.isCompoundAssignmentToken = void 0;
+exports.transformCompoundAssignmentExpression = transformCompoundAssignmentExpression;
+exports.transformCompoundAssignmentStatement = transformCompoundAssignmentStatement;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
@@ -127,7 +129,6 @@ 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);
@@ -167,7 +168,6 @@ function transformCompoundAssignmentStatement(context, node, lhs, rhs, operator)
         return (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements2);
     }
 }
-exports.transformCompoundAssignmentStatement = transformCompoundAssignmentStatement;
 function isSetterSkippingCompoundAssignmentOperator(operator) {
     return (operator === ts.SyntaxKind.AmpersandAmpersandToken ||
         operator === ts.SyntaxKind.BarBarToken ||

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformAssignmentPattern = exports.transformDestructuringAssignment = exports.isArrayLength = void 0;
+exports.isArrayLength = isArrayLength;
+exports.transformDestructuringAssignment = transformDestructuringAssignment;
+exports.transformAssignmentPattern = transformAssignmentPattern;
 const ts = require("typescript");
 const _1 = require(".");
 const lua = require("../../../LuaAST");
@@ -26,11 +28,9 @@ function isArrayLength(context, expression) {
             : undefined;
     return name === "length";
 }
-exports.isArrayLength = isArrayLength;
 function transformDestructuringAssignment(context, node, root, rightHasPrecedingStatements) {
     return transformAssignmentPattern(context, node.left, root, rightHasPrecedingStatements);
 }
-exports.transformDestructuringAssignment = transformDestructuringAssignment;
 function transformAssignmentPattern(context, node, root, rightHasPrecedingStatements) {
     switch (node.kind) {
         case ts.SyntaxKind.ObjectLiteralExpression:
@@ -39,7 +39,6 @@ function transformAssignmentPattern(context, node, root, rightHasPrecedingStatem
             return transformArrayLiteralAssignmentPattern(context, node, root, rightHasPrecedingStatements);
     }
 }
-exports.transformAssignmentPattern = transformAssignmentPattern;
 function transformArrayLiteralAssignmentPattern(context, node, root, rightHasPrecedingStatements) {
     return node.elements.flatMap((element, index) => {
         const indexedRoot = lua.createTableIndexExpression(root, lua.createNumericLiteral(index + 1), element);

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformBinaryExpressionStatement = exports.transformBinaryExpression = exports.transformBinaryOperation = exports.createShortCircuitBinaryExpressionPrecedingStatements = void 0;
+exports.transformBinaryExpression = void 0;
+exports.createShortCircuitBinaryExpressionPrecedingStatements = createShortCircuitBinaryExpressionPrecedingStatements;
+exports.transformBinaryOperation = transformBinaryOperation;
+exports.transformBinaryExpressionStatement = transformBinaryExpressionStatement;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../../CompilerOptions");
 const lua = require("../../../LuaAST");
@@ -80,7 +83,6 @@ function createShortCircuitBinaryExpressionPrecedingStatements(context, lhs, rhs
     const ifStatement = lua.createIfStatement(condition, lua.createBlock([...rightPrecedingStatements, lua.createAssignmentStatement(conditionIdentifier, rhs)]), undefined, node === null || node === void 0 ? void 0 : node.left);
     return { precedingStatements: [assignmentStatement, ifStatement], result: conditionIdentifier };
 }
-exports.createShortCircuitBinaryExpressionPrecedingStatements = createShortCircuitBinaryExpressionPrecedingStatements;
 function transformShortCircuitBinaryExpression(context, node, operator) {
     const lhs = context.transformExpression(node.left);
     const { precedingStatements, result } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(node.right));
@@ -96,7 +98,6 @@ function transformBinaryOperation(context, left, right, rightPrecedingStatements
         result: transformBinaryOperationWithNoPrecedingStatements(context, left, right, operator, node),
     };
 }
-exports.transformBinaryOperation = transformBinaryOperation;
 const transformBinaryExpression = (node, context) => {
     const operator = node.operatorToken.kind;
     const typeOfResult = (0, typeof_1.transformTypeOfBinaryExpression)(context, node);
@@ -167,7 +168,6 @@ function transformBinaryExpressionStatement(context, node) {
         return lua.createDoStatement(statements, expression);
     }
 }
-exports.transformBinaryExpressionStatement = transformBinaryExpressionStatement;
 function transformNullishCoalescingOperationNoPrecedingStatements(context, node, transformedLeft, transformedRight) {
     const lhsType = context.checker.getTypeAtLocation(node.left);
     // Check if we can take a shortcut to 'lhs or rhs' if the left-hand side cannot be 'false'.

package/dist/transformation/visitors/block.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformBlock = exports.transformScopeBlock = exports.transformBlockOrStatement = void 0;
+exports.transformBlock = void 0;
+exports.transformBlockOrStatement = transformBlockOrStatement;
+exports.transformScopeBlock = transformScopeBlock;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const scope_1 = require("../utils/scope");
 function transformBlockOrStatement(context, statement) {
     return context.transformStatements(ts.isBlock(statement) ? statement.statements : statement);
 }
-exports.transformBlockOrStatement = transformBlockOrStatement;
 function transformScopeBlock(context, node, scopeType) {
     context.pushScope(scopeType);
     const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
     const scope = context.popScope();
     return [lua.createBlock(statements, node), scope];
 }
-exports.transformScopeBlock = transformScopeBlock;
 const transformBlock = (node, context) => {
     context.pushScope(scope_1.ScopeType.Block);
     const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));

package/dist/transformation/visitors/call.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCalledExpression = exports.transformCallExpression = exports.transformContextualCallExpression = exports.transformCallAndArguments = exports.transformArguments = exports.validateArguments = void 0;
+exports.transformCallExpression = void 0;
+exports.validateArguments = validateArguments;
+exports.transformArguments = transformArguments;
+exports.transformCallAndArguments = transformCallAndArguments;
+exports.transformContextualCallExpression = transformContextualCallExpression;
+exports.getCalledExpression = getCalledExpression;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
@@ -31,12 +36,10 @@ function validateArguments(context, params, signature) {
         }
     }
 }
-exports.validateArguments = validateArguments;
 function transformArguments(context, params, signature, callContext) {
     validateArguments(context, params, signature);
     return (0, expression_list_1.transformExpressionList)(context, callContext ? [callContext, ...params] : params);
 }
-exports.transformArguments = transformArguments;
 function transformCallWithArguments(context, callExpression, transformedArguments, argPrecedingStatements, callContext) {
     let call = context.transformExpression(callExpression);
     let transformedContext;
@@ -59,7 +62,6 @@ function transformCallAndArguments(context, callExpression, params, signature, c
     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;
 function transformElementAccessCall(context, left, transformedArguments, argPrecedingStatements) {
     // Cache left-side if it has effects
     // local ____self = context; return ____self[argument](parameters);
@@ -118,7 +120,6 @@ function transformContextualCallExpression(context, node, args) {
         throw new Error(`Unsupported LeftHandSideExpression kind: ${ts.SyntaxKind[left.kind]}`);
     }
 }
-exports.transformContextualCallExpression = transformContextualCallExpression;
 function transformPropertyCall(context, node, calledMethod) {
     const signature = context.checker.getResolvedSignature(node);
     if (calledMethod.expression.kind === ts.SyntaxKind.SuperKeyword) {
@@ -203,5 +204,4 @@ exports.transformCallExpression = transformCallExpression;
 function getCalledExpression(node) {
     return ts.skipOuterExpressions(node.expression);
 }
-exports.getCalledExpression = getCalledExpression;
 //# sourceMappingURL=call.js.map

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

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConstructorDecoratingExpression = exports.createClassPropertyDecoratingExpression = exports.createClassAccessorDecoratingExpression = exports.createClassMethodDecoratingExpression = exports.createClassDecoratingExpression = exports.transformDecoratorExpression = void 0;
+exports.transformDecoratorExpression = transformDecoratorExpression;
+exports.createClassDecoratingExpression = createClassDecoratingExpression;
+exports.createClassMethodDecoratingExpression = createClassMethodDecoratingExpression;
+exports.createClassAccessorDecoratingExpression = createClassAccessorDecoratingExpression;
+exports.createClassPropertyDecoratingExpression = createClassPropertyDecoratingExpression;
+exports.createConstructorDecoratingExpression = createConstructorDecoratingExpression;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const diagnostics_1 = require("../../utils/diagnostics");
@@ -19,7 +24,6 @@ function transformDecoratorExpression(context, decorator) {
     }
     return context.transformExpression(expression);
 }
-exports.transformDecoratorExpression = transformDecoratorExpression;
 function createClassDecoratingExpression(context, classDeclaration, className) {
     var _a, _b, _c, _d;
     const classDecorators = (_b = (_a = ts.getDecorators(classDeclaration)) === null || _a === void 0 ? void 0 : _a.map(d => transformDecoratorExpression(context, d))) !== null && _b !== void 0 ? _b : [];
@@ -33,7 +37,6 @@ function createClassDecoratingExpression(context, classDeclaration, className) {
         name: lua.createStringLiteral((_d = (_c = classDeclaration.name) === null || _c === void 0 ? void 0 : _c.getText()) !== null && _d !== void 0 ? _d : ""),
     });
 }
-exports.createClassDecoratingExpression = createClassDecoratingExpression;
 function createClassMethodDecoratingExpression(context, methodDeclaration, originalMethod, className) {
     var _a, _b;
     const parameterDecorators = getParameterDecorators(context, methodDeclaration);
@@ -52,7 +55,6 @@ function createClassMethodDecoratingExpression(context, methodDeclaration, origi
         static: lua.createBooleanLiteral((0, utils_2.isStaticNode)(methodDeclaration)),
     });
 }
-exports.createClassMethodDecoratingExpression = createClassMethodDecoratingExpression;
 function createClassAccessorDecoratingExpression(context, accessor, originalAccessor, className) {
     var _a, _b;
     const accessorDecorators = (_b = (_a = ts.getDecorators(accessor)) === null || _a === void 0 ? void 0 : _a.map(d => transformDecoratorExpression(context, d))) !== null && _b !== void 0 ? _b : [];
@@ -70,7 +72,6 @@ function createClassAccessorDecoratingExpression(context, accessor, originalAcce
         static: lua.createBooleanLiteral((0, utils_2.isStaticNode)(accessor)),
     });
 }
-exports.createClassAccessorDecoratingExpression = createClassAccessorDecoratingExpression;
 function createClassPropertyDecoratingExpression(context, property, className) {
     var _a;
     const decorators = (_a = ts.getDecorators(property)) !== null && _a !== void 0 ? _a : [];
@@ -98,7 +99,6 @@ function createClassPropertyDecoratingExpression(context, property, className) {
         static: lua.createBooleanLiteral((0, utils_2.isStaticNode)(property)),
     });
 }
-exports.createClassPropertyDecoratingExpression = createClassPropertyDecoratingExpression;
 function createDecoratingExpression(context, className, originalValue, decorators, decoratorContext) {
     const decoratorTable = lua.createTableExpression(decorators.map(d => lua.createTableFieldExpression(d)));
     const decoratorContextTable = objectToLuaTableLiteral(decoratorContext);
@@ -136,5 +136,4 @@ function createConstructorDecoratingExpression(context, node, className) {
         return lua.createExpressionStatement(decorateMethod);
     }
 }
-exports.createConstructorDecoratingExpression = createConstructorDecoratingExpression;
 //# sourceMappingURL=decorators.js.map