typescript-to-lua 1.0.1 → 1.3.0

package/dist/transformation/visitors/typeof.js

@@ -8,7 +8,7 @@ const lualib_1 = require("../utils/lualib");
 const binary_expression_1 = require("./binary-expression");
 const transformTypeOfExpression = (node, context) => {
     const innerExpression = context.transformExpression(node.expression);
-    return lualib_1.transformLuaLibFunction(context, LuaLib_1.LuaLibFeature.TypeOf, node, innerExpression);
+    return (0, lualib_1.transformLuaLibFunction)(context, LuaLib_1.LuaLibFeature.TypeOf, node, innerExpression);
 };
 exports.transformTypeOfExpression = transformTypeOfExpression;
 function transformTypeOfBinaryExpression(context, node) {
@@ -43,7 +43,9 @@ function transformTypeOfBinaryExpression(context, node) {
     }
     const innerExpression = context.transformExpression(typeOfExpression.expression);
     const typeCall = lua.createCallExpression(lua.createIdentifier("type"), [innerExpression], typeOfExpression);
-    return binary_expression_1.transformBinaryOperation(context, typeCall, comparedExpression, operator, node);
+    const [precedingStatements, result] = (0, binary_expression_1.transformBinaryOperation)(context, typeCall, comparedExpression, [], operator, node);
+    context.addPrecedingStatements(precedingStatements);
+    return result;
 }
 exports.transformTypeOfBinaryExpression = transformTypeOfBinaryExpression;
 //# sourceMappingURL=typeof.js.map

package/dist/transformation/visitors/typescript.js

@@ -5,7 +5,7 @@ const ts = require("typescript");
 const assignment_validation_1 = require("../utils/assignment-validation");
 const transformAssertionExpression = (expression, context) => {
     if (!ts.isConstTypeReference(expression.type)) {
-        assignment_validation_1.validateAssignment(context, expression, context.checker.getTypeAtLocation(expression.expression), context.checker.getTypeAtLocation(expression.type));
+        (0, assignment_validation_1.validateAssignment)(context, expression, context.checker.getTypeAtLocation(expression.expression), context.checker.getTypeAtLocation(expression.type));
     }
     return context.transformExpression(expression.expression);
 };

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

@@ -12,32 +12,32 @@ function transformUnaryExpressionStatement(context, node) {
         (expression.operator === ts.SyntaxKind.PlusPlusToken || expression.operator === ts.SyntaxKind.MinusMinusToken)) {
         // ++i, --i
         const replacementOperator = expression.operator === ts.SyntaxKind.PlusPlusToken ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken;
-        return compound_1.transformCompoundAssignmentStatement(context, expression, expression.operand, ts.factory.createNumericLiteral(1), replacementOperator);
+        return (0, compound_1.transformCompoundAssignmentStatement)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), replacementOperator);
     }
     else if (ts.isPostfixUnaryExpression(expression)) {
         // i++, i--
         const replacementOperator = expression.operator === ts.SyntaxKind.PlusPlusToken ? ts.SyntaxKind.PlusToken : ts.SyntaxKind.MinusToken;
-        return compound_1.transformCompoundAssignmentStatement(context, expression, expression.operand, ts.factory.createNumericLiteral(1), replacementOperator);
+        return (0, compound_1.transformCompoundAssignmentStatement)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), replacementOperator);
     }
 }
 exports.transformUnaryExpressionStatement = transformUnaryExpressionStatement;
 const transformPostfixUnaryExpression = (expression, context) => {
     switch (expression.operator) {
         case ts.SyntaxKind.PlusPlusToken:
-            return compound_1.transformCompoundAssignmentExpression(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, true);
+            return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, true);
         case ts.SyntaxKind.MinusMinusToken:
-            return compound_1.transformCompoundAssignmentExpression(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, true);
+            return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, true);
         default:
-            utils_1.assertNever(expression.operator);
+            (0, utils_1.assertNever)(expression.operator);
     }
 };
 exports.transformPostfixUnaryExpression = transformPostfixUnaryExpression;
 const transformPrefixUnaryExpression = (expression, context) => {
     switch (expression.operator) {
         case ts.SyntaxKind.PlusPlusToken:
-            return compound_1.transformCompoundAssignmentExpression(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, false);
+            return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, false);
         case ts.SyntaxKind.MinusMinusToken:
-            return compound_1.transformCompoundAssignmentExpression(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, false);
+            return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, false);
         case ts.SyntaxKind.PlusToken:
             // TODO: Wrap with `Number`
             return context.transformExpression(expression.operand);
