typescript-to-lua 1.5.0 → 1.6.2

package/dist/LuaPrinter.js

@@ -142,6 +142,7 @@ class LuaPrinter {
             // Inline lualib features
             sourceChunks.push("-- Lua Library inline imports\n");
             sourceChunks.push((0, LuaLib_1.loadInlineLualibFeatures)(file.luaLibFeatures, this.emitHost));
+            sourceChunks.push("-- End of Lua Library inline imports\n");
         }
         if (this.options.sourceMapTraceback && !(0, CompilerOptions_1.isBundleEnabled)(this.options)) {
             // In bundle mode the traceback is being generated for the entire file in getBundleResult

package/dist/lualib/Map.lua

@@ -93,9 +93,8 @@ do
         return self:entries()
     end
     function Map.prototype.entries(self)
-        local ____temp_0 = self
-        local items = ____temp_0.items
-        local nextKey = ____temp_0.nextKey
+        local items = self.items
+        local nextKey = self.nextKey
         local key = self.firstKey
         return {
             [Symbol.iterator] = function(self)
@@ -123,9 +122,8 @@ do
         }
     end
     function Map.prototype.values(self)
-        local ____temp_1 = self
-        local items = ____temp_1.items
-        local nextKey = ____temp_1.nextKey
+        local items = self.items
+        local nextKey = self.nextKey
         local key = self.firstKey
         return {
             [Symbol.iterator] = function(self)

package/dist/lualib/Promise.lua

@@ -74,7 +74,7 @@ do
             end
         else
             local ____self_fulfilledCallbacks_2 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_2[#____self_fulfilledCallbacks_2 + 1] = function() return resolve(nil, nil) end
+            ____self_fulfilledCallbacks_2[#____self_fulfilledCallbacks_2 + 1] = function(____, v) return resolve(nil, v) end
         end
         if onRejected then
             local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
@@ -83,6 +83,9 @@ do
             if isRejected then
                 internalCallback(nil, self.rejectionReason)
             end
+        else
+            local ____self_rejectedCallbacks_4 = self.rejectedCallbacks
+            ____self_rejectedCallbacks_4[#____self_rejectedCallbacks_4 + 1] = function(____, err) return reject(nil, err) end
         end
         if isFulfilled then
             resolve(nil, self.value)
@@ -97,8 +100,8 @@ do
     end
     function __TS__Promise.prototype.finally(self, onFinally)
         if onFinally then
-            local ____self_finallyCallbacks_4 = self.finallyCallbacks
-            ____self_finallyCallbacks_4[#____self_finallyCallbacks_4 + 1] = onFinally
+            local ____self_finallyCallbacks_5 = self.finallyCallbacks
+            ____self_finallyCallbacks_5[#____self_finallyCallbacks_5 + 1] = onFinally
             if self.state ~= 0 then
                 onFinally(nil)
             end

package/dist/lualib/lualib_bundle.lua

@@ -651,7 +651,7 @@ do
             end
         else
             local ____self_fulfilledCallbacks_2 = self.fulfilledCallbacks
-            ____self_fulfilledCallbacks_2[#____self_fulfilledCallbacks_2 + 1] = function() return resolve(nil, nil) end
+            ____self_fulfilledCallbacks_2[#____self_fulfilledCallbacks_2 + 1] = function(____, v) return resolve(nil, v) end
         end
         if onRejected then
             local internalCallback = self:createPromiseResolvingCallback(onRejected, resolve, reject)
@@ -660,6 +660,9 @@ do
             if isRejected then
                 internalCallback(nil, self.rejectionReason)
             end
+        else
+            local ____self_rejectedCallbacks_4 = self.rejectedCallbacks
+            ____self_rejectedCallbacks_4[#____self_rejectedCallbacks_4 + 1] = function(____, err) return reject(nil, err) end
         end
         if isFulfilled then
             resolve(nil, self.value)
@@ -674,8 +677,8 @@ do
     end
     function __TS__Promise.prototype.finally(self, onFinally)
         if onFinally then
-            local ____self_finallyCallbacks_4 = self.finallyCallbacks
-            ____self_finallyCallbacks_4[#____self_finallyCallbacks_4 + 1] = onFinally
+            local ____self_finallyCallbacks_5 = self.finallyCallbacks
+            ____self_finallyCallbacks_5[#____self_finallyCallbacks_5 + 1] = onFinally
             if self.state ~= 0 then
                 onFinally(nil)
             end
@@ -1280,9 +1283,8 @@ do
         return self:entries()
     end
     function Map.prototype.entries(self)
-        local ____temp_0 = self
-        local items = ____temp_0.items
-        local nextKey = ____temp_0.nextKey
+        local items = self.items
+        local nextKey = self.nextKey
         local key = self.firstKey
         return {
             [Symbol.iterator] = function(self)
@@ -1310,9 +1312,8 @@ do
         }
     end
     function Map.prototype.values(self)
-        local ____temp_1 = self
-        local items = ____temp_1.items
-        local nextKey = ____temp_1.nextKey
+        local items = self.items
+        local nextKey = self.nextKey
         local key = self.firstKey
         return {
             [Symbol.iterator] = function(self)

package/dist/lualib-build/plugin.d.ts

@@ -7,7 +7,7 @@ export declare const lualibDiagnostic: ((message: string, file?: ts.SourceFile |
 };
 declare class LuaLibPlugin implements tstl.Plugin {
     visitors: {
-        303: (file: ts.SourceFile, context: tstl.TransformationContext) => tstl.File;
+        305: (file: ts.SourceFile, context: tstl.TransformationContext) => tstl.File;
     };
     printer: tstl.Printer;
     afterPrint(program: ts.Program, options: tstl.CompilerOptions, emitHost: EmitHost, result: ProcessedFile[]): ts.Diagnostic[];

package/dist/transformation/context/context.d.ts

@@ -16,7 +16,7 @@ export interface EmitResolver {
     moduleExportsSomeValue(moduleReferenceExpression: ts.Expression): boolean;
     getAllAccessorDeclarations(declaration: ts.AccessorDeclaration): AllAccessorDeclarations;
 }
-export interface DiagnosticsProducingTypeChecker extends ts.TypeChecker {
+export interface TypeCheckerWithEmitResolver extends ts.TypeChecker {
     getEmitResolver(sourceFile?: ts.SourceFile, cancellationToken?: ts.CancellationToken): EmitResolver;
 }
 export declare class TransformationContext {
@@ -24,7 +24,7 @@ export declare class TransformationContext {
     sourceFile: ts.SourceFile;
     private visitorMap;
     readonly diagnostics: ts.Diagnostic[];
-    readonly checker: DiagnosticsProducingTypeChecker;
+    readonly checker: TypeCheckerWithEmitResolver;
     readonly resolver: EmitResolver;
     readonly precedingStatementsStack: lua.Statement[][];
     readonly options: CompilerOptions;

package/dist/transformation/context/context.js

@@ -16,7 +16,7 @@ class TransformationContext {
         this.sourceFile = sourceFile;
         this.visitorMap = visitorMap;
         this.diagnostics = [];
-        this.checker = this.program.getDiagnosticsProducingTypeChecker();
+        this.checker = this.program.getTypeChecker();
         this.precedingStatementsStack = [];
         this.options = this.program.getCompilerOptions();
         this.luaTarget = (_a = this.options.luaTarget) !== null && _a !== void 0 ? _a : CompilerOptions_1.LuaTarget.Universal;

package/dist/transformation/utils/export.d.ts

@@ -3,7 +3,7 @@ import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 export declare function hasDefaultExportModifier(node: ts.Node): boolean;
 export declare function hasExportModifier(node: ts.Node): boolean;
-export declare const createDefaultExportStringLiteral: (original?: ts.Node | undefined) => lua.StringLiteral;
+export declare const createDefaultExportStringLiteral: (original?: ts.Node) => lua.StringLiteral;
 export declare function getExportedSymbolDeclaration(symbol: ts.Symbol): ts.Declaration | undefined;
 export declare function getSymbolFromIdentifier(context: TransformationContext, identifier: lua.Identifier): ts.Symbol | undefined;
 export declare function getIdentifierExportScope(context: TransformationContext, identifier: lua.Identifier): ts.SourceFile | ts.ModuleDeclaration | undefined;

package/dist/transformation/utils/function-context.js

@@ -59,8 +59,13 @@ function getDeclarationContextType({ program }, signatureDeclaration) {
     }
     // When using --noImplicitSelf and the signature is defined in a file targeted by the program apply the @noSelf rule.
     const options = program.getCompilerOptions();
-    if (options.noImplicitSelf && program.getRootFileNames().includes(signatureDeclaration.getSourceFile().fileName)) {
-        return ContextType.Void;
+    if (options.noImplicitSelf) {
+        const sourceFile = program.getSourceFile(signatureDeclaration.getSourceFile().fileName);
+        if (sourceFile !== undefined &&
+            !program.isSourceFileDefaultLibrary(sourceFile) &&
+            !program.isSourceFileFromExternalLibrary(sourceFile)) {
+            return ContextType.Void;
+        }
     }
     // Walk up to find @noSelf or @noSelfInFile
     if (hasNoSelfAncestor(signatureDeclaration)) {

package/dist/transformation/utils/lua-ast.d.ts

@@ -13,4 +13,4 @@ export declare function wrapInTable(...expressions: lua.Expression[]): lua.Table
 export declare function wrapInToStringForConcat(expression: lua.Expression): lua.Expression;
 export declare function createHoistableVariableDeclarationStatement(context: TransformationContext, identifier: lua.Identifier, initializer?: lua.Expression, tsOriginal?: ts.Node): lua.AssignmentStatement | lua.VariableDeclarationStatement;
 export declare function createLocalOrExportedOrGlobalDeclaration(context: TransformationContext, lhs: lua.Identifier | lua.Identifier[], rhs?: lua.Expression | lua.Expression[], tsOriginal?: ts.Node, overrideExportScope?: ts.SourceFile | ts.ModuleDeclaration): lua.Statement[];
-export declare const createNaN: (tsOriginal?: ts.Node | undefined) => lua.BinaryExpression;
+export declare const createNaN: (tsOriginal?: ts.Node) => lua.BinaryExpression;

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

@@ -72,17 +72,14 @@ function transformAssignmentWithRightPrecedingStatements(context, lhs, right, ri
 }
 exports.transformAssignmentWithRightPrecedingStatements = transformAssignmentWithRightPrecedingStatements;
 function transformDestructuredAssignmentExpression(context, expression) {
-    const rootIdentifier = context.createTempNameForNode(expression.right);
     let [rightPrecedingStatements, 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);
     }
-    const statements = [
-        lua.createVariableDeclarationStatement(rootIdentifier, right),
-        ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier, rightPrecedingStatements.length > 0),
-    ];
-    return { statements, result: rootIdentifier };
+    const rightExpr = (0, expression_list_1.moveToPrecedingTemp)(context, right, expression.right);
+    const statements = (0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rightExpr, rightPrecedingStatements.length > 0);
+    return { statements, result: rightExpr };
 }
 function transformAssignmentExpression(context, expression) {
     // Validate assignment
@@ -99,15 +96,12 @@ function transformAssignmentExpression(context, expression) {
         return result;
     }
     if (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) {
-        const tempVar = context.createTempNameForNode(expression.right);
         const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));
         const left = transformAssignmentLeftHandSideExpression(context, expression.left, precedingStatements.length > 0);
-        context.addPrecedingStatements([
-            ...precedingStatements,
-            lua.createVariableDeclarationStatement(tempVar, right, expression.right),
-            lua.createAssignmentStatement(left, lua.cloneIdentifier(tempVar), expression.left),
-        ]);
-        return lua.cloneIdentifier(tempVar);
+        context.addPrecedingStatements(precedingStatements);
+        const rightExpr = (0, expression_list_1.moveToPrecedingTemp)(context, right, expression.right);
+        context.addPrecedingStatements(lua.createAssignmentStatement(left, rightExpr, expression.left));
+        return rightExpr;
     }
     else {
         // Simple assignment
@@ -158,16 +152,8 @@ function transformAssignmentStatement(context, expression) {
             const left = expression.left.elements.map(e => transformAssignmentLeftHandSideExpression(context, e));
             return [lua.createAssignmentStatement(left, right, expression)];
         }
-        let [rightPrecedingStatements, 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);
-        }
-        const rootIdentifier = context.createTempNameForNode(expression.left);
-        return [
-            lua.createVariableDeclarationStatement(rootIdentifier, right),
-            ...(0, destructuring_assignments_1.transformDestructuringAssignment)(context, expression, rootIdentifier, rightPrecedingStatements.length > 0),
-        ];
+        const { statements } = transformDestructuredAssignmentExpression(context, expression);
+        return statements;
     }
     else {
         const [precedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(expression.right));

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

@@ -6,7 +6,10 @@ export declare const isCompoundAssignmentToken: (token: ts.BinaryOperator) => to
 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.AssignmentLeftHandSideExpression;
+    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[];

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

@@ -39,7 +39,7 @@ exports.unwrapCompoundAssignmentToken = unwrapCompoundAssignmentToken;
 function transformCompoundAssignment(context, expression, lhs, rhs, operator, isPostfix) {
     const left = (0, utils_1.cast)(context.transformExpression(lhs), lua.isAssignmentLeftHandSideExpression);
     const [rightPrecedingStatements, right] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(rhs));
-    if (lua.isTableIndexExpression(left) && shouldCacheTableIndexExpressions(left, rightPrecedingStatements)) {
+    if (lua.isTableIndexExpression(left)) {
         // Complex property/element accesses need to cache object/index expressions to avoid repeating side-effects
         // local __obj, __index = ${objExpression}, ${indexExpression};
         const obj = context.createTempNameForLuaExpression(left.table);
@@ -60,6 +60,15 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
             };
         }
         else {
+            if (isSetterSkippingCompoundAssignmentOperator(operator)) {
+                return {
+                    statements: [
+                        objAndIndexDeclaration,
+                        ...transformSetterSkippingCompoundAssignment(accessExpression, operator, right, rightPrecedingStatements),
+                    ],
+                    result: left,
+                };
+            }
             // local ____tmp = ____obj[____index] ${replacementOperator} ${right};
             // ____obj[____index] = ____tmp;
             // return ____tmp
@@ -83,24 +92,6 @@ function transformCompoundAssignment(context, expression, lhs, rhs, operator, is
         const assignStatements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, operatorExpression, rightPrecedingStatements);
         return { statements: [tmpDeclaration, ...precedingStatements, ...assignStatements], result: tmpIdentifier };
     }
-    else if (ts.isPropertyAccessExpression(lhs) || ts.isElementAccessExpression(lhs)) {
-        // Simple property/element access expressions need to cache in temp to avoid double-evaluation
-        // local ____tmp = ${left} ${replacementOperator} ${right};
-        // ${left} = ____tmp;
-        // return ____tmp
-        const tmpIdentifier = context.createTempNameForLuaExpression(left);
-        const [precedingStatements, operatorExpression] = (0, binary_expression_1.transformBinaryOperation)(context, left, right, rightPrecedingStatements, operator, expression);
-        const tmpDeclaration = lua.createVariableDeclarationStatement(tmpIdentifier, operatorExpression);
-        if (isSetterSkippingCompoundAssignmentOperator(operator)) {
-            const statements = [
-                tmpDeclaration,
-                ...transformSetterSkippingCompoundAssignment(tmpIdentifier, operator, right, precedingStatements),
-            ];
-            return { statements, result: tmpIdentifier };
-        }
-        const assignStatements = (0, assignments_1.transformAssignmentWithRightPrecedingStatements)(context, lhs, tmpIdentifier, precedingStatements);
-        return { statements: [tmpDeclaration, ...assignStatements], result: tmpIdentifier };
-    }
     else {
         if (rightPrecedingStatements.length > 0 && isSetterSkippingCompoundAssignmentOperator(operator)) {
             return {

package/dist/transformation/visitors/call.js

@@ -184,10 +184,9 @@ const transformCallExpression = (node, context) => {
         const parameters = transformArguments(context, node.arguments, signature, ts.factory.createThis());
         return lua.createCallExpression(lua.createTableIndexExpression(context.transformExpression(ts.factory.createSuper()), lua.createStringLiteral("____constructor")), parameters);
     }
-    const signatureDeclaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
     let callPath;
     let parameters;
-    const isContextualCall = !signatureDeclaration || (0, function_context_1.getDeclarationContextType)(context, signatureDeclaration) !== function_context_1.ContextType.Void;
+    const isContextualCall = isContextualCallExpression(context, signature);
     if (!isContextualCall) {
         [callPath, parameters] = transformCallAndArguments(context, calledExpression, node.arguments, signature);
     }
@@ -204,6 +203,13 @@ const transformCallExpression = (node, context) => {
     return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(callExpression) : callExpression;
 };
 exports.transformCallExpression = transformCallExpression;
+function isContextualCallExpression(context, signature) {
+    const declaration = signature === null || signature === void 0 ? void 0 : signature.getDeclaration();
+    if (!declaration) {
+        return !context.options.noImplicitSelf;
+    }
+    return (0, function_context_1.getDeclarationContextType)(context, declaration) !== function_context_1.ContextType.Void;
+}
 function getCalledExpression(node) {
     function unwrapExpression(expression) {
         expression = ts.skipOuterExpressions(expression);

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

@@ -12,7 +12,10 @@ const optional_chaining_1 = require("./optional-chaining");
 function shouldMoveToTemp(context, expression, tsOriginal) {
     return (!lua.isLiteral(expression) &&
         !(lua.isIdentifier(expression) && expression.symbolId === context_1.tempSymbolId) && // Treat generated temps as consts
-        !(tsOriginal && ((0, typescript_1.isConstIdentifier)(context, tsOriginal) || (0, optional_chaining_1.isOptionalContinuation)(tsOriginal))));
+        !(tsOriginal &&
+            ((0, typescript_1.isConstIdentifier)(context, tsOriginal) ||
+                (0, optional_chaining_1.isOptionalContinuation)(tsOriginal) ||
+                tsOriginal.kind === ts.SyntaxKind.ThisKeyword)));
 }
 exports.shouldMoveToTemp = shouldMoveToTemp;
 // Cache an expression in a preceding statement and return the temp identifier

package/dist/transformation/visitors/variable-declaration.d.ts

@@ -2,7 +2,7 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor, TransformationContext } from "../context";
 export declare function transformArrayBindingElement(context: TransformationContext, name: ts.ArrayBindingElement): lua.Identifier;
-export declare function transformBindingPattern(context: TransformationContext, pattern: ts.BindingPattern, table: lua.Identifier, propertyAccessStack?: ts.PropertyName[]): lua.Statement[];
+export declare function transformBindingPattern(context: TransformationContext, pattern: ts.BindingPattern, table: lua.Expression, propertyAccessStack?: ts.PropertyName[]): lua.Statement[];
 export declare function transformBindingVariableDeclaration(context: TransformationContext, bindingPattern: ts.BindingPattern, initializer?: ts.Expression): lua.Statement[];
 export declare function transformVariableDeclaration(context: TransformationContext, statement: ts.VariableDeclaration): lua.Statement[];
 export declare function checkVariableDeclarationList(context: TransformationContext, node: ts.VariableDeclarationList): void;

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

@@ -14,6 +14,7 @@ const function_1 = require("./function");
 const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const literal_1 = require("./literal");
+const expression_list_1 = require("./expression-list");
 function transformArrayBindingElement(context, name) {
     if (ts.isOmittedExpression(name)) {
         return lua.createAnonymousIdentifier(name);
@@ -117,22 +118,18 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
     const isComplexBindingElement = (e) => ts.isBindingElement(e) && (!ts.isIdentifier(e.name) || e.dotDotDotToken);
     if (ts.isObjectBindingPattern(bindingPattern) || bindingPattern.elements.some(isComplexBindingElement)) {
         let table;
-        if (initializer !== undefined && ts.isIdentifier(initializer)) {
-            table = (0, identifier_1.transformIdentifier)(context, initializer);
-        }
-        else {
+        if (initializer) {
             // Contain the expression in a temporary variable
-            if (initializer) {
-                table = context.createTempNameForNode(initializer);
-                let expression = context.transformExpression(initializer);
-                if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
-                    expression = (0, lua_ast_1.wrapInTable)(expression);
-                }
-                statements.push(lua.createVariableDeclarationStatement(table, expression));
-            }
-            else {
-                table = lua.createAnonymousIdentifier();
+            let expression = context.transformExpression(initializer);
+            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));
+            statements.push(...moveStatements);
+            table = movedExpr;
+        }
+        else {
+            table = lua.createAnonymousIdentifier();
         }
         statements.push(...transformBindingPattern(context, bindingPattern, table));
         return statements;

package/dist/transpilation/index.js

@@ -19,6 +19,7 @@ const fs = require("fs");
 const path = require("path");
 const ts = require("typescript");
 const tsconfig_1 = require("../cli/tsconfig");
+const utils_1 = require("../utils");
 const output_collector_1 = require("./output-collector");
 const transpiler_1 = require("./transpiler");
 __exportStar(require("./transpile"), exports);
@@ -44,8 +45,12 @@ exports.transpileProject = transpileProject;
 const libCache = {};
 /** @internal */
 function createVirtualProgram(input, options = {}) {
+    const normalizedFiles = {};
+    for (const [path, file] of Object.entries(input)) {
+        normalizedFiles[(0, utils_1.normalizeSlashes)(path)] = file;
+    }
     const compilerHost = {
-        fileExists: fileName => fileName in input || ts.sys.fileExists(fileName),
+        fileExists: fileName => fileName in normalizedFiles || ts.sys.fileExists(fileName),
         getCanonicalFileName: fileName => fileName,
         getCurrentDirectory: () => "",
         getDefaultLibFileName: ts.getDefaultLibFileName,
@@ -54,8 +59,8 @@ function createVirtualProgram(input, options = {}) {
         useCaseSensitiveFileNames: () => false,
         writeFile() { },
         getSourceFile(fileName) {
-            if (fileName in input) {
-                return ts.createSourceFile(fileName, input[fileName], ts.ScriptTarget.Latest, false);
+            if (fileName in normalizedFiles) {
+                return ts.createSourceFile(fileName, normalizedFiles[fileName], ts.ScriptTarget.Latest, false);
             }
             let filePath;
             if (fileName.startsWith("lib.")) {
@@ -75,7 +80,7 @@ function createVirtualProgram(input, options = {}) {
             }
         },
     };
-    return ts.createProgram(Object.keys(input), options, compilerHost);
+    return ts.createProgram(Object.keys(normalizedFiles), options, compilerHost);
 }
 exports.createVirtualProgram = createVirtualProgram;
 function transpileVirtualProject(files, options = {}) {

package/dist/transpilation/resolve.js

@@ -115,7 +115,7 @@ function resolveFileDependencies(file, context) {
     const dependencies = [];
     const diagnostics = [];
     for (const required of findRequiredPaths(file.code)) {
-        // Do no resolve lualib
+        // Do no resolve lualib - always use the lualib of the application entry point, not the lualib from external packages
         if (required === "lualib_bundle") {
             dependencies.push({ fileName: "lualib_bundle", code: "" });
             continue;

package/dist/transpilation/transpiler.js

@@ -16,9 +16,10 @@ class Transpiler {
     }
     emit(emitOptions) {
         var _a, _b;
-        const { program, writeFile = this.emitHost.writeFile } = emitOptions;
+        const { program, writeFile = this.emitHost.writeFile, plugins: optionsPlugins = [] } = emitOptions;
         const options = program.getCompilerOptions();
-        const { diagnostics: getPluginsDiagnostics, plugins } = (0, plugins_1.getPlugins)(program);
+        const { diagnostics: getPluginsDiagnostics, plugins: configPlugins } = (0, plugins_1.getPlugins)(program);
+        const plugins = [...optionsPlugins, ...configPlugins];
         const { diagnostics, transpiledFiles: freshFiles } = (0, transpile_1.getProgramTranspileResult)(this.emitHost, writeFile, {
             ...emitOptions,
             plugins,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.5.0",
+    "version": "1.6.2",
     "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/",
@@ -43,7 +43,7 @@
         "node": ">=12.13.0"
     },
     "peerDependencies": {
-        "typescript": "~4.6.2"
+        "typescript": "~4.7.3"
     },
     "dependencies": {
         "enhanced-resolve": "^5.8.2",
@@ -53,14 +53,14 @@
     "devDependencies": {
         "@types/fs-extra": "^8.1.0",
         "@types/glob": "^7.1.1",
-        "@types/jest": "^27.4.1",
+        "@types/jest": "^27.5.2",
         "@types/node": "^13.7.7",
         "@types/resolve": "1.14.0",
-        "@typescript-eslint/eslint-plugin": "^5.13.0",
-        "@typescript-eslint/parser": "^5.13.0",
-        "eslint": "^8.10.0",
-        "eslint-plugin-import": "^2.25.4",
-        "eslint-plugin-jest": "^26.1.1",
+        "@typescript-eslint/eslint-plugin": "^5.27.0",
+        "@typescript-eslint/parser": "^5.27.0",
+        "eslint": "^8.17.0",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-jest": "^26.4.6",
         "fs-extra": "^8.1.0",
         "javascript-stringify": "^2.0.1",
         "jest": "^27.3.0",
@@ -70,6 +70,6 @@
         "prettier": "^2.3.2",
         "ts-jest": "^27.1.3",
         "ts-node": "^10.3.0",
-        "typescript": "~4.6.2"
+        "typescript": "~4.7.3"
     }
 }