typescript-to-lua 1.6.2 → 1.7.1

package/dist/transpilation/resolve.js

@@ -21,79 +21,154 @@ 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;
+        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)}`);
+        }
+        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);
+        }
+    }
+    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 dependency = {
+            fileName: dependencyPath,
+            code: dependencyContent,
+        };
+        this.addAndResolveDependencies(dependency);
+    }
+    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)}`);
+        }
+        // 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, dependency);
+        const fileFromPath = this.getFileFromPath(resolvedPath);
+        if (fileFromPath)
+            return fileFromPath;
+        // Check if this is a sibling of a required lua file
+        if (requiringFile.fileName.endsWith(".lua")) {
+            const luaFilePath = resolveLuaPath(fileDirectory, dependency, this.emitHost);
+            if (luaFilePath) {
+                return luaFilePath;
             }
-            else {
-                const result = {
-                    resolvedFiles: [],
-                    diagnostics: [],
-                };
-                this.resultsCache.set(resolvedDependency, result);
-                return result;
+        }
+        // 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;
+        }
+        catch (e) {
+            // resolveSync errors if it fails to resolve
+        }
+        return undefined;
+    }
+    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;
+    }
+    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;
             }
         }
-        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)),
-                ],
-            };
+        // 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;
+            }
         }
     }
 }
 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
@@ -101,99 +176,11 @@ function resolveDependencies(program, files, emitHost) {
         if (options.tstlVerbose) {
             console.log(`Resolving dependencies for ${(0, utils_1.normalizeSlashes)(file.fileName)}`);
         }
-        const resolutionResult = resolveFileDependencies(file, resolutionContext);
-        outFiles.push(...resolutionResult.resolvedFiles);
-        diagnostics.push(...resolutionResult.diagnostics);
+        resolutionContext.addAndResolveDependencies(file);
     }
-    return { resolvedFiles: deduplicateResolvedFiles(outFiles), diagnostics };
+    return { resolvedFiles: [...resolutionContext.resolvedFiles.values()], diagnostics: resolutionContext.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;
-        }
-        // 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;
-        }
-        // 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 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;
-        }
-    }
-    // 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;
-        }
-    }
-    // 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;
-        }
-    }
-    catch (e) {
-        // resolveSync errors if it fails to resolve
-    }
-    return undefined;
-}
 function resolveLuaPath(fromPath, dependency, emitHost) {
     const splitDependency = dependency.split(".");
     if (splitDependency.length === 1) {
@@ -223,21 +210,17 @@ function walkUpFileTreeUntil(fromDirectory, predicate) {
     return undefined;
 }
 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;

package/dist/transpilation/transpile.js

@@ -8,8 +8,10 @@ const LuaPrinter_1 = require("../LuaPrinter");
 const transformation_1 = require("../transformation");
 const utils_1 = require("../utils");
 const transformers_1 = require("./transformers");
+const performance = require("../measure-performance");
 function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceFiles: targetSourceFiles, customTransformers = {}, plugins = [] }) {
     var _a, _b;
+    performance.startSection("beforeTransform");
     const options = program.getCompilerOptions();
     if (options.tstlVerbose) {
         console.log("Parsing project settings");
@@ -36,6 +38,7 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
             preEmitDiagnostics.push(...program.getDeclarationDiagnostics());
         }
         if (preEmitDiagnostics.length > 0) {
+            performance.endSection("beforeTransform");
             return { diagnostics: preEmitDiagnostics, transpiledFiles };
         }
     }
@@ -51,9 +54,12 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
         if (options.tstlVerbose) {
             console.log(`Transforming ${sourceFile.fileName}`);
         }
+        performance.startSection("transpile");
         const { file, diagnostics: transformDiagnostics } = (0, transformation_1.transformSourceFile)(program, sourceFile, visitorMap);
         diagnostics.push(...transformDiagnostics);
+        performance.endSection("transpile");
         if (!options.noEmit && !options.emitDeclarationOnly) {
+            performance.startSection("print");
             if (options.tstlVerbose) {
                 console.log(`Printing ${sourceFile.fileName}`);
             }
@@ -64,6 +70,7 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
                 luaAst: file,
                 ...printResult,
             });
