typescript-to-lua 1.0.0 → 1.2.0

package/dist/transpilation/bundle.js

@@ -1,24 +1,25 @@
 "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 = {}
 local ____moduleCache = {}
 local ____originalRequire = require
-local function require(file)
+local function require(file, ...)
     if ____moduleCache[file] then
         return ____moduleCache[file].value
     end
     if ____modules[file] then
-        ____moduleCache[file] = { value = ____modules[file]() }
+        local module = ____modules[file]
+        ____moduleCache[file] = { value = (select("#", ...) > 0) and module(...) or module(file) }
         return ____moduleCache[file].value
     else
         if ____originalRequire then
@@ -29,29 +30,71 @@ 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)));
     // Create ____modules table containing all entries from moduleTableEntries
     const moduleTable = createModuleTableNode(moduleTableEntries);
     // return require("<entry module path>")
-    const entryPoint = `return require(${createModulePath(entryModule, program)})\n`;
-    const sourceChunks = [requireOverride, moduleTable, entryPoint];
+    const entryPoint = `return require(${createModulePath(entryModule, program)}, ...)\n`;
+    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,
         {
@@ -64,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,10 +142,15 @@ 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));
+    // If the import is relative, always resolve it relative to the requiring file
+    // If the import is not relative, resolve it relative to options.baseUrl if it is set
+    const relativeTo = isRelative ? fileDirectory : (_a = options.baseUrl) !== null && _a !== void 0 ? _a : fileDirectory;
     // Check if file is a file in the project
-    const resolvedPath = path.join((_a = options.baseUrl) !== null && _a !== void 0 ? _a : fileDirectory, dependency);
+    const resolvedPath = path.join(relativeTo, dependency);
     const possibleProjectFiles = [
         resolvedPath,
         resolvedPath + ".ts",
@@ -232,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))) {
@@ -241,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}"`);
     }
@@ -276,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 !== "..")

package/dist/transpilation/transformers.js