@@ -46,9 +46,9 @@ const transformPrefixUnaryExpression = (expression, context) => {
         case ts.SyntaxKind.ExclamationToken:
             return lua.createUnaryExpression(context.transformExpression(expression.operand), lua.SyntaxKind.NotOperator);
         case ts.SyntaxKind.TildeToken:
-            return bit_1.transformUnaryBitOperation(context, expression, context.transformExpression(expression.operand), lua.SyntaxKind.BitwiseNotOperator);
+            return (0, bit_1.transformUnaryBitOperation)(context, expression, context.transformExpression(expression.operand), lua.SyntaxKind.BitwiseNotOperator);
         default:
-            utils_1.assertNever(expression.operator);
+            (0, utils_1.assertNever)(expression.operator);
     }
 };
 exports.transformPrefixUnaryExpression = transformPrefixUnaryExpression;

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

@@ -9,6 +9,8 @@ const diagnostics_1 = require("../utils/diagnostics");
 const export_1 = require("../utils/export");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
+const preceding_statements_1 = require("../utils/preceding-statements");
+const function_1 = require("./function");
 const identifier_1 = require("./identifier");
 const multi_1 = require("./language-extensions/multi");
 const literal_1 = require("./literal");
@@ -17,16 +19,21 @@ function transformArrayBindingElement(context, name) {
         return lua.createAnonymousIdentifier(name);
     }
     else if (ts.isIdentifier(name)) {
-        return identifier_1.transformIdentifier(context, name);
+        return (0, identifier_1.transformIdentifier)(context, name);
     }
     else if (ts.isBindingElement(name)) {
-        // TODO: It should always be true when called from `transformVariableDeclaration`,
-        // but could be false from `transformForOfLuaIteratorStatement`.
-        utils_1.assert(ts.isIdentifier(name.name));
-        return identifier_1.transformIdentifier(context, name.name);
+        if (ts.isIdentifier(name.name)) {
+            return (0, identifier_1.transformIdentifier)(context, name.name);
+        }
+        else {
+            // ts.isBindingPattern(name.name)
+            const tempName = context.createTempNameForNode(name.name);
+            context.addPrecedingStatements(transformBindingPattern(context, name.name, tempName));
+            return tempName;
+        }
     }
     else {
-        utils_1.assertNever(name);
+        (0, utils_1.assertNever)(name);
     }
 }
 exports.transformArrayBindingElement = transformArrayBindingElement;
@@ -48,11 +55,13 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
             continue;
         }
         // Build the path to the table
-        const tableExpression = propertyAccessStack.reduce((path, property) => lua.createTableIndexExpression(path, literal_1.transformPropertyName(context, property)), table);
+        const tableExpression = propertyAccessStack.reduce((path, property) => lua.createTableIndexExpression(path, (0, literal_1.transformPropertyName)(context, property)), table);
         // The identifier of the new variable
-        const variableName = identifier_1.transformIdentifier(context, element.name);
+        const variableName = (0, identifier_1.transformIdentifier)(context, element.name);
         // The field to extract
-        const propertyName = literal_1.transformPropertyName(context, (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name);
+        const elementName = (_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name;
+        const [precedingStatements, propertyName] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => (0, literal_1.transformPropertyName)(context, elementName));
+        result.push(...precedingStatements); // Keep property's preceding statements in order
         let expression;
         if (element.dotDotDotToken) {
             if (index !== pattern.elements.length - 1) {
@@ -78,20 +87,23 @@ function transformBindingPattern(context, pattern, table, propertyAccessStack =
                     }
                 }
                 const excludedPropertiesTable = excludedProperties.map(e => lua.createTableFieldExpression(lua.createBooleanLiteral(true), lua.createStringLiteral(e.text, e)));
-                expression = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ObjectRest, undefined, tableExpression, lua.createTableExpression(excludedPropertiesTable));
+                expression = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ObjectRest, undefined, tableExpression, lua.createTableExpression(excludedPropertiesTable));
             }
             else {
-                expression = lualib_1.transformLuaLibFunction(context, lualib_1.LuaLibFeature.ArraySlice, undefined, tableExpression, lua.createNumericLiteral(index));
+                expression = (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ArraySlice, undefined, tableExpression, lua.createNumericLiteral(index));
             }
         }
         else {
             expression = lua.createTableIndexExpression(tableExpression, ts.isObjectBindingPattern(pattern) ? propertyName : lua.createNumericLiteral(index + 1));
         }
