typescript-to-lua 1.6.3 → 1.7.2

package/dist/transformation/visitors/namespace.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformModuleDeclaration = exports.createModuleLocalNameIdentifier = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
-const annotations_1 = require("../utils/annotations");
-const diagnostics_1 = require("../utils/diagnostics");
 const export_1 = require("../utils/export");
 const lua_ast_1 = require("../utils/lua-ast");
 const safe_names_1 = require("../utils/safe-names");
@@ -33,16 +31,9 @@ function moduleHasEmittedBody(node) {
     }
     return false;
 }
-// Static context -> namespace dictionary keeping the current namespace for each transformation context
-const currentNamespaces = new WeakMap();
 const transformModuleDeclaration = (node, context) => {
     var _a, _b;
-    const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(node));
-    // If phantom namespace elide the declaration and return the body
-    if (annotations.has(annotations_1.AnnotationKind.Phantom)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.Phantom));
-    }
-    const currentNamespace = currentNamespaces.get(context);
+    const currentNamespace = context.currentNamespaces;
     const result = [];
     const symbol = context.checker.getSymbolAtLocation(node.name);
     const hasExports = symbol !== undefined && context.checker.getExportsOfModule(symbol).length > 0;
@@ -75,15 +66,15 @@ const transformModuleDeclaration = (node, context) => {
     }
     // Set current namespace for nested NS
     // Keep previous namespace to reset after block transpilation
-    currentNamespaces.set(context, node);
+    context.currentNamespaces = node;
     // Transform moduleblock to block and visit it
     if (moduleHasEmittedBody(node)) {
-        (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+        context.pushScope(scope_1.ScopeType.Block);
         const statements = (0, scope_1.performHoisting)(context, context.transformStatements(ts.isModuleBlock(node.body) ? node.body.statements : node.body));
-        (0, scope_1.popScope)(context);
+        context.popScope();
         result.push(lua.createDoStatement(statements));
     }
-    currentNamespaces.set(context, currentNamespace);
+    context.currentNamespaces = currentNamespace;
     return result;
 };
 exports.transformModuleDeclaration = transformModuleDeclaration;

package/dist/transformation/visitors/return.js

