typescript-to-lua 1.25.1 → 1.26.0

package/dist/CompilerOptions.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateOptions = exports.isBundleEnabled = exports.BuildMode = exports.LuaTarget = exports.LuaLibImportKind = void 0;
+exports.isBundleEnabled = exports.BuildMode = exports.LuaTarget = exports.LuaLibImportKind = void 0;
+exports.validateOptions = validateOptions;
 const typescript_1 = require("typescript");
 const diagnosticFactories = require("./transpilation/diagnostics");
 var LuaLibImportKind;
@@ -46,5 +47,4 @@ function validateOptions(options) {
     }
     return diagnostics;
 }
-exports.validateOptions = validateOptions;
 //# sourceMappingURL=CompilerOptions.js.map

package/dist/LuaAST.js

@@ -2,8 +2,82 @@
 // Simplified Lua AST based roughly on http://lua-users.org/wiki/MetaLuaAbstractSyntaxTree,
 // https://www.lua.org/manual/5.3/manual.html#9 and the TS AST implementation
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStringLiteral = exports.createNumericLiteral = exports.isNumericLiteral = exports.createArgLiteral = exports.isArgLiteral = exports.createDotsLiteral = exports.isDotsLiteral = exports.createBooleanLiteral = exports.isBooleanLiteral = exports.createNilLiteral = exports.isNilLiteral = exports.createExpressionStatement = exports.isExpressionStatement = exports.createBreakStatement = exports.isBreakStatement = exports.createReturnStatement = exports.isReturnStatement = exports.createLabelStatement = exports.isLabelStatement = exports.createGotoStatement = exports.isGotoStatement = exports.createForInStatement = exports.isForInStatement = exports.createForStatement = exports.isForStatement = exports.createRepeatStatement = exports.isRepeatStatement = exports.createWhileStatement = exports.isWhileStatement = exports.isIterationStatement = exports.createIfStatement = exports.isIfStatement = exports.createAssignmentStatement = exports.isAssignmentStatement = exports.createVariableDeclarationStatement = exports.isVariableDeclarationStatement = exports.createDoStatement = exports.isDoStatement = exports.createBlock = exports.isBlock = exports.createFile = exports.isFile = exports.setNodeFlags = exports.getOriginalPos = exports.setNodeOriginal = exports.setNodePosition = exports.cloneNode = exports.createNode = exports.NodeFlags = exports.SyntaxKind = void 0;
-exports.createParenthesizedExpression = exports.isParenthesizedExpression = exports.isInlineFunctionExpression = exports.isFunctionDefinition = exports.isAssignmentLeftHandSideExpression = exports.createTableIndexExpression = exports.isTableIndexExpression = exports.createAnonymousIdentifier = exports.cloneIdentifier = exports.createIdentifier = exports.isIdentifier = exports.createMethodCallExpression = exports.isMethodCallExpression = exports.createCallExpression = exports.isCallExpression = exports.createBinaryExpression = exports.isBinaryExpression = exports.createUnaryExpression = exports.isUnaryExpression = exports.createTableExpression = exports.isTableExpression = exports.createTableFieldExpression = exports.isTableFieldExpression = exports.createFunctionExpression = exports.isFunctionExpression = exports.isLiteral = exports.createStringLiteral = void 0;
+exports.NodeFlags = exports.SyntaxKind = void 0;
+exports.createNode = createNode;
+exports.cloneNode = cloneNode;
+exports.setNodePosition = setNodePosition;
+exports.setNodeOriginal = setNodeOriginal;
+exports.getOriginalPos = getOriginalPos;
+exports.setNodeFlags = setNodeFlags;
+exports.isFile = isFile;
+exports.createFile = createFile;
+exports.isBlock = isBlock;
+exports.createBlock = createBlock;
+exports.isDoStatement = isDoStatement;
+exports.createDoStatement = createDoStatement;
+exports.isVariableDeclarationStatement = isVariableDeclarationStatement;
+exports.createVariableDeclarationStatement = createVariableDeclarationStatement;
+exports.isAssignmentStatement = isAssignmentStatement;
+exports.createAssignmentStatement = createAssignmentStatement;
+exports.isIfStatement = isIfStatement;
+exports.createIfStatement = createIfStatement;
+exports.isIterationStatement = isIterationStatement;
+exports.isWhileStatement = isWhileStatement;
+exports.createWhileStatement = createWhileStatement;
+exports.isRepeatStatement = isRepeatStatement;
+exports.createRepeatStatement = createRepeatStatement;
+exports.isForStatement = isForStatement;
+exports.createForStatement = createForStatement;
+exports.isForInStatement = isForInStatement;
+exports.createForInStatement = createForInStatement;
+exports.isGotoStatement = isGotoStatement;
+exports.createGotoStatement = createGotoStatement;
+exports.isLabelStatement = isLabelStatement;
+exports.createLabelStatement = createLabelStatement;
+exports.isReturnStatement = isReturnStatement;
+exports.createReturnStatement = createReturnStatement;
+exports.isBreakStatement = isBreakStatement;
+exports.createBreakStatement = createBreakStatement;
+exports.isExpressionStatement = isExpressionStatement;
+exports.createExpressionStatement = createExpressionStatement;
+exports.isNilLiteral = isNilLiteral;
+exports.createNilLiteral = createNilLiteral;
+exports.isBooleanLiteral = isBooleanLiteral;
+exports.createBooleanLiteral = createBooleanLiteral;
+exports.isDotsLiteral = isDotsLiteral;
+exports.createDotsLiteral = createDotsLiteral;
+exports.isArgLiteral = isArgLiteral;
+exports.createArgLiteral = createArgLiteral;
+exports.isNumericLiteral = isNumericLiteral;
+exports.createNumericLiteral = createNumericLiteral;
+exports.isStringLiteral = isStringLiteral;
+exports.createStringLiteral = createStringLiteral;
+exports.isLiteral = isLiteral;
+exports.isFunctionExpression = isFunctionExpression;
+exports.createFunctionExpression = createFunctionExpression;
+exports.isTableFieldExpression = isTableFieldExpression;
+exports.createTableFieldExpression = createTableFieldExpression;
+exports.isTableExpression = isTableExpression;
+exports.createTableExpression = createTableExpression;
+exports.isUnaryExpression = isUnaryExpression;
+exports.createUnaryExpression = createUnaryExpression;
+exports.isBinaryExpression = isBinaryExpression;
+exports.createBinaryExpression = createBinaryExpression;
+exports.isCallExpression = isCallExpression;
+exports.createCallExpression = createCallExpression;
+exports.isMethodCallExpression = isMethodCallExpression;
+exports.createMethodCallExpression = createMethodCallExpression;
+exports.isIdentifier = isIdentifier;
+exports.createIdentifier = createIdentifier;
+exports.cloneIdentifier = cloneIdentifier;
+exports.createAnonymousIdentifier = createAnonymousIdentifier;
+exports.isTableIndexExpression = isTableIndexExpression;
+exports.createTableIndexExpression = createTableIndexExpression;
+exports.isAssignmentLeftHandSideExpression = isAssignmentLeftHandSideExpression;
+exports.isFunctionDefinition = isFunctionDefinition;
+exports.isInlineFunctionExpression = isInlineFunctionExpression;
+exports.isParenthesizedExpression = isParenthesizedExpression;
+exports.createParenthesizedExpression = createParenthesizedExpression;
 // We can elide a lot of nodes especially tokens and keywords
 // because we don't create the AST from text
 const ts = require("typescript");