-        result.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, variableName, expression));
+        result.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, variableName, expression));
         if (element.initializer) {
-            const identifier = export_1.addExportToIdentifier(context, variableName);
+            const identifier = (0, export_1.addExportToIdentifier)(context, variableName);
+            const tsInitializer = element.initializer;
+            const [initializerPrecedingStatements, initializer] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => context.transformExpression(tsInitializer));
             result.push(lua.createIfStatement(lua.createBinaryExpression(identifier, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator), lua.createBlock([
-                lua.createAssignmentStatement(identifier, context.transformExpression(element.initializer)),
+                ...initializerPrecedingStatements,
+                lua.createAssignmentStatement(identifier, initializer),
             ])));
         }
     }
@@ -106,18 +118,21 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
     if (ts.isObjectBindingPattern(bindingPattern) || bindingPattern.elements.some(isComplexBindingElement)) {
         let table;
         if (initializer !== undefined && ts.isIdentifier(initializer)) {
-            table = identifier_1.transformIdentifier(context, initializer);
+            table = (0, identifier_1.transformIdentifier)(context, initializer);
         }
         else {
             // Contain the expression in a temporary variable
-            table = lua.createAnonymousIdentifier();
             if (initializer) {
+                table = context.createTempNameForNode(initializer);
                 let expression = context.transformExpression(initializer);
-                if (multi_1.isMultiReturnCall(context, initializer)) {
-                    expression = lua_ast_1.wrapInTable(expression);
+                if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
+                    expression = (0, lua_ast_1.wrapInTable)(expression);
                 }
                 statements.push(lua.createVariableDeclarationStatement(table, expression));
             }
+            else {
+                table = lua.createAnonymousIdentifier();
+            }
         }
         statements.push(...transformBindingPattern(context, bindingPattern, table));
         return statements;
@@ -126,30 +141,30 @@ function transformBindingVariableDeclaration(context, bindingPattern, initialize
         ? bindingPattern.elements.map(e => transformArrayBindingElement(context, e))
         : lua.createAnonymousIdentifier();
     if (initializer) {
-        if (multi_1.isMultiReturnCall(context, initializer)) {
+        if ((0, multi_1.isMultiReturnCall)(context, initializer)) {
             // Don't unpack LuaMultiReturn functions
-            statements.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, vars, context.transformExpression(initializer), initializer));
+            statements.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, vars, context.transformExpression(initializer), initializer));
         }
         else if (ts.isArrayLiteralExpression(initializer)) {
             // Don't unpack array literals
             const values = initializer.elements.length > 0
                 ? initializer.elements.map(e => context.transformExpression(e))
                 : lua.createNilLiteral();
-            statements.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, vars, values, initializer));
+            statements.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, vars, values, initializer));
         }
         else {
             // local vars = this.transpileDestructingAssignmentValue(node.initializer);
-            const unpackedInitializer = lua_ast_1.createUnpackCall(context, context.transformExpression(initializer), initializer);
-            statements.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, vars, unpackedInitializer, initializer));
+            const unpackedInitializer = (0, lua_ast_1.createUnpackCall)(context, context.transformExpression(initializer), initializer);
+            statements.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, vars, unpackedInitializer, initializer));
         }
     }
     else {
-        statements.push(...lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, vars, lua.createNilLiteral(), initializer));
+        statements.push(...(0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, vars, lua.createNilLiteral(), initializer));
     }
     for (const element of bindingPattern.elements) {
         if (!ts.isOmittedExpression(element) && element.initializer) {
-            const variableName = identifier_1.transformIdentifier(context, element.name);
-            const identifier = export_1.addExportToIdentifier(context, variableName);
+            const variableName = (0, identifier_1.transformIdentifier)(context, element.name);
+            const identifier = (0, export_1.addExportToIdentifier)(context, variableName);
             statements.push(lua.createIfStatement(lua.createBinaryExpression(identifier, lua.createNilLiteral(), lua.SyntaxKind.EqualityOperator), lua.createBlock([
                 lua.createAssignmentStatement(identifier, context.transformExpression(element.initializer)),
             ])));
@@ -163,27 +178,35 @@ function transformVariableDeclaration(context, statement) {
     if (statement.initializer && statement.type) {
         const initializerType = context.checker.getTypeAtLocation(statement.initializer);
         const varType = context.checker.getTypeFromTypeNode(statement.type);
-        assignment_validation_1.validateAssignment(context, statement.initializer, initializerType, varType);
+        (0, assignment_validation_1.validateAssignment)(context, statement.initializer, initializerType, varType);
     }
     if (ts.isIdentifier(statement.name)) {
         // Find variable identifier
-        const identifierName = identifier_1.transformIdentifier(context, statement.name);
+        const identifierName = (0, identifier_1.transformIdentifier)(context, statement.name);
         const value = statement.initializer && context.transformExpression(statement.initializer);
-        return lua_ast_1.createLocalOrExportedOrGlobalDeclaration(context, identifierName, value, statement);
+        // Wrap functions being assigned to a type that contains additional properties in a callable table
+        // This catches 'const foo = function() {}; foo.bar = "FOOBAR";'
+        const wrappedValue = value &&
+            // Skip named function expressions because they will have been wrapped already
+            !(statement.initializer && ts.isFunctionExpression(statement.initializer) && statement.initializer.name) &&
+            (0, function_1.isFunctionTypeWithProperties)(context.checker.getTypeAtLocation(statement.name))
+            ? (0, function_1.createCallableTable)(value)
+            : value;
+        return (0, lua_ast_1.createLocalOrExportedOrGlobalDeclaration)(context, identifierName, wrappedValue, statement);
     }
     else if (ts.isArrayBindingPattern(statement.name) || ts.isObjectBindingPattern(statement.name)) {
         return transformBindingVariableDeclaration(context, statement.name, statement.initializer);
     }
     else {
-        return utils_1.assertNever(statement.name);
+        return (0, utils_1.assertNever)(statement.name);
     }
 }
 exports.transformVariableDeclaration = transformVariableDeclaration;
 function checkVariableDeclarationList(context, node) {
     if ((node.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) === 0) {
         const token = node.getFirstToken();
-        utils_1.assert(token);
-        context.diagnostics.push(diagnostics_1.unsupportedVarDeclaration(token));
+        (0, utils_1.assert)(token);
+        context.diagnostics.push((0, diagnostics_1.unsupportedVarDeclaration)(token));
     }
 }
 exports.checkVariableDeclarationList = checkVariableDeclarationList;

package/dist/transformation/visitors/void.d.ts

@@ -0,0 +1,6 @@
+import * as ts from "typescript";
+import * as lua from "../../LuaAST";
+import { TransformationContext } from "../context";
+import { FunctionVisitor } from "../context/visitors";
+export declare const transformVoidExpression: FunctionVisitor<ts.VoidExpression>;
+export declare const transformVoidExpressionStatement: (node: ts.VoidExpression, context: TransformationContext) => lua.VariableDeclarationStatement;

package/dist/transformation/visitors/void.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVoidExpressionStatement = exports.transformVoidExpression = void 0;
+const ts = require("typescript");
+const lua = require("../../LuaAST");
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void
+const transformVoidExpression = (node, context) => {
+    // If content is a literal it is safe to replace the entire expression with nil
+    if (!ts.isLiteralExpression(node.expression)) {
+        // local ____ = <expression>
+        context.addPrecedingStatements(lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression)));
+    }
+    return lua.createNilLiteral(node);
+};
+exports.transformVoidExpression = transformVoidExpression;
+const transformVoidExpressionStatement = (node, context) => 
+// In case of a void expression statement we can omit the IIFE
+lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), context.transformExpression(node.expression), node);
+exports.transformVoidExpressionStatement = transformVoidExpressionStatement;
+//# sourceMappingURL=void.js.map