+            performance.endSection("print");
         }
     };
     const transformers = (0, transformers_1.getTransformers)(program, diagnostics, customTransformers, processSourceFile);
@@ -78,6 +85,7 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
             writeFileResult(fileName, ...rest);
         }
     };
+    performance.endSection("beforeTransform");
     if (targetSourceFiles) {
         for (const file of targetSourceFiles) {
             if (isEmittableJsonFile(file)) {
@@ -93,6 +101,7 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
         // JSON files don't get through transformers and aren't written when outDir is the same as rootDir
         program.getSourceFiles().filter(isEmittableJsonFile).forEach(processSourceFile);
     }
+    performance.startSection("afterPrint");
     options.noEmit = oldNoEmit;
     if (options.noEmit || (options.noEmitOnError && diagnostics.length > 0)) {
         transpiledFiles = [];
@@ -103,6 +112,7 @@ function getProgramTranspileResult(emitHost, writeFileResult, { program, sourceF
             diagnostics.push(...pluginDiagnostics);
         }
     }
+    performance.endSection("afterPrint");
     return { diagnostics, transpiledFiles };
 }
 exports.getProgramTranspileResult = getProgramTranspileResult;

package/dist/transpilation/transpiler.d.ts

@@ -15,6 +15,7 @@ export declare class Transpiler {
     protected emitHost: EmitHost;
     constructor({ emitHost }?: TranspilerOptions);
     emit(emitOptions: EmitOptions): EmitResult;
+    private emitFiles;
     protected getEmitPlan(program: ts.Program, diagnostics: ts.Diagnostic[], files: ProcessedFile[]): {
         emitPlan: EmitFile[];
     };

package/dist/transpilation/transpiler.js

@@ -10,24 +10,34 @@ const bundle_1 = require("./bundle");
 const plugins_1 = require("./plugins");
 const resolve_1 = require("./resolve");
 const transpile_1 = require("./transpile");
+const performance = require("../measure-performance");
 class Transpiler {
     constructor({ emitHost = ts.sys } = {}) {
         this.emitHost = emitHost;
     }
     emit(emitOptions) {
-        var _a, _b;
         const { program, writeFile = this.emitHost.writeFile, plugins: optionsPlugins = [] } = emitOptions;
-        const options = program.getCompilerOptions();
         const { diagnostics: getPluginsDiagnostics, plugins: configPlugins } = (0, plugins_1.getPlugins)(program);
         const plugins = [...optionsPlugins, ...configPlugins];
-        const { diagnostics, transpiledFiles: freshFiles } = (0, transpile_1.getProgramTranspileResult)(this.emitHost, writeFile, {
+        const { diagnostics: transpileDiagnostics, transpiledFiles: freshFiles } = (0, transpile_1.getProgramTranspileResult)(this.emitHost, writeFile, {
             ...emitOptions,
             plugins,
         });
-        const { emitPlan } = this.getEmitPlan(program, diagnostics, freshFiles);
+        const { emitPlan } = this.getEmitPlan(program, transpileDiagnostics, freshFiles);
+        const emitDiagnostics = this.emitFiles(program, plugins, emitPlan, writeFile);
+        return {
+            diagnostics: getPluginsDiagnostics.concat(transpileDiagnostics, emitDiagnostics),
+            emitSkipped: emitPlan.length === 0,
+        };
+    }
+    emitFiles(program, plugins, emitPlan, writeFile) {
+        var _a, _b;
+        performance.startSection("emit");
+        const options = program.getCompilerOptions();
         if (options.tstlVerbose) {
             console.log("Emitting output");
         }
+        const diagnostics = [];
         for (const plugin of plugins) {
             if (plugin.beforeEmit) {
                 const beforeEmitPluginDiagnostics = (_a = plugin.beforeEmit(program, options, this.emitHost, emitPlan)) !== null && _a !== void 0 ? _a : [];
@@ -47,9 +57,11 @@ class Transpiler {
         if (options.tstlVerbose) {
             console.log("Emit finished!");
         }
-        return { diagnostics: getPluginsDiagnostics.concat(diagnostics), emitSkipped: emitPlan.length === 0 };
+        performance.endSection("emit");
+        return diagnostics;
     }
     getEmitPlan(program, diagnostics, files) {
+        performance.startSection("getEmitPlan");
         const options = program.getCompilerOptions();
         if (options.tstlVerbose) {
             console.log("Constructing emit plan");
@@ -80,6 +92,7 @@ class Transpiler {
                 outputPath: getEmitPath(file.fileName, program),
             }));
         }
+        performance.endSection("getEmitPlan");
         return { emitPlan };
     }
 }

package/dist/tstl.js

@@ -9,6 +9,7 @@ const parse_1 = require("./cli/parse");
 const report_1 = require("./cli/report");
 const tsconfig_1 = require("./cli/tsconfig");
 const CompilerOptions_1 = require("./CompilerOptions");
+const performance = require("./measure-performance");
 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 = (0, report_1.createDiagnosticReporter)(false);
 function updateReportDiagnostic(options) {
@@ -75,18 +76,22 @@ function performBuild(_args) {
     return ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
 }
 function performCompilation(rootNames, projectReferences, options, configFileParsingDiagnostics) {
+    if (options.measurePerformance)
+        performance.enableMeasurement();
+    performance.startSection("createProgram");
     const program = ts.createProgram({
         rootNames,
         options,
         projectReferences,
         configFileParsingDiagnostics,
     });
+    const preEmitDiagnostics = ts.getPreEmitDiagnostics(program);
+    performance.endSection("createProgram");
     const { diagnostics: transpileDiagnostics, emitSkipped } = new tstl.Transpiler().emit({ program });
-    const diagnostics = ts.sortAndDeduplicateDiagnostics([
-        ...ts.getPreEmitDiagnostics(program),
-        ...transpileDiagnostics,
-    ]);
+    const diagnostics = ts.sortAndDeduplicateDiagnostics([...preEmitDiagnostics, ...transpileDiagnostics]);
     diagnostics.forEach(reportDiagnostic);
+    if (options.measurePerformance)
+        reportPerformance();
     const exitCode = diagnostics.filter(d => d.category === ts.DiagnosticCategory.Error).length === 0
         ? ts.ExitStatus.Success
         : emitSkipped
@@ -111,6 +116,8 @@ function updateWatchCompilationHost(host, optionsToExtend) {
     host.afterProgramCreate = builderProgram => {
         const program = builderProgram.getProgram();
         const options = builderProgram.getCompilerOptions();
+        if (options.measurePerformance)
+            performance.enableMeasurement();
         const configFileParsingDiagnostics = updateConfigFile(options);
         let sourceFiles;
         if (!(0, CompilerOptions_1.isBundleEnabled)(options) && !hadErrorLastTime) {
@@ -137,11 +144,23 @@ function updateWatchCompilationHost(host, optionsToExtend) {
             ...emitDiagnostics,
         ]);
         diagnostics.forEach(reportDiagnostic);
+        if (options.measurePerformance)
+            reportPerformance();
         const errors = diagnostics.filter(d => d.category === ts.DiagnosticCategory.Error);
         hadErrorLastTime = errors.length > 0;
         host.onWatchStatusChange(cliDiagnostics.watchErrorSummary(errors.length), host.getNewLine(), options);
     };
 }
+function reportPerformance() {
+    if (performance.isMeasurementEnabled()) {
+        console.log("Performance measurements: ");
+        performance.forEachMeasure((name, duration) => {
+            console.log(`  ${name}: ${duration.toFixed(2)}ms`);
+        });
+        console.log(`Total: ${performance.getTotalDuration().toFixed(2)}ms`);
+        performance.disableMeasurement();
+    }
+}
 function checkNodeVersion() {
     const [major, minor] = process.version.slice(1).split(".").map(Number);
     const isValid = major > 12 || (major === 12 && minor >= 13);