@@ -48,7 +48,7 @@ exports.noImplicitSelfTransformer = noImplicitSelfTransformer;
 const stripParenthesisExpressionsTransformer = context => sourceFile => {
     // Remove parenthesis expressions before transforming to Lua, so transpiler is not hindered by extra ParenthesizedExpression nodes
     function unwrapParentheses(node) {
-        while (ts.isParenthesizedExpression(node)) {
+        while (ts.isParenthesizedExpression(node) && !ts.isOptionalChain(node.expression)) {
             node = node.expression;
         }
         return node;
@@ -58,6 +58,12 @@ const stripParenthesisExpressionsTransformer = context => sourceFile => {
         if (ts.isCallExpression(node)) {
             return ts.factory.updateCallExpression(node, unwrapParentheses(node.expression), node.typeArguments, node.arguments);
         }
+        else if (ts.isVoidExpression(node)) {
+            return ts.factory.updateVoidExpression(node, unwrapParentheses(node.expression));
+        }
+        else if (ts.isDeleteExpression(node)) {
+            return ts.factory.updateDeleteExpression(node, unwrapParentheses(node.expression));
+        }
         return ts.visitEachChild(node, visit, context);
     }
     return ts.visitNode(sourceFile, visit);
@@ -70,32 +76,46 @@ function loadTransformersFromOptions(program, diagnostics) {
         afterDeclarations: [],
     };
     const options = program.getCompilerOptions();
-    if (!options.plugins)
-        return customTransformers;
-    for (const [index, transformerImport] of options.plugins.entries()) {
-        if (!("transform" in transformerImport))
-            continue;
-        const optionName = `compilerOptions.plugins[${index}]`;
-        const { error: resolveError, result: factory } = utils_1.resolvePlugin("transformer", `${optionName}.transform`, utils_1.getConfigDirectory(options), transformerImport.transform, transformerImport.import);
-        if (resolveError)
-            diagnostics.push(resolveError);
-        if (factory === undefined)
-            continue;
-        const { error: loadError, transformer } = loadTransformer(optionName, program, factory, transformerImport);
-        if (loadError)
-            diagnostics.push(loadError);
-        if (transformer === undefined)
-            continue;
-        if (transformer.before) {
-            customTransformers.before.push(transformer.before);
-        }
-        if (transformer.after) {
-            customTransformers.after.push(transformer.after);
-        }
-        if (transformer.afterDeclarations) {
-            customTransformers.afterDeclarations.push(transformer.afterDeclarations);
+    if (options.plugins) {
+        for (const [index, transformerImport] of options.plugins.entries()) {
+            if (!("transform" in transformerImport))
+                continue;
+            const optionName = `compilerOptions.plugins[${index}]`;
+            const { error: resolveError, result: factory } = (0, utils_1.resolvePlugin)("transformer", `${optionName}.transform`, (0, utils_1.getConfigDirectory)(options), transformerImport.transform, transformerImport.import);
+            if (resolveError)
+                diagnostics.push(resolveError);
+            if (factory === undefined)
+                continue;
+            const { error: loadError, transformer } = loadTransformer(optionName, program, factory, transformerImport);
+            if (loadError)
+                diagnostics.push(loadError);
+            if (transformer === undefined)
+                continue;
+            if (transformer.before) {
+                customTransformers.before.push(transformer.before);
+            }
+            if (transformer.after) {
+                customTransformers.after.push(transformer.after);
+            }
+            if (transformer.afterDeclarations) {
+                customTransformers.afterDeclarations.push(transformer.afterDeclarations);
+            }
         }
     }
+    if (options.jsx === ts.JsxEmit.React) {
+        customTransformers.before.push(context => {
+            // if target < ES2017, typescript generates some unnecessary additional transformations in transformJSX.
+            // We can't control the target compiler option, so we override here.
+            const patchedContext = {
+                ...context,
+                getCompilerOptions: () => ({
+                    ...context.getCompilerOptions(),
+                    target: ts.ScriptTarget.ESNext,
+                }),
+            };
+            return ts.transformJsx(patchedContext);
+        });
+    }
     return customTransformers;
 }
 function loadTransformer(optionPath, program, factory, { transform, after = false, afterDeclarations = false, type = "program", ...extraOptions }) {

package/dist/transpilation/transpile.js

@@ -14,7 +14,7 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
     if (options.tstlVerbose) {
         console.log("Parsing project settings");
     }
-    const diagnostics = CompilerOptions_1.validateOptions(options);
+    const diagnostics = (0, CompilerOptions_1.validateOptions)(options);
     let transpiledFiles = [];
     if (options.noEmitOnError) {
         const preEmitDiagnostics = [
@@ -39,17 +39,17 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
             return { diagnostics: preEmitDiagnostics, transpiledFiles };
         }
     }
-    const plugins = plugins_1.getPlugins(program, diagnostics, customPlugins);
+    const plugins = (0, plugins_1.getPlugins)(program, diagnostics, customPlugins);
     if (options.tstlVerbose) {
         console.log(`Successfully loaded ${plugins.length} plugins`);
     }
-    const visitorMap = transformation_1.createVisitorMap(plugins.map(p => p.visitors).filter(utils_1.isNonNull));
-    const printer = LuaPrinter_1.createPrinter(plugins.map(p => p.printer).filter(utils_1.isNonNull));
+    const visitorMap = (0, transformation_1.createVisitorMap)(plugins.map(p => p.visitors).filter(utils_1.isNonNull));
+    const printer = (0, LuaPrinter_1.createPrinter)(plugins.map(p => p.printer).filter(utils_1.isNonNull));
     const processSourceFile = (sourceFile) => {
         if (options.tstlVerbose) {
             console.log(`Transforming ${sourceFile.fileName}`);
         }
-        const { file, diagnostics: transformDiagnostics } = transformation_1.transformSourceFile(program, sourceFile, visitorMap);
+        const { file, diagnostics: transformDiagnostics } = (0, transformation_1.transformSourceFile)(program, sourceFile, visitorMap);
         diagnostics.push(...transformDiagnostics);
         if (!options.noEmit && !options.emitDeclarationOnly) {
             if (options.tstlVerbose) {
@@ -64,7 +64,7 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
             });
         }
     };
-    const transformers = transformers_1.getTransformers(program, diagnostics, customTransformers, processSourceFile);
+    const transformers = (0, transformers_1.getTransformers)(program, diagnostics, customTransformers, processSourceFile);
     const isEmittableJsonFile = (sourceFile) => sourceFile.flags & ts.NodeFlags.JsonFile &&
         !options.emitDeclarationOnly &&
         !program.isSourceFileFromExternalLibrary(sourceFile);

package/dist/transpilation/transpiler.js

@@ -17,7 +17,7 @@ class Transpiler {
         var _a;
         const { program, writeFile = this.emitHost.writeFile } = emitOptions;
         const verbose = program.getCompilerOptions().tstlVerbose;
-        const { diagnostics, transpiledFiles: freshFiles } = transpile_1.getProgramTranspileResult(this.emitHost, writeFile, emitOptions);
+        const { diagnostics, transpiledFiles: freshFiles } = (0, transpile_1.getProgramTranspileResult)(this.emitHost, writeFile, emitOptions);
         const { emitPlan } = this.getEmitPlan(program, diagnostics, freshFiles);
         if (verbose) {
             console.log("Emitting output");
@@ -26,7 +26,7 @@ class Transpiler {
         const emitBOM = (_a = options.emitBOM) !== null && _a !== void 0 ? _a : false;
         for (const { outputPath, code, sourceMap, sourceFiles } of emitPlan) {
             if (verbose) {
-                console.log(`Emitting ${utils_1.normalizeSlashes(outputPath)}`);
+                console.log(`Emitting ${(0, utils_1.normalizeSlashes)(outputPath)}`);
             }
             writeFile(outputPath, code, emitBOM, undefined, sourceFiles);
             if (options.sourceMap && sourceMap !== undefined) {
@@ -44,7 +44,7 @@ class Transpiler {
             console.log("Constructing emit plan");
         }
         // Resolve imported modules and modify output Lua requires
-        const resolutionResult = resolve_1.resolveDependencies(program, files, this.emitHost);
+        const resolutionResult = (0, resolve_1.resolveDependencies)(program, files, this.emitHost);
         diagnostics.push(...resolutionResult.diagnostics);
         const lualibRequired = resolutionResult.resolvedFiles.some(f => f.fileName === "lualib_bundle");
         if (lualibRequired) {
@@ -54,12 +54,12 @@ class Transpiler {
                 console.log("Including lualib bundle");
             }
             // Add lualib bundle to source dir 'virtually', will be moved to correct output dir in emitPlan
-            const fileName = utils_1.normalizeSlashes(path.resolve(getSourceDir(program), "lualib_bundle.lua"));
-            resolutionResult.resolvedFiles.unshift({ fileName, code: LuaLib_1.getLuaLibBundle(this.emitHost) });
+            const fileName = (0, utils_1.normalizeSlashes)(path.resolve(getSourceDir(program), "lualib_bundle.lua"));
+            resolutionResult.resolvedFiles.unshift({ fileName, code: (0, LuaLib_1.getLuaLibBundle)(this.emitHost) });
         }
         let emitPlan;
-        if (CompilerOptions_1.isBundleEnabled(options)) {
-            const [bundleDiagnostics, bundleFile] = bundle_1.getBundleResult(program, resolutionResult.resolvedFiles);
+        if ((0, CompilerOptions_1.isBundleEnabled)(options)) {
+            const [bundleDiagnostics, bundleFile] = (0, bundle_1.getBundleResult)(program, resolutionResult.resolvedFiles);
             diagnostics.push(...bundleDiagnostics);
             emitPlan = [bundleFile];
         }
@@ -90,7 +90,7 @@ function getEmitPathRelativeToOutDir(fileName, program) {
         emitPathSplits[0] = "lua_modules";
     }
     // Make extension lua
-    emitPathSplits[emitPathSplits.length - 1] = utils_1.trimExtension(emitPathSplits[emitPathSplits.length - 1]) + ".lua";
+    emitPathSplits[emitPathSplits.length - 1] = (0, utils_1.trimExtension)(emitPathSplits[emitPathSplits.length - 1]) + ".lua";
     return path.join(...emitPathSplits);
 }
 exports.getEmitPathRelativeToOutDir = getEmitPathRelativeToOutDir;

package/dist/transpilation/utils.js

@@ -8,28 +8,30 @@ const cliDiagnostics = require("../cli/diagnostics");
 const diagnosticFactories = require("./diagnostics");
 const getConfigDirectory = (options) => options.configFilePath ? path.dirname(options.configFilePath) : process.cwd();
 exports.getConfigDirectory = getConfigDirectory;
+const getTstlDirectory = () => path.dirname(__dirname);
 function resolvePlugin(kind, optionName, basedir, query, importName = "default") {
     if (typeof query !== "string") {
         return { error: cliDiagnostics.compilerOptionRequiresAValueOfType(optionName, "string") };
     }
+    const isModuleNotFoundError = (error) => error.code === "MODULE_NOT_FOUND";
     let resolved;
     try {
         resolved = resolve.sync(query, { basedir, extensions: [".js", ".ts", ".tsx"] });
     }
     catch (err) {
-        if (err.code !== "MODULE_NOT_FOUND")
+        if (!isModuleNotFoundError(err))
             throw err;
         return { error: diagnosticFactories.couldNotResolveFrom(kind, query, basedir) };
     }
     const hasNoRequireHook = require.extensions[".ts"] === undefined;
     if (hasNoRequireHook && (resolved.endsWith(".ts") || resolved.endsWith(".tsx"))) {
         try {
-            const tsNodePath = resolve.sync("ts-node", { basedir });
+            const tsNodePath = resolve.sync("ts-node", { basedir: getTstlDirectory() });
             const tsNode = require(tsNodePath);
             tsNode.register({ transpileOnly: true });
         }
         catch (err) {
-            if (err.code !== "MODULE_NOT_FOUND")
+            if (!isModuleNotFoundError(err))
                 throw err;
             return { error: diagnosticFactories.toLoadItShouldBeTranspiled(kind, query) };
         }

package/dist/tstl.js

@@ -10,9 +10,9 @@ const report_1 = require("./cli/report");
 const tsconfig_1 = require("./cli/tsconfig");
 const CompilerOptions_1 = require("./CompilerOptions");
 const shouldBePretty = ({ pretty } = {}) => { var _a, _b, _c; return pretty !== undefined ? pretty : (_c = (_b = (_a = ts.sys).writeOutputIsTTY) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false; };
-let reportDiagnostic = report_1.createDiagnosticReporter(false);
+let reportDiagnostic = (0, report_1.createDiagnosticReporter)(false);
 function updateReportDiagnostic(options) {
-    reportDiagnostic = report_1.createDiagnosticReporter(shouldBePretty(options));
+    reportDiagnostic = (0, report_1.createDiagnosticReporter)(shouldBePretty(options));
 }
 function createWatchStatusReporter(options) {
     return ts.createWatchStatusReporter(ts.sys, shouldBePretty(options));
@@ -24,7 +24,7 @@ function executeCommandLine(args) {
             return performBuild(args.slice(1));
         }
     }
-    const commandLine = parse_1.parseCommandLine(args);
+    const commandLine = (0, parse_1.parseCommandLine)(args);
     if (commandLine.options.build) {
         reportDiagnostic(cliDiagnostics.optionBuildMustBeFirstCommandLineArgument());
         return ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
@@ -41,17 +41,17 @@ function executeCommandLine(args) {
     }
     if (commandLine.options.help) {
         console.log(information_1.versionString);
-        console.log(information_1.getHelpString());
+        console.log((0, information_1.getHelpString)());
         return ts.sys.exit(ts.ExitStatus.Success);
     }
-    const configFileName = tsconfig_1.locateConfigFile(commandLine);
+    const configFileName = (0, tsconfig_1.locateConfigFile)(commandLine);
     if (typeof configFileName === "object") {
         reportDiagnostic(configFileName);
         return ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
     }
     const commandLineOptions = commandLine.options;
     if (configFileName) {
-        const configParseResult = tsconfig_1.parseConfigFileWithSystem(configFileName, commandLineOptions);
+        const configParseResult = (0, tsconfig_1.parseConfigFileWithSystem)(configFileName, commandLineOptions);
         updateReportDiagnostic(configParseResult.options);
         if (configParseResult.options.watch) {
             createWatchOfConfigFile(configFileName, commandLineOptions);
@@ -106,14 +106,14 @@ function createWatchOfFilesAndCompilerOptions(rootFiles, options) {
 }
 function updateWatchCompilationHost(host, optionsToExtend) {
     let hadErrorLastTime = true;
-    const updateConfigFile = tsconfig_1.createConfigFileUpdater(optionsToExtend);
+    const updateConfigFile = (0, tsconfig_1.createConfigFileUpdater)(optionsToExtend);
     const transpiler = new tstl.Transpiler();
     host.afterProgramCreate = builderProgram => {
         const program = builderProgram.getProgram();
         const options = builderProgram.getCompilerOptions();
         const configFileParsingDiagnostics = updateConfigFile(options);
         let sourceFiles;
-        if (!CompilerOptions_1.isBundleEnabled(options) && !hadErrorLastTime) {
+        if (!(0, CompilerOptions_1.isBundleEnabled)(options) && !hadErrorLastTime) {
             sourceFiles = [];
             while (true) {
                 const currentFile = builderProgram.getSemanticDiagnosticsOfNextAffectedFile();

package/dist/utils.js

@@ -12,7 +12,7 @@ const intersperse = (values, separator) => values.flatMap((value, index) => (ind
 exports.intersperse = intersperse;
 const union = (...values) => [...new Set(...values)];
 exports.union = union;
-const intersection = (first, ...rest) => exports.union(first).filter(x => rest.every(r => r.includes(x)));
+const intersection = (first, ...rest) => (0, exports.union)(first).filter(x => rest.every(r => r.includes(x)));
 exports.intersection = intersection;
 const createDiagnosticFactoryWithCode = (code, create) => Object.assign((...args) => ({
     file: undefined,
@@ -25,7 +25,7 @@ const createDiagnosticFactoryWithCode = (code, create) => Object.assign((...args
 }), { code });
 exports.createDiagnosticFactoryWithCode = createDiagnosticFactoryWithCode;
 let serialDiagnosticCodeCounter = 100000;
-const createSerialDiagnosticFactory = (create) => exports.createDiagnosticFactoryWithCode(serialDiagnosticCodeCounter++, create);
+const createSerialDiagnosticFactory = (create) => (0, exports.createDiagnosticFactoryWithCode)(serialDiagnosticCodeCounter++, create);
 exports.createSerialDiagnosticFactory = createSerialDiagnosticFactory;
 const normalizeSlashes = (filePath) => filePath.replace(/\\/g, "/");
 exports.normalizeSlashes = normalizeSlashes;