package/dist/transpilation/bundle.d.ts

@@ -1,3 +1,6 @@
+import { SourceNode } from "source-map";
 import * as ts from "typescript";
 import { EmitFile, ProcessedFile } from "./utils";
+export declare const sourceMapTracebackBundlePlaceholder = "{#SourceMapTracebackBundle}";
+export declare function printStackTraceBundleOverride(rootNode: SourceNode): string;
 export declare function getBundleResult(program: ts.Program, files: ProcessedFile[]): [ts.Diagnostic[], EmitFile];

package/dist/transpilation/bundle.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBundleResult = void 0;
+exports.getBundleResult = exports.printStackTraceBundleOverride = exports.sourceMapTracebackBundlePlaceholder = void 0;
 const path = require("path");
 const source_map_1 = require("source-map");
 const LuaPrinter_1 = require("../LuaPrinter");
 const utils_1 = require("../utils");
 const diagnostics_1 = require("./diagnostics");
 const transpiler_1 = require("./transpiler");
-const createModulePath = (pathToResolve, program) => LuaPrinter_1.escapeString(utils_1.formatPathToLuaPath(utils_1.trimExtension(transpiler_1.getEmitPathRelativeToOutDir(pathToResolve, program))));
+const createModulePath = (pathToResolve, program) => (0, LuaPrinter_1.escapeString)((0, utils_1.formatPathToLuaPath)((0, utils_1.trimExtension)((0, transpiler_1.getEmitPathRelativeToOutDir)(pathToResolve, program))));
 // Override `require` to read from ____modules table.
 const requireOverride = `
 local ____modules = {}
@@ -30,16 +30,51 @@ local function require(file, ...)
     end
 end
 `;