@@ -98,17 +172,14 @@ function createNode(kind, tsOriginal) {
         return { kind, flags: NodeFlags.None };
     }
 }
-exports.createNode = createNode;
 function cloneNode(node) {
     return { ...node };
 }
-exports.cloneNode = cloneNode;
 function setNodePosition(node, position) {
     node.line = position.line;
     node.column = position.column;
     return node;
 }
-exports.setNodePosition = setNodePosition;
 function setNodeOriginal(node, tsOriginal) {
     if (node === undefined) {
         return undefined;
@@ -119,7 +190,6 @@ function setNodeOriginal(node, tsOriginal) {
     }
     return node;
 }
-exports.setNodeOriginal = setNodeOriginal;
 function getSourcePosition(sourceNode) {
     var _a;
     const parseTreeNode = (_a = ts.getParseTreeNode(sourceNode)) !== null && _a !== void 0 ? _a : sourceNode;
@@ -132,16 +202,13 @@ function getSourcePosition(sourceNode) {
 function getOriginalPos(node) {
     return { line: node.line, column: node.column };
 }
-exports.getOriginalPos = getOriginalPos;
 function setNodeFlags(node, flags) {
     node.flags = flags;
     return node;
 }
-exports.setNodeFlags = setNodeFlags;
 function isFile(node) {
     return node.kind === SyntaxKind.File;
 }
-exports.isFile = isFile;
 function createFile(statements, luaLibFeatures, trivia, tsOriginal) {
     const file = createNode(SyntaxKind.File, tsOriginal);
     file.statements = statements;
@@ -149,31 +216,25 @@ function createFile(statements, luaLibFeatures, trivia, tsOriginal) {
     file.trivia = trivia;
     return file;
 }
-exports.createFile = createFile;
 function isBlock(node) {
     return node.kind === SyntaxKind.Block;
 }
-exports.isBlock = isBlock;
 function createBlock(statements, tsOriginal) {
     const block = createNode(SyntaxKind.Block, tsOriginal);
     block.statements = statements;
     return block;
 }
-exports.createBlock = createBlock;
 function isDoStatement(node) {
     return node.kind === SyntaxKind.DoStatement;
 }
-exports.isDoStatement = isDoStatement;
 function createDoStatement(statements, tsOriginal) {
     const statement = createNode(SyntaxKind.DoStatement, tsOriginal);
     statement.statements = statements;
     return statement;
 }
-exports.createDoStatement = createDoStatement;
 function isVariableDeclarationStatement(node) {
     return node.kind === SyntaxKind.VariableDeclarationStatement;
 }
-exports.isVariableDeclarationStatement = isVariableDeclarationStatement;
 function createVariableDeclarationStatement(left, right, tsOriginal) {
     const statement = createNode(SyntaxKind.VariableDeclarationStatement, tsOriginal);
     statement.left = (0, utils_1.castArray)(left);
@@ -181,22 +242,18 @@ function createVariableDeclarationStatement(left, right, tsOriginal) {
         statement.right = (0, utils_1.castArray)(right);
     return statement;
 }
-exports.createVariableDeclarationStatement = createVariableDeclarationStatement;
 function isAssignmentStatement(node) {
     return node.kind === SyntaxKind.AssignmentStatement;
 }
-exports.isAssignmentStatement = isAssignmentStatement;
 function createAssignmentStatement(left, right, tsOriginal) {
     const statement = createNode(SyntaxKind.AssignmentStatement, tsOriginal);
     statement.left = (0, utils_1.castArray)(left);
     statement.right = right ? (0, utils_1.castArray)(right) : [];
     return statement;
 }
-exports.createAssignmentStatement = createAssignmentStatement;
 function isIfStatement(node) {
     return node.kind === SyntaxKind.IfStatement;
 }
-exports.isIfStatement = isIfStatement;
 function createIfStatement(condition, ifBlock, elseBlock, tsOriginal) {
     const statement = createNode(SyntaxKind.IfStatement, tsOriginal);
     statement.condition = condition;
@@ -204,40 +261,33 @@ function createIfStatement(condition, ifBlock, elseBlock, tsOriginal) {
     statement.elseBlock = elseBlock;
     return statement;
 }
-exports.createIfStatement = createIfStatement;
 function isIterationStatement(node) {
     return (node.kind === SyntaxKind.WhileStatement ||
         node.kind === SyntaxKind.RepeatStatement ||
         node.kind === SyntaxKind.ForStatement ||
         node.kind === SyntaxKind.ForInStatement);
 }
-exports.isIterationStatement = isIterationStatement;
 function isWhileStatement(node) {
     return node.kind === SyntaxKind.WhileStatement;
 }
-exports.isWhileStatement = isWhileStatement;
 function createWhileStatement(body, condition, tsOriginal) {
     const statement = createNode(SyntaxKind.WhileStatement, tsOriginal);
     statement.body = body;
     statement.condition = condition;
     return statement;
 }
-exports.createWhileStatement = createWhileStatement;
 function isRepeatStatement(node) {
     return node.kind === SyntaxKind.RepeatStatement;
 }
-exports.isRepeatStatement = isRepeatStatement;
 function createRepeatStatement(body, condition, tsOriginal) {
     const statement = createNode(SyntaxKind.RepeatStatement, tsOriginal);
     statement.body = body;
     statement.condition = condition;
     return statement;
 }
-exports.createRepeatStatement = createRepeatStatement;
 function isForStatement(node) {
     return node.kind === SyntaxKind.ForStatement;
 }
-exports.isForStatement = isForStatement;
 function createForStatement(body, controlVariable, controlVariableInitializer, limitExpression, stepExpression, tsOriginal) {
     const statement = createNode(SyntaxKind.ForStatement, tsOriginal);
     statement.body = body;
@@ -247,11 +297,9 @@ function createForStatement(body, controlVariable, controlVariableInitializer, l
     statement.stepExpression = stepExpression;
     return statement;
 }
-exports.createForStatement = createForStatement;
 function isForInStatement(node) {
     return node.kind === SyntaxKind.ForInStatement;
 }
-exports.isForInStatement = isForInStatement;
 function createForInStatement(body, names, expressions, tsOriginal) {
     const statement = createNode(SyntaxKind.ForInStatement, tsOriginal);
     statement.body = body;
@@ -259,107 +307,84 @@ function createForInStatement(body, names, expressions, tsOriginal) {
     statement.expressions = expressions;
     return statement;
 }
-exports.createForInStatement = createForInStatement;
 function isGotoStatement(node) {
     return node.kind === SyntaxKind.GotoStatement;
 }
-exports.isGotoStatement = isGotoStatement;
 function createGotoStatement(label, tsOriginal) {
     const statement = createNode(SyntaxKind.GotoStatement, tsOriginal);
     statement.label = label;
     return statement;
 }
-exports.createGotoStatement = createGotoStatement;
 function isLabelStatement(node) {
     return node.kind === SyntaxKind.LabelStatement;
 }
-exports.isLabelStatement = isLabelStatement;
 function createLabelStatement(name, tsOriginal) {
     const statement = createNode(SyntaxKind.LabelStatement, tsOriginal);
     statement.name = name;
     return statement;
 }
-exports.createLabelStatement = createLabelStatement;
 function isReturnStatement(node) {
     return node.kind === SyntaxKind.ReturnStatement;
 }
-exports.isReturnStatement = isReturnStatement;
 function createReturnStatement(expressions, tsOriginal) {
     const statement = createNode(SyntaxKind.ReturnStatement, tsOriginal);
     statement.expressions = expressions;
     return statement;
 }
-exports.createReturnStatement = createReturnStatement;
 function isBreakStatement(node) {
     return node.kind === SyntaxKind.BreakStatement;
 }
-exports.isBreakStatement = isBreakStatement;
 function createBreakStatement(tsOriginal) {
     return createNode(SyntaxKind.BreakStatement, tsOriginal);
 }
-exports.createBreakStatement = createBreakStatement;
 function isExpressionStatement(node) {
     return node.kind === SyntaxKind.ExpressionStatement;
 }
-exports.isExpressionStatement = isExpressionStatement;
 function createExpressionStatement(expressions, tsOriginal) {
     const statement = createNode(SyntaxKind.ExpressionStatement, tsOriginal);
     statement.expression = expressions;
     return statement;
 }
-exports.createExpressionStatement = createExpressionStatement;
 function isNilLiteral(node) {
     return node.kind === SyntaxKind.NilKeyword;
 }
-exports.isNilLiteral = isNilLiteral;
 function createNilLiteral(tsOriginal) {
     return createNode(SyntaxKind.NilKeyword, tsOriginal);
 }
-exports.createNilLiteral = createNilLiteral;
 function isBooleanLiteral(node) {
     return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword;
 }
-exports.isBooleanLiteral = isBooleanLiteral;
 function createBooleanLiteral(value, tsOriginal) {
     return createNode(value ? SyntaxKind.TrueKeyword : SyntaxKind.FalseKeyword, tsOriginal);
 }
-exports.createBooleanLiteral = createBooleanLiteral;
 function isDotsLiteral(node) {
     return node.kind === SyntaxKind.DotsKeyword;
 }
-exports.isDotsLiteral = isDotsLiteral;
 function createDotsLiteral(tsOriginal) {
     return createNode(SyntaxKind.DotsKeyword, tsOriginal);
 }
-exports.createDotsLiteral = createDotsLiteral;
 function isArgLiteral(node) {
     return node.kind === SyntaxKind.ArgKeyword;
 }
-exports.isArgLiteral = isArgLiteral;
 function createArgLiteral(tsOriginal) {
     return createNode(SyntaxKind.ArgKeyword, tsOriginal);
 }
-exports.createArgLiteral = createArgLiteral;
 function isNumericLiteral(node) {
     return node.kind === SyntaxKind.NumericLiteral;
 }
-exports.isNumericLiteral = isNumericLiteral;
 function createNumericLiteral(value, tsOriginal) {
     const expression = createNode(SyntaxKind.NumericLiteral, tsOriginal);
     expression.value = value;
     return expression;
 }
-exports.createNumericLiteral = createNumericLiteral;
 function isStringLiteral(node) {
     return node.kind === SyntaxKind.StringLiteral;
 }
-exports.isStringLiteral = isStringLiteral;
 function createStringLiteral(value, tsOriginal) {
     const expression = createNode(SyntaxKind.StringLiteral, tsOriginal);
     expression.value = value;
     return expression;
 }
-exports.createStringLiteral = createStringLiteral;
 function isLiteral(node) {
     return (isNilLiteral(node) ||
         isDotsLiteral(node) ||
@@ -368,11 +393,9 @@ function isLiteral(node) {
         isNumericLiteral(node) ||
         isStringLiteral(node));
 }
-exports.isLiteral = isLiteral;
 function isFunctionExpression(node) {
     return node.kind === SyntaxKind.FunctionExpression;
 }
-exports.isFunctionExpression = isFunctionExpression;
 function createFunctionExpression(body, params, dots, flags = NodeFlags.None, tsOriginal) {
     const expression = createNode(SyntaxKind.FunctionExpression, tsOriginal);
     expression.body = body;
@@ -381,43 +404,35 @@ function createFunctionExpression(body, params, dots, flags = NodeFlags.None, ts
     expression.flags = flags;
     return expression;
 }
-exports.createFunctionExpression = createFunctionExpression;
 function isTableFieldExpression(node) {
     return node.kind === SyntaxKind.TableFieldExpression;
 }
-exports.isTableFieldExpression = isTableFieldExpression;
 function createTableFieldExpression(value, key, tsOriginal) {
     const expression = createNode(SyntaxKind.TableFieldExpression, tsOriginal);
     expression.value = value;
     expression.key = key;
     return expression;
 }
-exports.createTableFieldExpression = createTableFieldExpression;
 function isTableExpression(node) {
     return node.kind === SyntaxKind.TableExpression;
 }
-exports.isTableExpression = isTableExpression;
 function createTableExpression(fields = [], tsOriginal) {
     const expression = createNode(SyntaxKind.TableExpression, tsOriginal);
     expression.fields = fields;
     return expression;
 }
-exports.createTableExpression = createTableExpression;
 function isUnaryExpression(node) {
     return node.kind === SyntaxKind.UnaryExpression;
 }
-exports.isUnaryExpression = isUnaryExpression;
 function createUnaryExpression(operand, operator, tsOriginal) {
     const expression = createNode(SyntaxKind.UnaryExpression, tsOriginal);
     expression.operand = operand;
     expression.operator = operator;
     return expression;
 }
-exports.createUnaryExpression = createUnaryExpression;
 function isBinaryExpression(node) {
     return node.kind === SyntaxKind.BinaryExpression;
 }
-exports.isBinaryExpression = isBinaryExpression;
 function createBinaryExpression(left, right, operator, tsOriginal) {
     const expression = createNode(SyntaxKind.BinaryExpression, tsOriginal);
     expression.left = left;
@@ -425,22 +440,18 @@ function createBinaryExpression(left, right, operator, tsOriginal) {
     expression.operator = operator;
     return expression;
 }
-exports.createBinaryExpression = createBinaryExpression;
 function isCallExpression(node) {
     return node.kind === SyntaxKind.CallExpression;
 }
-exports.isCallExpression = isCallExpression;
 function createCallExpression(expression, params, tsOriginal) {
     const callExpression = createNode(SyntaxKind.CallExpression, tsOriginal);
     callExpression.expression = expression;
     callExpression.params = params;
     return callExpression;
 }
-exports.createCallExpression = createCallExpression;
 function isMethodCallExpression(node) {
     return node.kind === SyntaxKind.MethodCallExpression;
 }
-exports.isMethodCallExpression = isMethodCallExpression;
 function createMethodCallExpression(prefixExpression, name, params, tsOriginal) {
     const callExpression = createNode(SyntaxKind.MethodCallExpression, tsOriginal);
     callExpression.prefixExpression = prefixExpression;
@@ -448,11 +459,9 @@ function createMethodCallExpression(prefixExpression, name, params, tsOriginal)
     callExpression.params = params;
     return callExpression;
 }
-exports.createMethodCallExpression = createMethodCallExpression;
 function isIdentifier(node) {
     return node.kind === SyntaxKind.Identifier;
 }
-exports.isIdentifier = isIdentifier;
 function createIdentifier(text, tsOriginal, symbolId, originalName) {
     const expression = createNode(SyntaxKind.Identifier, tsOriginal);
     expression.exportable = true;
@@ -461,38 +470,31 @@ function createIdentifier(text, tsOriginal, symbolId, originalName) {
     expression.originalName = originalName;
     return expression;
 }
-exports.createIdentifier = createIdentifier;
 function cloneIdentifier(identifier, tsOriginal) {
     return createIdentifier(identifier.text, tsOriginal, identifier.symbolId, identifier.originalName);
 }
-exports.cloneIdentifier = cloneIdentifier;
 function createAnonymousIdentifier(tsOriginal) {
     const expression = createNode(SyntaxKind.Identifier, tsOriginal);
     expression.exportable = false;
     expression.text = "____";
     return expression;
 }
-exports.createAnonymousIdentifier = createAnonymousIdentifier;
 function isTableIndexExpression(node) {
     return node.kind === SyntaxKind.TableIndexExpression;
 }
-exports.isTableIndexExpression = isTableIndexExpression;
 function createTableIndexExpression(table, index, tsOriginal) {
     const expression = createNode(SyntaxKind.TableIndexExpression, tsOriginal);
     expression.table = table;
     expression.index = index;
     return expression;
 }
-exports.createTableIndexExpression = createTableIndexExpression;
 function isAssignmentLeftHandSideExpression(node) {
     return isIdentifier(node) || isTableIndexExpression(node);
 }
-exports.isAssignmentLeftHandSideExpression = isAssignmentLeftHandSideExpression;
 function isFunctionDefinition(statement) {
     var _a;
     return statement.left.length === 1 && ((_a = statement.right) === null || _a === void 0 ? void 0 : _a.length) === 1 && isFunctionExpression(statement.right[0]);
 }
-exports.isFunctionDefinition = isFunctionDefinition;
 function isInlineFunctionExpression(expression) {
     var _a;
     return (((_a = expression.body.statements) === null || _a === void 0 ? void 0 : _a.length) === 1 &&
@@ -500,15 +502,12 @@ function isInlineFunctionExpression(expression) {
         expression.body.statements[0].expressions !== undefined &&
         (expression.flags & NodeFlags.Inline) !== 0);
 }
-exports.isInlineFunctionExpression = isInlineFunctionExpression;
 function isParenthesizedExpression(node) {
     return node.kind === SyntaxKind.ParenthesizedExpression;
 }
-exports.isParenthesizedExpression = isParenthesizedExpression;
 function createParenthesizedExpression(expression, tsOriginal) {
     const parenthesizedExpression = createNode(SyntaxKind.ParenthesizedExpression, tsOriginal);
     parenthesizedExpression.expression = expression;
     return parenthesizedExpression;
 }
-exports.createParenthesizedExpression = createParenthesizedExpression;
 //# sourceMappingURL=LuaAST.js.map

package/dist/LuaLib.js

@@ -1,6 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findUsedLualibFeatures = exports.buildMinimalLualibBundle = exports.getLualibBundleReturn = exports.getLuaLibBundle = exports.loadImportedLualibFeatures = exports.loadInlineLualibFeatures = exports.resolveRecursiveLualibFeatures = exports.readLuaLibFeature = exports.getLuaLibExportToFeatureMap = exports.getLuaLibModulesInfo = exports.luaLibModulesInfoFileName = exports.resolveLuaLibDir = exports.LuaLibFeature = void 0;
+exports.luaLibModulesInfoFileName = exports.LuaLibFeature = void 0;
+exports.resolveLuaLibDir = resolveLuaLibDir;
+exports.getLuaLibModulesInfo = getLuaLibModulesInfo;
+exports.getLuaLibExportToFeatureMap = getLuaLibExportToFeatureMap;
+exports.readLuaLibFeature = readLuaLibFeature;
+exports.resolveRecursiveLualibFeatures = resolveRecursiveLualibFeatures;
+exports.loadInlineLualibFeatures = loadInlineLualibFeatures;
+exports.loadImportedLualibFeatures = loadImportedLualibFeatures;
+exports.getLuaLibBundle = getLuaLibBundle;
+exports.getLualibBundleReturn = getLualibBundleReturn;
+exports.buildMinimalLualibBundle = buildMinimalLualibBundle;
+exports.findUsedLualibFeatures = findUsedLualibFeatures;
 const path = require("path");
 const lua = require("./LuaAST");
 const CompilerOptions_1 = require("./CompilerOptions");
@@ -128,7 +139,6 @@ function resolveLuaLibDir(luaTarget) {
     const luaLibDir = luaTarget === CompilerOptions_1.LuaTarget.Lua50 ? "5.0" : "universal";
     return path.resolve(__dirname, path.join("..", "dist", "lualib", luaLibDir));
 }
-exports.resolveLuaLibDir = resolveLuaLibDir;
 exports.luaLibModulesInfoFileName = "lualib_module_info.json";
 const luaLibModulesInfo = new Map();
 function getLuaLibModulesInfo(luaTarget, emitHost) {
@@ -144,7 +154,6 @@ function getLuaLibModulesInfo(luaTarget, emitHost) {
     }
     return luaLibModulesInfo.get(luaTarget);
 }
-exports.getLuaLibModulesInfo = getLuaLibModulesInfo;
 // This caches the names of lualib exports to their LuaLibFeature, avoiding a linear search for every lookup
 const lualibExportToFeature = new Map();
 function getLuaLibExportToFeatureMap(luaTarget, emitHost) {
@@ -160,7 +169,6 @@ function getLuaLibExportToFeatureMap(luaTarget, emitHost) {
     }
     return lualibExportToFeature.get(luaTarget);
 }
-exports.getLuaLibExportToFeatureMap = getLuaLibExportToFeatureMap;
 const lualibFeatureCache = new Map();
 function readLuaLibFeature(feature, luaTarget, emitHost) {
     const featureMap = (0, utils_1.getOrUpdate)(lualibFeatureCache, luaTarget, () => new Map());
@@ -174,7 +182,6 @@ function readLuaLibFeature(feature, luaTarget, emitHost) {
     }
     return featureMap.get(feature);
 }
-exports.readLuaLibFeature = readLuaLibFeature;
 function resolveRecursiveLualibFeatures(features, luaTarget, emitHost, luaLibModulesInfo = getLuaLibModulesInfo(luaTarget, emitHost)) {
     const loadedFeatures = new Set();
     const result = [];
@@ -194,13 +201,11 @@ function resolveRecursiveLualibFeatures(features, luaTarget, emitHost, luaLibMod
     }
     return result;
 }
-exports.resolveRecursiveLualibFeatures = resolveRecursiveLualibFeatures;
 function loadInlineLualibFeatures(features, luaTarget, emitHost) {
     return resolveRecursiveLualibFeatures(features, luaTarget, emitHost)
         .map(feature => readLuaLibFeature(feature, luaTarget, emitHost))
         .join("\n");
 }
-exports.loadInlineLualibFeatures = loadInlineLualibFeatures;
 function loadImportedLualibFeatures(features, luaTarget, emitHost) {
     const luaLibModuleInfo = getLuaLibModulesInfo(luaTarget, emitHost);
     const imports = Array.from(features).flatMap(feature => luaLibModuleInfo[feature].exports);
@@ -219,7 +224,6 @@ function loadImportedLualibFeatures(features, luaTarget, emitHost) {
     }
     return statements;
 }
-exports.loadImportedLualibFeatures = loadImportedLualibFeatures;
 const luaLibBundleContent = new Map();
 function getLuaLibBundle(luaTarget, emitHost) {
     const lualibPath = path.join(resolveLuaLibDir(luaTarget), "lualib_bundle.lua");
@@ -234,18 +238,15 @@ function getLuaLibBundle(luaTarget, emitHost) {
     }
     return luaLibBundleContent.get(lualibPath);
 }
-exports.getLuaLibBundle = getLuaLibBundle;
 function getLualibBundleReturn(exportedValues) {
     return `\nreturn {\n${exportedValues.map(exportName => `  ${exportName} = ${exportName}`).join(",\n")}\n}\n`;
 }
-exports.getLualibBundleReturn = getLualibBundleReturn;
 function buildMinimalLualibBundle(features, luaTarget, emitHost) {
     const code = loadInlineLualibFeatures(features, luaTarget, emitHost);
     const moduleInfo = getLuaLibModulesInfo(luaTarget, emitHost);
     const exports = Array.from(features).flatMap(feature => moduleInfo[feature].exports);
     return code + getLualibBundleReturn(exports);
 }
-exports.buildMinimalLualibBundle = buildMinimalLualibBundle;
 function findUsedLualibFeatures(luaTarget, emitHost, luaContents) {
     const features = new Set();
     const exportToFeatureMap = getLuaLibExportToFeatureMap(luaTarget, emitHost);
@@ -265,5 +266,4 @@ function findUsedLualibFeatures(luaTarget, emitHost, luaContents) {
     }
     return features;
 }
-exports.findUsedLualibFeatures = findUsedLualibFeatures;
 //# sourceMappingURL=LuaLib.js.map

package/dist/LuaPrinter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LuaPrinter = exports.createPrinter = exports.tstlHeader = exports.escapeString = void 0;
+exports.LuaPrinter = exports.tstlHeader = exports.escapeString = void 0;
+exports.createPrinter = createPrinter;
 const path = require("path");
 const source_map_1 = require("source-map");
 const CompilerOptions_1 = require("./CompilerOptions");
@@ -71,7 +72,6 @@ function createPrinter(printers) {
         throw new Error("Only one plugin can specify 'printer'");
     }
 }
-exports.createPrinter = createPrinter;
 class LuaPrinter {
     constructor(emitHost, program, sourceFile) {
         this.emitHost = emitHost;

package/dist/cli/information.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHelpString = exports.versionString = exports.version = void 0;
+exports.versionString = exports.version = void 0;
+exports.getHelpString = getHelpString;
 const parse_1 = require("./parse");
 exports.version = require("../../package.json").version;
 exports.versionString = `Version ${exports.version}`;
@@ -27,5 +28,4 @@ function getHelpString() {
     }
     return result;
 }
-exports.getHelpString = getHelpString;
 //# sourceMappingURL=information.js.map

package/dist/cli/parse.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCommandLine = exports.updateParsedConfigFile = exports.optionDeclarations = void 0;
+exports.optionDeclarations = void 0;
+exports.updateParsedConfigFile = updateParsedConfigFile;
+exports.parseCommandLine = parseCommandLine;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../CompilerOptions");
 const cliDiagnostics = require("./diagnostics");
@@ -115,11 +117,9 @@ function updateParsedConfigFile(parsedConfigFile) {
     }
     return parsedConfigFile;
 }
-exports.updateParsedConfigFile = updateParsedConfigFile;
 function parseCommandLine(args) {
     return updateParsedCommandLine(ts.parseCommandLine(args), args);
 }
-exports.parseCommandLine = parseCommandLine;
 function updateParsedCommandLine(parsedCommandLine, args) {
     for (let i = 0; i < args.length; i++) {
         if (!args[i].startsWith("-"))

package/dist/cli/report.d.ts

@@ -1,10 +1,10 @@
 import * as ts from "typescript";
 export declare const prepareDiagnosticForFormatting: (diagnostic: ts.Diagnostic) => {
     code: any;
-    reportsUnnecessary?: {} | undefined;
-    reportsDeprecated?: {} | undefined;
-    source?: string | undefined;
-    relatedInformation?: ts.DiagnosticRelatedInformation[] | undefined;
+    reportsUnnecessary?: {};
+    reportsDeprecated?: {};
+    source?: string;
+    relatedInformation?: ts.DiagnosticRelatedInformation[];
     category: ts.DiagnosticCategory;
     file: ts.SourceFile | undefined;
     start: number | undefined;