@@ -60,7 +60,6 @@ const transformReturnStatement = (statement, context) => {
 };
 exports.transformReturnStatement = transformReturnStatement;
 function createReturnStatement(context, values, node) {
-    const results = [...values];
     if ((0, typescript_1.isInAsyncFunction)(node)) {
         return lua.createReturnStatement([
             lua.createCallExpression(lua.createIdentifier("____awaiter_resolve"), [lua.createNilLiteral(), ...values]),
@@ -68,9 +67,9 @@ function createReturnStatement(context, values, node) {
     }
     if (isInTryCatch(context)) {
         // Bubble up explicit return flag and check if we're inside a try/catch block
-        results.unshift(lua.createBooleanLiteral(true));
+        values = [lua.createBooleanLiteral(true), ...values];
     }
-    return lua.createReturnStatement(results, node);
+    return lua.createReturnStatement(values, node);
 }
 exports.createReturnStatement = createReturnStatement;
 function isInTryCatch(context) {

package/dist/transformation/visitors/sourceFile.js

@@ -5,7 +5,6 @@ const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
 const lua_ast_1 = require("../utils/lua-ast");
-const lualib_1 = require("../utils/lualib");
 const preceding_statements_1 = require("../utils/preceding-statements");
 const scope_1 = require("../utils/scope");
 const typescript_1 = require("../utils/typescript");
@@ -28,9 +27,9 @@ const transformSourceFileNode = (node, context) => {
         }
     }
     else {
-        (0, scope_1.pushScope)(context, scope_1.ScopeType.File);
+        context.pushScope(scope_1.ScopeType.File);
         statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
-        (0, scope_1.popScope)(context);
+        context.popScope();
         if (context.isModule) {
             // If export equals was not used. Create the exports table.
             // local ____exports = {}
@@ -42,7 +41,7 @@ const transformSourceFileNode = (node, context) => {
         }
     }
     const trivia = (_b = (_a = node.getFullText().match(/^#!.*\r?\n/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
-    return lua.createFile(statements, (0, lualib_1.getUsedLuaLibFeatures)(context), trivia, node);
+    return lua.createFile(statements, context.usedLuaLibFeatures, trivia, node);
 };
 exports.transformSourceFileNode = transformSourceFileNode;
 //# sourceMappingURL=sourceFile.js.map

package/dist/transformation/visitors/spread.js

@@ -3,13 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSpreadElement = exports.isOptimizedVarArgSpread = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
-const annotations_1 = require("../utils/annotations");
 const lua_ast_1 = require("../utils/lua-ast");
 const lualib_1 = require("../utils/lualib");
 const scope_1 = require("../utils/scope");
 const typescript_1 = require("../utils/typescript");
 const multi_1 = require("./language-extensions/multi");
-const diagnostics_1 = require("../utils/diagnostics");
 const vararg_1 = require("./language-extensions/vararg");
 function isOptimizedVarArgSpread(context, symbol, identifier) {
     var _a;
@@ -53,9 +51,6 @@ exports.isOptimizedVarArgSpread = isOptimizedVarArgSpread;
 const transformSpreadElement = (node, context) => {
     const tsInnerExpression = ts.skipOuterExpressions(node.expression);
     if (ts.isIdentifier(tsInnerExpression)) {
-        if ((0, annotations_1.isVarargType)(context, tsInnerExpression)) {
-            context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.Vararg));
-        }
         const symbol = context.checker.getSymbolAtLocation(tsInnerExpression);
         if (symbol && isOptimizedVarArgSpread(context, symbol, tsInnerExpression)) {
             return lua.createDotsLiteral(node);

package/dist/transformation/visitors/switch.js

@@ -39,7 +39,7 @@ const coalesceCondition = (condition, conditionPrecedingStatements, switchVariab
     return [[...conditionPrecedingStatements, ...precedingStatements], comparison];
 };
 const transformSwitchStatement = (statement, context) => {
-    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Switch);
+    const scope = context.pushScope(scope_1.ScopeType.Switch);
     // Give the switch and condition accumulator a unique name to prevent nested switches from acting up.
     const switchName = `____switch${scope.id}`;
     const conditionName = `____cond${scope.id}`;
@@ -158,7 +158,7 @@ const transformSwitchStatement = (statement, context) => {
     if (hoistedIdentifiers.length > 0) {
         statements.unshift(lua.createVariableDeclarationStatement(hoistedIdentifiers));
     }
-    (0, scope_1.popScope)(context);
+    context.popScope();
     // Add the switch expression after hoisting
     const expression = context.transformExpression(statement.expression);
     statements.unshift(lua.createVariableDeclarationStatement(switchVariable, expression));

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

@@ -201,7 +201,7 @@ function transformVariableDeclaration(context, statement) {
         // Skip named function expressions because they will have been wrapped already
         if (ts.isFunctionExpression(initializer) && initializer.name)
             return false;
-        return (0, function_1.isFunctionTypeWithProperties)(context.checker.getTypeAtLocation(statement.name));
+        return (0, function_1.isFunctionTypeWithProperties)(context, context.checker.getTypeAtLocation(statement.name));
     }
 }
 exports.transformVariableDeclaration = transformVariableDeclaration;

package/dist/transpilation/plugins.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPlugins = void 0;
 const utils_1 = require("./utils");
+const performance = require("../measure-performance");
 function getPlugins(program) {
     var _a;
+    performance.startSection("getPlugins");
     const diagnostics = [];
     const pluginsFromOptions = [];
     const options = program.getCompilerOptions();
@@ -20,6 +22,7 @@ function getPlugins(program) {
     if (options.tstlVerbose) {
         console.log(`Loaded ${pluginsFromOptions.length} plugins`);
     }
+    performance.endSection("getPlugins");
     return { diagnostics, plugins: pluginsFromOptions };
 }
 exports.getPlugins = getPlugins;

package/dist/transpilation/resolve.js

@@ -21,223 +21,238 @@ class ResolutionContext {
         this.program = program;
         this.options = options;
         this.emitHost = emitHost;
-        this.resultsCache = new Map();
+        this.diagnostics = [];
+        this.resolvedFiles = new Map();
+        this.processedDependencies = new Set();
+        // value is false if already searched but not found
+        this.pathToFile = new Map();
         this.noResolvePaths = new Set(options.noResolvePaths);
     }
-    resolve(file, required) {
+    addAndResolveDependencies(file) {
+        if (this.resolvedFiles.has(file.fileName))
+            return;
+        this.resolvedFiles.set(file.fileName, file);
+        for (const required of findRequiredPaths(file.code)) {
+            // Do not resolve noResolution paths
+            if (required.startsWith("@NoResolution:")) {
+                // Remove @NoResolution prefix if not building in library mode
+                if (!isBuildModeLibrary(this.program)) {
+                    const path = required.replace("@NoResolution:", "");
+                    replaceRequireInCode(file, required, path);
+                    replaceRequireInSourceMap(file, required, path);
+                }
+                // Skip
+                continue;
+            }
+            // Try to resolve the import starting from the directory `file` is in
+            this.resolveImport(file, required);
+        }
+    }
+    resolveImport(file, required) {
+        // Do no resolve lualib - always use the lualib of the application entry point, not the lualib from external packages
+        if (required === "lualib_bundle") {
+            this.resolvedFiles.set("lualib_bundle", { fileName: "lualib_bundle", code: "" });
+            return;
+        }
         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: [] };
+            return;
         }
-        const resolvedDependency = resolveDependency(file, required, this.program, this.emitHost);
-        if (resolvedDependency) {
-            if (this.options.tstlVerbose) {
-                console.log(`Resolved ${required} to ${(0, utils_1.normalizeSlashes)(resolvedDependency)}`);
-            }
-            // Figure out resolved require path and dependency output path
-            const resolvedRequire = (0, transpiler_1.getEmitPathRelativeToOutDir)(resolvedDependency, this.program);
-            if (shouldRewriteRequires(resolvedDependency, this.program)) {
-                replaceRequireInCode(file, required, resolvedRequire);
-                replaceRequireInSourceMap(file, required, resolvedRequire);
-            }
-            // 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 ${(0, utils_1.normalizeSlashes)(resolvedDependency)}`);
-                }
-                return this.resultsCache.get(resolvedDependency);
-            }
-            // If dependency is not part of project, add dependency to output and resolve its dependencies recursively
-            if (shouldIncludeDependency(resolvedDependency, this.program)) {
-                // If dependency resolved successfully, read its content
-                const dependencyContent = this.emitHost.readFile(resolvedDependency);
-                if (dependencyContent === undefined) {
-                    return { resolvedFiles: [], diagnostics: [(0, diagnostics_1.couldNotReadDependency)(resolvedDependency)] };
-                }
-                const dependency = {
-                    fileName: resolvedDependency,
-                    code: dependencyContent,
-                };
-                const nestedDependencies = resolveFileDependencies(dependency, this);
-                // Cache result and return
-                const result = {
-                    resolvedFiles: [dependency, ...nestedDependencies.resolvedFiles],
-                    diagnostics: [...nestedDependencies.diagnostics],
-                };
-                this.resultsCache.set(resolvedDependency, result);
-                return result;
-            }
-            else {
-                const result = {
-                    resolvedFiles: [],
-                    diagnostics: [],
-                };
-                this.resultsCache.set(resolvedDependency, result);
-                return result;
-            }
+        const dependencyPath = this.resolveDependencyPath(file, required);
+        if (!dependencyPath)
+            return this.couldNotResolveImport(required, file);
+        if (this.options.tstlVerbose) {
+            console.log(`Resolved ${required} to ${(0, utils_1.normalizeSlashes)(dependencyPath)}`);
         }
-        else {
-            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: [
-                    (0, diagnostics_1.couldNotResolveRequire)(required, path.relative((0, transpiler_1.getProjectRoot)(this.program), file.fileName)),
-                ],
-            };
+        this.processDependency(dependencyPath);
+        // Figure out resolved require path and dependency output path
+        if (shouldRewriteRequires(dependencyPath, this.program)) {
+            const resolvedRequire = (0, transpiler_1.getEmitPathRelativeToOutDir)(dependencyPath, this.program);
+            replaceRequireInCode(file, required, resolvedRequire);
+            replaceRequireInSourceMap(file, required, resolvedRequire);
         }
     }
-}
-function resolveDependencies(program, files, emitHost) {
-    const outFiles = [...files];
-    const diagnostics = [];
-    const options = program.getCompilerOptions();
-    const resolutionContext = new ResolutionContext(program, options, emitHost);
-    // Resolve dependencies for all processed files
-    for (const file of files) {
-        if (options.tstlVerbose) {
-            console.log(`Resolving dependencies for ${(0, utils_1.normalizeSlashes)(file.fileName)}`);
+    processDependency(dependencyPath) {
+        if (this.processedDependencies.has(dependencyPath))
+            return;
+        this.processedDependencies.add(dependencyPath);
+        if (!shouldIncludeDependency(dependencyPath, this.program))
+            return;
+        // If dependency is not part of project, add dependency to output and resolve its dependencies recursively
+        const dependencyContent = this.emitHost.readFile(dependencyPath);
+        if (dependencyContent === undefined) {
+            this.diagnostics.push((0, diagnostics_1.couldNotReadDependency)(dependencyPath));
+            return;
         }
-        const resolutionResult = resolveFileDependencies(file, resolutionContext);
-        outFiles.push(...resolutionResult.resolvedFiles);
-        diagnostics.push(...resolutionResult.diagnostics);
+        const dependency = {
+            fileName: dependencyPath,
+            code: dependencyContent,
+        };
+        this.addAndResolveDependencies(dependency);
     }
-    return { resolvedFiles: deduplicateResolvedFiles(outFiles), diagnostics };
-}
-exports.resolveDependencies = resolveDependencies;
-function deduplicateResolvedFiles(files) {
-    return [...new Map(files.map(f => [f.fileName, f])).values()];
-}
-function resolveFileDependencies(file, context) {
-    const dependencies = [];
-    const diagnostics = [];
-    for (const required of findRequiredPaths(file.code)) {
-        // 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;
+    couldNotResolveImport(required, file) {
+        const fallbackRequire = fallbackResolve(required, (0, transpiler_1.getSourceDir)(this.program), path.dirname(file.fileName));
+        replaceRequireInCode(file, required, fallbackRequire);
+        replaceRequireInSourceMap(file, required, fallbackRequire);
+        this.diagnostics.push((0, diagnostics_1.couldNotResolveRequire)(required, path.relative((0, transpiler_1.getProjectRoot)(this.program), file.fileName)));
+    }
+    resolveDependencyPath(requiringFile, dependency) {
+        var _a;
+        const fileDirectory = path.dirname(requiringFile.fileName);
+        if (this.options.tstlVerbose) {
+            console.log(`Resolving "${dependency}" from ${(0, utils_1.normalizeSlashes)(requiringFile.fileName)}`);
         }
-        // Do not resolve noResolution paths
-        if (required.startsWith("@NoResolution:")) {
-            // Remove @NoResolution prefix if not building in library mode
-            if (!isBuildModeLibrary(context.program)) {
-                const path = required.replace("@NoResolution:", "");
-                replaceRequireInCode(file, required, path);
-                replaceRequireInSourceMap(file, required, path);
-            }
-            // Skip
-            continue;
+        const requiredFromLuaFile = requiringFile.fileName.endsWith(".lua");
+        const dependencyPath = requiredFromLuaFile ? luaRequireToPath(dependency) : dependency;
+        if (requiredFromLuaFile && isNodeModulesFile(requiringFile.fileName)) {
+            // If requiring file is in lua module, try to resolve sibling in that file first
+            const resolvedNodeModulesFile = this.resolveLuaDependencyPathFromNodeModules(requiringFile, dependencyPath);
+            if (resolvedNodeModulesFile)
+                return resolvedNodeModulesFile;
         }
-        // Try to resolve the import starting from the directory `file` is in
-        const resolvedDependency = context.resolve(file, required);
-        dependencies.push(...resolvedDependency.resolvedFiles);
-        diagnostics.push(...resolvedDependency.diagnostics);
-    }
-    return { resolvedFiles: deduplicateResolvedFiles(dependencies), diagnostics };
-}
-function resolveDependency(requiringFile, dependency, program, emitHost) {
-    var _a;
-    const options = program.getCompilerOptions();
-    const fileDirectory = path.dirname(requiringFile.fileName);
-    if (options.tstlVerbose) {
-        console.log(`Resolving "${dependency}" from ${(0, utils_1.normalizeSlashes)(requiringFile.fileName)}`);
-    }
-    // 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(relativeTo, dependency);
-    const possibleProjectFiles = [
-        resolvedPath,
-        resolvedPath + ".ts",
-        path.join(resolvedPath, "index.ts"),
-        resolvedPath + ".tsx",
-        path.join(resolvedPath, "index.tsx"), // tsx index
-    ];
-    for (const possibleFile of possibleProjectFiles) {
-        if (isProjectFile(possibleFile, program)) {
-            return possibleFile;
+        // 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 = this.options.baseUrl) !== null && _a !== void 0 ? _a : fileDirectory;
+        // Check if file is a file in the project
+        const resolvedPath = path.join(relativeTo, dependencyPath);
+        const fileFromPath = this.getFileFromPath(resolvedPath);
+        if (fileFromPath)
+            return fileFromPath;
+        if (this.options.paths && this.options.baseUrl) {
+            // If no file found yet and paths are present, try to find project file via paths mappings
+            const fileFromPaths = this.tryGetModuleNameFromPaths(dependencyPath, this.options.paths, this.options.baseUrl);
+            if (fileFromPaths)
+                return fileFromPaths;
         }
-    }
-    // Check if this is a lua file in the project sources
-    const possibleLuaProjectFiles = [
-        resolvedPath + ".lua",
-        path.join(resolvedPath, "index.lua"),
-        path.join(resolvedPath, "init.lua"), // lua looks for <require>/init.lua if it cannot find <require>.lua
-    ];
-    for (const possibleFile of possibleLuaProjectFiles) {
-        if (emitHost.fileExists(possibleFile)) {
-            return possibleFile;
+        // Not a TS file in our project sources, use resolver to check if we can find dependency
+        try {
+            const resolveResult = resolver.resolveSync({}, fileDirectory, dependencyPath);
+            if (resolveResult)
+                return resolveResult;
         }
-    }
-    // Check if this is a sibling of a required lua file
-    if (requiringFile.fileName.endsWith(".lua")) {
-        const luaFilePath = resolveLuaPath(fileDirectory, dependency, emitHost);
-        if (luaFilePath) {
-            return luaFilePath;
+        catch (e) {
+            // resolveSync errors if it fails to resolve
         }
+        return undefined;
     }
-    // Not a TS file in our project sources, use resolver to check if we can find dependency
-    try {
-        const resolveResult = resolver.resolveSync({}, fileDirectory, dependency);
-        if (resolveResult) {
-            return resolveResult;
+    resolveLuaDependencyPathFromNodeModules(requiringFile, dependency) {
+        // We don't know for sure where the lua root is, so guess it is at package root
+        const splitPath = path.normalize(requiringFile.fileName).split(path.sep);
+        let packageRootIndex = splitPath.lastIndexOf("node_modules") + 2;
+        let packageRoot = splitPath.slice(0, packageRootIndex).join(path.sep);
+        while (packageRootIndex < splitPath.length) {
+            // Try to find lua file relative to currently guessed Lua root
+            const resolvedPath = path.join(packageRoot, dependency);
+            const fileFromPath = this.getFileFromPath(resolvedPath);
+            if (fileFromPath) {
+                return fileFromPath;
+            }
+            else {
+                // Did not find file at current root, try again one directory deeper
+                packageRoot = path.join(packageRoot, splitPath[packageRootIndex++]);
+            }
         }
+        return undefined;
     }
-    catch (e) {
-        // resolveSync errors if it fails to resolve
+    getFileFromPath(resolvedPath) {
+        const existingFile = this.pathToFile.get(resolvedPath);
+        if (existingFile)
+            return existingFile;
+        if (existingFile === false)
+            return undefined;
+        const file = this.searchForFileFromPath(resolvedPath);
+        this.pathToFile.set(resolvedPath, file !== null && file !== void 0 ? file : false);
+        return file;
     }
-    return undefined;
-}
-function resolveLuaPath(fromPath, dependency, emitHost) {
-    const splitDependency = dependency.split(".");
-    if (splitDependency.length === 1) {
-        // If dependency has just one part (the file), look for a lua file with that name
-        const fileDirectory = walkUpFileTreeUntil(fromPath, dir => emitHost.fileExists(path.join(dir, dependency) + ".lua"));
-        if (fileDirectory) {
-            return path.join(fileDirectory, dependency) + ".lua";
+    searchForFileFromPath(resolvedPath) {
+        const possibleProjectFiles = [
+            resolvedPath,
+            resolvedPath + ".ts",
+            path.join(resolvedPath, "index.ts"),
+            resolvedPath + ".tsx",
+            path.join(resolvedPath, "index.tsx"), // tsx index
+        ];
+        for (const possibleFile of possibleProjectFiles) {
+            if (isProjectFile(possibleFile, this.program)) {
+                return possibleFile;
+            }
+        }
+        // Check if this is a lua file in the project sources
+        const possibleLuaProjectFiles = [
+            resolvedPath + ".lua",
+            path.join(resolvedPath, "index.lua"),
+            path.join(resolvedPath, "init.lua"), // lua looks for <require>/init.lua if it cannot find <require>.lua
+        ];
+        for (const possibleFile of possibleLuaProjectFiles) {
+            if (this.emitHost.fileExists(possibleFile)) {
+                return possibleFile;
+            }
         }
     }
-    else {
-        // If dependency has multiple parts, look for the first directory of the require path, which must be in the lua root
-        const luaRoot = walkUpFileTreeUntil(fromPath, dir => emitHost.directoryExists(path.join(dir, splitDependency[0])));
-        if (luaRoot) {
-            return path.join(luaRoot, dependency.replace(/\./g, path.sep)) + ".lua";
+    // Taken from TS and modified: https://github.com/microsoft/TypeScript/blob/88a1e3a1dd8d2d86e844ff1c16d5f041cebcfdb9/src/compiler/moduleSpecifiers.ts#L562
+    tryGetModuleNameFromPaths(relativeToBaseUrl, paths, baseUrl) {
+        const relativeImport = removeTrailingDirectorySeparator((0, utils_1.normalizeSlashes)(relativeToBaseUrl));
+        for (const [importPattern, targetPatterns] of Object.entries(paths)) {
+            const pattern = removeFileExtension((0, utils_1.normalizeSlashes)(importPattern));
+            const indexOfStar = pattern.indexOf("*");
+            if (indexOfStar !== -1) {
+                // Try to match <prefix>*<suffix> to relativeImport
+                const prefix = pattern.substring(0, indexOfStar);
+                const suffix = pattern.substring(indexOfStar + 1);
+                if ((relativeImport.length >= prefix.length + suffix.length &&
+                    relativeImport.startsWith(prefix) &&
+                    relativeImport.endsWith(suffix)) ||
+                    (!suffix && relativeImport === removeTrailingDirectorySeparator(prefix))) {
+                    // If import matches <prefix>*<suffix>, extract the matched * path
+                    const matchedStar = relativeImport.substring(prefix.length, relativeImport.length - suffix.length);
+                    // Try to resolve to the target patterns with filled in * pattern
+                    for (const target of targetPatterns) {
+                        const file = this.getFileFromPath(path.join(baseUrl, target.replace("*", matchedStar)));
+                        if (file)
+                            return file;
+                    }
+                }
+            }
+            else if (pattern === relativeImport) {
+                // If there is no * pattern, check for exact matches and try those targets
+                for (const target of targetPatterns) {
+                    const file = this.getFileFromPath(path.join(baseUrl, target));
+                    if (file)
+                        return file;
+                }
+            }
         }
     }
 }
-function walkUpFileTreeUntil(fromDirectory, predicate) {
-    const currentDir = path.normalize(fromDirectory).split(path.sep);
-    while (currentDir.length > 0) {
-        const dir = currentDir.join(path.sep);
-        if (predicate(dir)) {
-            return dir;
+function resolveDependencies(program, files, emitHost) {
+    const options = program.getCompilerOptions();
+    const resolutionContext = new ResolutionContext(program, options, emitHost);
+    // Resolve dependencies for all processed files
+    for (const file of files) {
+        if (options.tstlVerbose) {
+            console.log(`Resolving dependencies for ${(0, utils_1.normalizeSlashes)(file.fileName)}`);
         }
-        currentDir.pop();
+        resolutionContext.addAndResolveDependencies(file);
     }
-    return undefined;
+    return { resolvedFiles: [...resolutionContext.resolvedFiles.values()], diagnostics: resolutionContext.diagnostics };
 }
+exports.resolveDependencies = resolveDependencies;
 function shouldRewriteRequires(resolvedDependency, program) {
-    return !isNodeModulesFile(resolvedDependency) || !isBuildModeLibrary(program);
+    return !isBuildModeLibrary(program) || !isNodeModulesFile(resolvedDependency);
 }
 function shouldIncludeDependency(resolvedDependency, program) {
     // Never include lua files (again) that are transpiled from project sources
-    if (!hasSourceFileInProject(resolvedDependency, program)) {
-        // Always include lua files not in node_modules (internal lua sources)
-        if (!isNodeModulesFile(resolvedDependency)) {
-            return true;
-        }
-        else {
-            // Only include node_modules files if not in library mode
-            return !isBuildModeLibrary(program);
-        }
-    }
-    return false;
+    if (hasSourceFileInProject(resolvedDependency, program))
+        return false;
+    // Always include lua files not in node_modules (internal lua sources)
+    if (!isNodeModulesFile(resolvedDependency))
+        return true;
+    // Only include node_modules files if not in library mode
+    return !isBuildModeLibrary(program);
 }
 function isBuildModeLibrary(program) {
     return program.getCompilerOptions().buildMode === CompilerOptions_1.BuildMode.Library;
@@ -245,7 +260,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))) {
@@ -257,7 +272,7 @@ function replaceRequireInCode(file, originalRequire, newRequire) {
     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}")`);
+    file.code = file.code.replace(new RegExp(`(^|\\s|;|=|\\()require\\("${escapedRequire}"\\)`), `$1require("${requirePath}")`);
 }
 function replaceRequireInSourceMap(file, originalRequire, newRequire) {
     const requirePath = (0, utils_1.formatPathToLuaPath)(newRequire.replace(".lua", ""));
@@ -302,4 +317,13 @@ function fallbackResolve(required, sourceRootDir, fileDir) {
         .filter(s => s !== "." && s !== "..")
         .join(path.sep));
 }
+function luaRequireToPath(requirePath) {
+    return requirePath.replace(/\./g, path.sep);
+}
+function removeFileExtension(path) {
+    return path.includes(".") ? (0, utils_1.trimExtension)(path) : path;
+}
+function removeTrailingDirectorySeparator(path) {
+    return path.endsWith("/") || path.endsWith("\\") ? path.substring(0, -1) : path;
+}
 //# sourceMappingURL=resolve.js.map