+exports.sourceMapTracebackBundlePlaceholder = "{#SourceMapTracebackBundle}";
+function printStackTraceBundleOverride(rootNode) {
+    const map = {};
+    const getLineNumber = (line, fallback) => {
+        const data = map[line];
+        if (data === undefined) {
+            return fallback;
+        }
+        if (typeof data === "number") {
+            return data;
+        }
+        return data.line;
+    };
+    const transformLineData = (data) => {
+        if (typeof data === "number") {
+            return data;
+        }
+        return `{line = ${data.line}, file = "${data.file}"}`;
+    };
+    let currentLine = 1;
+    rootNode.walk((chunk, mappedPosition) => {
+        if (mappedPosition.line !== undefined && mappedPosition.line > 0) {
+            const line = getLineNumber(currentLine, mappedPosition.line);
+            map[currentLine] = {
+                line,
+                file: path.basename(mappedPosition.source),
+            };
+        }
+        currentLine += chunk.split("\n").length - 1;
+    });
+    const mapItems = Object.entries(map).map(([line, original]) => `["${line}"] = ${transformLineData(original)}`);
+    const mapString = "{" + mapItems.join(",") + "}";
+    return `__TS__SourceMapTraceBack(debug.getinfo(1).short_src, ${mapString});`;
+}
+exports.printStackTraceBundleOverride = printStackTraceBundleOverride;
 function getBundleResult(program, files) {
     const diagnostics = [];
     const options = program.getCompilerOptions();
-    const bundleFile = utils_1.cast(options.luaBundle, utils_1.isNonNull);
-    const entryModule = utils_1.cast(options.luaBundleEntry, utils_1.isNonNull);
+    const bundleFile = (0, utils_1.cast)(options.luaBundle, utils_1.isNonNull);
+    const entryModule = (0, utils_1.cast)(options.luaBundleEntry, utils_1.isNonNull);
     // Resolve project settings relative to project file.
-    const resolvedEntryModule = path.resolve(transpiler_1.getSourceDir(program), entryModule);
-    const outputPath = path.resolve(transpiler_1.getEmitOutDir(program), bundleFile);
+    const resolvedEntryModule = path.resolve((0, transpiler_1.getSourceDir)(program), entryModule);
+    const outputPath = path.resolve((0, transpiler_1.getEmitOutDir)(program), bundleFile);
     if (program.getSourceFile(resolvedEntryModule) === undefined && program.getSourceFile(entryModule) === undefined) {
-        diagnostics.push(diagnostics_1.couldNotFindBundleEntryPoint(entryModule));
+        diagnostics.push((0, diagnostics_1.couldNotFindBundleEntryPoint)(entryModule));
     }
     // For each file: ["<module path>"] = function() <lua content> end,
     const moduleTableEntries = files.map(f => moduleSourceNode(f, createModulePath(f.fileName, program)));
@@ -47,12 +82,19 @@ function getBundleResult(program, files) {
     const moduleTable = createModuleTableNode(moduleTableEntries);
     // return require("<entry module path>")
     const entryPoint = `return require(${createModulePath(entryModule, program)}, ...)\n`;
-    const sourceChunks = [requireOverride, moduleTable, entryPoint];
+    const footers = [];
+    if (options.sourceMapTraceback) {
+        // Generates SourceMapTraceback for the entire file
+        footers.push('require("lualib_bundle")\n');
+        footers.push(`${exports.sourceMapTracebackBundlePlaceholder}\n`);
+    }
+    const sourceChunks = [requireOverride, moduleTable, ...footers, entryPoint];
     if (!options.noHeader) {
         sourceChunks.unshift(LuaPrinter_1.tstlHeader);
     }
     const bundleNode = joinSourceChunks(sourceChunks);
-    const { code, map } = bundleNode.toStringWithSourceMap();
+    let { code, map } = bundleNode.toStringWithSourceMap();
+    code = code.replace(exports.sourceMapTracebackBundlePlaceholder, printStackTraceBundleOverride(bundleNode));
     return [
         diagnostics,
         {
@@ -65,7 +107,7 @@ function getBundleResult(program, files) {
 }
 exports.getBundleResult = getBundleResult;
 function moduleSourceNode({ code, sourceMapNode }, modulePath) {
-    const tableEntryHead = `[${modulePath}] = function(...) `;
+    const tableEntryHead = `[${modulePath}] = function(...) \n`;
     const tableEntryTail = " end,\n";
     return joinSourceChunks([tableEntryHead, sourceMapNode !== null && sourceMapNode !== void 0 ? sourceMapNode : code, tableEntryTail]);
 }

package/dist/transpilation/diagnostics.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.unsupportedJsxEmit = exports.cannotBundleLibrary = exports.usingLuaBundleWithInlineMightGenerateDuplicateCode = exports.luaBundleEntryIsRequired = exports.couldNotFindBundleEntryPoint = exports.transformerShouldBeATsTransformerFactory = exports.shouldHaveAExport = exports.couldNotResolveFrom = exports.toLoadItShouldBeTranspiled = exports.couldNotReadDependency = exports.couldNotResolveRequire = void 0;
 const ts = require("typescript");
 const utils_1 = require("../utils");
-const createDiagnosticFactory = (getMessage, category = ts.DiagnosticCategory.Error) => utils_1.createSerialDiagnosticFactory((...args) => ({ messageText: getMessage(...args), category }));
-exports.couldNotResolveRequire = createDiagnosticFactory((requirePath, containingFile) => `Could not resolve require path '${requirePath}' in file ${containingFile}.`);
+const createDiagnosticFactory = (getMessage, category = ts.DiagnosticCategory.Error) => (0, utils_1.createSerialDiagnosticFactory)((...args) => ({ messageText: getMessage(...args), category }));
+exports.couldNotResolveRequire = createDiagnosticFactory((requirePath, containingFile) => `Could not resolve lua source files for require path '${requirePath}' in file ${containingFile}.`);
 exports.couldNotReadDependency = createDiagnosticFactory((dependency) => `Could not read content of resolved dependency ${dependency}.`);
 exports.toLoadItShouldBeTranspiled = createDiagnosticFactory((kind, transform) => `To load "${transform}" ${kind} it should be transpiled or "ts-node" should be installed.`);
 exports.couldNotResolveFrom = createDiagnosticFactory((kind, transform, base) => `Could not resolve "${transform}" ${kind} from "${base}".`);
@@ -12,7 +12,7 @@ exports.shouldHaveAExport = createDiagnosticFactory((kind, transform, importName
 exports.transformerShouldBeATsTransformerFactory = createDiagnosticFactory((transform) => `"${transform}" transformer should be a ts.TransformerFactory or an object with ts.TransformerFactory values.`);
 exports.couldNotFindBundleEntryPoint = createDiagnosticFactory((entryPoint) => `Could not find bundle entry point '${entryPoint}'. It should be a file in the project.`);
 exports.luaBundleEntryIsRequired = createDiagnosticFactory(() => "'luaBundleEntry' is required when 'luaBundle' is enabled.");
-exports.usingLuaBundleWithInlineMightGenerateDuplicateCode = utils_1.createSerialDiagnosticFactory(() => ({
+exports.usingLuaBundleWithInlineMightGenerateDuplicateCode = (0, utils_1.createSerialDiagnosticFactory)(() => ({
     category: ts.DiagnosticCategory.Warning,
     messageText: "Using 'luaBundle' with 'luaLibImport: \"inline\"' might generate duplicate code. " +
         "It is recommended to use 'luaLibImport: \"require\"'.",

package/dist/transpilation/index.js

@@ -30,7 +30,7 @@ function transpileFiles(rootNames, options = {}, writeFile) {
 }
 exports.transpileFiles = transpileFiles;
 function transpileProject(configFileName, optionsToExtend, writeFile) {
-    const parseResult = tsconfig_1.parseConfigFileWithSystem(configFileName, optionsToExtend);
+    const parseResult = (0, tsconfig_1.parseConfigFileWithSystem)(configFileName, optionsToExtend);
     if (parseResult.errors.length > 0) {
         return { diagnostics: parseResult.errors, emitSkipped: true };
     }
@@ -76,7 +76,7 @@ function createVirtualProgram(input, options = {}) {
 exports.createVirtualProgram = createVirtualProgram;
 function transpileVirtualProject(files, options = {}) {
     const program = createVirtualProgram(files, options);
-    const collector = output_collector_1.createEmitOutputCollector();
+    const collector = (0, output_collector_1.createEmitOutputCollector)();
     const { diagnostics: transpileDiagnostics } = new transpiler_1.Transpiler().emit({ program, writeFile: collector.writeFile });
     const diagnostics = ts.sortAndDeduplicateDiagnostics([
         ...ts.getPreEmitDiagnostics(program),

package/dist/transpilation/output-collector.js

@@ -5,13 +5,13 @@ const utils_1 = require("../utils");
 function createEmitOutputCollector() {
     const files = [];
     const writeFile = (fileName, data, _bom, _onError, sourceFiles = []) => {
-        let file = files.find(f => utils_1.intersection(f.sourceFiles, sourceFiles).length > 0);
+        let file = files.find(f => (0, utils_1.intersection)(f.sourceFiles, sourceFiles).length > 0);
         if (!file) {
             file = { outPath: fileName, sourceFiles: [...sourceFiles] };
             files.push(file);
         }
         else {
-            file.sourceFiles = utils_1.union(file.sourceFiles, sourceFiles);
+            file.sourceFiles = (0, utils_1.union)(file.sourceFiles, sourceFiles);
         }
         if (fileName.endsWith(".lua")) {
             file.lua = data;

package/dist/transpilation/plugins.js

@@ -8,7 +8,7 @@ function getPlugins(program, diagnostics, customPlugins) {
     const options = program.getCompilerOptions();
     for (const [index, pluginOption] of ((_a = options.luaPlugins) !== null && _a !== void 0 ? _a : []).entries()) {
         const optionName = `tstl.luaPlugins[${index}]`;
-        const { error: resolveError, result: factory } = utils_1.resolvePlugin("plugin", `${optionName}.name`, utils_1.getConfigDirectory(options), pluginOption.name, pluginOption.import);
+        const { error: resolveError, result: factory } = (0, utils_1.resolvePlugin)("plugin", `${optionName}.name`, (0, utils_1.getConfigDirectory)(options), pluginOption.name, pluginOption.import);
         if (resolveError)
             diagnostics.push(resolveError);
         if (factory === undefined)

package/dist/transpilation/resolve.js

@@ -21,15 +21,22 @@ class ResolutionContext {
         this.options = options;
         this.emitHost = emitHost;
         this.resultsCache = new Map();
+        this.noResolvePaths = new Set(options.noResolvePaths);
     }
     resolve(file, required) {
+        if (this.noResolvePaths.has(required)) {
+            if (this.options.tstlVerbose) {
+                console.log(`Skipping module resolution of ${required} as it is in the tsconfig noResolvePaths.`);
+            }
+            return { resolvedFiles: [], diagnostics: [] };
+        }
         const resolvedDependency = resolveDependency(file, required, this.program, this.emitHost);
         if (resolvedDependency) {
             if (this.options.tstlVerbose) {
-                console.log(`Resolved ${required} to ${utils_1.normalizeSlashes(resolvedDependency)}`);
+                console.log(`Resolved ${required} to ${(0, utils_1.normalizeSlashes)(resolvedDependency)}`);
             }
             // Figure out resolved require path and dependency output path
-            const resolvedRequire = transpiler_1.getEmitPathRelativeToOutDir(resolvedDependency, this.program);
+            const resolvedRequire = (0, transpiler_1.getEmitPathRelativeToOutDir)(resolvedDependency, this.program);
             if (shouldRewriteRequires(resolvedDependency, this.program)) {
                 replaceRequireInCode(file, required, resolvedRequire);
                 replaceRequireInSourceMap(file, required, resolvedRequire);
@@ -37,7 +44,7 @@ class ResolutionContext {
             // Check cache to prevent resolving nested dependencies double to break dependency loops
             if (this.resultsCache.has(resolvedDependency)) {
                 if (this.options.tstlVerbose) {
-                    console.log(`Resolution cache hit for ${utils_1.normalizeSlashes(resolvedDependency)}`);
+                    console.log(`Resolution cache hit for ${(0, utils_1.normalizeSlashes)(resolvedDependency)}`);
                 }
                 return this.resultsCache.get(resolvedDependency);
             }
@@ -46,7 +53,7 @@ class ResolutionContext {
                 // If dependency resolved successfully, read its content
                 const dependencyContent = this.emitHost.readFile(resolvedDependency);
                 if (dependencyContent === undefined) {
-                    return { resolvedFiles: [], diagnostics: [diagnostics_1.couldNotReadDependency(resolvedDependency)] };
+                    return { resolvedFiles: [], diagnostics: [(0, diagnostics_1.couldNotReadDependency)(resolvedDependency)] };
                 }
                 const dependency = {
                     fileName: resolvedDependency,
@@ -71,13 +78,13 @@ class ResolutionContext {
             }
         }
         else {
-            const fallbackRequire = fallbackResolve(required, transpiler_1.getSourceDir(this.program), path.dirname(file.fileName));
+            const fallbackRequire = fallbackResolve(required, (0, transpiler_1.getSourceDir)(this.program), path.dirname(file.fileName));
             replaceRequireInCode(file, required, fallbackRequire);
             replaceRequireInSourceMap(file, required, fallbackRequire);
             return {
                 resolvedFiles: [],
                 diagnostics: [
-                    diagnostics_1.couldNotResolveRequire(required, path.relative(transpiler_1.getProjectRoot(this.program), file.fileName)),
+                    (0, diagnostics_1.couldNotResolveRequire)(required, path.relative((0, transpiler_1.getProjectRoot)(this.program), file.fileName)),
                 ],
             };
         }
@@ -91,7 +98,7 @@ function resolveDependencies(program, files, emitHost) {
     // Resolve dependencies for all processed files
     for (const file of files) {
         if (options.tstlVerbose) {
-            console.log(`Resolving dependencies for ${utils_1.normalizeSlashes(file.fileName)}`);
+            console.log(`Resolving dependencies for ${(0, utils_1.normalizeSlashes)(file.fileName)}`);
         }
         const resolutionResult = resolveFileDependencies(file, resolutionContext);
         outFiles.push(...resolutionResult.resolvedFiles);
@@ -135,7 +142,7 @@ function resolveDependency(requiringFile, dependency, program, emitHost) {
     const options = program.getCompilerOptions();
     const fileDirectory = path.dirname(requiringFile.fileName);
     if (options.tstlVerbose) {
-        console.log(`Resolving "${dependency}" from ${utils_1.normalizeSlashes(fileDirectory)}`);
+        console.log(`Resolving "${dependency}" from ${(0, utils_1.normalizeSlashes)(fileDirectory)}`);
     }
     // Check if the import is relative
     const isRelative = ["/", "./", "../"].some(p => dependency.startsWith(p));
@@ -237,7 +244,7 @@ function isBuildModeLibrary(program) {
 function findRequiredPaths(code) {
     // Find all require("<path>") paths in a lua code string
     const paths = [];
-    const pattern = /(^|\s|;|=)require\("(.+)"\)/g;
+    const pattern = /(^|\s|;|=)require\("(.+?)"\)/g;
     // eslint-disable-next-line @typescript-eslint/ban-types
     let match;
     while ((match = pattern.exec(code))) {
@@ -246,13 +253,13 @@ function findRequiredPaths(code) {
     return paths;
 }
 function replaceRequireInCode(file, originalRequire, newRequire) {
-    const requirePath = utils_1.formatPathToLuaPath(newRequire.replace(".lua", ""));
+    const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
     // Escape special characters to prevent the regex from breaking...
     const escapedRequire = originalRequire.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
     file.code = file.code.replace(new RegExp(`(^|\\s|;|=)require\\("${escapedRequire}"\\)`), `$1require("${requirePath}")`);
 }
 function replaceRequireInSourceMap(file, originalRequire, newRequire) {
-    const requirePath = utils_1.formatPathToLuaPath(newRequire.replace(".lua", ""));
+    const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
     if (file.sourceMapNode) {
         replaceInSourceMap(file.sourceMapNode, file.sourceMapNode, `"${originalRequire}"`, `"${requirePath}"`);
     }
@@ -281,14 +288,14 @@ function isProjectFile(file, program) {
     return program.getSourceFile(file) !== undefined;
 }
 function hasSourceFileInProject(filePath, program) {
-    const pathWithoutExtension = utils_1.trimExtension(filePath);
+    const pathWithoutExtension = (0, utils_1.trimExtension)(filePath);
     return (isProjectFile(pathWithoutExtension + ".ts", program) ||
         isProjectFile(pathWithoutExtension + ".tsx", program) ||
         isProjectFile(pathWithoutExtension + ".json", program));
 }
 // Transform an import path to a lua require that is probably not correct, but can be used as fallback when regular resolution fails
 function fallbackResolve(required, sourceRootDir, fileDir) {
-    return utils_1.formatPathToLuaPath(path
+    return (0, utils_1.formatPathToLuaPath)(path
         .normalize(path.join(path.relative(sourceRootDir, fileDir), required))
         .split(path.sep)
         .filter(s => s !== "." && s !== "..")