@vortex-ai/cli 0.1.41 → 0.1.45

package/dist/index.mjs

@@ -2260,7 +2260,7 @@ var require_typescript = __commonJS({
         usingSingleLineStringWriter: () => usingSingleLineStringWriter,
         utf16EncodeAsString: () => utf16EncodeAsString,
         validateLocaleAndSetLanguage: () => validateLocaleAndSetLanguage,
-        version: () => version,
+        version: () => version2,
         versionMajorMinor: () => versionMajorMinor,
         visitArray: () => visitArray,
         visitCommaListElements: () => visitCommaListElements,
@@ -2284,7 +2284,7 @@ var require_typescript = __commonJS({
       });
       module2.exports = __toCommonJS(typescript_exports);
       var versionMajorMinor = "5.9";
-      var version = "5.9.2";
+      var version2 = "5.9.2";
       var Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -3668,10 +3668,10 @@ var require_typescript = __commonJS({
       function and(f, g) {
         return (arg) => f(arg) && g(arg);
       }
-      function or(...fs4) {
+      function or(...fs5) {
         return (...args) => {
           let lastResult;
-          for (const f of fs4) {
+          for (const f of fs5) {
             lastResult = f(...args);
             if (lastResult) {
               return lastResult;
@@ -4920,9 +4920,9 @@ ${lanes.join("\n")}
          * Tests whether a version matches the range. This is equivalent to `satisfies(version, range, { includePrerelease: true })`.
          * in `node-semver`.
          */
-        test(version2) {
-          if (typeof version2 === "string") version2 = new Version(version2);
-          return testDisjunction(version2, this._alternatives);
+        test(version22) {
+          if (typeof version22 === "string") version22 = new Version(version22);
+          return testDisjunction(version22, this._alternatives);
         }
         toString() {
           return formatDisjunction(this._alternatives);
@@ -4956,14 +4956,14 @@ ${lanes.join("\n")}
         const match = partialRegExp.exec(text);
         if (!match) return void 0;
         const [, major, minor = "*", patch = "*", prerelease, build2] = match;
-        const version2 = new Version(
+        const version22 = new Version(
           isWildcard(major) ? 0 : parseInt(major, 10),
           isWildcard(major) || isWildcard(minor) ? 0 : parseInt(minor, 10),
           isWildcard(major) || isWildcard(minor) || isWildcard(patch) ? 0 : parseInt(patch, 10),
           prerelease,
           build2
         );
-        return { version: version2, major, minor, patch };
+        return { version: version22, major, minor, patch };
       }
       function parseHyphen(left, right, comparators) {
         const leftResult = parsePartial(left);
@@ -4983,46 +4983,46 @@ ${lanes.join("\n")}
       function parseComparator(operator, text, comparators) {
         const result = parsePartial(text);
         if (!result) return false;
-        const { version: version2, major, minor, patch } = result;
+        const { version: version22, major, minor, patch } = result;
         if (!isWildcard(major)) {
           switch (operator) {
             case "~":
-              comparators.push(createComparator(">=", version2));
+              comparators.push(createComparator(">=", version22));
               comparators.push(createComparator(
                 "<",
-                version2.increment(
+                version22.increment(
                   isWildcard(minor) ? "major" : "minor"
                 )
               ));
               break;
             case "^":
-              comparators.push(createComparator(">=", version2));
+              comparators.push(createComparator(">=", version22));
               comparators.push(createComparator(
                 "<",
-                version2.increment(
-                  version2.major > 0 || isWildcard(minor) ? "major" : version2.minor > 0 || isWildcard(patch) ? "minor" : "patch"
+                version22.increment(
+                  version22.major > 0 || isWildcard(minor) ? "major" : version22.minor > 0 || isWildcard(patch) ? "minor" : "patch"
                 )
               ));
               break;
             case "<":
             case ">=":
               comparators.push(
-                isWildcard(minor) || isWildcard(patch) ? createComparator(operator, version2.with({ prerelease: "0" })) : createComparator(operator, version2)
+                isWildcard(minor) || isWildcard(patch) ? createComparator(operator, version22.with({ prerelease: "0" })) : createComparator(operator, version22)
               );
               break;
             case "<=":
             case ">":
               comparators.push(
-                isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version2.increment("major").with({ prerelease: "0" })) : isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version2.increment("minor").with({ prerelease: "0" })) : createComparator(operator, version2)
+                isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version22.increment("major").with({ prerelease: "0" })) : isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version22.increment("minor").with({ prerelease: "0" })) : createComparator(operator, version22)
               );
               break;
             case "=":
             case void 0:
               if (isWildcard(minor) || isWildcard(patch)) {
-                comparators.push(createComparator(">=", version2.with({ prerelease: "0" })));
-                comparators.push(createComparator("<", version2.increment(isWildcard(minor) ? "major" : "minor").with({ prerelease: "0" })));
+                comparators.push(createComparator(">=", version22.with({ prerelease: "0" })));
+                comparators.push(createComparator("<", version22.increment(isWildcard(minor) ? "major" : "minor").with({ prerelease: "0" })));
               } else {
-                comparators.push(createComparator("=", version2));
+                comparators.push(createComparator("=", version22));
               }
               break;
             default:
@@ -5039,21 +5039,21 @@ ${lanes.join("\n")}
       function createComparator(operator, operand) {
         return { operator, operand };
       }
-      function testDisjunction(version2, alternatives) {
+      function testDisjunction(version22, alternatives) {
         if (alternatives.length === 0) return true;
         for (const alternative of alternatives) {
-          if (testAlternative(version2, alternative)) return true;
+          if (testAlternative(version22, alternative)) return true;
         }
         return false;
       }
-      function testAlternative(version2, comparators) {
+      function testAlternative(version22, comparators) {
         for (const comparator of comparators) {
-          if (!testComparator(version2, comparator.operator, comparator.operand)) return false;
+          if (!testComparator(version22, comparator.operator, comparator.operand)) return false;
         }
         return true;
       }
-      function testComparator(version2, operator, operand) {
-        const cmp = version2.compareTo(operand);
+      function testComparator(version22, operator, operand) {
+        const cmp = version22.compareTo(operand);
         switch (operator) {
           case "<":
             return cmp < 0;
@@ -5246,7 +5246,7 @@ ${lanes.join("\n")}
       var tracing;
       var tracingEnabled;
       ((tracingEnabled2) => {
-        let fs4;
+        let fs5;
         let traceCount = 0;
         let traceFd = 0;
         let mode;
@@ -5255,9 +5255,9 @@ ${lanes.join("\n")}
         const legend = [];
         function startTracing2(tracingMode, traceDir, configFilePath) {
           Debug.assert(!tracing, "Tracing already started");
-          if (fs4 === void 0) {
+          if (fs5 === void 0) {
             try {
-              fs4 = __require("fs");
+              fs5 = __require("fs");
             } catch (e) {
               throw new Error(`tracing requires having fs
 (original error: ${e.message || e})`);
@@ -5268,8 +5268,8 @@ ${lanes.join("\n")}
           if (legendPath === void 0) {
             legendPath = combinePaths(traceDir, "legend.json");
           }
-          if (!fs4.existsSync(traceDir)) {
-            fs4.mkdirSync(traceDir, { recursive: true });
+          if (!fs5.existsSync(traceDir)) {
+            fs5.mkdirSync(traceDir, { recursive: true });
           }
           const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
           const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
@@ -5279,10 +5279,10 @@ ${lanes.join("\n")}
             tracePath,
             typesPath
           });
-          traceFd = fs4.openSync(tracePath, "w");
+          traceFd = fs5.openSync(tracePath, "w");
           tracing = tracingEnabled2;
           const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp(), pid: 1, tid: 1 };
-          fs4.writeSync(
+          fs5.writeSync(
             traceFd,
             "[\n" + [{ name: "process_name", args: { name: "tsc" }, ...meta }, { name: "thread_name", args: { name: "Main" }, ...meta }, { name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }].map((v) => JSON.stringify(v)).join(",\n")
           );
@@ -5291,10 +5291,10 @@ ${lanes.join("\n")}
         function stopTracing() {
           Debug.assert(tracing, "Tracing is not in progress");
           Debug.assert(!!typeCatalog.length === (mode !== "server"));
-          fs4.writeSync(traceFd, `
+          fs5.writeSync(traceFd, `
 ]
 `);
-          fs4.closeSync(traceFd);
+          fs5.closeSync(traceFd);
           tracing = void 0;
           if (typeCatalog.length) {
             dumpTypes(typeCatalog);
@@ -5366,11 +5366,11 @@ ${lanes.join("\n")}
         function writeEvent(eventType, phase, name, args, extras, time = 1e3 * timestamp()) {
           if (mode === "server" && phase === "checkTypes") return;
           mark("beginTracing");
-          fs4.writeSync(traceFd, `,
+          fs5.writeSync(traceFd, `,
 {"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time},"name":"${name}"`);
-          if (extras) fs4.writeSync(traceFd, `,${extras}`);
-          if (args) fs4.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
-          fs4.writeSync(traceFd, `}`);
+          if (extras) fs5.writeSync(traceFd, `,${extras}`);
+          if (args) fs5.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
+          fs5.writeSync(traceFd, `}`);
           mark("endTracing");
           measure("Tracing", "beginTracing", "endTracing");
         }
@@ -5392,9 +5392,9 @@ ${lanes.join("\n")}
           var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
           mark("beginDumpTypes");
           const typesPath = legend[legend.length - 1].typesPath;
-          const typesFd = fs4.openSync(typesPath, "w");
+          const typesFd = fs5.openSync(typesPath, "w");
           const recursionIdentityMap = /* @__PURE__ */ new Map();
-          fs4.writeSync(typesFd, "[");
+          fs5.writeSync(typesFd, "[");
           const numTypes = types.length;
           for (let i = 0; i < numTypes; i++) {
             const type = types[i];
@@ -5490,13 +5490,13 @@ ${lanes.join("\n")}
               flags: Debug.formatTypeFlags(type.flags).split("|"),
               display
             };
-            fs4.writeSync(typesFd, JSON.stringify(descriptor));
+            fs5.writeSync(typesFd, JSON.stringify(descriptor));
             if (i < numTypes - 1) {
-              fs4.writeSync(typesFd, ",\n");
+              fs5.writeSync(typesFd, ",\n");
             }
           }
-          fs4.writeSync(typesFd, "]\n");
-          fs4.closeSync(typesFd);
+          fs5.writeSync(typesFd, "]\n");
+          fs5.closeSync(typesFd);
           mark("endDumpTypes");
           measure("Dump types", "beginDumpTypes", "endDumpTypes");
         }
@@ -5504,7 +5504,7 @@ ${lanes.join("\n")}
           if (!legendPath) {
             return;
           }
-          fs4.writeFileSync(legendPath, JSON.stringify(legend));
+          fs5.writeFileSync(legendPath, JSON.stringify(legend));
         }
         tracingEnabled2.dumpLegend = dumpLegend;
       })(tracingEnabled || (tracingEnabled = {}));
@@ -7886,17 +7886,17 @@ ${lanes.join("\n")}
       }
       function createSingleWatcherPerName(cache, useCaseSensitiveFileNames2, name, callback, createWatcher) {
         const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
-        const path4 = toCanonicalFileName(name);
-        const existing = cache.get(path4);
+        const path5 = toCanonicalFileName(name);
+        const existing = cache.get(path5);
         if (existing) {
           existing.callbacks.push(callback);
         } else {
-          cache.set(path4, {
+          cache.set(path5, {
             watcher: createWatcher(
               // Cant infer types correctly so lets satisfy checker
               (param1, param2, param3) => {
                 var _a;
-                return (_a = cache.get(path4)) == null ? void 0 : _a.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
+                return (_a = cache.get(path5)) == null ? void 0 : _a.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
               }
             ),
             callbacks: [callback]
@@ -7904,10 +7904,10 @@ ${lanes.join("\n")}
         }
         return {
           close: () => {
-            const watcher = cache.get(path4);
+            const watcher = cache.get(path5);
             if (!watcher) return;
             if (!orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length) return;
-            cache.delete(path4);
+            cache.delete(path5);
             closeFileWatcherOf(watcher);
           }
         };
@@ -8159,13 +8159,13 @@ ${lanes.join("\n")}
             (newChildWatches || (newChildWatches = [])).push(childWatcher);
           }
         }
-        function isIgnoredPath(path4, options) {
-          return some(ignoredPaths, (searchPath) => isInPath(path4, searchPath)) || isIgnoredByWatchOptions(path4, options, useCaseSensitiveFileNames2, getCurrentDirectory);
+        function isIgnoredPath(path5, options) {
+          return some(ignoredPaths, (searchPath) => isInPath(path5, searchPath)) || isIgnoredByWatchOptions(path5, options, useCaseSensitiveFileNames2, getCurrentDirectory);
         }
-        function isInPath(path4, searchPath) {
-          if (path4.includes(searchPath)) return true;
+        function isInPath(path5, searchPath) {
+          if (path5.includes(searchPath)) return true;
           if (useCaseSensitiveFileNames2) return false;
-          return toCanonicalFilePath(path4).includes(searchPath);
+          return toCanonicalFilePath(path5).includes(searchPath);
         }
       }
       var FileSystemEntryKind = /* @__PURE__ */ ((FileSystemEntryKind2) => {
@@ -8543,8 +8543,8 @@ ${lanes.join("\n")}
       }
       function patchWriteFileEnsuringDirectory(sys2) {
         const originalWriteFile = sys2.writeFile;
-        sys2.writeFile = (path4, data, writeBom) => writeFileEnsuringDirectories(
-          path4,
+        sys2.writeFile = (path5, data, writeBom) => writeFileEnsuringDirectories(
+          path5,
           data,
           !!writeBom,
           (path22, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path22, data2, writeByteOrderMark),
@@ -8588,7 +8588,7 @@ ${lanes.join("\n")}
             // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
             // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
             fsSupportsRecursiveFsWatch,
-            getAccessibleSortedChildDirectories: (path4) => getAccessibleFileSystemEntries(path4).directories,
+            getAccessibleSortedChildDirectories: (path5) => getAccessibleFileSystemEntries(path5).directories,
             realpath,
             tscWatchFile: process.env.TSC_WATCHFILE,
             useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER,
@@ -8615,7 +8615,7 @@ ${lanes.join("\n")}
             watchFile: watchFile2,
             watchDirectory,
             preferNonRecursiveWatch: !fsSupportsRecursiveFsWatch,
-            resolvePath: (path4) => _path.resolve(path4),
+            resolvePath: (path5) => _path.resolve(path5),
             fileExists,
             directoryExists,
             getAccessibleFileSystemEntries,
@@ -8650,8 +8650,8 @@ ${lanes.join("\n")}
               }
               return process.memoryUsage().heapUsed;
             },
-            getFileSize(path4) {
-              const stat = statSync(path4);
+            getFileSize(path5) {
+              const stat = statSync(path5);
               if (stat == null ? void 0 : stat.isFile()) {
                 return stat.size;
               }
@@ -8695,14 +8695,14 @@ ${lanes.join("\n")}
             }
           };
           return nodeSystem;
-          function statSync(path4) {
+          function statSync(path5) {
             try {
-              return _fs.statSync(path4, statSyncOptions);
+              return _fs.statSync(path5, statSyncOptions);
             } catch {
               return void 0;
             }
           }
-          function enableCPUProfiler(path4, cb) {
+          function enableCPUProfiler(path5, cb) {
             if (activeSession) {
               cb();
               return false;
@@ -8717,7 +8717,7 @@ ${lanes.join("\n")}
             session.post("Profiler.enable", () => {
               session.post("Profiler.start", () => {
                 activeSession = session;
-                profilePath = path4;
+                profilePath = path5;
                 cb();
               });
             });
@@ -8861,9 +8861,9 @@ ${lanes.join("\n")}
               }
             }
           }
-          function getAccessibleFileSystemEntries(path4) {
+          function getAccessibleFileSystemEntries(path5) {
             try {
-              const entries = _fs.readdirSync(path4 || ".", { withFileTypes: true });
+              const entries = _fs.readdirSync(path5 || ".", { withFileTypes: true });
               const files = [];
               const directories = [];
               for (const dirent of entries) {
@@ -8873,7 +8873,7 @@ ${lanes.join("\n")}
                 }
                 let stat;
                 if (typeof dirent === "string" || dirent.isSymbolicLink()) {
-                  const name = combinePaths(path4, entry);
+                  const name = combinePaths(path5, entry);
                   stat = statSync(name);
                   if (!stat) {
                     continue;
@@ -8894,11 +8894,11 @@ ${lanes.join("\n")}
               return emptyFileSystemEntries;
             }
           }
-          function readDirectory(path4, extensions, excludes, includes, depth) {
-            return matchFiles(path4, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
+          function readDirectory(path5, extensions, excludes, includes, depth) {
+            return matchFiles(path5, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
-          function fileSystemEntryExists(path4, entryKind) {
-            const stat = statSync(path4);
+          function fileSystemEntryExists(path5, entryKind) {
+            const stat = statSync(path5);
             if (!stat) {
               return false;
             }
@@ -8911,47 +8911,47 @@ ${lanes.join("\n")}
                 return false;
             }
           }
-          function fileExists(path4) {
+          function fileExists(path5) {
             return fileSystemEntryExists(
-              path4,
+              path5,
               0
               /* File */
             );
           }
-          function directoryExists(path4) {
+          function directoryExists(path5) {
             return fileSystemEntryExists(
-              path4,
+              path5,
               1
               /* Directory */
             );
           }
-          function getDirectories(path4) {
-            return getAccessibleFileSystemEntries(path4).directories.slice();
+          function getDirectories(path5) {
+            return getAccessibleFileSystemEntries(path5).directories.slice();
           }
-          function fsRealPathHandlingLongPath(path4) {
-            return path4.length < 260 ? _fs.realpathSync.native(path4) : _fs.realpathSync(path4);
+          function fsRealPathHandlingLongPath(path5) {
+            return path5.length < 260 ? _fs.realpathSync.native(path5) : _fs.realpathSync(path5);
           }
-          function realpath(path4) {
+          function realpath(path5) {
             try {
-              return fsRealpath(path4);
+              return fsRealpath(path5);
             } catch {
-              return path4;
+              return path5;
             }
           }
-          function getModifiedTime3(path4) {
+          function getModifiedTime3(path5) {
             var _a;
-            return (_a = statSync(path4)) == null ? void 0 : _a.mtime;
+            return (_a = statSync(path5)) == null ? void 0 : _a.mtime;
           }
-          function setModifiedTime(path4, time) {
+          function setModifiedTime(path5, time) {
             try {
-              _fs.utimesSync(path4, time, time);
+              _fs.utimesSync(path5, time, time);
             } catch {
               return;
             }
           }
-          function deleteFile(path4) {
+          function deleteFile(path5) {
             try {
-              return _fs.unlinkSync(path4);
+              return _fs.unlinkSync(path5);
             } catch {
               return;
             }
@@ -8991,41 +8991,41 @@ ${lanes.join("\n")}
       function isAnyDirectorySeparator(charCode) {
         return charCode === 47 || charCode === 92;
       }
-      function isUrl(path4) {
-        return getEncodedRootLength(path4) < 0;
+      function isUrl(path5) {
+        return getEncodedRootLength(path5) < 0;
       }
-      function isRootedDiskPath(path4) {
-        return getEncodedRootLength(path4) > 0;
+      function isRootedDiskPath(path5) {
+        return getEncodedRootLength(path5) > 0;
       }
-      function isDiskPathRoot(path4) {
-        const rootLength = getEncodedRootLength(path4);
-        return rootLength > 0 && rootLength === path4.length;
+      function isDiskPathRoot(path5) {
+        const rootLength = getEncodedRootLength(path5);
+        return rootLength > 0 && rootLength === path5.length;
       }
-      function pathIsAbsolute(path4) {
-        return getEncodedRootLength(path4) !== 0;
+      function pathIsAbsolute(path5) {
+        return getEncodedRootLength(path5) !== 0;
       }
-      function pathIsRelative(path4) {
-        return /^\.\.?(?:$|[\\/])/.test(path4);
+      function pathIsRelative(path5) {
+        return /^\.\.?(?:$|[\\/])/.test(path5);
       }
-      function pathIsBareSpecifier(path4) {
-        return !pathIsAbsolute(path4) && !pathIsRelative(path4);
+      function pathIsBareSpecifier(path5) {
+        return !pathIsAbsolute(path5) && !pathIsRelative(path5);
       }
       function hasExtension(fileName) {
         return getBaseFileName(fileName).includes(".");
       }
-      function fileExtensionIs(path4, extension) {
-        return path4.length > extension.length && endsWith(path4, extension);
+      function fileExtensionIs(path5, extension) {
+        return path5.length > extension.length && endsWith(path5, extension);
       }
-      function fileExtensionIsOneOf(path4, extensions) {
+      function fileExtensionIsOneOf(path5, extensions) {
         for (const extension of extensions) {
-          if (fileExtensionIs(path4, extension)) {
+          if (fileExtensionIs(path5, extension)) {
             return true;
           }
         }
         return false;
       }
-      function hasTrailingDirectorySeparator(path4) {
-        return path4.length > 0 && isAnyDirectorySeparator(path4.charCodeAt(path4.length - 1));
+      function hasTrailingDirectorySeparator(path5) {
+        return path5.length > 0 && isAnyDirectorySeparator(path5.charCodeAt(path5.length - 1));
       }
       function isVolumeCharacter(charCode) {
         return charCode >= 97 && charCode <= 122 || charCode >= 65 && charCode <= 90;
@@ -9039,111 +9039,111 @@ ${lanes.join("\n")}
         }
         return -1;
       }
-      function getEncodedRootLength(path4) {
-        if (!path4) return 0;
-        const ch0 = path4.charCodeAt(0);
+      function getEncodedRootLength(path5) {
+        if (!path5) return 0;
+        const ch0 = path5.charCodeAt(0);
         if (ch0 === 47 || ch0 === 92) {
-          if (path4.charCodeAt(1) !== ch0) return 1;
-          const p1 = path4.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
-          if (p1 < 0) return path4.length;
+          if (path5.charCodeAt(1) !== ch0) return 1;
+          const p1 = path5.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
+          if (p1 < 0) return path5.length;
           return p1 + 1;
         }
-        if (isVolumeCharacter(ch0) && path4.charCodeAt(1) === 58) {
-          const ch2 = path4.charCodeAt(2);
+        if (isVolumeCharacter(ch0) && path5.charCodeAt(1) === 58) {
+          const ch2 = path5.charCodeAt(2);
           if (ch2 === 47 || ch2 === 92) return 3;
-          if (path4.length === 2) return 2;
+          if (path5.length === 2) return 2;
         }
-        const schemeEnd = path4.indexOf(urlSchemeSeparator);
+        const schemeEnd = path5.indexOf(urlSchemeSeparator);
         if (schemeEnd !== -1) {
           const authorityStart = schemeEnd + urlSchemeSeparator.length;
-          const authorityEnd = path4.indexOf(directorySeparator, authorityStart);
+          const authorityEnd = path5.indexOf(directorySeparator, authorityStart);
           if (authorityEnd !== -1) {
-            const scheme = path4.slice(0, schemeEnd);
-            const authority = path4.slice(authorityStart, authorityEnd);
-            if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path4.charCodeAt(authorityEnd + 1))) {
-              const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path4, authorityEnd + 2);
+            const scheme = path5.slice(0, schemeEnd);
+            const authority = path5.slice(authorityStart, authorityEnd);
+            if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path5.charCodeAt(authorityEnd + 1))) {
+              const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path5, authorityEnd + 2);
               if (volumeSeparatorEnd !== -1) {
-                if (path4.charCodeAt(volumeSeparatorEnd) === 47) {
+                if (path5.charCodeAt(volumeSeparatorEnd) === 47) {
                   return ~(volumeSeparatorEnd + 1);
                 }
-                if (volumeSeparatorEnd === path4.length) {
+                if (volumeSeparatorEnd === path5.length) {
                   return ~volumeSeparatorEnd;
                 }
               }
             }
             return ~(authorityEnd + 1);
           }
-          return ~path4.length;
+          return ~path5.length;
         }
         return 0;
       }
-      function getRootLength(path4) {
-        const rootLength = getEncodedRootLength(path4);
+      function getRootLength(path5) {
+        const rootLength = getEncodedRootLength(path5);
         return rootLength < 0 ? ~rootLength : rootLength;
       }
-      function getDirectoryPath(path4) {
-        path4 = normalizeSlashes(path4);
-        const rootLength = getRootLength(path4);
-        if (rootLength === path4.length) return path4;
-        path4 = removeTrailingDirectorySeparator(path4);
-        return path4.slice(0, Math.max(rootLength, path4.lastIndexOf(directorySeparator)));
-      }
-      function getBaseFileName(path4, extensions, ignoreCase) {
-        path4 = normalizeSlashes(path4);
-        const rootLength = getRootLength(path4);
-        if (rootLength === path4.length) return "";
-        path4 = removeTrailingDirectorySeparator(path4);
-        const name = path4.slice(Math.max(getRootLength(path4), path4.lastIndexOf(directorySeparator) + 1));
+      function getDirectoryPath(path5) {
+        path5 = normalizeSlashes(path5);
+        const rootLength = getRootLength(path5);
+        if (rootLength === path5.length) return path5;
+        path5 = removeTrailingDirectorySeparator(path5);
+        return path5.slice(0, Math.max(rootLength, path5.lastIndexOf(directorySeparator)));
+      }
+      function getBaseFileName(path5, extensions, ignoreCase) {
+        path5 = normalizeSlashes(path5);
+        const rootLength = getRootLength(path5);
+        if (rootLength === path5.length) return "";
+        path5 = removeTrailingDirectorySeparator(path5);
+        const name = path5.slice(Math.max(getRootLength(path5), path5.lastIndexOf(directorySeparator) + 1));
         const extension = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(name, extensions, ignoreCase) : void 0;
         return extension ? name.slice(0, name.length - extension.length) : name;
       }
-      function tryGetExtensionFromPath(path4, extension, stringEqualityComparer) {
+      function tryGetExtensionFromPath(path5, extension, stringEqualityComparer) {
         if (!startsWith(extension, ".")) extension = "." + extension;
-        if (path4.length >= extension.length && path4.charCodeAt(path4.length - extension.length) === 46) {
-          const pathExtension = path4.slice(path4.length - extension.length);
+        if (path5.length >= extension.length && path5.charCodeAt(path5.length - extension.length) === 46) {
+          const pathExtension = path5.slice(path5.length - extension.length);
           if (stringEqualityComparer(pathExtension, extension)) {
             return pathExtension;
           }
         }
       }
-      function getAnyExtensionFromPathWorker(path4, extensions, stringEqualityComparer) {
+      function getAnyExtensionFromPathWorker(path5, extensions, stringEqualityComparer) {
         if (typeof extensions === "string") {
-          return tryGetExtensionFromPath(path4, extensions, stringEqualityComparer) || "";
+          return tryGetExtensionFromPath(path5, extensions, stringEqualityComparer) || "";
         }
         for (const extension of extensions) {
-          const result = tryGetExtensionFromPath(path4, extension, stringEqualityComparer);
+          const result = tryGetExtensionFromPath(path5, extension, stringEqualityComparer);
           if (result) return result;
         }
         return "";
       }
-      function getAnyExtensionFromPath(path4, extensions, ignoreCase) {
+      function getAnyExtensionFromPath(path5, extensions, ignoreCase) {
         if (extensions) {
-          return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path4), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
+          return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path5), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
         }
-        const baseFileName = getBaseFileName(path4);
+        const baseFileName = getBaseFileName(path5);
         const extensionIndex = baseFileName.lastIndexOf(".");
         if (extensionIndex >= 0) {
           return baseFileName.substring(extensionIndex);
         }
         return "";
       }
-      function pathComponents(path4, rootLength) {
-        const root = path4.substring(0, rootLength);
-        const rest = path4.substring(rootLength).split(directorySeparator);
+      function pathComponents(path5, rootLength) {
+        const root = path5.substring(0, rootLength);
+        const rest = path5.substring(rootLength).split(directorySeparator);
         if (rest.length && !lastOrUndefined(rest)) rest.pop();
         return [root, ...rest];
       }
-      function getPathComponents(path4, currentDirectory = "") {
-        path4 = combinePaths(currentDirectory, path4);
-        return pathComponents(path4, getRootLength(path4));
+      function getPathComponents(path5, currentDirectory = "") {
+        path5 = combinePaths(currentDirectory, path5);
+        return pathComponents(path5, getRootLength(path5));
       }
       function getPathFromPathComponents(pathComponents2, length2) {
         if (pathComponents2.length === 0) return "";
         const root = pathComponents2[0] && ensureTrailingDirectorySeparator(pathComponents2[0]);
         return root + pathComponents2.slice(1, length2).join(directorySeparator);
       }
-      function normalizeSlashes(path4) {
-        return path4.includes("\\") ? path4.replace(backslashRegExp, directorySeparator) : path4;
+      function normalizeSlashes(path5) {
+        return path5.includes("\\") ? path5.replace(backslashRegExp, directorySeparator) : path5;
       }
       function reducePathComponents(components) {
         if (!some(components)) return [];
@@ -9164,39 +9164,39 @@ ${lanes.join("\n")}
         }
         return reduced;
       }
-      function combinePaths(path4, ...paths) {
-        if (path4) path4 = normalizeSlashes(path4);
+      function combinePaths(path5, ...paths) {
+        if (path5) path5 = normalizeSlashes(path5);
         for (let relativePath of paths) {
           if (!relativePath) continue;
           relativePath = normalizeSlashes(relativePath);
-          if (!path4 || getRootLength(relativePath) !== 0) {
-            path4 = relativePath;
+          if (!path5 || getRootLength(relativePath) !== 0) {
+            path5 = relativePath;
           } else {
-            path4 = ensureTrailingDirectorySeparator(path4) + relativePath;
+            path5 = ensureTrailingDirectorySeparator(path5) + relativePath;
           }
         }
-        return path4;
+        return path5;
       }
-      function resolvePath(path4, ...paths) {
-        return normalizePath(some(paths) ? combinePaths(path4, ...paths) : normalizeSlashes(path4));
+      function resolvePath(path5, ...paths) {
+        return normalizePath(some(paths) ? combinePaths(path5, ...paths) : normalizeSlashes(path5));
       }
-      function getNormalizedPathComponents(path4, currentDirectory) {
-        return reducePathComponents(getPathComponents(path4, currentDirectory));
+      function getNormalizedPathComponents(path5, currentDirectory) {
+        return reducePathComponents(getPathComponents(path5, currentDirectory));
       }
-      function getNormalizedAbsolutePath(path4, currentDirectory) {
-        let rootLength = getRootLength(path4);
+      function getNormalizedAbsolutePath(path5, currentDirectory) {
+        let rootLength = getRootLength(path5);
         if (rootLength === 0 && currentDirectory) {
-          path4 = combinePaths(currentDirectory, path4);
-          rootLength = getRootLength(path4);
+          path5 = combinePaths(currentDirectory, path5);
+          rootLength = getRootLength(path5);
         } else {
-          path4 = normalizeSlashes(path4);
+          path5 = normalizeSlashes(path5);
         }
-        const simpleNormalized = simpleNormalizePath(path4);
+        const simpleNormalized = simpleNormalizePath(path5);
         if (simpleNormalized !== void 0) {
           return simpleNormalized.length > rootLength ? removeTrailingDirectorySeparator(simpleNormalized) : simpleNormalized;
         }
-        const length2 = path4.length;
-        const root = path4.substring(0, rootLength);
+        const length2 = path5.length;
+        const root = path5.substring(0, rootLength);
         let normalized;
         let index = rootLength;
         let segmentStart = index;
@@ -9204,23 +9204,23 @@ ${lanes.join("\n")}
         let seenNonDotDotSegment = rootLength !== 0;
         while (index < length2) {
           segmentStart = index;
-          let ch = path4.charCodeAt(index);
+          let ch = path5.charCodeAt(index);
           while (ch === 47 && index + 1 < length2) {
             index++;
-            ch = path4.charCodeAt(index);
+            ch = path5.charCodeAt(index);
           }
           if (index > segmentStart) {
-            normalized ?? (normalized = path4.substring(0, segmentStart - 1));
+            normalized ?? (normalized = path5.substring(0, segmentStart - 1));
             segmentStart = index;
           }
-          let segmentEnd = path4.indexOf(directorySeparator, index + 1);
+          let segmentEnd = path5.indexOf(directorySeparator, index + 1);
           if (segmentEnd === -1) {
             segmentEnd = length2;
           }
           const segmentLength = segmentEnd - segmentStart;
-          if (segmentLength === 1 && path4.charCodeAt(index) === 46) {
-            normalized ?? (normalized = path4.substring(0, normalizedUpTo));
-          } else if (segmentLength === 2 && path4.charCodeAt(index) === 46 && path4.charCodeAt(index + 1) === 46) {
+          if (segmentLength === 1 && path5.charCodeAt(index) === 46) {
+            normalized ?? (normalized = path5.substring(0, normalizedUpTo));
+          } else if (segmentLength === 2 && path5.charCodeAt(index) === 46 && path5.charCodeAt(index + 1) === 46) {
             if (!seenNonDotDotSegment) {
               if (normalized !== void 0) {
                 normalized += normalized.length === rootLength ? ".." : "/..";
@@ -9229,9 +9229,9 @@ ${lanes.join("\n")}
               }
             } else if (normalized === void 0) {
               if (normalizedUpTo - 2 >= 0) {
-                normalized = path4.substring(0, Math.max(rootLength, path4.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
+                normalized = path5.substring(0, Math.max(rootLength, path5.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
               } else {
-                normalized = path4.substring(0, normalizedUpTo);
+                normalized = path5.substring(0, normalizedUpTo);
               }
             } else {
               const lastSlash = normalized.lastIndexOf(directorySeparator);
@@ -9249,36 +9249,36 @@ ${lanes.join("\n")}
               normalized += directorySeparator;
             }
             seenNonDotDotSegment = true;
-            normalized += path4.substring(segmentStart, segmentEnd);
+            normalized += path5.substring(segmentStart, segmentEnd);
           } else {
             seenNonDotDotSegment = true;
             normalizedUpTo = segmentEnd;
           }
           index = segmentEnd + 1;
         }
-        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path4) : path4);
+        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path5) : path5);
       }
-      function normalizePath(path4) {
-        path4 = normalizeSlashes(path4);
-        let normalized = simpleNormalizePath(path4);
+      function normalizePath(path5) {
+        path5 = normalizeSlashes(path5);
+        let normalized = simpleNormalizePath(path5);
         if (normalized !== void 0) {
           return normalized;
         }
-        normalized = getNormalizedAbsolutePath(path4, "");
-        return normalized && hasTrailingDirectorySeparator(path4) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+        normalized = getNormalizedAbsolutePath(path5, "");
+        return normalized && hasTrailingDirectorySeparator(path5) ? ensureTrailingDirectorySeparator(normalized) : normalized;
       }
-      function simpleNormalizePath(path4) {
-        if (!relativePathSegmentRegExp.test(path4)) {
-          return path4;
+      function simpleNormalizePath(path5) {
+        if (!relativePathSegmentRegExp.test(path5)) {
+          return path5;
         }
-        let simplified = path4.replace(/\/\.\//g, "/");
+        let simplified = path5.replace(/\/\.\//g, "/");
         if (simplified.startsWith("./")) {
           simplified = simplified.slice(2);
         }
-        if (simplified !== path4) {
-          path4 = simplified;
-          if (!relativePathSegmentRegExp.test(path4)) {
-            return path4;
+        if (simplified !== path5) {
+          path5 = simplified;
+          if (!relativePathSegmentRegExp.test(path5)) {
+            return path5;
           }
         }
         return void 0;
@@ -9294,31 +9294,31 @@ ${lanes.join("\n")}
         const nonCanonicalizedPath = isRootedDiskPath(fileName) ? normalizePath(fileName) : getNormalizedAbsolutePath(fileName, basePath);
         return getCanonicalFileName(nonCanonicalizedPath);
       }
-      function removeTrailingDirectorySeparator(path4) {
-        if (hasTrailingDirectorySeparator(path4)) {
-          return path4.substr(0, path4.length - 1);
+      function removeTrailingDirectorySeparator(path5) {
+        if (hasTrailingDirectorySeparator(path5)) {
+          return path5.substr(0, path5.length - 1);
         }
-        return path4;
+        return path5;
       }
-      function ensureTrailingDirectorySeparator(path4) {
-        if (!hasTrailingDirectorySeparator(path4)) {
-          return path4 + directorySeparator;
+      function ensureTrailingDirectorySeparator(path5) {
+        if (!hasTrailingDirectorySeparator(path5)) {
+          return path5 + directorySeparator;
         }
-        return path4;
+        return path5;
       }
-      function ensurePathIsNonModuleName(path4) {
-        return !pathIsAbsolute(path4) && !pathIsRelative(path4) ? "./" + path4 : path4;
+      function ensurePathIsNonModuleName(path5) {
+        return !pathIsAbsolute(path5) && !pathIsRelative(path5) ? "./" + path5 : path5;
       }
-      function changeAnyExtension(path4, ext, extensions, ignoreCase) {
-        const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path4, extensions, ignoreCase) : getAnyExtensionFromPath(path4);
-        return pathext ? path4.slice(0, path4.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path4;
+      function changeAnyExtension(path5, ext, extensions, ignoreCase) {
+        const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path5, extensions, ignoreCase) : getAnyExtensionFromPath(path5);
+        return pathext ? path5.slice(0, path5.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path5;
       }
-      function changeFullExtension(path4, newExtension) {
-        const declarationExtension = getDeclarationFileExtension(path4);
+      function changeFullExtension(path5, newExtension) {
+        const declarationExtension = getDeclarationFileExtension(path5);
         if (declarationExtension) {
-          return path4.slice(0, path4.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
+          return path5.slice(0, path5.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
         }
-        return changeAnyExtension(path4, newExtension);
+        return changeAnyExtension(path5, newExtension);
       }
       var relativePathSegmentRegExp = /\/\/|(?:^|\/)\.\.?(?:$|\/)/;
       function comparePathsWorker(a, b, componentComparer) {
@@ -20771,8 +20771,8 @@ ${lanes.join("\n")}
       function getResolvedExternalModuleName(host, file, referenceFile) {
         return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName);
       }
-      function getCanonicalAbsolutePath(host, path4) {
-        return host.getCanonicalFileName(getNormalizedAbsolutePath(path4, host.getCurrentDirectory()));
+      function getCanonicalAbsolutePath(host, path5) {
+        return host.getCanonicalFileName(getNormalizedAbsolutePath(path5, host.getCurrentDirectory()));
       }
       function getExternalModuleNameFromDeclaration(host, resolver, declaration) {
         const file = resolver.getExternalModuleFileFromDeclaration(declaration);
@@ -20815,20 +20815,20 @@ ${lanes.join("\n")}
       }
       function getDeclarationEmitOutputFilePathWorker(fileName, options, host) {
         const outputDir = options.declarationDir || options.outDir;
-        const path4 = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f)) : fileName;
-        const declarationExtension = getDeclarationEmitExtensionForPath(path4);
-        return removeFileExtension(path4) + declarationExtension;
+        const path5 = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f)) : fileName;
+        const declarationExtension = getDeclarationEmitExtensionForPath(path5);
+        return removeFileExtension(path5) + declarationExtension;
       }
-      function getDeclarationEmitExtensionForPath(path4) {
-        return fileExtensionIsOneOf(path4, [
+      function getDeclarationEmitExtensionForPath(path5) {
+        return fileExtensionIsOneOf(path5, [
           ".mjs",
           ".mts"
           /* Mts */
-        ]) ? ".d.mts" : fileExtensionIsOneOf(path4, [
+        ]) ? ".d.mts" : fileExtensionIsOneOf(path5, [
           ".cjs",
           ".cts"
           /* Cts */
-        ]) ? ".d.cts" : fileExtensionIsOneOf(path4, [
+        ]) ? ".d.cts" : fileExtensionIsOneOf(path5, [
           ".json"
           /* Json */
         ]) ? `.d.json.ts` : (
@@ -20836,8 +20836,8 @@ ${lanes.join("\n")}
           ".d.ts"
         );
       }
-      function getPossibleOriginalInputExtensionForExtension(path4) {
-        return fileExtensionIsOneOf(path4, [
+      function getPossibleOriginalInputExtensionForExtension(path5) {
+        return fileExtensionIsOneOf(path5, [
           ".d.mts",
           ".mjs",
           ".mts"
@@ -20846,7 +20846,7 @@ ${lanes.join("\n")}
           ".mts",
           ".mjs"
           /* Mjs */
-        ] : fileExtensionIsOneOf(path4, [
+        ] : fileExtensionIsOneOf(path5, [
           ".d.cts",
           ".cjs",
           ".cts"
@@ -20855,7 +20855,7 @@ ${lanes.join("\n")}
           ".cts",
           ".cjs"
           /* Cjs */
-        ] : fileExtensionIsOneOf(path4, [`.d.json.ts`]) ? [
+        ] : fileExtensionIsOneOf(path5, [`.d.json.ts`]) ? [
           ".json"
           /* Json */
         ] : [
@@ -20940,12 +20940,12 @@ ${lanes.join("\n")}
           createDirectory(directoryPath);
         }
       }
-      function writeFileEnsuringDirectories(path4, data, writeByteOrderMark, writeFile2, createDirectory, directoryExists) {
+      function writeFileEnsuringDirectories(path5, data, writeByteOrderMark, writeFile2, createDirectory, directoryExists) {
         try {
-          writeFile2(path4, data, writeByteOrderMark);
+          writeFile2(path5, data, writeByteOrderMark);
         } catch {
-          ensureDirectoriesExist(getDirectoryPath(normalizePath(path4)), createDirectory, directoryExists);
-          writeFile2(path4, data, writeByteOrderMark);
+          ensureDirectoriesExist(getDirectoryPath(normalizePath(path5)), createDirectory, directoryExists);
+          writeFile2(path5, data, writeByteOrderMark);
         }
       }
       function getLineOfLocalPosition(sourceFile, pos) {
@@ -21645,20 +21645,20 @@ ${lanes.join("\n")}
         }
         return getStringFromExpandedCharCodes(expandedCharCodes);
       }
-      function readJsonOrUndefined(path4, hostOrText) {
-        const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path4);
+      function readJsonOrUndefined(path5, hostOrText) {
+        const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path5);
         if (!jsonText) return void 0;
         let result = tryParseJson(jsonText);
         if (result === void 0) {
-          const looseResult = parseConfigFileTextToJson(path4, jsonText);
+          const looseResult = parseConfigFileTextToJson(path5, jsonText);
           if (!looseResult.error) {
             result = looseResult.config;
           }
         }
         return result;
       }
-      function readJson(path4, host) {
-        return readJsonOrUndefined(path4, host) || {};
+      function readJson(path5, host) {
+        return readJsonOrUndefined(path5, host) || {};
       }
       function tryParseJson(text) {
         try {
@@ -22808,7 +22808,7 @@ ${lanes.join("\n")}
           getSymlinkedFiles: () => symlinkedFiles,
           getSymlinkedDirectories: () => symlinkedDirectories,
           getSymlinkedDirectoriesByRealpath: () => symlinkedDirectoriesByRealpath,
-          setSymlinkedFile: (path4, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path4, real),
+          setSymlinkedFile: (path5, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path5, real),
           setSymlinkedDirectory: (symlink, real) => {
             let symlinkPath = toPath(symlink, cwd, getCanonicalFileName);
             if (!containsIgnoredPath(symlinkPath)) {
@@ -22868,8 +22868,8 @@ ${lanes.join("\n")}
       function stripLeadingDirectorySeparator(s) {
         return isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : void 0;
       }
-      function tryRemoveDirectoryPrefix(path4, dirPath, getCanonicalFileName) {
-        const withoutPrefix = tryRemovePrefix(path4, dirPath, getCanonicalFileName);
+      function tryRemoveDirectoryPrefix(path5, dirPath, getCanonicalFileName) {
+        const withoutPrefix = tryRemovePrefix(path5, dirPath, getCanonicalFileName);
         return withoutPrefix === void 0 ? void 0 : stripLeadingDirectorySeparator(withoutPrefix);
       }
       var reservedCharacterPattern = /[^\w\s/]/g;
@@ -22995,25 +22995,25 @@ ${lanes.join("\n")}
       function replaceWildcardCharacter(match, singleAsteriskRegexFragment) {
         return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match;
       }
-      function getFileMatcherPatterns(path4, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
-        path4 = normalizePath(path4);
+      function getFileMatcherPatterns(path5, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
+        path5 = normalizePath(path5);
         currentDirectory = normalizePath(currentDirectory);
-        const absolutePath = combinePaths(currentDirectory, path4);
+        const absolutePath = combinePaths(currentDirectory, path5);
         return {
           includeFilePatterns: map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), (pattern) => `^${pattern}$`),
           includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
           includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
           excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-          basePaths: getBasePaths(path4, includes, useCaseSensitiveFileNames2)
+          basePaths: getBasePaths(path5, includes, useCaseSensitiveFileNames2)
         };
       }
       function getRegexFromPattern(pattern, useCaseSensitiveFileNames2) {
         return new RegExp(pattern, useCaseSensitiveFileNames2 ? "" : "i");
       }
-      function matchFiles(path4, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
-        path4 = normalizePath(path4);
+      function matchFiles(path5, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
+        path5 = normalizePath(path5);
         currentDirectory = normalizePath(currentDirectory);
-        const patterns = getFileMatcherPatterns(path4, excludes, includes, useCaseSensitiveFileNames2, currentDirectory);
+        const patterns = getFileMatcherPatterns(path5, excludes, includes, useCaseSensitiveFileNames2, currentDirectory);
         const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map((pattern) => getRegexFromPattern(pattern, useCaseSensitiveFileNames2));
         const includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames2);
         const excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames2);
@@ -23058,17 +23058,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function getBasePaths(path4, includes, useCaseSensitiveFileNames2) {
-        const basePaths = [path4];
+      function getBasePaths(path5, includes, useCaseSensitiveFileNames2) {
+        const basePaths = [path5];
         if (includes) {
           const includeBasePaths = [];
           for (const include of includes) {
-            const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path4, include));
+            const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path5, include));
             includeBasePaths.push(getIncludeBasePath(absolute));
           }
           includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames2));
           for (const includeBasePath of includeBasePaths) {
-            if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path4, !useCaseSensitiveFileNames2))) {
+            if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path5, !useCaseSensitiveFileNames2))) {
               basePaths.push(includeBasePath);
             }
           }
@@ -23332,24 +23332,24 @@ ${lanes.join("\n")}
         ".json"
         /* Json */
       ];
-      function removeFileExtension(path4) {
+      function removeFileExtension(path5) {
         for (const ext of extensionsToRemove) {
-          const extensionless = tryRemoveExtension(path4, ext);
+          const extensionless = tryRemoveExtension(path5, ext);
           if (extensionless !== void 0) {
             return extensionless;
           }
         }
-        return path4;
+        return path5;
       }
-      function tryRemoveExtension(path4, extension) {
-        return fileExtensionIs(path4, extension) ? removeExtension(path4, extension) : void 0;
+      function tryRemoveExtension(path5, extension) {
+        return fileExtensionIs(path5, extension) ? removeExtension(path5, extension) : void 0;
       }
-      function removeExtension(path4, extension) {
-        return path4.substring(0, path4.length - extension.length);
+      function removeExtension(path5, extension) {
+        return path5.substring(0, path5.length - extension.length);
       }
-      function changeExtension(path4, newExtension) {
+      function changeExtension(path5, newExtension) {
         return changeAnyExtension(
-          path4,
+          path5,
           newExtension,
           extensionsToRemove,
           /*ignoreCase*/
@@ -23375,8 +23375,8 @@ ${lanes.join("\n")}
         let matchableStringSet;
         let patterns;
         const pathList = getOwnKeys(paths);
-        for (const path4 of pathList) {
-          const patternOrStr = tryParsePattern(path4);
+        for (const path5 of pathList) {
+          const patternOrStr = tryParsePattern(path5);
           if (patternOrStr === void 0) {
             continue;
           } else if (typeof patternOrStr === "string") {
@@ -23403,15 +23403,15 @@ ${lanes.join("\n")}
       function resolutionExtensionIsTSOrJson(ext) {
         return extensionIsTS(ext) || ext === ".json";
       }
-      function extensionFromPath(path4) {
-        const ext = tryGetExtensionFromPath2(path4);
-        return ext !== void 0 ? ext : Debug.fail(`File ${path4} has unknown extension.`);
+      function extensionFromPath(path5) {
+        const ext = tryGetExtensionFromPath2(path5);
+        return ext !== void 0 ? ext : Debug.fail(`File ${path5} has unknown extension.`);
       }
-      function isAnySupportedFileExtension(path4) {
-        return tryGetExtensionFromPath2(path4) !== void 0;
+      function isAnySupportedFileExtension(path5) {
+        return tryGetExtensionFromPath2(path5) !== void 0;
       }
-      function tryGetExtensionFromPath2(path4) {
-        return find(extensionsToRemove, (e) => fileExtensionIs(path4, e));
+      function tryGetExtensionFromPath2(path5) {
+        return find(extensionsToRemove, (e) => fileExtensionIs(path5, e));
       }
       function isCheckJsEnabledForFile(sourceFile, compilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
@@ -23720,8 +23720,8 @@ ${lanes.join("\n")}
           return false;
         }
       }
-      function containsIgnoredPath(path4) {
-        return some(ignoredPaths, (p) => path4.includes(p));
+      function containsIgnoredPath(path5) {
+        return some(ignoredPaths, (p) => path5.includes(p));
       }
       function getContainingNodeArray(node) {
         if (!node.parent) return void 0;
@@ -43517,7 +43517,7 @@ ${lanes.join("\n")}
               const typeReferenceDirectives = context.typeReferenceDirectives;
               const libReferenceDirectives = context.libReferenceDirectives;
               forEach(toArray(entryOrList), (arg) => {
-                const { types, lib, path: path4, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
+                const { types, lib, path: path5, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
                 const preserve = _preserve === "true" ? true : void 0;
                 if (arg.arguments["no-default-lib"] === "true") {
                   context.hasNoDefaultLib = true;
@@ -43526,8 +43526,8 @@ ${lanes.join("\n")}
                   typeReferenceDirectives.push({ pos: types.pos, end: types.end, fileName: types.value, ...parsed ? { resolutionMode: parsed } : {}, ...preserve ? { preserve } : {} });
                 } else if (lib) {
                   libReferenceDirectives.push({ pos: lib.pos, end: lib.end, fileName: lib.value, ...preserve ? { preserve } : {} });
-                } else if (path4) {
-                  referencedFiles.push({ pos: path4.pos, end: path4.end, fileName: path4.value, ...preserve ? { preserve } : {} });
+                } else if (path5) {
+                  referencedFiles.push({ pos: path5.pos, end: path5.end, fileName: path5.value, ...preserve ? { preserve } : {} });
                 } else {
                   reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);
                 }
@@ -45956,9 +45956,9 @@ ${lanes.join("\n")}
         if (specs[0] === defaultIncludeSpec) return void 0;
         return specs;
       }
-      function matchesSpecs(path4, includeSpecs, excludeSpecs, host) {
+      function matchesSpecs(path5, includeSpecs, excludeSpecs, host) {
         if (!includeSpecs) return returnTrue;
-        const patterns = getFileMatcherPatterns(path4, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
+        const patterns = getFileMatcherPatterns(path5, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
         const excludeRe = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames);
         const includeRe = patterns.includeFilePattern && getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames);
         if (includeRe) {
@@ -46603,9 +46603,9 @@ ${lanes.join("\n")}
             const setPropertyInResultIfNotUndefined = (propertyName) => {
               if (ownConfig.raw[propertyName]) return;
               if (extendsRaw[propertyName]) {
-                result[propertyName] = map(extendsRaw[propertyName], (path4) => startsWithConfigDirTemplate(path4) || isRootedDiskPath(path4) ? path4 : combinePaths(
+                result[propertyName] = map(extendsRaw[propertyName], (path5) => startsWithConfigDirTemplate(path5) || isRootedDiskPath(path5) ? path5 : combinePaths(
                   relativeDifference || (relativeDifference = convertToRelativePath(getDirectoryPath(extendedConfigPath), basePath, createGetCanonicalFileName(host.useCaseSensitiveFileNames))),
-                  path4
+                  path5
                 ));
               }
             };
@@ -46759,11 +46759,11 @@ ${lanes.join("\n")}
         return void 0;
       }
       function getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache, result) {
-        const path4 = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
+        const path5 = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
         let value;
         let extendedResult;
         let extendedConfig;
-        if (extendedConfigCache && (value = extendedConfigCache.get(path4))) {
+        if (extendedConfigCache && (value = extendedConfigCache.get(path5))) {
           ({ extendedResult, extendedConfig } = value);
         } else {
           extendedResult = readJsonConfigFile(extendedConfigPath, (path22) => host.readFile(path22));
@@ -46781,7 +46781,7 @@ ${lanes.join("\n")}
             );
           }
           if (extendedConfigCache) {
-            extendedConfigCache.set(path4, { extendedResult, extendedConfig });
+            extendedConfigCache.set(path5, { extendedResult, extendedConfig });
           }
         }
         if (sourceFile) {
@@ -47049,24 +47049,24 @@ ${lanes.join("\n")}
             }
             const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2);
             if (match) {
-              const { key, path: path4, flags } = match;
+              const { key, path: path5, flags } = match;
               const existingPath = wildCardKeyToPath.get(key);
               const existingFlags = existingPath !== void 0 ? wildcardDirectories[existingPath] : void 0;
               if (existingFlags === void 0 || existingFlags < flags) {
-                wildcardDirectories[existingPath !== void 0 ? existingPath : path4] = flags;
-                if (existingPath === void 0) wildCardKeyToPath.set(key, path4);
+                wildcardDirectories[existingPath !== void 0 ? existingPath : path5] = flags;
+                if (existingPath === void 0) wildCardKeyToPath.set(key, path5);
                 if (flags === 1) {
                   recursiveKeys.push(key);
                 }
               }
             }
           }
-          for (const path4 in wildcardDirectories) {
-            if (hasProperty(wildcardDirectories, path4)) {
+          for (const path5 in wildcardDirectories) {
+            if (hasProperty(wildcardDirectories, path5)) {
               for (const recursiveKey of recursiveKeys) {
-                const key = toCanonicalKey(path4, useCaseSensitiveFileNames2);
+                const key = toCanonicalKey(path5, useCaseSensitiveFileNames2);
                 if (key !== recursiveKey && containsPath(recursiveKey, key, basePath, !useCaseSensitiveFileNames2)) {
-                  delete wildcardDirectories[path4];
+                  delete wildcardDirectories[path5];
                 }
               }
             }
@@ -47074,8 +47074,8 @@ ${lanes.join("\n")}
         }
         return wildcardDirectories;
       }
-      function toCanonicalKey(path4, useCaseSensitiveFileNames2) {
-        return useCaseSensitiveFileNames2 ? path4 : toFileNameLowerCase(path4);
+      function toCanonicalKey(path5, useCaseSensitiveFileNames2) {
+        return useCaseSensitiveFileNames2 ? path5 : toFileNameLowerCase(path5);
       }
       function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2) {
         const match = wildcardDirectoryPattern.exec(spec);
@@ -47091,10 +47091,10 @@ ${lanes.join("\n")}
           };
         }
         if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
-          const path4 = removeTrailingDirectorySeparator(spec);
+          const path5 = removeTrailingDirectorySeparator(spec);
           return {
-            key: toCanonicalKey(path4, useCaseSensitiveFileNames2),
-            path: path4,
+            key: toCanonicalKey(path5, useCaseSensitiveFileNames2),
+            path: path5,
             flags: 1
             /* Recursive */
           };
@@ -47333,11 +47333,11 @@ ${lanes.join("\n")}
           }
           return;
         }
-        const path4 = normalizePath(combinePaths(baseDirectory, fileName));
+        const path5 = normalizePath(combinePaths(baseDirectory, fileName));
         if (state.traceEnabled) {
-          trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path4);
+          trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path5);
         }
-        return path4;
+        return path5;
       }
       function readPackageJsonTypesFields(jsonContent, baseDirectory, state) {
         return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state) || readPackageJsonPathField(jsonContent, "types", baseDirectory, state);
@@ -47384,7 +47384,7 @@ ${lanes.join("\n")}
       }
       var typeScriptVersion;
       function getPackageJsonTypesVersionsPaths(typesVersions) {
-        if (!typeScriptVersion) typeScriptVersion = new Version(version);
+        if (!typeScriptVersion) typeScriptVersion = new Version(version2);
         for (const key in typesVersions) {
           if (!hasProperty(typesVersions, key)) continue;
           const keyRange = VersionRange.tryParse(key);
@@ -47851,13 +47851,13 @@ ${lanes.join("\n")}
           directoryToModuleNameMap.update(options2);
         }
         function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
-          const path4 = toPath(directoryName, currentDirectory, getCanonicalFileName);
-          return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path4, () => createModeAwareCache());
+          const path5 = toPath(directoryName, currentDirectory, getCanonicalFileName);
+          return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path5, () => createModeAwareCache());
         }
         function getFromDirectoryCache(name, mode, directoryName, redirectedReference) {
           var _a, _b;
-          const path4 = toPath(directoryName, currentDirectory, getCanonicalFileName);
-          return (_b = (_a = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a.get(path4)) == null ? void 0 : _b.get(name, mode);
+          const path5 = toPath(directoryName, currentDirectory, getCanonicalFileName);
+          return (_b = (_a = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a.get(path5)) == null ? void 0 : _b.get(name, mode);
         }
       }
       function createModeAwareCacheKey(specifier, mode) {
@@ -47934,14 +47934,14 @@ ${lanes.join("\n")}
             return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName));
           }
           function set(directory, result) {
-            const path4 = toPath(directory, currentDirectory, getCanonicalFileName);
-            if (directoryPathMap.has(path4)) {
+            const path5 = toPath(directory, currentDirectory, getCanonicalFileName);
+            if (directoryPathMap.has(path5)) {
               return;
             }
-            directoryPathMap.set(path4, result);
+            directoryPathMap.set(path5, result);
             const resolvedFileName = getResolvedFileName(result);
-            const commonPrefix = resolvedFileName && getCommonPrefix(path4, resolvedFileName);
-            let current = path4;
+            const commonPrefix = resolvedFileName && getCommonPrefix(path5, resolvedFileName);
+            let current = path5;
             while (current !== commonPrefix) {
               const parent2 = getDirectoryPath(current);
               if (parent2 === current || directoryPathMap.has(parent2)) {
@@ -48505,16 +48505,16 @@ ${lanes.join("\n")}
         const combined = combinePaths(containingDirectory, moduleName);
         const parts = getPathComponents(combined);
         const lastPart = lastOrUndefined(parts);
-        const path4 = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
-        return { path: path4, parts };
+        const path5 = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
+        return { path: path5, parts };
       }
-      function realPath(path4, host, traceEnabled) {
+      function realPath(path5, host, traceEnabled) {
         if (!host.realpath) {
-          return path4;
+          return path5;
         }
-        const real = normalizePath(host.realpath(path4));
+        const real = normalizePath(host.realpath(path5));
         if (traceEnabled) {
-          trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path4, real);
+          trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path5, real);
         }
         return real;
       }
@@ -48559,25 +48559,25 @@ ${lanes.join("\n")}
         return void 0;
       }
       var nodeModulesPathPart = "/node_modules/";
-      function pathContainsNodeModules(path4) {
-        return path4.includes(nodeModulesPathPart);
+      function pathContainsNodeModules(path5) {
+        return path5.includes(nodeModulesPathPart);
       }
       function parseNodeModuleFromPath(resolved, isFolder) {
-        const path4 = normalizePath(resolved);
-        const idx = path4.lastIndexOf(nodeModulesPathPart);
+        const path5 = normalizePath(resolved);
+        const idx = path5.lastIndexOf(nodeModulesPathPart);
         if (idx === -1) {
           return void 0;
         }
         const indexAfterNodeModules = idx + nodeModulesPathPart.length;
-        let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path4, indexAfterNodeModules, isFolder);
-        if (path4.charCodeAt(indexAfterNodeModules) === 64) {
-          indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path4, indexAfterPackageName, isFolder);
+        let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path5, indexAfterNodeModules, isFolder);
+        if (path5.charCodeAt(indexAfterNodeModules) === 64) {
+          indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path5, indexAfterPackageName, isFolder);
         }
-        return path4.slice(0, indexAfterPackageName);
+        return path5.slice(0, indexAfterPackageName);
       }
-      function moveToNextDirectorySeparatorIfAvailable(path4, prevSeparatorIndex, isFolder) {
-        const nextSeparatorIndex = path4.indexOf(directorySeparator, prevSeparatorIndex + 1);
-        return nextSeparatorIndex === -1 ? isFolder ? path4.length : prevSeparatorIndex : nextSeparatorIndex;
+      function moveToNextDirectorySeparatorIfAvailable(path5, prevSeparatorIndex, isFolder) {
+        const nextSeparatorIndex = path5.indexOf(directorySeparator, prevSeparatorIndex + 1);
+        return nextSeparatorIndex === -1 ? isFolder ? path5.length : prevSeparatorIndex : nextSeparatorIndex;
       }
       function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) {
         return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
@@ -48719,8 +48719,8 @@ ${lanes.join("\n")}
             return extensions & 4 && !isDeclarationFileName(candidate + originalExtension) && tryExtension(`.d${originalExtension}.ts`) || void 0;
         }
         function tryExtension(ext, resolvedUsingTsExtension) {
-          const path4 = tryFile(candidate + ext, onlyRecordFailures, state);
-          return path4 === void 0 ? void 0 : { path: path4, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
+          const path5 = tryFile(candidate + ext, onlyRecordFailures, state);
+          return path5 === void 0 ? void 0 : { path: path5, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
         }
       }
       function tryFile(fileName, onlyRecordFailures, state) {
@@ -48932,9 +48932,9 @@ ${lanes.join("\n")}
               state
             );
             if (peerPackageJson) {
-              const version2 = peerPackageJson.contents.packageJsonContent.version;
-              result += `+${key}@${version2}`;
-              if (state.traceEnabled) trace(state.host, Diagnostics.Found_peerDependency_0_with_1_version, key, version2);
+              const version22 = peerPackageJson.contents.packageJsonContent.version;
+              result += `+${key}@${version22}`;
+              if (state.traceEnabled) trace(state.host, Diagnostics.Found_peerDependency_0_with_1_version, key, version22);
             } else {
               if (state.traceEnabled) trace(state.host, Diagnostics.Failed_to_find_peerDependency_0, key);
             }
@@ -49032,7 +49032,7 @@ ${lanes.join("\n")}
             false
           );
           if (state.traceEnabled) {
-            trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, moduleName);
+            trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version2, moduleName);
           }
           const pathPatterns = tryParsePatterns(versionPaths.paths);
           const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, pathPatterns, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
@@ -49416,10 +49416,10 @@ ${lanes.join("\n")}
             /*value*/
             void 0
           );
-          function toAbsolutePath(path4) {
+          function toAbsolutePath(path5) {
             var _a2, _b2;
-            if (path4 === void 0) return path4;
-            return getNormalizedAbsolutePath(path4, (_b2 = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a2));
+            if (path5 === void 0) return path5;
+            return getNormalizedAbsolutePath(path5, (_b2 = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a2));
           }
           function combineDirectoryPath(root, dir) {
             return ensureTrailingDirectorySeparator(combinePaths(root, dir));
@@ -49514,7 +49514,7 @@ ${lanes.join("\n")}
         if (!startsWith(key, "types@")) return false;
         const range = VersionRange.tryParse(key.substring("types@".length));
         if (!range) return false;
-        return range.test(version);
+        return range.test(version2);
       }
       function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
         return loadModuleFromNearestNodeModulesDirectoryWorker(
@@ -49650,7 +49650,7 @@ ${lanes.join("\n")}
         const versionPaths = rest !== "" && packageInfo ? getVersionPathsOfPackageJsonInfo(packageInfo, state) : void 0;
         if (versionPaths) {
           if (state.traceEnabled) {
-            trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, rest);
+            trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version2, rest);
           }
           const packageDirectoryExists = nodeModulesDirectoryExists && directoryProbablyExists(packageDirectory, state.host);
           const pathPatterns = tryParsePatterns(versionPaths.paths);
@@ -49670,10 +49670,10 @@ ${lanes.join("\n")}
             trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
           }
           const resolved = forEach(paths[matchedPatternText], (subst) => {
-            const path4 = matchedStar ? replaceFirstStar(subst, matchedStar) : subst;
-            const candidate = normalizePath(combinePaths(baseDirectory, path4));
+            const path5 = matchedStar ? replaceFirstStar(subst, matchedStar) : subst;
+            const candidate = normalizePath(combinePaths(baseDirectory, path5));
             if (state.traceEnabled) {
-              trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path4);
+              trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path5);
             }
             const extension = tryGetExtensionFromPath2(subst);
             if (extension !== void 0) {
@@ -53826,10 +53826,10 @@ ${lanes.join("\n")}
         if (a === void 0 || b === void 0) return false;
         return comparePaths(a, b, ignoreCase) === 0;
       }
-      function countPathComponents(path4) {
+      function countPathComponents(path5) {
         let count = 0;
-        for (let i = startsWith(path4, "./") ? 2 : 0; i < path4.length; i++) {
-          if (path4.charCodeAt(i) === 47) count++;
+        for (let i = startsWith(path5, "./") ? 2 : 0; i < path5.length; i++) {
+          if (path5.charCodeAt(i) === 47) count++;
         }
         return count;
       }
@@ -53946,9 +53946,9 @@ ${lanes.join("\n")}
           host,
           /*preferSymlinks*/
           true,
-          (path4, isRedirect) => {
-            const isInNodeModules = pathContainsNodeModules(path4);
-            allFileNames.set(path4, { path: info.getCanonicalFileName(path4), isRedirect, isInNodeModules });
+          (path5, isRedirect) => {
+            const isInNodeModules = pathContainsNodeModules(path5);
+            allFileNames.set(path5, { path: info.getCanonicalFileName(path5), isRedirect, isInNodeModules });
             importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules;
           }
         );
@@ -53956,8 +53956,8 @@ ${lanes.join("\n")}
         for (let directory = info.canonicalSourceDirectory; allFileNames.size !== 0; ) {
           const directoryStart = ensureTrailingDirectorySeparator(directory);
           let pathsInDirectory;
-          allFileNames.forEach(({ path: path4, isRedirect, isInNodeModules }, fileName) => {
-            if (startsWith(path4, directoryStart)) {
+          allFileNames.forEach(({ path: path5, isRedirect, isInNodeModules }, fileName) => {
+            if (startsWith(path5, directoryStart)) {
               (pathsInDirectory || (pathsInDirectory = [])).push({ path: fileName, isRedirect, isInNodeModules });
               allFileNames.delete(fileName);
             }
@@ -54260,17 +54260,17 @@ ${lanes.join("\n")}
         }
         return processEnding(shortest, allowedEndings, compilerOptions);
       }
-      function tryGetModuleNameAsNodeModule({ path: path4, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
+      function tryGetModuleNameAsNodeModule({ path: path5, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
         if (!host.fileExists || !host.readFile) {
           return void 0;
         }
-        const parts = getNodeModulePathParts(path4);
+        const parts = getNodeModulePathParts(path5);
         if (!parts) {
           return void 0;
         }
         const preferences = getModuleSpecifierPreferences(userPreferences, host, options, importingSourceFile);
         const allowedEndings = preferences.getAllowedEndingsInPreferredOrder();
-        let moduleSpecifier = path4;
+        let moduleSpecifier = path5;
         let isPackageRootPath = false;
         if (!packageNameOnly) {
           let packageRootIndex = parts.packageRootIndex;
@@ -54291,7 +54291,7 @@ ${lanes.join("\n")}
               break;
             }
             if (!moduleFileName) moduleFileName = moduleFileToTry;
-            packageRootIndex = path4.indexOf(directorySeparator, packageRootIndex + 1);
+            packageRootIndex = path5.indexOf(directorySeparator, packageRootIndex + 1);
             if (packageRootIndex === -1) {
               moduleSpecifier = processEnding(moduleFileName, allowedEndings, options, host);
               break;
@@ -54311,9 +54311,9 @@ ${lanes.join("\n")}
         return getEmitModuleResolutionKind(options) === 1 && packageName === nodeModulesDirectoryName ? void 0 : packageName;
         function tryDirectoryWithPackageJson(packageRootIndex) {
           var _a, _b;
-          const packageRootPath = path4.substring(0, packageRootIndex);
+          const packageRootPath = path5.substring(0, packageRootIndex);
           const packageJsonPath = combinePaths(packageRootPath, "package.json");
-          let moduleFileToTry = path4;
+          let moduleFileToTry = path5;
           let maybeBlockedByTypesVersions = false;
           const cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
           if (isPackageJsonInfo(cachedPackageJson) || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
@@ -54326,7 +54326,7 @@ ${lanes.join("\n")}
               const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(
                 options,
                 host,
-                path4,
+                path5,
                 packageRootPath,
                 packageName2,
                 packageJsonContent.exports,
@@ -54336,12 +54336,12 @@ ${lanes.join("\n")}
                 return { ...fromExports, verbatimFromExports: true };
               }
               if (packageJsonContent == null ? void 0 : packageJsonContent.exports) {
-                return { moduleFileToTry: path4, blockedByExports: true };
+                return { moduleFileToTry: path5, blockedByExports: true };
               }
             }
             const versionPaths = (packageJsonContent == null ? void 0 : packageJsonContent.typesVersions) ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) : void 0;
             if (versionPaths) {
-              const subModuleName = path4.slice(packageRootPath.length + 1);
+              const subModuleName = path5.slice(packageRootPath.length + 1);
               const fromPaths = tryGetModuleNameFromPaths(
                 subModuleName,
                 versionPaths.paths,
@@ -54376,7 +54376,7 @@ ${lanes.join("\n")}
           return { moduleFileToTry };
         }
       }
-      function tryGetAnyFileFromPath(host, path4) {
+      function tryGetAnyFileFromPath(host, path5) {
         if (!host.fileExists) return;
         const extensions = flatten(getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, {
           extension: "json",
@@ -54385,15 +54385,15 @@ ${lanes.join("\n")}
           /* JSON */
         }]));
         for (const e of extensions) {
-          const fullPath = path4 + e;
+          const fullPath = path5 + e;
           if (host.fileExists(fullPath)) {
             return fullPath;
           }
         }
       }
-      function getPathsRelativeToRootDirs(path4, rootDirs, getCanonicalFileName) {
+      function getPathsRelativeToRootDirs(path5, rootDirs, getCanonicalFileName) {
         return mapDefined(rootDirs, (rootDir) => {
-          const relativePath = getRelativePathIfInSameVolume(path4, rootDir, getCanonicalFileName);
+          const relativePath = getRelativePathIfInSameVolume(path5, rootDir, getCanonicalFileName);
           return relativePath !== void 0 && isPathRelativeToParent(relativePath) ? void 0 : relativePath;
         });
       }
@@ -54510,10 +54510,10 @@ ${lanes.join("\n")}
             return void 0;
         }
       }
-      function getRelativePathIfInSameVolume(path4, directoryPath, getCanonicalFileName) {
+      function getRelativePathIfInSameVolume(path5, directoryPath, getCanonicalFileName) {
         const relativePath = getRelativePathToDirectoryOrUrl(
           directoryPath,
-          path4,
+          path5,
           directoryPath,
           getCanonicalFileName,
           /*isAbsolutePathAnUrl*/
@@ -54521,8 +54521,8 @@ ${lanes.join("\n")}
         );
         return isRootedDiskPath(relativePath) ? void 0 : relativePath;
       }
-      function isPathRelativeToParent(path4) {
-        return startsWith(path4, "..");
+      function isPathRelativeToParent(path5) {
+        return startsWith(path5, "..");
       }
       function getDefaultResolutionModeForFile(file, host, compilerOptions) {
         return isFullSourceFile(file) ? host.getDefaultResolutionModeForFile(file) : getDefaultResolutionModeForFileWorker(file, compilerOptions);
@@ -69556,10 +69556,10 @@ ${lanes.join("\n")}
           const text = identifier.escapedText;
           if (text) {
             const parentSymbol = name.kind === 167 ? getUnresolvedSymbolForEntityName(name.left) : name.kind === 212 ? getUnresolvedSymbolForEntityName(name.expression) : void 0;
-            const path4 = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
-            let result = unresolvedSymbols.get(path4);
+            const path5 = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
+            let result = unresolvedSymbols.get(path5);
             if (!result) {
-              unresolvedSymbols.set(path4, result = createSymbol(
+              unresolvedSymbols.set(path5, result = createSymbol(
                 524288,
                 text,
                 1048576
@@ -74360,24 +74360,24 @@ ${lanes.join("\n")}
               }
               return;
             }
-            let path4 = "";
+            let path5 = "";
             const secondaryRootErrors = [];
             while (stack.length) {
               const [msg, ...args] = stack.pop();
               switch (msg.code) {
                 case Diagnostics.Types_of_property_0_are_incompatible.code: {
-                  if (path4.indexOf("new ") === 0) {
-                    path4 = `(${path4})`;
+                  if (path5.indexOf("new ") === 0) {
+                    path5 = `(${path5})`;
                   }
                   const str = "" + args[0];
-                  if (path4.length === 0) {
-                    path4 = `${str}`;
+                  if (path5.length === 0) {
+                    path5 = `${str}`;
                   } else if (isIdentifierText(str, getEmitScriptTarget(compilerOptions))) {
-                    path4 = `${path4}.${str}`;
+                    path5 = `${path5}.${str}`;
                   } else if (str[0] === "[" && str[str.length - 1] === "]") {
-                    path4 = `${path4}${str}`;
+                    path5 = `${path5}${str}`;
                   } else {
-                    path4 = `${path4}[${str}]`;
+                    path5 = `${path5}[${str}]`;
                   }
                   break;
                 }
@@ -74385,7 +74385,7 @@ ${lanes.join("\n")}
                 case Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code:
                 case Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code:
                 case Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: {
-                  if (path4.length === 0) {
+                  if (path5.length === 0) {
                     let mappedMsg = msg;
                     if (msg.code === Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
                       mappedMsg = Diagnostics.Call_signature_return_types_0_and_1_are_incompatible;
@@ -74396,7 +74396,7 @@ ${lanes.join("\n")}
                   } else {
                     const prefix = msg.code === Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code || msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? "new " : "";
                     const params = msg.code === Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code || msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? "" : "...";
-                    path4 = `${prefix}${path4}(${params})`;
+                    path5 = `${prefix}${path5}(${params})`;
                   }
                   break;
                 }
@@ -74412,10 +74412,10 @@ ${lanes.join("\n")}
                   return Debug.fail(`Unhandled Diagnostic: ${msg.code}`);
               }
             }
-            if (path4) {
+            if (path5) {
               reportError(
-                path4[path4.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
-                path4
+                path5[path5.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
+                path5
               );
             } else {
               secondaryRootErrors.shift();
@@ -123699,7 +123699,7 @@ ${lanes.join("\n")}
           }
         }
         function createImportCallExpressionAMD(arg, containsLexicalThis) {
-          const resolve3 = factory2.createUniqueName("resolve");
+          const resolve4 = factory2.createUniqueName("resolve");
           const reject = factory2.createUniqueName("reject");
           const parameters = [
             factory2.createParameterDeclaration(
@@ -123708,7 +123708,7 @@ ${lanes.join("\n")}
               /*dotDotDotToken*/
               void 0,
               /*name*/
-              resolve3
+              resolve4
             ),
             factory2.createParameterDeclaration(
               /*modifiers*/
@@ -123725,7 +123725,7 @@ ${lanes.join("\n")}
                 factory2.createIdentifier("require"),
                 /*typeArguments*/
                 void 0,
-                [factory2.createArrayLiteralExpression([arg || factory2.createOmittedExpression()]), resolve3, reject]
+                [factory2.createArrayLiteralExpression([arg || factory2.createOmittedExpression()]), resolve4, reject]
               )
             )
           ]);
@@ -129483,9 +129483,9 @@ ${lanes.join("\n")}
       function createAddOutput() {
         let outputs;
         return { addOutput, getOutputs };
-        function addOutput(path4) {
-          if (path4) {
-            (outputs || (outputs = [])).push(path4);
+        function addOutput(path5) {
+          if (path5) {
+            (outputs || (outputs = [])).push(path5);
           }
         }
         function getOutputs() {
@@ -129644,7 +129644,7 @@ ${lanes.join("\n")}
             emitSkipped = true;
             return;
           }
-          const buildInfo = host.getBuildInfo() || { version };
+          const buildInfo = host.getBuildInfo() || { version: version2 };
           writeFile(
             host,
             emitterDiagnostics,
@@ -134711,7 +134711,7 @@ ${lanes.join("\n")}
         return {
           useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
           fileExists,
-          readFile: (path4, encoding) => host.readFile(path4, encoding),
+          readFile: (path5, encoding) => host.readFile(path5, encoding),
           directoryExists: host.directoryExists && directoryExists,
           getDirectories,
           readDirectory,
@@ -134728,8 +134728,8 @@ ${lanes.join("\n")}
         function getCachedFileSystemEntries(rootDirPath) {
           return cachedReadDirectoryResult.get(ensureTrailingDirectorySeparator(rootDirPath));
         }
-        function getCachedFileSystemEntriesForBaseDir(path4) {
-          const entries = getCachedFileSystemEntries(getDirectoryPath(path4));
+        function getCachedFileSystemEntriesForBaseDir(path5) {
+          const entries = getCachedFileSystemEntries(getDirectoryPath(path5));
           if (!entries) {
             return entries;
           }
@@ -134784,8 +134784,8 @@ ${lanes.join("\n")}
           return index >= 0;
         }
         function writeFile2(fileName, data, writeByteOrderMark) {
-          const path4 = toPath3(fileName);
-          const result = getCachedFileSystemEntriesForBaseDir(path4);
+          const path5 = toPath3(fileName);
+          const result = getCachedFileSystemEntriesForBaseDir(path5);
           if (result) {
             updateFilesOfFileSystemEntry(
               result,
@@ -134797,17 +134797,17 @@ ${lanes.join("\n")}
           return host.writeFile(fileName, data, writeByteOrderMark);
         }
         function fileExists(fileName) {
-          const path4 = toPath3(fileName);
-          const result = getCachedFileSystemEntriesForBaseDir(path4);
+          const path5 = toPath3(fileName);
+          const result = getCachedFileSystemEntriesForBaseDir(path5);
           return result && hasEntry(result.sortedAndCanonicalizedFiles, getCanonicalFileName(getBaseNameOfFileName(fileName))) || host.fileExists(fileName);
         }
         function directoryExists(dirPath) {
-          const path4 = toPath3(dirPath);
-          return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path4)) || host.directoryExists(dirPath);
+          const path5 = toPath3(dirPath);
+          return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path5)) || host.directoryExists(dirPath);
         }
         function createDirectory(dirPath) {
-          const path4 = toPath3(dirPath);
-          const result = getCachedFileSystemEntriesForBaseDir(path4);
+          const path5 = toPath3(dirPath);
+          const result = getCachedFileSystemEntriesForBaseDir(path5);
           if (result) {
             const baseName = getBaseNameOfFileName(dirPath);
             const canonicalizedBaseName = getCanonicalFileName(baseName);
@@ -134835,15 +134835,15 @@ ${lanes.join("\n")}
           }
           return host.readDirectory(rootDir, extensions, excludes, includes, depth);
           function getFileSystemEntries(dir) {
-            const path4 = toPath3(dir);
-            if (path4 === rootDirPath) {
-              return rootResult || getFileSystemEntriesFromHost(dir, path4);
+            const path5 = toPath3(dir);
+            if (path5 === rootDirPath) {
+              return rootResult || getFileSystemEntriesFromHost(dir, path5);
             }
-            const result = tryReadDirectory2(dir, path4);
-            return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path4) : emptyFileSystemEntries;
+            const result = tryReadDirectory2(dir, path5);
+            return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path5) : emptyFileSystemEntries;
           }
-          function getFileSystemEntriesFromHost(dir, path4) {
-            if (rootSymLinkResult && path4 === rootDirPath) return rootSymLinkResult;
+          function getFileSystemEntriesFromHost(dir, path5) {
+            if (rootSymLinkResult && path5 === rootDirPath) return rootSymLinkResult;
             const result = {
               files: map(host.readDirectory(
                 dir,
@@ -134856,7 +134856,7 @@ ${lanes.join("\n")}
               ), getBaseNameOfFileName) || emptyArray,
               directories: host.getDirectories(dir) || emptyArray
             };
-            if (path4 === rootDirPath) rootSymLinkResult = result;
+            if (path5 === rootDirPath) rootSymLinkResult = result;
             return result;
           }
         }
@@ -135315,15 +135315,15 @@ ${lanes.join("\n")}
           return getDirectoryPath(normalizePath(system.getExecutingFilePath()));
         }
         const newLine = getNewLineCharacter(options);
-        const realpath = system.realpath && ((path4) => system.realpath(path4));
+        const realpath = system.realpath && ((path5) => system.realpath(path5));
         const compilerHost = {
           getSourceFile: createGetSourceFile((fileName) => compilerHost.readFile(fileName), setParentNodes),
           getDefaultLibLocation,
           getDefaultLibFileName: (options2) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options2)),
           writeFile: createWriteFileMeasuringIO(
-            (path4, data, writeByteOrderMark) => system.writeFile(path4, data, writeByteOrderMark),
-            (path4) => (compilerHost.createDirectory || system.createDirectory)(path4),
-            (path4) => directoryExists(path4)
+            (path5, data, writeByteOrderMark) => system.writeFile(path5, data, writeByteOrderMark),
+            (path5) => (compilerHost.createDirectory || system.createDirectory)(path5),
+            (path5) => directoryExists(path5)
           ),
           getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
           useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
@@ -135334,9 +135334,9 @@ ${lanes.join("\n")}
           trace: (s) => system.write(s + newLine),
           directoryExists: (directoryName) => system.directoryExists(directoryName),
           getEnvironmentVariable: (name) => system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : "",
-          getDirectories: (path4) => system.getDirectories(path4),
+          getDirectories: (path5) => system.getDirectories(path5),
           realpath,
-          readDirectory: (path4, extensions, include, exclude, depth) => system.readDirectory(path4, extensions, include, exclude, depth),
+          readDirectory: (path5, extensions, include, exclude, depth) => system.readDirectory(path5, extensions, include, exclude, depth),
           createDirectory: (d) => system.createDirectory(d),
           createHash: maybeBind(system, system.createHash)
         };
@@ -135775,13 +135775,13 @@ ${lanes.join("\n")}
       }
       function getLibraryNameFromLibFileName(libFileName) {
         const components = libFileName.split(".");
-        let path4 = components[1];
+        let path5 = components[1];
         let i = 2;
         while (components[i] && components[i] !== "d") {
-          path4 += (i === 2 ? "/" : "-") + components[i];
+          path5 += (i === 2 ? "/" : "-") + components[i];
           i++;
         }
-        return "@typescript/lib-" + path4;
+        return "@typescript/lib-" + path5;
       }
       function isReferencedFile(reason) {
         switch (reason == null ? void 0 : reason.kind) {
@@ -136857,18 +136857,18 @@ ${lanes.join("\n")}
             filesByName.set(newSourceFile.path, newSourceFile);
           }
           const oldFilesByNameMap = oldProgram.getFilesByNameMap();
-          oldFilesByNameMap.forEach((oldFile, path4) => {
+          oldFilesByNameMap.forEach((oldFile, path5) => {
             if (!oldFile) {
-              filesByName.set(path4, oldFile);
+              filesByName.set(path5, oldFile);
               return;
             }
-            if (oldFile.path === path4) {
+            if (oldFile.path === path5) {
               if (oldProgram.isSourceFileFromExternalLibrary(oldFile)) {
                 sourceFilesFoundSearchingNodeModules.set(oldFile.path, true);
               }
               return;
             }
-            filesByName.set(path4, filesByName.get(oldFile.path));
+            filesByName.set(path5, filesByName.get(oldFile.path));
           });
           const isConfigIdentical = oldOptions.configFile && oldOptions.configFile === options.configFile || !oldOptions.configFile && !options.configFile && !optionsHaveChanges(oldOptions, options, optionDeclarations);
           programDiagnostics.reuseStateFromOldProgram(oldProgram.getProgramDiagnosticsContainer(), isConfigIdentical);
@@ -136906,9 +136906,9 @@ ${lanes.join("\n")}
             getModeForResolutionAtIndex: getModeForResolutionAtIndex2,
             readFile: (f) => host.readFile(f),
             fileExists: (f) => {
-              const path4 = toPath3(f);
-              if (getSourceFileByPath(path4)) return true;
-              if (missingFileNames.has(path4)) return false;
+              const path5 = toPath3(f);
+              if (getSourceFileByPath(path5)) return true;
+              if (missingFileNames.has(path5)) return false;
               return host.fileExists(f);
             },
             realpath: maybeBind(host, host.realpath),
@@ -137048,8 +137048,8 @@ ${lanes.join("\n")}
         function getSourceFile(fileName) {
           return getSourceFileByPath(toPath3(fileName));
         }
-        function getSourceFileByPath(path4) {
-          return filesByName.get(path4) || void 0;
+        function getSourceFileByPath(path5) {
+          return filesByName.get(path5) || void 0;
         }
         function getDiagnosticsHelper(sourceFile, getDiagnostics2, cancellationToken) {
           if (sourceFile) {
@@ -137692,16 +137692,16 @@ ${lanes.join("\n")}
             addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, [fileName, existingFile.fileName]);
           }
         }
-        function createRedirectedSourceFile(redirectTarget, unredirected, fileName, path4, resolvedPath, originalFileName, sourceFileOptions) {
+        function createRedirectedSourceFile(redirectTarget, unredirected, fileName, path5, resolvedPath, originalFileName, sourceFileOptions) {
           var _a2;
           const redirect = parseNodeFactory.createRedirectedSourceFile({ redirectTarget, unredirected });
           redirect.fileName = fileName;
-          redirect.path = path4;
+          redirect.path = path5;
           redirect.resolvedPath = resolvedPath;
           redirect.originalFileName = originalFileName;
           redirect.packageJsonLocations = ((_a2 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _a2.length) ? sourceFileOptions.packageJsonLocations : void 0;
           redirect.packageJsonScope = sourceFileOptions.packageJsonScope;
-          sourceFilesFoundSearchingNodeModules.set(path4, currentNodeModulesDepth > 0);
+          sourceFilesFoundSearchingNodeModules.set(path5, currentNodeModulesDepth > 0);
           return redirect;
         }
         function findSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
@@ -137723,18 +137723,18 @@ ${lanes.join("\n")}
         }
         function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
           var _a2, _b2;
-          const path4 = toPath3(fileName);
+          const path5 = toPath3(fileName);
           if (useSourceOfProjectReferenceRedirect) {
-            let source = getRedirectFromOutput(path4);
+            let source = getRedirectFromOutput(path5);
             if (!source && host.realpath && options.preserveSymlinks && isDeclarationFileName(fileName) && fileName.includes(nodeModulesPathPart)) {
               const realPath2 = toPath3(host.realpath(fileName));
-              if (realPath2 !== path4) source = getRedirectFromOutput(realPath2);
+              if (realPath2 !== path5) source = getRedirectFromOutput(realPath2);
             }
             if (source == null ? void 0 : source.source) {
               const file2 = findSourceFile(source.source, isDefaultLib, ignoreNoDefaultLib, reason, packageId);
               if (file2) addFileToFilesByName(
                 file2,
-                path4,
+                path5,
                 fileName,
                 /*redirectedPath*/
                 void 0
@@ -137743,8 +137743,8 @@ ${lanes.join("\n")}
             }
           }
           const originalFileName = fileName;
-          if (filesByName.has(path4)) {
-            const file2 = filesByName.get(path4);
+          if (filesByName.has(path5)) {
+            const file2 = filesByName.get(path5);
             const addedReason = addFileIncludeReason(
               file2 || void 0,
               reason,
@@ -137810,28 +137810,28 @@ ${lanes.join("\n")}
             const packageIdKey = packageIdToString(packageId);
             const fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
             if (fileFromPackageId) {
-              const dupFile = createRedirectedSourceFile(fileFromPackageId, file, fileName, path4, toPath3(fileName), originalFileName, sourceFileOptions);
+              const dupFile = createRedirectedSourceFile(fileFromPackageId, file, fileName, path5, toPath3(fileName), originalFileName, sourceFileOptions);
               redirectTargetsMap.add(fileFromPackageId.path, fileName);
-              addFileToFilesByName(dupFile, path4, fileName, redirectedPath);
+              addFileToFilesByName(dupFile, path5, fileName, redirectedPath);
               addFileIncludeReason(
                 dupFile,
                 reason,
                 /*checkExisting*/
                 false
               );
-              sourceFileToPackageName.set(path4, packageIdToPackageName(packageId));
+              sourceFileToPackageName.set(path5, packageIdToPackageName(packageId));
               processingOtherFiles.push(dupFile);
               return dupFile;
             } else if (file) {
               packageIdToSourceFile.set(packageIdKey, file);
-              sourceFileToPackageName.set(path4, packageIdToPackageName(packageId));
+              sourceFileToPackageName.set(path5, packageIdToPackageName(packageId));
             }
           }
-          addFileToFilesByName(file, path4, fileName, redirectedPath);
+          addFileToFilesByName(file, path5, fileName, redirectedPath);
           if (file) {
-            sourceFilesFoundSearchingNodeModules.set(path4, currentNodeModulesDepth > 0);
+            sourceFilesFoundSearchingNodeModules.set(path5, currentNodeModulesDepth > 0);
             file.fileName = fileName;
-            file.path = path4;
+            file.path = path5;
             file.resolvedPath = toPath3(fileName);
             file.originalFileName = originalFileName;
             file.packageJsonLocations = ((_b2 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _b2.length) ? sourceFileOptions.packageJsonLocations : void 0;
@@ -137843,7 +137843,7 @@ ${lanes.join("\n")}
               false
             );
             if (host.useCaseSensitiveFileNames()) {
-              const pathLowerCase = toFileNameLowerCase(path4);
+              const pathLowerCase = toFileNameLowerCase(path5);
               const existingFile = filesByNameIgnoreCase.get(pathLowerCase);
               if (existingFile) {
                 reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason);
@@ -137876,18 +137876,18 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function addFileToFilesByName(file, path4, fileName, redirectedPath) {
+        function addFileToFilesByName(file, path5, fileName, redirectedPath) {
           if (redirectedPath) {
             updateFilesByNameMap(fileName, redirectedPath, file);
-            updateFilesByNameMap(fileName, path4, file || false);
+            updateFilesByNameMap(fileName, path5, file || false);
           } else {
-            updateFilesByNameMap(fileName, path4, file);
+            updateFilesByNameMap(fileName, path5, file);
           }
         }
-        function updateFilesByNameMap(fileName, path4, file) {
-          filesByName.set(path4, file);
-          if (file !== void 0) missingFileNames.delete(path4);
-          else missingFileNames.set(path4, fileName);
+        function updateFilesByNameMap(fileName, path5, file) {
+          filesByName.set(path5, file);
+          if (file !== void 0) missingFileNames.delete(path5);
+          else missingFileNames.set(path5, fileName);
         }
         function getRedirectFromSourceFile(fileName) {
           return mapSourceFileToResolvedRef == null ? void 0 : mapSourceFileToResolvedRef.get(toPath3(fileName));
@@ -137895,8 +137895,8 @@ ${lanes.join("\n")}
         function forEachResolvedProjectReference2(cb) {
           return forEachResolvedProjectReference(resolvedProjectReferences, cb);
         }
-        function getRedirectFromOutput(path4) {
-          return mapOutputFileToResolvedRef == null ? void 0 : mapOutputFileToResolvedRef.get(path4);
+        function getRedirectFromOutput(path5) {
+          return mapOutputFileToResolvedRef == null ? void 0 : mapOutputFileToResolvedRef.get(path5);
         }
         function isSourceOfProjectReferenceRedirect(fileName) {
           return useSourceOfProjectReferenceRedirect && !!getRedirectFromSourceFile(fileName);
@@ -138196,7 +138196,7 @@ ${lanes.join("\n")}
             const getCommonSourceDirectory3 = memoize(() => getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()));
             commandLine.fileNames.forEach((fileName) => {
               if (isDeclarationFileName(fileName)) return;
-              const path4 = toPath3(fileName);
+              const path5 = toPath3(fileName);
               let outputDts;
               if (!fileExtensionIs(
                 fileName,
@@ -138210,7 +138210,7 @@ ${lanes.join("\n")}
                   outputDts = outDts;
                 }
               }
-              mapSourceFileToResolvedRef.set(path4, { resolvedRef, outputDts });
+              mapSourceFileToResolvedRef.set(path5, { resolvedRef, outputDts });
             });
           }
           if (commandLine.projectReferences) {
@@ -138898,9 +138898,9 @@ ${lanes.join("\n")}
         host.compilerHost.fileExists = fileExists;
         let directoryExists;
         if (originalDirectoryExists) {
-          directoryExists = host.compilerHost.directoryExists = (path4) => {
-            if (originalDirectoryExists.call(host.compilerHost, path4)) {
-              handleDirectoryCouldBeSymlink(path4);
+          directoryExists = host.compilerHost.directoryExists = (path5) => {
+            if (originalDirectoryExists.call(host.compilerHost, path5)) {
+              handleDirectoryCouldBeSymlink(path5);
               return true;
             }
             if (!host.getResolvedProjectReferences()) return false;
@@ -138919,14 +138919,14 @@ ${lanes.join("\n")}
               });
             }
             return fileOrDirectoryExistsUsingSource(
-              path4,
+              path5,
               /*isFile*/
               false
             );
           };
         }
         if (originalGetDirectories) {
-          host.compilerHost.getDirectories = (path4) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path4) ? originalGetDirectories.call(host.compilerHost, path4) : [];
+          host.compilerHost.getDirectories = (path5) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path5) ? originalGetDirectories.call(host.compilerHost, path5) : [];
         }
         if (originalRealpath) {
           host.compilerHost.realpath = (s) => {
@@ -139564,7 +139564,7 @@ ${lanes.join("\n")}
           const useOldState = canReuseOldState(referencedMap, oldState);
           newProgram.getTypeChecker();
           for (const sourceFile of newProgram.getSourceFiles()) {
-            const version2 = Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
+            const version22 = Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
             const oldUncommittedSignature = useOldState ? (_a = oldState.oldSignatures) == null ? void 0 : _a.get(sourceFile.resolvedPath) : void 0;
             const signature = oldUncommittedSignature === void 0 ? useOldState ? (_b = oldState.fileInfos.get(sourceFile.resolvedPath)) == null ? void 0 : _b.signature : void 0 : oldUncommittedSignature || void 0;
             if (referencedMap) {
@@ -139574,7 +139574,7 @@ ${lanes.join("\n")}
               }
             }
             fileInfos.set(sourceFile.resolvedPath, {
-              version: version2,
+              version: version22,
               signature,
               // No need to calculate affectsGlobalScope with --out since its not used at all
               affectsGlobalScope: !options.outFile ? isFileAffectingGlobalScope(sourceFile) || void 0 : void 0,
@@ -139593,12 +139593,12 @@ ${lanes.join("\n")}
           state.allFileNames = void 0;
         }
         BuilderState2.releaseCache = releaseCache2;
-        function getFilesAffectedBy(state, programOfThisState, path4, cancellationToken, host) {
+        function getFilesAffectedBy(state, programOfThisState, path5, cancellationToken, host) {
           var _a;
           const result = getFilesAffectedByWithOldState(
             state,
             programOfThisState,
-            path4,
+            path5,
             cancellationToken,
             host
           );
@@ -139606,8 +139606,8 @@ ${lanes.join("\n")}
           return result;
         }
         BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
-        function getFilesAffectedByWithOldState(state, programOfThisState, path4, cancellationToken, host) {
-          const sourceFile = programOfThisState.getSourceFileByPath(path4);
+        function getFilesAffectedByWithOldState(state, programOfThisState, path5, cancellationToken, host) {
+          const sourceFile = programOfThisState.getSourceFileByPath(path5);
           if (!sourceFile) {
             return emptyArray;
           }
@@ -139617,9 +139617,9 @@ ${lanes.join("\n")}
           return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
         }
         BuilderState2.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
-        function updateSignatureOfFile(state, signature, path4) {
-          state.fileInfos.get(path4).signature = signature;
-          (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path4);
+        function updateSignatureOfFile(state, signature, path5) {
+          state.fileInfos.get(path5).signature = signature;
+          (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path5);
         }
         BuilderState2.updateSignatureOfFile = updateSignatureOfFile;
         function computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, onNewSignature) {
@@ -139688,10 +139688,10 @@ ${lanes.join("\n")}
           const seenMap = /* @__PURE__ */ new Set();
           const queue = [sourceFile.resolvedPath];
           while (queue.length) {
-            const path4 = queue.pop();
-            if (!seenMap.has(path4)) {
-              seenMap.add(path4);
-              const references = state.referencedMap.getValues(path4);
+            const path5 = queue.pop();
+            if (!seenMap.has(path5)) {
+              seenMap.add(path5);
+              const references = state.referencedMap.getValues(path5);
               if (references) {
                 for (const key of references.keys()) {
                   queue.push(key);
@@ -139699,9 +139699,9 @@ ${lanes.join("\n")}
               }
             }
           }
-          return arrayFrom(mapDefinedIterator(seenMap.keys(), (path4) => {
+          return arrayFrom(mapDefinedIterator(seenMap.keys(), (path5) => {
             var _a;
-            return ((_a = programOfThisState.getSourceFileByPath(path4)) == null ? void 0 : _a.fileName) ?? path4;
+            return ((_a = programOfThisState.getSourceFileByPath(path5)) == null ? void 0 : _a.fileName) ?? path5;
           }));
         }
         BuilderState2.getAllDependencies = getAllDependencies;
@@ -139880,7 +139880,7 @@ ${lanes.join("\n")}
           oldInfo.version !== info.version || // Implied formats dont match
           oldInfo.impliedFormat !== info.impliedFormat || // Referenced files changed
           !hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) || // Referenced file was deleted in the new program
-          newReferences && forEachKey(newReferences, (path4) => !state.fileInfos.has(path4) && oldState.fileInfos.has(path4))) {
+          newReferences && forEachKey(newReferences, (path5) => !state.fileInfos.has(path5) && oldState.fileInfos.has(path5))) {
             addFileToChangeSet(sourceFilePath);
           } else {
             const sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
@@ -139946,8 +139946,8 @@ ${lanes.join("\n")}
         }
         if (useOldState && state.semanticDiagnosticsPerFile.size !== state.fileInfos.size && oldState.checkPending !== state.checkPending) state.buildInfoEmitPending = true;
         return state;
-        function addFileToChangeSet(path4) {
-          state.changedFilesSet.add(path4);
+        function addFileToChangeSet(path5) {
+          state.changedFilesSet.add(path5);
           if (outFilePath) {
             canCopySemanticDiagnostics = false;
             canCopyEmitDiagnostics = false;
@@ -140011,9 +140011,9 @@ ${lanes.join("\n")}
           result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, diagnosticFilePath, newProgram, toPathInBuildInfoDirectory)) : [] : void 0;
           return result;
         });
-        function toPathInBuildInfoDirectory(path4) {
+        function toPathInBuildInfoDirectory(path5) {
           buildInfoDirectory ?? (buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory())));
-          return toPath(path4, buildInfoDirectory, newProgram.getCanonicalFileName);
+          return toPath(path5, buildInfoDirectory, newProgram.getCanonicalFileName);
         }
       }
       function convertToDiagnosticRelatedInformation(diagnostic, diagnosticFilePath, newProgram, toPath3) {
@@ -140088,10 +140088,10 @@ ${lanes.join("\n")}
           state.affectedFilesPendingEmit = void 0;
           state.programEmitPending = void 0;
         }
-        (_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.forEach((emitKind, path4) => {
+        (_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.forEach((emitKind, path5) => {
           const pending = !isForDtsErrors ? emitKind & 7 : emitKind & (7 | 48);
-          if (!pending) state.affectedFilesPendingEmit.delete(path4);
-          else state.affectedFilesPendingEmit.set(path4, pending);
+          if (!pending) state.affectedFilesPendingEmit.delete(path5);
+          else state.affectedFilesPendingEmit.set(path5, pending);
         });
         if (state.programEmitPending) {
           const pending = !isForDtsErrors ? state.programEmitPending & 7 : state.programEmitPending & (7 | 48);
@@ -140111,11 +140111,11 @@ ${lanes.join("\n")}
       function getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles, isForDtsErrors) {
         var _a;
         if (!((_a = state.affectedFilesPendingEmit) == null ? void 0 : _a.size)) return void 0;
-        return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path4) => {
+        return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path5) => {
           var _a2;
-          const affectedFile = state.program.getSourceFileByPath(path4);
+          const affectedFile = state.program.getSourceFileByPath(path5);
           if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
-            state.affectedFilesPendingEmit.delete(path4);
+            state.affectedFilesPendingEmit.delete(path5);
             return void 0;
           }
           const seenKind = (_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedFile.resolvedPath);
@@ -140131,11 +140131,11 @@ ${lanes.join("\n")}
       function getNextPendingEmitDiagnosticsFile(state, isForDtsErrors) {
         var _a;
         if (!((_a = state.emitDiagnosticsPerFile) == null ? void 0 : _a.size)) return void 0;
-        return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path4) => {
+        return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path5) => {
           var _a2;
-          const affectedFile = state.program.getSourceFileByPath(path4);
+          const affectedFile = state.program.getSourceFileByPath(path5);
           if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
-            state.emitDiagnosticsPerFile.delete(path4);
+            state.emitDiagnosticsPerFile.delete(path5);
             return void 0;
           }
           const seenKind = ((_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedFile.resolvedPath)) || 0;
@@ -140170,10 +140170,10 @@ ${lanes.join("\n")}
           host
         );
       }
-      function handleDtsMayChangeOf(state, path4, invalidateJsFiles, cancellationToken, host) {
-        removeSemanticDiagnosticsOf(state, path4);
-        if (!state.changedFilesSet.has(path4)) {
-          const sourceFile = state.program.getSourceFileByPath(path4);
+      function handleDtsMayChangeOf(state, path5, invalidateJsFiles, cancellationToken, host) {
+        removeSemanticDiagnosticsOf(state, path5);
+        if (!state.changedFilesSet.has(path5)) {
+          const sourceFile = state.program.getSourceFileByPath(path5);
           if (sourceFile) {
             BuilderState.updateShapeSignature(
               state,
@@ -140187,13 +140187,13 @@ ${lanes.join("\n")}
             if (invalidateJsFiles) {
               addToAffectedFilesPendingEmit(
                 state,
-                path4,
+                path5,
                 getBuilderFileEmit(state.compilerOptions)
               );
             } else if (getEmitDeclarations(state.compilerOptions)) {
               addToAffectedFilesPendingEmit(
                 state,
-                path4,
+                path5,
                 state.compilerOptions.declarationMap ? 56 : 24
                 /* Dts */
               );
@@ -140201,17 +140201,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function removeSemanticDiagnosticsOf(state, path4) {
+      function removeSemanticDiagnosticsOf(state, path5) {
         if (!state.semanticDiagnosticsFromOldState) {
           return true;
         }
-        state.semanticDiagnosticsFromOldState.delete(path4);
-        state.semanticDiagnosticsPerFile.delete(path4);
+        state.semanticDiagnosticsFromOldState.delete(path5);
+        state.semanticDiagnosticsPerFile.delete(path5);
         return !state.semanticDiagnosticsFromOldState.size;
       }
-      function isChangedSignature(state, path4) {
-        const oldSignature = Debug.checkDefined(state.oldSignatures).get(path4) || void 0;
-        const newSignature = Debug.checkDefined(state.fileInfos.get(path4)).signature;
+      function isChangedSignature(state, path5) {
+        const oldSignature = Debug.checkDefined(state.oldSignatures).get(path5) || void 0;
+        const newSignature = Debug.checkDefined(state.fileInfos.get(path5)).signature;
         return newSignature !== oldSignature;
       }
       function handleDtsMayChangeOfGlobalScope(state, filePath, invalidateJsFiles, cancellationToken, host) {
@@ -140318,13 +140318,13 @@ ${lanes.join("\n")}
       }
       function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken, semanticDiagnosticsPerFile) {
         semanticDiagnosticsPerFile ?? (semanticDiagnosticsPerFile = state.semanticDiagnosticsPerFile);
-        const path4 = sourceFile.resolvedPath;
-        const cachedDiagnostics = semanticDiagnosticsPerFile.get(path4);
+        const path5 = sourceFile.resolvedPath;
+        const cachedDiagnostics = semanticDiagnosticsPerFile.get(path5);
         if (cachedDiagnostics) {
           return filterSemanticDiagnostics(cachedDiagnostics, state.compilerOptions);
         }
         const diagnostics = state.program.getBindAndCheckDiagnostics(sourceFile, cancellationToken);
-        semanticDiagnosticsPerFile.set(path4, diagnostics);
+        semanticDiagnosticsPerFile.set(path5, diagnostics);
         state.buildInfoEmitPending = true;
         return filterSemanticDiagnostics(diagnostics, state.compilerOptions);
       }
@@ -140378,7 +140378,7 @@ ${lanes.join("\n")}
             root: arrayFrom(rootFileNames, (r) => relativeToBuildInfo(r)),
             errors: state.hasErrors ? true : void 0,
             checkPending: state.checkPending,
-            version
+            version: version2
           };
           return buildInfo2;
         }
@@ -140410,7 +140410,7 @@ ${lanes.join("\n")}
             // Actual value
             errors: state.hasErrors ? true : void 0,
             checkPending: state.checkPending,
-            version
+            version: version2
           };
           return buildInfo2;
         }
@@ -140472,11 +140472,11 @@ ${lanes.join("\n")}
         if ((_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.size) {
           const fullEmitForOptions = getBuilderFileEmit(state.compilerOptions);
           const seenFiles = /* @__PURE__ */ new Set();
-          for (const path4 of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
-            if (tryAddToSet(seenFiles, path4)) {
-              const file = state.program.getSourceFileByPath(path4);
+          for (const path5 of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
+            if (tryAddToSet(seenFiles, path5)) {
+              const file = state.program.getSourceFileByPath(path5);
               if (!file || !sourceFileMayBeEmitted(file, state.program)) continue;
-              const fileId = toFileId(path4), pendingEmit = state.affectedFilesPendingEmit.get(path4);
+              const fileId = toFileId(path5), pendingEmit = state.affectedFilesPendingEmit.get(path5);
               affectedFilesPendingEmit = append(
                 affectedFilesPendingEmit,
                 pendingEmit === fullEmitForOptions ? fileId : (
@@ -140507,20 +140507,20 @@ ${lanes.join("\n")}
           latestChangedDtsFile,
           errors: state.hasErrors ? true : void 0,
           checkPending: state.checkPending,
-          version
+          version: version2
         };
         return buildInfo;
-        function relativeToBuildInfoEnsuringAbsolutePath(path4) {
-          return relativeToBuildInfo(getNormalizedAbsolutePath(path4, currentDirectory));
+        function relativeToBuildInfoEnsuringAbsolutePath(path5) {
+          return relativeToBuildInfo(getNormalizedAbsolutePath(path5, currentDirectory));
         }
-        function relativeToBuildInfo(path4) {
-          return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path4, state.program.getCanonicalFileName));
+        function relativeToBuildInfo(path5) {
+          return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path5, state.program.getCanonicalFileName));
         }
-        function toFileId(path4) {
-          let fileId = fileNameToFileId.get(path4);
+        function toFileId(path5) {
+          let fileId = fileNameToFileId.get(path5);
           if (fileId === void 0) {
-            fileNames.push(relativeToBuildInfo(path4));
-            fileNameToFileId.set(path4, fileId = fileNames.length);
+            fileNames.push(relativeToBuildInfo(path5));
+            fileNameToFileId.set(path5, fileId = fileNames.length);
           }
           return fileId;
         }
@@ -140534,8 +140534,8 @@ ${lanes.join("\n")}
           }
           return fileIdListId;
         }
-        function tryAddRoot(path4, fileId) {
-          const file = state.program.getSourceFile(path4);
+        function tryAddRoot(path5, fileId) {
+          const file = state.program.getSourceFile(path5);
           if (!state.program.getFileIncludeReasons().get(file.path).some(
             (r) => r.kind === 0
             /* RootFile */
@@ -140552,10 +140552,10 @@ ${lanes.join("\n")}
         }
         function toResolvedRoot() {
           let result;
-          rootFileNames.forEach((path4) => {
-            const file = state.program.getSourceFileByPath(path4);
-            if (file && path4 !== file.resolvedPath) {
-              result = append(result, [toFileId(file.resolvedPath), toFileId(path4)]);
+          rootFileNames.forEach((path5) => {
+            const file = state.program.getSourceFileByPath(path5);
+            if (file && path5 !== file.resolvedPath) {
+              result = append(result, [toFileId(file.resolvedPath), toFileId(path5)]);
             }
           });
           return result;
@@ -140663,8 +140663,8 @@ ${lanes.join("\n")}
         function toChangeFileSet() {
           let changeFileSet;
           if (state.changedFilesSet.size) {
-            for (const path4 of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
-              changeFileSet = append(changeFileSet, toFileId(path4));
+            for (const path5 of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
+              changeFileSet = append(changeFileSet, toFileId(path5));
             }
           }
           return changeFileSet;
@@ -141163,8 +141163,8 @@ ${lanes.join("\n")}
         const changedFilesSet = new Set(map(buildInfo.changeFileSet, toFilePath));
         if (isIncrementalBundleEmitBuildInfo(buildInfo)) {
           buildInfo.fileInfos.forEach((fileInfo, index) => {
-            const path4 = toFilePath(index + 1);
-            fileInfos.set(path4, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
+            const path5 = toFilePath(index + 1);
+            fileInfos.set(path5, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
           });
           state = {
             fileInfos,
@@ -141183,10 +141183,10 @@ ${lanes.join("\n")}
           filePathsSetList = (_b = buildInfo.fileIdsList) == null ? void 0 : _b.map((fileIds) => new Set(fileIds.map(toFilePath)));
           const emitSignatures = ((_c = buildInfo.options) == null ? void 0 : _c.composite) && !buildInfo.options.outFile ? /* @__PURE__ */ new Map() : void 0;
           buildInfo.fileInfos.forEach((fileInfo, index) => {
-            const path4 = toFilePath(index + 1);
+            const path5 = toFilePath(index + 1);
             const stateFileInfo = toBuilderStateFileInfoForMultiEmit(fileInfo);
-            fileInfos.set(path4, stateFileInfo);
-            if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path4, stateFileInfo.signature);
+            fileInfos.set(path5, stateFileInfo);
+            if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path5, stateFileInfo.signature);
           });
           (_d = buildInfo.emitSignatures) == null ? void 0 : _d.forEach((value) => {
             if (isNumber(value)) emitSignatures.delete(toFilePath(value));
@@ -141240,11 +141240,11 @@ ${lanes.join("\n")}
           close: noop,
           hasChangedEmitSignature: returnFalse
         };
-        function toPathInBuildInfoDirectory(path4) {
-          return toPath(path4, buildInfoDirectory, getCanonicalFileName);
+        function toPathInBuildInfoDirectory(path5) {
+          return toPath(path5, buildInfoDirectory, getCanonicalFileName);
         }
-        function toAbsolutePath(path4) {
-          return getNormalizedAbsolutePath(path4, buildInfoDirectory);
+        function toAbsolutePath(path5) {
+          return getNormalizedAbsolutePath(path5, buildInfoDirectory);
         }
         function toFilePath(fileId) {
           return filePaths[fileId - 1];
@@ -141283,30 +141283,30 @@ ${lanes.join("\n")}
         const roots = /* @__PURE__ */ new Map();
         const resolvedRoots = new Map(program2.resolvedRoot);
         program2.fileInfos.forEach((fileInfo, index) => {
-          const path4 = toPath(program2.fileNames[index], buildInfoDirectory, getCanonicalFileName);
-          const version2 = isString(fileInfo) ? fileInfo : fileInfo.version;
-          fileInfos.set(path4, version2);
+          const path5 = toPath(program2.fileNames[index], buildInfoDirectory, getCanonicalFileName);
+          const version22 = isString(fileInfo) ? fileInfo : fileInfo.version;
+          fileInfos.set(path5, version22);
           if (rootIndex < program2.root.length) {
             const current = program2.root[rootIndex];
             const fileId = index + 1;
             if (isArray(current)) {
               if (current[0] <= fileId && fileId <= current[1]) {
-                addRoot(fileId, path4);
+                addRoot(fileId, path5);
                 if (current[1] === fileId) rootIndex++;
               }
             } else if (current === fileId) {
-              addRoot(fileId, path4);
+              addRoot(fileId, path5);
               rootIndex++;
             }
           }
         });
         return { fileInfos, roots };
-        function addRoot(fileId, path4) {
+        function addRoot(fileId, path5) {
           const root = resolvedRoots.get(fileId);
           if (root) {
-            roots.set(toPath(program2.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path4);
+            roots.set(toPath(program2.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path5);
           } else {
-            roots.set(path4, void 0);
+            roots.set(path5, void 0);
           }
         }
       }
@@ -141381,11 +141381,11 @@ ${lanes.join("\n")}
           newConfigFileParsingDiagnostics
         );
       }
-      function removeIgnoredPath(path4) {
-        if (endsWith(path4, "/node_modules/.staging")) {
-          return removeSuffix(path4, "/.staging");
+      function removeIgnoredPath(path5) {
+        if (endsWith(path5, "/node_modules/.staging")) {
+          return removeSuffix(path5, "/.staging");
         }
-        return some(ignoredPaths, (searchPath) => path4.includes(searchPath)) ? void 0 : path4;
+        return some(ignoredPaths, (searchPath) => path5.includes(searchPath)) ? void 0 : path5;
       }
       function perceivedOsRootLengthForWatching(pathComponents2, length2) {
         if (length2 <= 1) return 1;
@@ -141411,8 +141411,8 @@ ${lanes.join("\n")}
         const perceivedOsRootLength = perceivedOsRootLengthForWatching(pathComponents2, length2);
         return length2 > perceivedOsRootLength + 1;
       }
-      function canWatchDirectoryOrFilePath(path4) {
-        return canWatchDirectoryOrFile(getPathComponents(path4));
+      function canWatchDirectoryOrFilePath(path5) {
+        return canWatchDirectoryOrFile(getPathComponents(path5));
       }
       function canWatchAtTypes(atTypes) {
         return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(getDirectoryPath(atTypes));
@@ -141706,11 +141706,11 @@ ${lanes.join("\n")}
           filesWithChangedSetOfUnresolvedImports = void 0;
           return collected;
         }
-        function isFileWithInvalidatedNonRelativeUnresolvedImports(path4) {
+        function isFileWithInvalidatedNonRelativeUnresolvedImports(path5) {
           if (!filesWithInvalidatedNonRelativeUnresolvedImports) {
             return false;
           }
-          const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path4);
+          const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path5);
           return !!value && !!value.length;
         }
         function createHasInvalidatedResolutions(customHasInvalidatedResolutions, customHasInvalidatedLibResolutions) {
@@ -141718,7 +141718,7 @@ ${lanes.join("\n")}
           const collected = filesWithInvalidatedResolutions;
           filesWithInvalidatedResolutions = void 0;
           return {
-            hasInvalidatedResolutions: (path4) => customHasInvalidatedResolutions(path4) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path4)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path4),
+            hasInvalidatedResolutions: (path5) => customHasInvalidatedResolutions(path5) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path5)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path5),
             hasInvalidatedLibResolutions: (libFileName) => {
               var _a;
               return customHasInvalidatedLibResolutions(libFileName) || !!((_a = resolvedLibraries == null ? void 0 : resolvedLibraries.get(libFileName)) == null ? void 0 : _a.isInvalidated);
@@ -141774,11 +141774,11 @@ ${lanes.join("\n")}
               if (expected) impliedFormatPackageJsons.set(newFile.resolvedPath, newFile.packageJsonLocations);
               else impliedFormatPackageJsons.delete(newFile.resolvedPath);
             });
-            impliedFormatPackageJsons.forEach((existing, path4) => {
-              const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path4);
-              if (!newFile || newFile.resolvedPath !== path4) {
+            impliedFormatPackageJsons.forEach((existing, path5) => {
+              const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path5);
+              if (!newFile || newFile.resolvedPath !== path5) {
                 existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
-                impliedFormatPackageJsons.delete(path4);
+                impliedFormatPackageJsons.delete(path5);
               }
             });
           }
@@ -141797,16 +141797,16 @@ ${lanes.join("\n")}
             packageDirWatchers.delete(packageDirPath);
           }
         }
-        function closeDirectoryWatchesOfFailedLookup(watcher, path4) {
+        function closeDirectoryWatchesOfFailedLookup(watcher, path5) {
           if (watcher.refCount === 0) {
-            directoryWatchesOfFailedLookups.delete(path4);
+            directoryWatchesOfFailedLookups.delete(path5);
             watcher.watcher.close();
           }
         }
-        function closeFileWatcherOfAffectingLocation(watcher, path4) {
+        function closeFileWatcherOfAffectingLocation(watcher, path5) {
           var _a;
           if (watcher.files === 0 && watcher.resolutions === 0 && !((_a = watcher.symlinks) == null ? void 0 : _a.size)) {
-            fileWatchesOfAffectingLocations.delete(path4);
+            fileWatchesOfAffectingLocations.delete(path5);
             watcher.watcher.close();
           }
         }
@@ -141825,10 +141825,10 @@ ${lanes.join("\n")}
           logChanges
         }) {
           var _a;
-          const path4 = resolutionHost.toPath(containingFile);
-          const resolutionsInFile = perFileCache.get(path4) || perFileCache.set(path4, createModeAwareCache()).get(path4);
+          const path5 = resolutionHost.toPath(containingFile);
+          const resolutionsInFile = perFileCache.get(path5) || perFileCache.set(path5, createModeAwareCache()).get(path5);
           const resolvedModules = [];
-          const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path4);
+          const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path5);
           const program2 = resolutionHost.getCurrentProgram();
           const oldRedirect = program2 && ((_a = program2.getRedirectFromSourceFile(containingFile)) == null ? void 0 : _a.resolvedRef);
           const unmatchedRedirects = oldRedirect ? !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : !!redirectedReference;
@@ -141846,13 +141846,13 @@ ${lanes.join("\n")}
               }
               resolutionsInFile.set(name, mode, resolution);
               if (resolution !== existingResolution) {
-                watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path4, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
+                watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path5, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
                 if (existingResolution) {
-                  stopWatchFailedLookupLocationOfResolution(existingResolution, path4, getResolutionWithResolvedFileName);
+                  stopWatchFailedLookupLocationOfResolution(existingResolution, path5, getResolutionWithResolvedFileName);
                 }
               }
               if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
-                filesWithChangedSetOfUnresolvedImports.push(path4);
+                filesWithChangedSetOfUnresolvedImports.push(path5);
                 logChanges = false;
               }
             } else {
@@ -141883,7 +141883,7 @@ ${lanes.join("\n")}
           if (resolutionsInFile.size() !== seenNamesInFile.size()) {
             resolutionsInFile.forEach((resolution, name, mode) => {
               if (!seenNamesInFile.has(name, mode)) {
-                stopWatchFailedLookupLocationOfResolution(resolution, path4, getResolutionWithResolvedFileName);
+                stopWatchFailedLookupLocationOfResolution(resolution, path5, getResolutionWithResolvedFileName);
                 resolutionsInFile.delete(name, mode);
               }
             });
@@ -141957,18 +141957,18 @@ ${lanes.join("\n")}
           if (!resolution || resolution.isInvalidated) {
             const existingResolution = resolution;
             resolution = resolveLibrary(libraryName, resolveFrom, options, host, libraryResolutionCache);
-            const path4 = resolutionHost.toPath(resolveFrom);
+            const path5 = resolutionHost.toPath(resolveFrom);
             watchFailedLookupLocationsOfExternalModuleResolutions(
               libraryName,
               resolution,
-              path4,
+              path5,
               getResolvedModuleFromResolution,
               /*deferWatchingNonRelativeResolution*/
               false
             );
             resolvedLibraries.set(libFileName, resolution);
             if (existingResolution) {
-              stopWatchFailedLookupLocationOfResolution(existingResolution, path4, getResolvedModuleFromResolution);
+              stopWatchFailedLookupLocationOfResolution(existingResolution, path5, getResolvedModuleFromResolution);
             }
           } else {
             if (isTraceEnabled(options, host)) {
@@ -141987,8 +141987,8 @@ ${lanes.join("\n")}
         }
         function resolveSingleModuleNameWithoutWatching(moduleName, containingFile) {
           var _a, _b;
-          const path4 = resolutionHost.toPath(containingFile);
-          const resolutionsInFile = resolvedModuleNames.get(path4);
+          const path5 = resolutionHost.toPath(containingFile);
+          const resolutionsInFile = resolvedModuleNames.get(path5);
           const resolution = resolutionsInFile == null ? void 0 : resolutionsInFile.get(
             moduleName,
             /*mode*/
@@ -142145,13 +142145,13 @@ ${lanes.join("\n")}
             (symlinkWatcher.symlinks ?? (symlinkWatcher.symlinks = /* @__PURE__ */ new Set())).add(affectingLocation);
           }
         }
-        function invalidateAffectingFileWatcher(path4, packageJsonMap) {
+        function invalidateAffectingFileWatcher(path5, packageJsonMap) {
           var _a;
-          const watcher = fileWatchesOfAffectingLocations.get(path4);
-          if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path4);
-          if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path4);
+          const watcher = fileWatchesOfAffectingLocations.get(path5);
+          if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path5);
+          if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path5);
           (_a = watcher == null ? void 0 : watcher.symlinks) == null ? void 0 : _a.forEach((path22) => invalidateAffectingFileWatcher(path22, packageJsonMap));
-          packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path4));
+          packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path5));
         }
         function watchFailedLookupLocationOfNonRelativeModuleResolutions() {
           nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfResolution);
@@ -142390,7 +142390,7 @@ ${lanes.join("\n")}
         function invalidatePackageJsonMap() {
           const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
           if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) {
-            packageJsonMap.forEach((_value, path4) => isInvalidatedFailedLookup(path4) ? packageJsonMap.delete(path4) : void 0);
+            packageJsonMap.forEach((_value, path5) => isInvalidatedFailedLookup(path5) ? packageJsonMap.delete(path5) : void 0);
           }
         }
         function invalidateResolutionsOfFailedLookupLocations() {
@@ -143008,9 +143008,9 @@ ${lanes.join("\n")}
           getDefaultLibLocation: maybeBind(host, host.getDefaultLibLocation),
           getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
           writeFile: createWriteFileMeasuringIO(
-            (path4, data, writeByteOrderMark) => host.writeFile(path4, data, writeByteOrderMark),
-            (path4) => host.createDirectory(path4),
-            (path4) => host.directoryExists(path4)
+            (path5, data, writeByteOrderMark) => host.writeFile(path5, data, writeByteOrderMark),
+            (path5) => host.createDirectory(path5),
+            (path5) => host.directoryExists(path5)
           ),
           getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
           useCaseSensitiveFileNames: () => useCaseSensitiveFileNames2,
@@ -143081,16 +143081,16 @@ ${lanes.join("\n")}
           getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
           getDefaultLibLocation,
           getDefaultLibFileName: (options) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
-          fileExists: (path4) => system.fileExists(path4),
-          readFile: (path4, encoding) => system.readFile(path4, encoding),
-          directoryExists: (path4) => system.directoryExists(path4),
-          getDirectories: (path4) => system.getDirectories(path4),
-          readDirectory: (path4, extensions, exclude, include, depth) => system.readDirectory(path4, extensions, exclude, include, depth),
+          fileExists: (path5) => system.fileExists(path5),
+          readFile: (path5, encoding) => system.readFile(path5, encoding),
+          directoryExists: (path5) => system.directoryExists(path5),
+          getDirectories: (path5) => system.getDirectories(path5),
+          readDirectory: (path5, extensions, exclude, include, depth) => system.readDirectory(path5, extensions, exclude, include, depth),
           realpath: maybeBind(system, system.realpath),
           getEnvironmentVariable: maybeBind(system, system.getEnvironmentVariable),
           trace: (s) => system.write(s + system.newLine),
-          createDirectory: (path4) => system.createDirectory(path4),
-          writeFile: (path4, data, writeByteOrderMark) => system.writeFile(path4, data, writeByteOrderMark),
+          createDirectory: (path5) => system.createDirectory(path5),
+          writeFile: (path5, data, writeByteOrderMark) => system.writeFile(path5, data, writeByteOrderMark),
           createHash: maybeBind(system, system.createHash),
           createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
           storeSignatureInfo: system.storeSignatureInfo,
@@ -143185,7 +143185,7 @@ ${lanes.join("\n")}
           if (!content) return void 0;
           buildInfo = getBuildInfo(buildInfoPath, content);
         }
-        if (!buildInfo || buildInfo.version !== version || !isIncrementalBuildInfo(buildInfo)) return void 0;
+        if (!buildInfo || buildInfo.version !== version2 || !isIncrementalBuildInfo(buildInfo)) return void 0;
         return createBuilderProgramUsingIncrementalBuildInfo(buildInfo, buildInfoPath, host);
       }
       function createIncrementalCompilerHost(options, system = sys) {
@@ -143403,7 +143403,7 @@ ${lanes.join("\n")}
             originalWriteFile,
             readFileWithCache
           } = changeCompilerHostLikeToUseCache(compilerHost, toPath3);
-          if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path4) => getSourceVersion(path4, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+          if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path5) => getSourceVersion(path5, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
             if (hasChangedConfigFileParsingErrors) {
               if (reportFileChangeDetectedOnCreateProgram) {
                 reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
@@ -143497,14 +143497,14 @@ ${lanes.join("\n")}
           return typeof hostSourceFile.version === "boolean";
         }
         function fileExists(fileName) {
-          const path4 = toPath3(fileName);
-          if (isFileMissingOnHost(sourceFilesCache.get(path4))) {
+          const path5 = toPath3(fileName);
+          if (isFileMissingOnHost(sourceFilesCache.get(path5))) {
             return false;
           }
           return directoryStructureHost.fileExists(fileName);
         }
-        function getVersionedSourceFileByPath(fileName, path4, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
-          const hostSourceFile = sourceFilesCache.get(path4);
+        function getVersionedSourceFileByPath(fileName, path5, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
+          const hostSourceFile = sourceFilesCache.get(path5);
           if (isFileMissingOnHost(hostSourceFile)) {
             return void 0;
           }
@@ -143516,41 +143516,41 @@ ${lanes.join("\n")}
                 hostSourceFile.sourceFile = sourceFile;
                 hostSourceFile.version = sourceFile.version;
                 if (!hostSourceFile.fileWatcher) {
-                  hostSourceFile.fileWatcher = watchFilePath(path4, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
+                  hostSourceFile.fileWatcher = watchFilePath(path5, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
                 }
               } else {
                 if (hostSourceFile.fileWatcher) {
                   hostSourceFile.fileWatcher.close();
                 }
-                sourceFilesCache.set(path4, false);
+                sourceFilesCache.set(path5, false);
               }
             } else {
               if (sourceFile) {
-                const fileWatcher = watchFilePath(path4, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
-                sourceFilesCache.set(path4, { sourceFile, version: sourceFile.version, fileWatcher });
+                const fileWatcher = watchFilePath(path5, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
+                sourceFilesCache.set(path5, { sourceFile, version: sourceFile.version, fileWatcher });
               } else {
-                sourceFilesCache.set(path4, false);
+                sourceFilesCache.set(path5, false);
               }
             }
             return sourceFile;
           }
           return hostSourceFile.sourceFile;
         }
-        function nextSourceFileVersion(path4) {
-          const hostSourceFile = sourceFilesCache.get(path4);
+        function nextSourceFileVersion(path5) {
+          const hostSourceFile = sourceFilesCache.get(path5);
           if (hostSourceFile !== void 0) {
             if (isFileMissingOnHost(hostSourceFile)) {
-              sourceFilesCache.set(path4, { version: false });
+              sourceFilesCache.set(path5, { version: false });
             } else {
               hostSourceFile.version = false;
             }
           }
         }
-        function getSourceVersion(path4, readFileWithCache) {
-          const hostSourceFile = sourceFilesCache.get(path4);
+        function getSourceVersion(path5, readFileWithCache) {
+          const hostSourceFile = sourceFilesCache.get(path5);
           if (!hostSourceFile) return void 0;
           if (hostSourceFile.version) return hostSourceFile.version;
-          const text = readFileWithCache(path4);
+          const text = readFileWithCache(path5);
           return text !== void 0 ? getSourceFileVersionAsHashFromText(compilerHost, text) : void 0;
         }
         function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) {
@@ -143729,28 +143729,28 @@ ${lanes.join("\n")}
         }
         function onReleaseParsedCommandLine(fileName) {
           var _a;
-          const path4 = toPath3(fileName);
-          const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(path4);
+          const path5 = toPath3(fileName);
+          const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(path5);
           if (!config2) return;
-          parsedConfigs.delete(path4);
+          parsedConfigs.delete(path5);
           if (config2.watchedDirectories) clearMap(config2.watchedDirectories, closeFileWatcherOf);
           (_a = config2.watcher) == null ? void 0 : _a.close();
-          clearSharedExtendedConfigFileWatcher(path4, sharedExtendedConfigFileWatchers);
+          clearSharedExtendedConfigFileWatcher(path5, sharedExtendedConfigFileWatchers);
         }
-        function watchFilePath(path4, file, callback, pollingInterval, options, watchType) {
-          return watchFile2(file, (fileName, eventKind) => callback(fileName, eventKind, path4), pollingInterval, options, watchType);
+        function watchFilePath(path5, file, callback, pollingInterval, options, watchType) {
+          return watchFile2(file, (fileName, eventKind) => callback(fileName, eventKind, path5), pollingInterval, options, watchType);
         }
-        function onSourceFileChange(fileName, eventKind, path4) {
-          updateCachedSystemWithFile(fileName, path4, eventKind);
-          if (eventKind === 2 && sourceFilesCache.has(path4)) {
-            resolutionCache.invalidateResolutionOfFile(path4);
+        function onSourceFileChange(fileName, eventKind, path5) {
+          updateCachedSystemWithFile(fileName, path5, eventKind);
+          if (eventKind === 2 && sourceFilesCache.has(path5)) {
+            resolutionCache.invalidateResolutionOfFile(path5);
           }
-          nextSourceFileVersion(path4);
+          nextSourceFileVersion(path5);
           scheduleProgramUpdate();
         }
-        function updateCachedSystemWithFile(fileName, path4, eventKind) {
+        function updateCachedSystemWithFile(fileName, path5, eventKind) {
           if (cachedDirectoryStructureHost) {
-            cachedDirectoryStructureHost.addOrDeleteFile(fileName, path4, eventKind);
+            cachedDirectoryStructureHost.addOrDeleteFile(fileName, path5, eventKind);
           }
         }
         function watchMissingFilePath(missingFilePath, missingFileName) {
@@ -143971,9 +143971,9 @@ ${lanes.join("\n")}
       }
       function createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus) {
         const host = createProgramHost(system, createProgram2);
-        host.getModifiedTime = system.getModifiedTime ? (path4) => system.getModifiedTime(path4) : returnUndefined;
-        host.setModifiedTime = system.setModifiedTime ? (path4, date) => system.setModifiedTime(path4, date) : noop;
-        host.deleteFile = system.deleteFile ? (path4) => system.deleteFile(path4) : noop;
+        host.getModifiedTime = system.getModifiedTime ? (path5) => system.getModifiedTime(path5) : returnUndefined;
+        host.setModifiedTime = system.setModifiedTime ? (path5, date) => system.setModifiedTime(path5, date) : noop;
+        host.deleteFile = system.deleteFile ? (path5) => system.deleteFile(path5) : noop;
         host.reportDiagnostic = reportDiagnostic || createDiagnosticReporter(system);
         host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system);
         host.now = maybeBind(system, system.now);
@@ -144144,8 +144144,8 @@ ${lanes.join("\n")}
       }
       function toResolvedConfigFilePath(state, fileName) {
         const { resolvedConfigFilePaths } = state;
-        const path4 = resolvedConfigFilePaths.get(fileName);
-        if (path4 !== void 0) return path4;
+        const path5 = resolvedConfigFilePaths.get(fileName);
+        if (path5 !== void 0) return path5;
         const resolvedPath = toPath2(state, fileName);
         resolvedConfigFilePaths.set(fileName, resolvedPath);
         return resolvedPath;
@@ -144533,7 +144533,7 @@ ${lanes.join("\n")}
             void 0,
             (name, text, writeByteOrderMark, onError, sourceFiles, data) => {
               var _a2;
-              const path4 = toPath2(state, name);
+              const path5 = toPath2(state, name);
               emittedOutputs.set(toPath2(state, name), name);
               if (data == null ? void 0 : data.buildInfo) {
                 now || (now = getCurrentTime(state.host));
@@ -144563,7 +144563,7 @@ ${lanes.join("\n")}
               );
               if (data == null ? void 0 : data.differsOnlyInMap) state.host.setModifiedTime(name, modifiedTime);
               else if (!isIncremental && state.watch) {
-                (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path4, now || (now = getCurrentTime(state.host)));
+                (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path5, now || (now = getCurrentTime(state.host)));
               }
             },
             cancellationToken,
@@ -144747,8 +144747,8 @@ ${lanes.join("\n")}
         return !!value.watcher;
       }
       function getModifiedTime2(state, fileName) {
-        const path4 = toPath2(state, fileName);
-        const existing = state.filesWatched.get(path4);
+        const path5 = toPath2(state, fileName);
+        const existing = state.filesWatched.get(path5);
         if (state.watch && !!existing) {
           if (!isFileWatcherWithModifiedTime(existing)) return existing;
           if (existing.modifiedTime) return existing.modifiedTime;
@@ -144756,20 +144756,20 @@ ${lanes.join("\n")}
         const result = getModifiedTime(state.host, fileName);
         if (state.watch) {
           if (existing) existing.modifiedTime = result;
-          else state.filesWatched.set(path4, result);
+          else state.filesWatched.set(path5, result);
         }
         return result;
       }
       function watchFile(state, file, callback, pollingInterval, options, watchType, project) {
-        const path4 = toPath2(state, file);
-        const existing = state.filesWatched.get(path4);
+        const path5 = toPath2(state, file);
+        const existing = state.filesWatched.get(path5);
         if (existing && isFileWatcherWithModifiedTime(existing)) {
           existing.callbacks.push(callback);
         } else {
           const watcher = state.watchFile(
             file,
             (fileName, eventKind, modifiedTime) => {
-              const existing2 = Debug.checkDefined(state.filesWatched.get(path4));
+              const existing2 = Debug.checkDefined(state.filesWatched.get(path5));
               Debug.assert(isFileWatcherWithModifiedTime(existing2));
               existing2.modifiedTime = modifiedTime;
               existing2.callbacks.forEach((cb) => cb(fileName, eventKind, modifiedTime));
@@ -144779,14 +144779,14 @@ ${lanes.join("\n")}
             watchType,
             project
           );
-          state.filesWatched.set(path4, { callbacks: [callback], watcher, modifiedTime: existing });
+          state.filesWatched.set(path5, { callbacks: [callback], watcher, modifiedTime: existing });
         }
         return {
           close: () => {
-            const existing2 = Debug.checkDefined(state.filesWatched.get(path4));
+            const existing2 = Debug.checkDefined(state.filesWatched.get(path5));
             Debug.assert(isFileWatcherWithModifiedTime(existing2));
             if (existing2.callbacks.length === 1) {
-              state.filesWatched.delete(path4);
+              state.filesWatched.delete(path5);
               closeFileWatcherOf(existing2);
             } else {
               unorderedRemoveItem(existing2.callbacks, callback);
@@ -144801,19 +144801,19 @@ ${lanes.join("\n")}
         return result;
       }
       function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
-        const path4 = toPath2(state, buildInfoPath);
+        const path5 = toPath2(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
-        return (existing == null ? void 0 : existing.path) === path4 ? existing : void 0;
+        return (existing == null ? void 0 : existing.path) === path5 ? existing : void 0;
       }
       function getBuildInfo3(state, buildInfoPath, resolvedConfigPath, modifiedTime) {
-        const path4 = toPath2(state, buildInfoPath);
+        const path5 = toPath2(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
-        if (existing !== void 0 && existing.path === path4) {
+        if (existing !== void 0 && existing.path === path5) {
           return existing.buildInfo || void 0;
         }
         const value = state.readFileWithCache(buildInfoPath);
         const buildInfo = value ? getBuildInfo(buildInfoPath, value) : void 0;
-        state.buildInfoCache.set(resolvedConfigPath, { path: path4, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
+        state.buildInfoCache.set(resolvedConfigPath, { path: path5, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
         return buildInfo;
       }
       function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) {
@@ -144888,7 +144888,7 @@ ${lanes.join("\n")}
           };
         }
         const incrementalBuildInfo = isIncremental && isIncrementalBuildInfo(buildInfo) ? buildInfo : void 0;
-        if ((incrementalBuildInfo || !isIncremental) && buildInfo.version !== version) {
+        if ((incrementalBuildInfo || !isIncremental) && buildInfo.version !== version2) {
           return {
             type: 14,
             version: buildInfo.version
@@ -144944,17 +144944,17 @@ ${lanes.join("\n")}
           }
           const inputPath = toPath2(state, inputFile);
           if (buildInfoTime < inputTime) {
-            let version2;
+            let version22;
             let currentVersion;
             if (incrementalBuildInfo) {
               if (!buildInfoVersionMap) buildInfoVersionMap = getBuildInfoFileVersionMap(incrementalBuildInfo, buildInfoPath, host);
               const resolvedInputPath = buildInfoVersionMap.roots.get(inputPath);
-              version2 = buildInfoVersionMap.fileInfos.get(resolvedInputPath ?? inputPath);
-              const text = version2 ? state.readFileWithCache(resolvedInputPath ?? inputFile) : void 0;
+              version22 = buildInfoVersionMap.fileInfos.get(resolvedInputPath ?? inputPath);
+              const text = version22 ? state.readFileWithCache(resolvedInputPath ?? inputFile) : void 0;
               currentVersion = text !== void 0 ? getSourceFileVersionAsHashFromText(host, text) : void 0;
-              if (version2 && version2 === currentVersion) pseudoInputUpToDate = true;
+              if (version22 && version22 === currentVersion) pseudoInputUpToDate = true;
             }
-            if (!version2 || version2 !== currentVersion) {
+            if (!version22 || version22 !== currentVersion) {
               return {
                 type: 5,
                 outOfDateOutputFileName: buildInfoPath,
@@ -144994,11 +144994,11 @@ ${lanes.join("\n")}
           const outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
           for (const output of outputs) {
             if (output === buildInfoPath) continue;
-            const path4 = toPath2(state, output);
-            let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path4);
+            const path5 = toPath2(state, output);
+            let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path5);
             if (!outputTime) {
               outputTime = getModifiedTime(state.host, output);
-              outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path4, outputTime);
+              outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path5, outputTime);
             }
             if (outputTime === missingFileModifiedTime) {
               return {
@@ -145052,7 +145052,7 @@ ${lanes.join("\n")}
         const packageJsonLookups = state.lastCachedPackageJsonLookups.get(resolvedPath);
         const dependentPackageFileStatus = packageJsonLookups && forEachKey(
           packageJsonLookups,
-          (path4) => checkConfigFileUpToDateStatus(state, path4, oldestOutputFileTime, oldestOutputFileName)
+          (path5) => checkConfigFileUpToDateStatus(state, path5, oldestOutputFileTime, oldestOutputFileName)
         );
         if (dependentPackageFileStatus) return dependentPackageFileStatus;
         return {
@@ -145102,8 +145102,8 @@ ${lanes.join("\n")}
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
           let reportVerbose = !!state.options.verbose;
           for (const file of outputs) {
-            const path4 = toPath2(state, file);
-            if (skipOutputs == null ? void 0 : skipOutputs.has(path4)) continue;
+            const path5 = toPath2(state, file);
+            if (skipOutputs == null ? void 0 : skipOutputs.has(path5)) continue;
             if (reportVerbose) {
               reportVerbose = false;
               reportStatus(state, verboseMessage, proj.options.configFilePath);
@@ -145111,8 +145111,8 @@ ${lanes.join("\n")}
             host.setModifiedTime(file, now || (now = getCurrentTime(state.host)));
             if (file === buildInfoPath) getBuildInfoCacheEntry(state, buildInfoPath, projectPath).modifiedTime = now;
             else if (outputTimeStampMap) {
-              outputTimeStampMap.set(path4, now);
-              modifiedOutputs.add(path4);
+              outputTimeStampMap.set(path5, now);
+              modifiedOutputs.add(path5);
             }
           }
         }
@@ -145540,8 +145540,8 @@ ${lanes.join("\n")}
           close: () => stopWatching(state)
         };
       }
-      function relName(state, path4) {
-        return convertToRelativePath(path4, state.compilerHost.getCurrentDirectory(), state.compilerHost.getCanonicalFileName);
+      function relName(state, path5) {
+        return convertToRelativePath(path5, state.compilerHost.getCurrentDirectory(), state.compilerHost.getCanonicalFileName);
       }
       function reportStatus(state, message, ...args) {
         state.host.reportSolutionBuilderStatus(createCompilerDiagnostic(message, ...args));
@@ -145707,7 +145707,7 @@ ${lanes.join("\n")}
               Diagnostics.Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2,
               relName(state, configFileName),
               status.version,
-              version
+              version2
             );
           case 17:
             return reportStatus(
@@ -145760,13 +145760,13 @@ ${lanes.join("\n")}
         } else if (file.isDeclarationFile) {
           return "Definitions";
         }
-        const path4 = file.path;
-        if (fileExtensionIsOneOf(path4, supportedTSExtensionsFlat)) {
+        const path5 = file.path;
+        if (fileExtensionIsOneOf(path5, supportedTSExtensionsFlat)) {
           return "TypeScript";
-        } else if (fileExtensionIsOneOf(path4, supportedJSExtensionsFlat)) {
+        } else if (fileExtensionIsOneOf(path5, supportedJSExtensionsFlat)) {
           return "JavaScript";
         } else if (fileExtensionIs(
-          path4,
+          path5,
           ".json"
           /* Json */
         )) {
@@ -145795,7 +145795,7 @@ ${lanes.join("\n")}
         return !!commandLine.options.all ? toSorted(optionDeclarations.concat(tscBuildOption), (a, b) => compareStringsCaseInsensitive(a.name, b.name)) : filter(optionDeclarations.concat(tscBuildOption), (v) => !!v.showInSimplifiedHelpView);
       }
       function printVersion(sys2) {
-        sys2.write(getDiagnosticText(Diagnostics.Version_0, version) + sys2.newLine);
+        sys2.write(getDiagnosticText(Diagnostics.Version_0, version2) + sys2.newLine);
       }
       function createColors(sys2) {
         const showColors = defaultIsPretty(sys2);
@@ -146047,7 +146047,7 @@ ${lanes.join("\n")}
       }
       function printEasyHelp(sys2, simpleOptions) {
         const colors = createColors(sys2);
-        let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
+        let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version2)}`)];
         output.push(colors.bold(getDiagnosticText(Diagnostics.COMMON_COMMANDS)) + sys2.newLine + sys2.newLine);
         example("tsc", Diagnostics.Compiles_the_current_project_tsconfig_json_in_the_working_directory);
         example("tsc app.ts util.ts", Diagnostics.Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options);
@@ -146094,7 +146094,7 @@ ${lanes.join("\n")}
         }
       }
       function printAllHelp(sys2, compilerOptions, buildOptions, watchOptions) {
-        let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
+        let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version2)}`)];
         output = [...output, ...generateSectionOptionsOutput(
           sys2,
           getDiagnosticText(Diagnostics.ALL_COMPILER_OPTIONS),
@@ -146126,7 +146126,7 @@ ${lanes.join("\n")}
         }
       }
       function printBuildHelp(sys2, buildOptions) {
-        let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
+        let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version2)}`)];
         output = [...output, ...generateSectionOptionsOutput(
           sys2,
           getDiagnosticText(Diagnostics.BUILD_OPTIONS),
@@ -146378,7 +146378,7 @@ ${lanes.join("\n")}
             );
           }
         }
-        const commandLine = parseCommandLine(commandLineArgs, (path4) => system.readFile(path4));
+        const commandLine = parseCommandLine(commandLineArgs, (path5) => system.readFile(path5));
         if (commandLine.options.generateCpuProfile && system.enableCPUProfiler) {
           system.enableCPUProfiler(commandLine.options.generateCpuProfile, () => executeCommandLineWorker(
             system,
@@ -148254,12 +148254,12 @@ ${lanes.join("\n")}
         return nodeCoreModules.has(moduleName) ? "node" : moduleName;
       }
       function loadSafeList(host, safeListPath) {
-        const result = readConfigFile(safeListPath, (path4) => host.readFile(path4));
+        const result = readConfigFile(safeListPath, (path5) => host.readFile(path5));
         return new Map(Object.entries(result.config));
       }
       function loadTypesMap(host, typesMapPath) {
         var _a;
-        const result = readConfigFile(typesMapPath, (path4) => host.readFile(path4));
+        const result = readConfigFile(typesMapPath, (path5) => host.readFile(path5));
         if ((_a = result.config) == null ? void 0 : _a.simpleMap) {
           return new Map(Object.entries(result.config.simpleMap));
         }
@@ -148271,9 +148271,9 @@ ${lanes.join("\n")}
         }
         const inferredTypings = /* @__PURE__ */ new Map();
         fileNames = mapDefined(fileNames, (fileName) => {
-          const path4 = normalizePath(fileName);
-          if (hasJSFileExtension(path4)) {
-            return path4;
+          const path5 = normalizePath(fileName);
+          if (hasJSFileExtension(path5)) {
+            return path5;
           }
         });
         const filesToWatch = [];
@@ -148335,7 +148335,7 @@ ${lanes.join("\n")}
           let manifestTypingNames;
           if (host.fileExists(manifestPath)) {
             filesToWatch2.push(manifestPath);
-            manifest = readConfigFile(manifestPath, (path4) => host.readFile(path4)).config;
+            manifest = readConfigFile(manifestPath, (path5) => host.readFile(path5)).config;
             manifestTypingNames = flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], getOwnKeys);
             addInferredTypings(manifestTypingNames, `Typing names in '${manifestPath}' dependencies`);
           }
@@ -148369,7 +148369,7 @@ ${lanes.join("\n")}
           if (log) log(`Searching for typing names in ${packagesFolderPath}; all files: ${JSON.stringify(dependencyManifestNames)}`);
           for (const manifestPath2 of dependencyManifestNames) {
             const normalizedFileName = normalizePath(manifestPath2);
-            const result2 = readConfigFile(normalizedFileName, (path4) => host.readFile(path4));
+            const result2 = readConfigFile(normalizedFileName, (path5) => host.readFile(path5));
             const manifest2 = result2.config;
             if (!manifest2.name) {
               continue;
@@ -151149,14 +151149,14 @@ ${lanes.join("\n")}
       function tryGetDirectories(host, directoryName) {
         return tryIOAndConsumeErrors(host, host.getDirectories, directoryName) || [];
       }
-      function tryReadDirectory(host, path4, extensions, exclude, include) {
-        return tryIOAndConsumeErrors(host, host.readDirectory, path4, extensions, exclude, include) || emptyArray;
+      function tryReadDirectory(host, path5, extensions, exclude, include) {
+        return tryIOAndConsumeErrors(host, host.readDirectory, path5, extensions, exclude, include) || emptyArray;
       }
-      function tryFileExists(host, path4) {
-        return tryIOAndConsumeErrors(host, host.fileExists, path4);
+      function tryFileExists(host, path5) {
+        return tryIOAndConsumeErrors(host, host.fileExists, path5);
       }
-      function tryDirectoryExists(host, path4) {
-        return tryAndIgnoreErrors(() => directoryProbablyExists(path4, host)) || false;
+      function tryDirectoryExists(host, path5) {
+        return tryAndIgnoreErrors(() => directoryProbablyExists(path5, host)) || false;
       }
       function tryAndIgnoreErrors(cb) {
         try {
@@ -151998,13 +151998,13 @@ ${lanes.join("\n")}
       function getIsExcluded(excludePatterns, host) {
         var _a;
         const realpathsWithSymlinks = (_a = host.getSymlinkCache) == null ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
-        return ({ fileName, path: path4 }) => {
+        return ({ fileName, path: path5 }) => {
           if (excludePatterns.some((p) => p.test(fileName))) return true;
           if ((realpathsWithSymlinks == null ? void 0 : realpathsWithSymlinks.size) && pathContainsNodeModules(fileName)) {
             let dir = getDirectoryPath(fileName);
             return forEachAncestorDirectoryStoppingAtGlobalCache(
               host,
-              getDirectoryPath(path4),
+              getDirectoryPath(path5),
               (dirPath) => {
                 const symlinks = realpathsWithSymlinks.get(ensureTrailingDirectorySeparator(dirPath));
                 if (symlinks) {
@@ -153659,38 +153659,38 @@ ${lanes.join("\n")}
           }
           return settingsOrHost;
         }
-        function acquireDocument(fileName, compilationSettings, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
-          const path4 = toPath(fileName, currentDirectory, getCanonicalFileName);
+        function acquireDocument(fileName, compilationSettings, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
+          const path5 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-          return acquireDocumentWithKey(fileName, path4, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions);
+          return acquireDocumentWithKey(fileName, path5, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
         }
-        function acquireDocumentWithKey(fileName, path4, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
+        function acquireDocumentWithKey(fileName, path5, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
           return acquireOrUpdateDocument(
             fileName,
-            path4,
+            path5,
             compilationSettings,
             key,
             scriptSnapshot,
-            version2,
+            version22,
             /*acquiring*/
             true,
             scriptKind,
             languageVersionOrOptions
           );
         }
-        function updateDocument(fileName, compilationSettings, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
-          const path4 = toPath(fileName, currentDirectory, getCanonicalFileName);
+        function updateDocument(fileName, compilationSettings, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
+          const path5 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-          return updateDocumentWithKey(fileName, path4, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions);
+          return updateDocumentWithKey(fileName, path5, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
         }
-        function updateDocumentWithKey(fileName, path4, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
+        function updateDocumentWithKey(fileName, path5, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
           return acquireOrUpdateDocument(
             fileName,
-            path4,
+            path5,
             getCompilationSettings(compilationSettings),
             key,
             scriptSnapshot,
-            version2,
+            version22,
             /*acquiring*/
             false,
             scriptKind,
@@ -153702,7 +153702,7 @@ ${lanes.join("\n")}
           Debug.assert(scriptKind === void 0 || !entry || entry.sourceFile.scriptKind === scriptKind, `Script kind should match provided ScriptKind:${scriptKind} and sourceFile.scriptKind: ${entry == null ? void 0 : entry.sourceFile.scriptKind}, !entry: ${!entry}`);
           return entry;
         }
-        function acquireOrUpdateDocument(fileName, path4, compilationSettingsOrHost, key, scriptSnapshot, version2, acquiring, scriptKind, languageVersionOrOptions) {
+        function acquireOrUpdateDocument(fileName, path5, compilationSettingsOrHost, key, scriptSnapshot, version22, acquiring, scriptKind, languageVersionOrOptions) {
           var _a, _b, _c, _d;
           scriptKind = ensureScriptKind(fileName, scriptKind);
           const compilationSettings = getCompilationSettings(compilationSettingsOrHost);
@@ -153710,7 +153710,7 @@ ${lanes.join("\n")}
           const scriptTarget = scriptKind === 6 ? 100 : getEmitScriptTarget(compilationSettings);
           const sourceFileOptions = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : {
             languageVersion: scriptTarget,
-            impliedNodeFormat: host && getImpliedNodeFormatForFile(path4, (_d = (_c = (_b = (_a = host.getCompilerHost) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getModuleResolutionCache) == null ? void 0 : _c.call(_b)) == null ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
+            impliedNodeFormat: host && getImpliedNodeFormatForFile(path5, (_d = (_c = (_b = (_a = host.getCompilerHost) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getModuleResolutionCache) == null ? void 0 : _c.call(_b)) == null ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
             setExternalModuleIndicator: getSetExternalModuleIndicator(compilationSettings),
             jsDocParsingMode
           };
@@ -153723,15 +153723,15 @@ ${lanes.join("\n")}
             if (buckets.size > oldBucketCount) {
               tracing.instant(tracing.Phase.Session, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: keyWithMode });
             }
-            const otherBucketKey = !isDeclarationFileName(path4) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path4) && bucketKey);
+            const otherBucketKey = !isDeclarationFileName(path5) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path5) && bucketKey);
             if (otherBucketKey) {
-              tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path: path4, key1: otherBucketKey, key2: keyWithMode });
+              tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path: path5, key1: otherBucketKey, key2: keyWithMode });
             }
           }
-          const bucketEntry = bucket.get(path4);
+          const bucketEntry = bucket.get(path5);
           let entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind);
           if (!entry && externalCache) {
-            const sourceFile = externalCache.getDocument(keyWithMode, path4);
+            const sourceFile = externalCache.getDocument(keyWithMode, path5);
             if (sourceFile && sourceFile.scriptKind === scriptKind && sourceFile.text === getSnapshotText(scriptSnapshot)) {
               Debug.assert(acquiring);
               entry = {
@@ -153746,13 +153746,13 @@ ${lanes.join("\n")}
               fileName,
               scriptSnapshot,
               sourceFileOptions,
-              version2,
+              version22,
               /*setNodeParents*/
               false,
               scriptKind
             );
             if (externalCache) {
-              externalCache.setDocument(keyWithMode, path4, sourceFile);
+              externalCache.setDocument(keyWithMode, path5, sourceFile);
             }
             entry = {
               sourceFile,
@@ -153760,10 +153760,10 @@ ${lanes.join("\n")}
             };
             setBucketEntry();
           } else {
-            if (entry.sourceFile.version !== version2) {
-              entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version2, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot));
+            if (entry.sourceFile.version !== version22) {
+              entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version22, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot));
               if (externalCache) {
-                externalCache.setDocument(keyWithMode, path4, entry.sourceFile);
+                externalCache.setDocument(keyWithMode, path5, entry.sourceFile);
               }
             }
             if (acquiring) {
@@ -153774,35 +153774,35 @@ ${lanes.join("\n")}
           return entry.sourceFile;
           function setBucketEntry() {
             if (!bucketEntry) {
-              bucket.set(path4, entry);
+              bucket.set(path5, entry);
             } else if (isDocumentRegistryEntry(bucketEntry)) {
               const scriptKindMap = /* @__PURE__ */ new Map();
               scriptKindMap.set(bucketEntry.sourceFile.scriptKind, bucketEntry);
               scriptKindMap.set(scriptKind, entry);
-              bucket.set(path4, scriptKindMap);
+              bucket.set(path5, scriptKindMap);
             } else {
               bucketEntry.set(scriptKind, entry);
             }
           }
         }
         function releaseDocument(fileName, compilationSettings, scriptKind, impliedNodeFormat) {
-          const path4 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path5 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(compilationSettings);
-          return releaseDocumentWithKey(path4, key, scriptKind, impliedNodeFormat);
+          return releaseDocumentWithKey(path5, key, scriptKind, impliedNodeFormat);
         }
-        function releaseDocumentWithKey(path4, key, scriptKind, impliedNodeFormat) {
+        function releaseDocumentWithKey(path5, key, scriptKind, impliedNodeFormat) {
           const bucket = Debug.checkDefined(buckets.get(getDocumentRegistryBucketKeyWithMode(key, impliedNodeFormat)));
-          const bucketEntry = bucket.get(path4);
+          const bucketEntry = bucket.get(path5);
           const entry = getDocumentRegistryEntry(bucketEntry, scriptKind);
           entry.languageServiceRefCount--;
           Debug.assert(entry.languageServiceRefCount >= 0);
           if (entry.languageServiceRefCount === 0) {
             if (isDocumentRegistryEntry(bucketEntry)) {
-              bucket.delete(path4);
+              bucket.delete(path5);
             } else {
               bucketEntry.delete(scriptKind);
               if (bucketEntry.size === 1) {
-                bucket.set(path4, firstDefinedIterator(bucketEntry.values(), identity));
+                bucket.set(path5, firstDefinedIterator(bucketEntry.values(), identity));
               }
             }
           }
@@ -153838,10 +153838,10 @@ ${lanes.join("\n")}
       }
       function getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper) {
         const canonicalOldPath = getCanonicalFileName(oldFileOrDirPath);
-        return (path4) => {
-          const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path4, pos: 0 });
-          const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path4);
-          return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path4, getCanonicalFileName) : updatedPath;
+        return (path5) => {
+          const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path5, pos: 0 });
+          const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path5);
+          return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path5, getCanonicalFileName) : updatedPath;
         };
         function getUpdatedPath(pathToUpdate) {
           if (getCanonicalFileName(pathToUpdate) === canonicalOldPath) return newFileOrDirPath;
@@ -153917,10 +153917,10 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function relativePath(path4) {
+        function relativePath(path5) {
           return getRelativePathFromDirectory(
             configDir,
-            path4,
+            path5,
             /*ignoreCase*/
             !useCaseSensitiveFileNames2
           );
@@ -154728,8 +154728,8 @@ ${lanes.join("\n")}
           return toPath(fileName, currentDirectory, getCanonicalFileName);
         }
         function getDocumentPositionMapper2(generatedFileName, sourceFileName) {
-          const path4 = toPath3(generatedFileName);
-          const value = documentPositionMappers.get(path4);
+          const path5 = toPath3(generatedFileName);
+          const value = documentPositionMappers.get(path5);
           if (value) return value;
           let mapper;
           if (host.getDocumentPositionMapper) {
@@ -154743,7 +154743,7 @@ ${lanes.join("\n")}
               (f) => !host.fileExists || host.fileExists(f) ? host.readFile(f) : void 0
             );
           }
-          documentPositionMappers.set(path4, mapper || identitySourceMapConsumer);
+          documentPositionMappers.set(path5, mapper || identitySourceMapConsumer);
           return mapper || identitySourceMapConsumer;
         }
         function tryGetSourcePosition(info) {
@@ -154771,21 +154771,21 @@ ${lanes.join("\n")}
         function getSourceFile(fileName) {
           const program2 = host.getProgram();
           if (!program2) return void 0;
-          const path4 = toPath3(fileName);
-          const file = program2.getSourceFileByPath(path4);
-          return file && file.resolvedPath === path4 ? file : void 0;
+          const path5 = toPath3(fileName);
+          const file = program2.getSourceFileByPath(path5);
+          return file && file.resolvedPath === path5 ? file : void 0;
         }
         function getOrCreateSourceFileLike(fileName) {
-          const path4 = toPath3(fileName);
-          const fileFromCache = sourceFileLike.get(path4);
+          const path5 = toPath3(fileName);
+          const fileFromCache = sourceFileLike.get(path5);
           if (fileFromCache !== void 0) return fileFromCache ? fileFromCache : void 0;
           if (!host.readFile || host.fileExists && !host.fileExists(fileName)) {
-            sourceFileLike.set(path4, false);
+            sourceFileLike.set(path5, false);
             return void 0;
           }
           const text = host.readFile(fileName);
           const file = text ? createSourceFileLike(text) : false;
-          sourceFileLike.set(path4, file);
+          sourceFileLike.set(path5, file);
           return file ? file : void 0;
         }
         function getSourceFileLike(fileName) {
@@ -162612,7 +162612,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             throw new Error("Could not find file: '" + fileName + "'.");
           }
           const scriptKind = getScriptKind(fileName, this.host);
-          const version2 = this.host.getScriptVersion(fileName);
+          const version22 = this.host.getScriptVersion(fileName);
           let sourceFile;
           if (this.currentFileName !== fileName) {
             const options = {
@@ -162632,17 +162632,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               fileName,
               scriptSnapshot,
               options,
-              version2,
+              version22,
               /*setNodeParents*/
               true,
               scriptKind
             );
-          } else if (this.currentFileVersion !== version2) {
+          } else if (this.currentFileVersion !== version22) {
             const editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot);
-            sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version2, editRange);
+            sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version22, editRange);
           }
           if (sourceFile) {
-            this.currentFileVersion = version2;
+            this.currentFileVersion = version22;
             this.currentFileName = fileName;
             this.currentFileScriptSnapshot = scriptSnapshot;
             this.currentSourceFile = sourceFile;
@@ -162650,18 +162650,18 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           return this.currentSourceFile;
         }
       };
-      function setSourceFileFields(sourceFile, scriptSnapshot, version2) {
-        sourceFile.version = version2;
+      function setSourceFileFields(sourceFile, scriptSnapshot, version22) {
+        sourceFile.version = version22;
         sourceFile.scriptSnapshot = scriptSnapshot;
       }
-      function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTargetOrOptions, version2, setNodeParents, scriptKind) {
+      function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTargetOrOptions, version22, setNodeParents, scriptKind) {
         const sourceFile = createSourceFile(fileName, getSnapshotText(scriptSnapshot), scriptTargetOrOptions, setNodeParents, scriptKind);
-        setSourceFileFields(sourceFile, scriptSnapshot, version2);
+        setSourceFileFields(sourceFile, scriptSnapshot, version22);
         return sourceFile;
       }
-      function updateLanguageServiceSourceFile(sourceFile, scriptSnapshot, version2, textChangeRange, aggressiveChecks) {
+      function updateLanguageServiceSourceFile(sourceFile, scriptSnapshot, version22, textChangeRange, aggressiveChecks) {
         if (textChangeRange) {
-          if (version2 !== sourceFile.version) {
+          if (version22 !== sourceFile.version) {
             let newText;
             const prefix = textChangeRange.span.start !== 0 ? sourceFile.text.substr(0, textChangeRange.span.start) : "";
             const suffix = textSpanEnd(textChangeRange.span) !== sourceFile.text.length ? sourceFile.text.substr(textSpanEnd(textChangeRange.span)) : "";
@@ -162672,7 +162672,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               newText = prefix && suffix ? prefix + changedText + suffix : prefix ? prefix + changedText : changedText + suffix;
             }
             const newSourceFile = updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
-            setSourceFileFields(newSourceFile, scriptSnapshot, version2);
+            setSourceFileFields(newSourceFile, scriptSnapshot, version22);
             newSourceFile.nameTable = void 0;
             if (sourceFile !== newSourceFile && sourceFile.scriptSnapshot) {
               if (sourceFile.scriptSnapshot.dispose) {
@@ -162693,7 +162693,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           sourceFile.fileName,
           scriptSnapshot,
           options,
-          version2,
+          version22,
           /*setNodeParents*/
           true,
           sourceFile.scriptKind
@@ -162877,12 +162877,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             directoryExists: (directoryName) => {
               return directoryProbablyExists(directoryName, host);
             },
-            getDirectories: (path4) => {
-              return host.getDirectories ? host.getDirectories(path4) : [];
+            getDirectories: (path5) => {
+              return host.getDirectories ? host.getDirectories(path5) : [];
             },
-            readDirectory: (path4, extensions, exclude, include, depth) => {
+            readDirectory: (path5, extensions, exclude, include, depth) => {
               Debug.checkDefined(host.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'");
-              return host.readDirectory(path4, extensions, exclude, include, depth);
+              return host.readDirectory(path5, extensions, exclude, include, depth);
             },
             onReleaseOldSourceFile,
             onReleaseParsedCommandLine,
@@ -162945,11 +162945,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           program2.getTypeChecker();
           return;
           function getParsedCommandLine(fileName) {
-            const path4 = toPath(fileName, currentDirectory, getCanonicalFileName);
-            const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path4);
+            const path5 = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path5);
             if (existing !== void 0) return existing || void 0;
             const result = host.getParsedCommandLine ? host.getParsedCommandLine(fileName) : getParsedCommandLineOfConfigFileUsingSourceFile(fileName);
-            (parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path4, result || false);
+            (parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path5, result || false);
             return result;
           }
           function getParsedCommandLineOfConfigFileUsingSourceFile(configFileName) {
@@ -162991,7 +162991,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           function getOrCreateSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
             return getOrCreateSourceFileByPath(fileName, toPath(fileName, currentDirectory, getCanonicalFileName), languageVersionOrOptions, onError, shouldCreateNewSourceFile);
           }
-          function getOrCreateSourceFileByPath(fileName, path4, languageVersionOrOptions, _onError, shouldCreateNewSourceFile) {
+          function getOrCreateSourceFileByPath(fileName, path5, languageVersionOrOptions, _onError, shouldCreateNewSourceFile) {
             Debug.assert(compilerHost, "getOrCreateSourceFileByPath called after typical CompilerHost lifetime, check the callstack something with a reference to an old host.");
             const scriptSnapshot = host.getScriptSnapshot(fileName);
             if (!scriptSnapshot) {
@@ -163000,17 +163000,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             const scriptKind = getScriptKind(fileName, host);
             const scriptVersion = host.getScriptVersion(fileName);
             if (!shouldCreateNewSourceFile) {
-              const oldSourceFile = program2 && program2.getSourceFileByPath(path4);
+              const oldSourceFile = program2 && program2.getSourceFileByPath(path5);
               if (oldSourceFile) {
                 if (scriptKind === oldSourceFile.scriptKind || releasedScriptKinds.has(oldSourceFile.resolvedPath)) {
-                  return documentRegistry.updateDocumentWithKey(fileName, path4, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
+                  return documentRegistry.updateDocumentWithKey(fileName, path5, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
                 } else {
                   documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, documentRegistry.getKeyForCompilationSettings(program2.getCompilerOptions()), oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat);
                   releasedScriptKinds.add(oldSourceFile.resolvedPath);
                 }
               }
             }
-            return documentRegistry.acquireDocumentWithKey(fileName, path4, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
+            return documentRegistry.acquireDocumentWithKey(fileName, path5, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
           }
         }
         function getProgram() {
@@ -163616,7 +163616,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           return isArray(action) ? Promise.all(action.map((a) => applySingleCodeActionCommand(a))) : applySingleCodeActionCommand(action);
         }
         function applySingleCodeActionCommand(action) {
-          const getPath = (path4) => toPath(path4, currentDirectory, getCanonicalFileName);
+          const getPath = (path5) => toPath(path5, currentDirectory, getCanonicalFileName);
           Debug.assertEqual(action.type, "install package");
           return host.installPackage ? host.installPackage({ fileName: getPath(action.file), packageName: action.packageName }) : Promise.reject("Host does not implement `installPackage`");
         }
@@ -163960,8 +163960,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           function isLetterOrDigit(char) {
             return char >= 97 && char <= 122 || char >= 65 && char <= 90 || char >= 48 && char <= 57;
           }
-          function isNodeModulesFile(path4) {
-            return path4.includes("/node_modules/");
+          function isNodeModulesFile(path5) {
+            return path5.includes("/node_modules/");
           }
         }
         function getRenameInfo2(fileName, position, preferences) {
@@ -177595,11 +177595,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           }
         });
       }
-      function generateJSDocParamTagsForDestructuring(path4, pattern, initializer, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
+      function generateJSDocParamTagsForDestructuring(path5, pattern, initializer, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
         if (!isJs) {
           return [
             getJSDocParamAnnotation(
-              path4,
+              path5,
               initializer,
               dotDotDotToken,
               isJs,
@@ -177613,7 +177613,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             )
           ];
         }
-        return patternWorker(path4, pattern, initializer, dotDotDotToken, { tabstop: 1 });
+        return patternWorker(path5, pattern, initializer, dotDotDotToken, { tabstop: 1 });
         function patternWorker(path22, pattern2, initializer2, dotDotDotToken2, counter) {
           if (isObjectBindingPattern(pattern2) && !dotDotDotToken2) {
             const oldTabstop = counter.tabstop;
@@ -182236,21 +182236,21 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function getFragmentDirectory(fragment) {
         return containsSlash(fragment) ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
       }
-      function getCompletionsForPathMapping(path4, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program2, host, moduleSpecifierResolutionHost) {
-        const parsedPath = tryParsePattern(path4);
+      function getCompletionsForPathMapping(path5, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program2, host, moduleSpecifierResolutionHost) {
+        const parsedPath = tryParsePattern(path5);
         if (!parsedPath) {
           return emptyArray;
         }
         if (typeof parsedPath === "string") {
           return justPathMappingName(
-            path4,
+            path5,
             "script"
             /* scriptElement */
           );
         }
         const remainingFragment = tryRemovePrefix(fragment, parsedPath.prefix);
         if (remainingFragment === void 0) {
-          const starIsFullPathComponent = endsWith(path4, "/*");
+          const starIsFullPathComponent = endsWith(path5, "/*");
           return starIsFullPathComponent ? justPathMappingName(
             parsedPath.prefix,
             "directory"
@@ -182336,9 +182336,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         function getDirectoryMatches(directoryName) {
           return mapDefined(tryGetDirectories(host, directoryName), (dir) => dir === "node_modules" ? void 0 : directoryResult(dir));
         }
-        function trimPrefixAndSuffix(path4, prefix) {
+        function trimPrefixAndSuffix(path5, prefix) {
           return firstDefined(matchingSuffixes, (suffix) => {
-            const inner = withoutStartAndEnd(normalizePath(path4), prefix, suffix);
+            const inner = withoutStartAndEnd(normalizePath(path5), prefix, suffix);
             return inner === void 0 ? void 0 : removeLeadingDirectorySeparator(inner);
           });
         }
@@ -182346,8 +182346,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function withoutStartAndEnd(s, start, end) {
         return startsWith(s, start) && endsWith(s, end) ? s.slice(start.length, s.length - end.length) : void 0;
       }
-      function removeLeadingDirectorySeparator(path4) {
-        return path4[0] === directorySeparator ? path4.slice(1) : path4;
+      function removeLeadingDirectorySeparator(path5) {
+        return path5[0] === directorySeparator ? path5.slice(1) : path5;
       }
       function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) {
         const ambientModules = checker.getAmbientModules().map((sym) => stripQuotes(sym.name));
@@ -182462,10 +182462,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           /* ESNext */
         ) ? void 0 : createTextSpan(textStart + offset, length2);
       }
-      function isPathRelativeToScript(path4) {
-        if (path4 && path4.length >= 2 && path4.charCodeAt(0) === 46) {
-          const slashIndex = path4.length >= 3 && path4.charCodeAt(1) === 46 ? 2 : 1;
-          const slashCharCode = path4.charCodeAt(slashIndex);
+      function isPathRelativeToScript(path5) {
+        if (path5 && path5.length >= 2 && path5.charCodeAt(0) === 46) {
+          const slashIndex = path5.length >= 3 && path5.charCodeAt(1) === 46 ? 2 : 1;
+          const slashCharCode = path5.charCodeAt(slashIndex);
           return slashCharCode === 47 || slashCharCode === 92;
         }
         return false;
@@ -186880,7 +186880,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return ts_textChanges_exports.ChangeTracker.with(
           { host, formatContext, preferences },
           (changeTracker) => {
-            const parsed = contents.map((c) => parse2(sourceFile, c));
+            const parsed = contents.map((c) => parse3(sourceFile, c));
             const flattenedLocations = focusLocations && flatten(focusLocations);
             for (const nodes of parsed) {
               placeNodeGroup(
@@ -186893,7 +186893,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           }
         );
       }
-      function parse2(sourceFile, content) {
+      function parse3(sourceFile, content) {
         const nodeKinds = [
           {
             parse: () => createSourceFile(
@@ -197743,7 +197743,7 @@ ${options.prefix}` : "\n" : options.prefix
         usingSingleLineStringWriter: () => usingSingleLineStringWriter,
         utf16EncodeAsString: () => utf16EncodeAsString,
         validateLocaleAndSetLanguage: () => validateLocaleAndSetLanguage,
-        version: () => version,
+        version: () => version2,
         versionMajorMinor: () => versionMajorMinor,
         visitArray: () => visitArray,
         visitCommaListElements: () => visitCommaListElements,
@@ -197768,7 +197768,7 @@ ${options.prefix}` : "\n" : options.prefix
       var enableDeprecationWarnings = true;
       var typeScriptVersion2;
       function getTypeScriptVersion() {
-        return typeScriptVersion2 ?? (typeScriptVersion2 = new Version(version));
+        return typeScriptVersion2 ?? (typeScriptVersion2 = new Version(version2));
       }
       function formatDeprecationMessage(name, error2, errorAfter, since, message) {
         let deprecationMessage = error2 ? "DeprecationError: " : "DeprecationWarning: ";
@@ -197808,12 +197808,12 @@ ${options.prefix}` : "\n" : options.prefix
         };
       }
       function createDeprecation(name, options = {}) {
-        const version2 = typeof options.typeScriptVersion === "string" ? new Version(options.typeScriptVersion) : options.typeScriptVersion ?? getTypeScriptVersion();
+        const version22 = typeof options.typeScriptVersion === "string" ? new Version(options.typeScriptVersion) : options.typeScriptVersion ?? getTypeScriptVersion();
         const errorAfter = typeof options.errorAfter === "string" ? new Version(options.errorAfter) : options.errorAfter;
         const warnAfter = typeof options.warnAfter === "string" ? new Version(options.warnAfter) : options.warnAfter;
         const since = typeof options.since === "string" ? new Version(options.since) : options.since ?? warnAfter;
-        const error2 = options.error || errorAfter && version2.compareTo(errorAfter) >= 0;
-        const warn = !warnAfter || version2.compareTo(warnAfter) >= 0;
+        const error2 = options.error || errorAfter && version22.compareTo(errorAfter) >= 0;
+        const warn = !warnAfter || version22.compareTo(warnAfter) >= 0;
         return error2 ? createErrorDeprecation(name, errorAfter, since, options.message) : warn ? createWarningDeprecation(name, errorAfter, since, options.message) : noop;
       }
       function wrapFunction(deprecation, func) {
@@ -198208,11 +198208,11 @@ ${options.prefix}` : "\n" : options.prefix
                   this.log.writeLine(`Adding entry into typings cache: '${packageName}' => '${typingFile}'`);
                 }
                 const info = npmLock.packages && getProperty(npmLock.packages, `node_modules/${key}`) || getProperty(npmLock.dependencies, key);
-                const version2 = info && info.version;
-                if (!version2) {
+                const version22 = info && info.version;
+                if (!version22) {
                   continue;
                 }
-                const newTyping = { typingLocation: typingFile, version: new Version(version2) };
+                const newTyping = { typingLocation: typingFile, version: new Version(version22) };
                 this.packageNameToTypingLocation.set(packageName, newTyping);
               }
             }
@@ -198277,7 +198277,7 @@ ${options.prefix}` : "\n" : options.prefix
           this.sendResponse({
             kind: EventBeginInstallTypes,
             eventId: requestId,
-            typingsInstallerVersion: version,
+            typingsInstallerVersion: version2,
             projectName: req.projectName
           });
           const scopedTypings = filteredTypings.map(typingsName);
@@ -198319,7 +198319,7 @@ ${options.prefix}` : "\n" : options.prefix
                 projectName: req.projectName,
                 packagesToInstall: scopedTypings,
                 installSuccess: ok,
-                typingsInstallerVersion: version
+                typingsInstallerVersion: version2
               };
               this.sendResponse(response);
             }
@@ -198436,17 +198436,17 @@ ${options.prefix}` : "\n" : options.prefix
       function createNormalizedPathMap() {
         const map2 = /* @__PURE__ */ new Map();
         return {
-          get(path4) {
-            return map2.get(path4);
+          get(path5) {
+            return map2.get(path5);
           },
-          set(path4, value) {
-            map2.set(path4, value);
+          set(path5, value) {
+            map2.set(path5, value);
           },
-          contains(path4) {
-            return map2.has(path4);
+          contains(path5) {
+            return map2.has(path5);
           },
-          remove(path4) {
-            map2.delete(path4);
+          remove(path5) {
+            map2.delete(path5);
           }
         };
       }
@@ -198959,12 +198959,12 @@ ${options.prefix}` : "\n" : options.prefix
         return fileName[0] === "^" || (fileName.includes("walkThroughSnippet:/") || fileName.includes("untitled:/")) && getBaseFileName(fileName)[0] === "^" || fileName.includes(":^") && !fileName.includes(directorySeparator);
       }
       var ScriptInfo = class {
-        constructor(host, fileName, scriptKind, hasMixedContent, path4, initialVersion) {
+        constructor(host, fileName, scriptKind, hasMixedContent, path5, initialVersion) {
           this.host = host;
           this.fileName = fileName;
           this.scriptKind = scriptKind;
           this.hasMixedContent = hasMixedContent;
-          this.path = path4;
+          this.path = path5;
           this.containingProjects = [];
           this.isDynamic = isDynamicFileName(fileName);
           this.textStorage = new TextStorage(host, this, initialVersion);
@@ -199599,8 +199599,8 @@ ${options.prefix}` : "\n" : options.prefix
         useCaseSensitiveFileNames() {
           return this.projectService.host.useCaseSensitiveFileNames;
         }
-        readDirectory(path4, extensions, exclude, include, depth) {
-          return this.directoryStructureHost.readDirectory(path4, extensions, exclude, include, depth);
+        readDirectory(path5, extensions, exclude, include, depth) {
+          return this.directoryStructureHost.readDirectory(path5, extensions, exclude, include, depth);
         }
         readFile(fileName) {
           return this.projectService.host.readFile(fileName);
@@ -199609,8 +199609,8 @@ ${options.prefix}` : "\n" : options.prefix
           return this.projectService.host.writeFile(fileName, content);
         }
         fileExists(file) {
-          const path4 = this.toPath(file);
-          return !!this.projectService.getScriptInfoForPath(path4) || !this.isWatchedMissingFile(path4) && this.directoryStructureHost.fileExists(file);
+          const path5 = this.toPath(file);
+          return !!this.projectService.getScriptInfoForPath(path5) || !this.isWatchedMissingFile(path5) && this.directoryStructureHost.fileExists(file);
         }
         /** @internal */
         resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
@@ -199635,11 +199635,11 @@ ${options.prefix}` : "\n" : options.prefix
         resolveLibrary(libraryName, resolveFrom, options, libFileName) {
           return this.resolutionCache.resolveLibrary(libraryName, resolveFrom, options, libFileName);
         }
-        directoryExists(path4) {
-          return this.directoryStructureHost.directoryExists(path4);
+        directoryExists(path5) {
+          return this.directoryStructureHost.directoryExists(path5);
         }
-        getDirectories(path4) {
-          return this.directoryStructureHost.getDirectories(path4);
+        getDirectories(path5) {
+          return this.directoryStructureHost.getDirectories(path5);
         }
         /** @internal */
         getCachedDirectoryStructureHost() {
@@ -199902,16 +199902,16 @@ ${options.prefix}` : "\n" : options.prefix
             }
           }));
         }
-        getSourceFile(path4) {
+        getSourceFile(path5) {
           if (!this.program) {
             return void 0;
           }
-          return this.program.getSourceFileByPath(path4);
+          return this.program.getSourceFileByPath(path5);
         }
         /** @internal */
-        getSourceFileOrConfigFile(path4) {
+        getSourceFileOrConfigFile(path5) {
           const options = this.program.getCompilerOptions();
-          return path4 === options.configFilePath ? options.configFile : this.getSourceFile(path4);
+          return path5 === options.configFilePath ? options.configFile : this.getSourceFile(path5);
         }
         close() {
           var _a;
@@ -200088,8 +200088,8 @@ ${options.prefix}` : "\n" : options.prefix
         }
         // add a root file that doesnt exist on host
         addMissingFileRoot(fileName) {
-          const path4 = this.projectService.toPath(fileName);
-          this.rootFilesMap.set(path4, { fileName });
+          const path5 = this.projectService.toPath(fileName);
+          this.rootFilesMap.set(path5, { fileName });
           this.markAsDirty();
         }
         removeFile(info, fileExists, detachFromProject) {
@@ -200255,22 +200255,22 @@ ${options.prefix}` : "\n" : options.prefix
           const toRemove = new Map(this.typingWatchers);
           if (!this.typingWatchers) this.typingWatchers = /* @__PURE__ */ new Map();
           this.typingWatchers.isInvoked = false;
-          const createProjectWatcher = (path4, typingsWatcherType) => {
-            const canonicalPath = this.toPath(path4);
+          const createProjectWatcher = (path5, typingsWatcherType) => {
+            const canonicalPath = this.toPath(path5);
             toRemove.delete(canonicalPath);
             if (!this.typingWatchers.has(canonicalPath)) {
               const watchType = typingsWatcherType === "FileWatcher" ? WatchType.TypingInstallerLocationFile : WatchType.TypingInstallerLocationDirectory;
               this.typingWatchers.set(
                 canonicalPath,
                 canWatchDirectoryOrFilePath(canonicalPath) ? typingsWatcherType === "FileWatcher" ? this.projectService.watchFactory.watchFile(
-                  path4,
+                  path5,
                   () => !this.typingWatchers.isInvoked ? this.onTypingInstallerWatchInvoke() : this.writeLog(`TypingWatchers already invoked`),
                   2e3,
                   this.projectService.getWatchOptions(this),
                   watchType,
                   this
                 ) : this.projectService.watchFactory.watchDirectory(
-                  path4,
+                  path5,
                   (f) => {
                     if (this.typingWatchers.isInvoked) return this.writeLog(`TypingWatchers already invoked`);
                     if (!fileExtensionIs(
@@ -200285,7 +200285,7 @@ ${options.prefix}` : "\n" : options.prefix
                   this.projectService.getWatchOptions(this),
                   watchType,
                   this
-                ) : (this.writeLog(`Skipping watcher creation at ${path4}:: ${getDetailWatchInfo(watchType, this)}`), noopFileWatcher)
+                ) : (this.writeLog(`Skipping watcher creation at ${path5}:: ${getDetailWatchInfo(watchType, this)}`), noopFileWatcher)
               );
             }
           };
@@ -200330,9 +200330,9 @@ ${options.prefix}` : "\n" : options.prefix
               /* DirectoryWatcher */
             );
           }
-          toRemove.forEach((watch, path4) => {
+          toRemove.forEach((watch, path5) => {
             watch.close();
-            this.typingWatchers.delete(path4);
+            this.typingWatchers.delete(path5);
           });
         }
         /** @internal */
@@ -200366,9 +200366,9 @@ ${options.prefix}` : "\n" : options.prefix
           let hasNewProgram = false;
           if (this.program && (!oldProgram || this.program !== oldProgram && this.program.structureIsReused !== 2)) {
             hasNewProgram = true;
-            this.rootFilesMap.forEach((value, path4) => {
+            this.rootFilesMap.forEach((value, path5) => {
               var _a2;
-              const file = this.program.getSourceFileByPath(path4);
+              const file = this.program.getSourceFileByPath(path5);
               const info = value.info;
               if (!file || ((_a2 = value.info) == null ? void 0 : _a2.path) === file.resolvedPath) return;
               value.info = this.projectService.getScriptInfo(file.fileName);
@@ -200524,8 +200524,8 @@ ${options.prefix}` : "\n" : options.prefix
           );
           return fileWatcher;
         }
-        isWatchedMissingFile(path4) {
-          return !!this.missingFilesMap && this.missingFilesMap.has(path4);
+        isWatchedMissingFile(path5) {
+          return !!this.missingFilesMap && this.missingFilesMap.has(path5);
         }
         /** @internal */
         addGeneratedFileWatch(generatedFile, sourceFile) {
@@ -200534,17 +200534,17 @@ ${options.prefix}` : "\n" : options.prefix
               this.generatedFilesMap = this.createGeneratedFileWatcher(generatedFile);
             }
           } else {
-            const path4 = this.toPath(sourceFile);
+            const path5 = this.toPath(sourceFile);
             if (this.generatedFilesMap) {
               if (isGeneratedFileWatcher(this.generatedFilesMap)) {
                 Debug.fail(`${this.projectName} Expected to not have --out watcher for generated file with options: ${JSON.stringify(this.compilerOptions)}`);
                 return;
               }
-              if (this.generatedFilesMap.has(path4)) return;
+              if (this.generatedFilesMap.has(path5)) return;
             } else {
               this.generatedFilesMap = /* @__PURE__ */ new Map();
             }
-            this.generatedFilesMap.set(path4, this.createGeneratedFileWatcher(generatedFile));
+            this.generatedFilesMap.set(path5, this.createGeneratedFileWatcher(generatedFile));
           }
         }
         createGeneratedFileWatcher(generatedFile) {
@@ -200944,7 +200944,7 @@ ${options.prefix}` : "\n" : options.prefix
         isDefaultProjectForOpenFiles() {
           return !!forEachEntry(
             this.projectService.openFiles,
-            (_projectRootPath, path4) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path4)) === this
+            (_projectRootPath, path5) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path5)) === this
           );
         }
         /** @internal */
@@ -202118,33 +202118,33 @@ ${options.prefix}` : "\n" : options.prefix
           getCurrentDirectory: () => service.host.getCurrentDirectory(),
           useCaseSensitiveFileNames: service.host.useCaseSensitiveFileNames
         };
-        function watchFile2(path4, callback) {
+        function watchFile2(path5, callback) {
           return getOrCreateFileWatcher(
             watchedFiles,
-            path4,
+            path5,
             callback,
-            (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path: path4 } })
+            (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path: path5 } })
           );
         }
-        function watchDirectory(path4, callback, recursive) {
+        function watchDirectory(path5, callback, recursive) {
           return getOrCreateFileWatcher(
             recursive ? watchedDirectoriesRecursive : watchedDirectories,
-            path4,
+            path5,
             callback,
             (id) => ({
               eventName: CreateDirectoryWatcherEvent,
               data: {
                 id,
-                path: path4,
+                path: path5,
                 recursive: !!recursive,
                 // Special case node_modules as we watch it for changes to closed script infos as well
-                ignoreUpdate: !path4.endsWith("/node_modules") ? true : void 0
+                ignoreUpdate: !path5.endsWith("/node_modules") ? true : void 0
               }
             })
           );
         }
-        function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path4, callback, event) {
-          const key = service.toPath(path4);
+        function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path5, callback, event) {
+          const key = service.toPath(path5);
           let id = pathToId.get(key);
           if (!id) pathToId.set(key, id = ids++);
           let callbacks = idToCallbacks.get(id);
@@ -202313,13 +202313,13 @@ ${options.prefix}` : "\n" : options.prefix
           return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());
         }
         /** @internal */
-        setDocument(key, path4, sourceFile) {
-          const info = Debug.checkDefined(this.getScriptInfoForPath(path4));
+        setDocument(key, path5, sourceFile) {
+          const info = Debug.checkDefined(this.getScriptInfoForPath(path5));
           info.cacheSourceFile = { key, sourceFile };
         }
         /** @internal */
-        getDocument(key, path4) {
-          const info = this.getScriptInfoForPath(path4);
+        getDocument(key, path5) {
+          const info = this.getScriptInfoForPath(path5);
           return info && info.cacheSourceFile && info.cacheSourceFile.key === key ? info.cacheSourceFile.sourceFile : void 0;
         }
         /** @internal */
@@ -202441,7 +202441,7 @@ ${options.prefix}` : "\n" : options.prefix
           const event = {
             eventName: ProjectsUpdatedInBackgroundEvent,
             data: {
-              openFiles: arrayFrom(this.openFiles.keys(), (path4) => this.getScriptInfoForPath(path4).fileName)
+              openFiles: arrayFrom(this.openFiles.keys(), (path5) => this.getScriptInfoForPath(path5).fileName)
             }
           };
           this.eventHandler(event);
@@ -202663,11 +202663,11 @@ ${options.prefix}` : "\n" : options.prefix
         }
         delayUpdateSourceInfoProjects(sourceInfos) {
           if (sourceInfos) {
-            sourceInfos.forEach((_value, path4) => this.delayUpdateProjectsOfScriptInfoPath(path4));
+            sourceInfos.forEach((_value, path5) => this.delayUpdateProjectsOfScriptInfoPath(path5));
           }
         }
-        delayUpdateProjectsOfScriptInfoPath(path4) {
-          const info = this.getScriptInfoForPath(path4);
+        delayUpdateProjectsOfScriptInfoPath(path5) {
+          const info = this.getScriptInfoForPath(path5);
           if (info) {
             this.delayUpdateProjectGraphs(
               info.containingProjects,
@@ -202761,8 +202761,8 @@ ${options.prefix}` : "\n" : options.prefix
             const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath);
             if (!project) return;
             if (configuredProjectForConfig !== project && this.getHostPreferences().includeCompletionsForModuleExports) {
-              const path4 = this.toPath(configFileName);
-              if (find((_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path4)) {
+              const path5 = this.toPath(configFileName);
+              if (find((_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path5)) {
                 project.markAutoImportProviderAsDirty();
               }
             }
@@ -202817,10 +202817,10 @@ ${options.prefix}` : "\n" : options.prefix
                 });
                 return;
               }
-              const path4 = this.toPath(canonicalConfigFilePath);
-              project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path4);
+              const path5 = this.toPath(canonicalConfigFilePath);
+              project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path5);
               this.delayUpdateProjectGraph(project);
-              if (this.getHostPreferences().includeCompletionsForModuleExports && find((_c = project.getCurrentProgram()) == null ? void 0 : _c.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path4)) {
+              if (this.getHostPreferences().includeCompletionsForModuleExports && find((_c = project.getCurrentProgram()) == null ? void 0 : _c.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path5)) {
                 project.markAutoImportProviderAsDirty();
               }
             }
@@ -202845,20 +202845,20 @@ ${options.prefix}` : "\n" : options.prefix
             canonicalConfigFilePath,
             "Change in config file detected"
           );
-          this.openFiles.forEach((_projectRootPath, path4) => {
+          this.openFiles.forEach((_projectRootPath, path5) => {
             var _a, _b;
-            const configFileForOpenFile = this.configFileForOpenFiles.get(path4);
-            if (!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(path4))) return;
-            this.configFileForOpenFiles.delete(path4);
-            const info = this.getScriptInfoForPath(path4);
+            const configFileForOpenFile = this.configFileForOpenFiles.get(path5);
+            if (!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(path5))) return;
+            this.configFileForOpenFiles.delete(path5);
+            const info = this.getScriptInfoForPath(path5);
             const newConfigFileNameForInfo = this.getConfigFileNameForFile(
               info,
               /*findFromCacheOnly*/
               false
             );
             if (!newConfigFileNameForInfo) return;
-            if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path4))) {
-              (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path4, configFileForOpenFile);
+            if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path5))) {
+              (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path5, configFileForOpenFile);
             }
           });
           this.delayEnsureProjectForOpenFiles();
@@ -202953,8 +202953,8 @@ ${options.prefix}` : "\n" : options.prefix
           return project;
         }
         assignOrphanScriptInfosToInferredProject() {
-          this.openFiles.forEach((projectRootPath, path4) => {
-            const info = this.getScriptInfoForPath(path4);
+          this.openFiles.forEach((projectRootPath, path5) => {
+            const info = this.getScriptInfoForPath(path5);
             if (info.isOrphan()) {
               this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             }
@@ -203266,8 +203266,8 @@ ${options.prefix}` : "\n" : options.prefix
           this.configuredProjects.forEach(printProjectWithoutFileNames);
           this.inferredProjects.forEach(printProjectWithoutFileNames);
           this.logger.info("Open files: ");
-          this.openFiles.forEach((projectRootPath, path4) => {
-            const info = this.getScriptInfoForPath(path4);
+          this.openFiles.forEach((projectRootPath, path5) => {
+            const info = this.getScriptInfoForPath(path5);
             this.logger.info(`	FileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`);
             this.logger.info(`		Projects: ${info.containingProjects.map((p) => p.getProjectName())}`);
           });
@@ -203358,7 +203358,7 @@ ${options.prefix}` : "\n" : options.prefix
             configFileName: configFileName(),
             projectType: project instanceof ExternalProject ? "external" : "configured",
             languageServiceEnabled: project.languageServiceEnabled,
-            version
+            version: version2
           };
           this.eventHandler({ eventName: ProjectInfoTelemetryEvent, data });
           function configFileName() {
@@ -203593,12 +203593,12 @@ ${options.prefix}` : "\n" : options.prefix
             const newRootFile = propertyReader.getFileName(f);
             const fileName = toNormalizedPath(newRootFile);
             const isDynamic = isDynamicFileName(fileName);
-            let path4;
+            let path5;
             if (!isDynamic && !project.fileExists(newRootFile)) {
-              path4 = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
-              const existingValue = projectRootFilesMap.get(path4);
+              path5 = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
+              const existingValue = projectRootFilesMap.get(path5);
               if (existingValue) {
-                if (((_a = existingValue.info) == null ? void 0 : _a.path) === path4) {
+                if (((_a = existingValue.info) == null ? void 0 : _a.path) === path5) {
                   project.removeFile(
                     existingValue.info,
                     /*fileExists*/
@@ -203610,7 +203610,7 @@ ${options.prefix}` : "\n" : options.prefix
                 }
                 existingValue.fileName = fileName;
               } else {
-                projectRootFilesMap.set(path4, { fileName });
+                projectRootFilesMap.set(path5, { fileName });
               }
             } else {
               const scriptKind = propertyReader.getScriptKind(f, this.hostConfiguration.extraFileExtensions);
@@ -203624,8 +203624,8 @@ ${options.prefix}` : "\n" : options.prefix
                 /*deferredDeleteOk*/
                 false
               ));
-              path4 = scriptInfo.path;
-              const existingValue = projectRootFilesMap.get(path4);
+              path5 = scriptInfo.path;
+              const existingValue = projectRootFilesMap.get(path5);
               if (!existingValue || existingValue.info !== scriptInfo) {
                 project.addRoot(scriptInfo, fileName);
                 if (scriptInfo.isScriptOpen()) {
@@ -203635,11 +203635,11 @@ ${options.prefix}` : "\n" : options.prefix
                 existingValue.fileName = fileName;
               }
             }
-            newRootScriptInfoMap.set(path4, true);
+            newRootScriptInfoMap.set(path5, true);
           }
           if (projectRootFilesMap.size > newRootScriptInfoMap.size) {
-            projectRootFilesMap.forEach((value, path4) => {
-              if (!newRootScriptInfoMap.has(path4)) {
+            projectRootFilesMap.forEach((value, path5) => {
+              if (!newRootScriptInfoMap.has(path5)) {
                 if (value.info) {
                   project.removeFile(
                     value.info,
@@ -203648,7 +203648,7 @@ ${options.prefix}` : "\n" : options.prefix
                     true
                   );
                 } else {
-                  projectRootFilesMap.delete(path4);
+                  projectRootFilesMap.delete(path5);
                 }
               }
             });
@@ -203885,8 +203885,8 @@ ${options.prefix}` : "\n" : options.prefix
         }
         /** @internal */
         getScriptInfoOrConfig(uncheckedFileName) {
-          const path4 = toNormalizedPath(uncheckedFileName);
-          const info = this.getScriptInfoForNormalizedPath(path4);
+          const path5 = toNormalizedPath(uncheckedFileName);
+          const info = this.getScriptInfoForNormalizedPath(path5);
           if (info) return info;
           const configProject = this.configuredProjects.get(this.toPath(uncheckedFileName));
           return configProject && configProject.getCompilerOptions().configFile;
@@ -203898,7 +203898,7 @@ ${options.prefix}` : "\n" : options.prefix
               this.filenameToScriptInfo.entries(),
               (entry) => entry[1].deferredDelete ? void 0 : entry
             ),
-            ([path4, scriptInfo]) => ({ path: path4, fileName: scriptInfo.fileName })
+            ([path5, scriptInfo]) => ({ path: path5, fileName: scriptInfo.fileName })
           );
           this.logger.msg(
             `Could not find file ${JSON.stringify(fileName)}.
@@ -203930,7 +203930,7 @@ All files are: ${JSON.stringify(names)}`,
                   if (!projects) {
                     projects = createMultiMap();
                     projects.add(toAddInfo.path, project);
-                  } else if (!forEachEntry(projects, (projs, path4) => path4 === toAddInfo.path ? false : contains(projs, project))) {
+                  } else if (!forEachEntry(projects, (projs, path5) => path5 === toAddInfo.path ? false : contains(projs, project))) {
                     projects.add(toAddInfo.path, project);
                   }
                 }
@@ -204092,8 +204092,8 @@ All files are: ${JSON.stringify(names)}`,
         }
         getOrCreateScriptInfoWorker(fileName, currentDirectory, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn, deferredDeleteOk) {
           Debug.assert(fileContent === void 0 || openedByClient, "ScriptInfo needs to be opened by client to be able to set its user defined content");
-          const path4 = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
-          let info = this.filenameToScriptInfo.get(path4);
+          const path5 = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
+          let info = this.filenameToScriptInfo.get(path5);
           if (!info) {
             const isDynamic = isDynamicFileName(fileName);
             Debug.assert(isRootedDiskPath(fileName) || isDynamic || openedByClient, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })}
@@ -204105,7 +204105,7 @@ Dynamic files must always be opened with service's current directory or service
             if (!openedByClient && !isDynamic && !(hostToQueryFileExistsOn || this.host).fileExists(fileName)) {
               return;
             }
-            info = new ScriptInfo(this.host, fileName, scriptKind, hasMixedContent, path4, this.filenameToScriptInfoVersion.get(path4));
+            info = new ScriptInfo(this.host, fileName, scriptKind, hasMixedContent, path5, this.filenameToScriptInfoVersion.get(path5));
             this.filenameToScriptInfo.set(info.path, info);
             this.filenameToScriptInfoVersion.delete(info.path);
             if (!openedByClient) {
@@ -204252,9 +204252,9 @@ Dynamic files must always be opened with service's current directory or service
         getSourceFileLike(fileName, projectNameOrProject, declarationInfo) {
           const project = projectNameOrProject.projectName ? projectNameOrProject : this.findProject(projectNameOrProject);
           if (project) {
-            const path4 = project.toPath(fileName);
-            const sourceFile = project.getSourceFile(path4);
-            if (sourceFile && sourceFile.resolvedPath === path4) return sourceFile;
+            const path5 = project.toPath(fileName);
+            const sourceFile = project.getSourceFile(path5);
+            if (sourceFile && sourceFile.resolvedPath === path5) return sourceFile;
           }
           const info = this.getOrCreateScriptInfoNotOpenedByClient(
             fileName,
@@ -204420,8 +204420,8 @@ Dynamic files must always be opened with service's current directory or service
               }
             });
           });
-          this.openFiles.forEach((_projectRootPath, path4) => {
-            const info = this.getScriptInfoForPath(path4);
+          this.openFiles.forEach((_projectRootPath, path5) => {
+            const info = this.getScriptInfoForPath(path5);
             if (find(info.containingProjects, isExternalProject)) return;
             this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
               info,
@@ -204474,14 +204474,14 @@ Dynamic files must always be opened with service's current directory or service
           const pendingOpenFileProjectUpdates = this.pendingOpenFileProjectUpdates;
           this.pendingOpenFileProjectUpdates = void 0;
           pendingOpenFileProjectUpdates == null ? void 0 : pendingOpenFileProjectUpdates.forEach(
-            (_config, path4) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
-              this.getScriptInfoForPath(path4),
+            (_config, path5) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+              this.getScriptInfoForPath(path5),
               5
               /* Create */
             )
           );
-          this.openFiles.forEach((projectRootPath, path4) => {
-            const info = this.getScriptInfoForPath(path4);
+          this.openFiles.forEach((projectRootPath, path5) => {
+            const info = this.getScriptInfoForPath(path5);
             if (info.isOrphan()) {
               this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             } else {
@@ -204992,9 +204992,9 @@ Dynamic files must always be opened with service's current directory or service
             }
           });
           if (!toRemoveConfiguredProjects.size) return toRemoveConfiguredProjects;
-          forEachEntry(this.openFiles, (_projectRootPath, path4) => {
-            if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path4)) return;
-            const info = this.getScriptInfoForPath(path4);
+          forEachEntry(this.openFiles, (_projectRootPath, path5) => {
+            if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path5)) return;
+            const info = this.getScriptInfoForPath(path5);
             if (find(info.containingProjects, isExternalProject)) return;
             const result = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
               info,
@@ -205043,8 +205043,8 @@ Dynamic files must always be opened with service's current directory or service
                 sourceInfos = info.sourceMapFilePath.sourceInfos;
               }
               if (!sourceInfos) return;
-              if (!forEachKey(sourceInfos, (path4) => {
-                const info2 = this.getScriptInfoForPath(path4);
+              if (!forEachKey(sourceInfos, (path5) => {
+                const info2 = this.getScriptInfoForPath(path5);
                 return !!info2 && (info2.isScriptOpen() || !info2.isOrphan());
               })) {
                 return;
@@ -205068,7 +205068,7 @@ Dynamic files must always be opened with service's current directory or service
                 sourceInfos = info.sourceMapFilePath.sourceInfos;
               }
               if (sourceInfos) {
-                sourceInfos.forEach((_value, path4) => toRemoveScriptInfos.delete(path4));
+                sourceInfos.forEach((_value, path5) => toRemoveScriptInfos.delete(path5));
               }
             }
           });
@@ -205551,9 +205551,9 @@ Dynamic files must always be opened with service's current directory or service
             }
           );
         }
-        watchPackageJsonFile(file, path4, project) {
+        watchPackageJsonFile(file, path5, project) {
           Debug.assert(project !== void 0);
-          let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path4);
+          let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path5);
           if (!result) {
             let watcher = this.watchFactory.watchFile(
               file,
@@ -205561,11 +205561,11 @@ Dynamic files must always be opened with service's current directory or service
                 switch (eventKind) {
                   case 0:
                   case 1:
-                    this.packageJsonCache.addOrUpdate(fileName, path4);
+                    this.packageJsonCache.addOrUpdate(fileName, path5);
                     this.onPackageJsonChange(result);
                     break;
                   case 2:
-                    this.packageJsonCache.delete(path4);
+                    this.packageJsonCache.delete(path5);
                     this.onPackageJsonChange(result);
                     result.projects.clear();
                     result.close();
@@ -205582,11 +205582,11 @@ Dynamic files must always be opened with service's current directory or service
                 if (result.projects.size || !watcher) return;
                 watcher.close();
                 watcher = void 0;
-                (_a = this.packageJsonFilesMap) == null ? void 0 : _a.delete(path4);
-                this.packageJsonCache.invalidate(path4);
+                (_a = this.packageJsonFilesMap) == null ? void 0 : _a.delete(path5);
+                this.packageJsonCache.invalidate(path5);
               }
             };
-            this.packageJsonFilesMap.set(path4, result);
+            this.packageJsonFilesMap.set(path5, result);
           }
           result.projects.add(project);
           (project.packageJsonWatches ?? (project.packageJsonWatches = /* @__PURE__ */ new Set())).add(result);
@@ -205776,14 +205776,14 @@ Dynamic files must always be opened with service's current directory or service
             );
           }
         };
-        function addOrUpdate(fileName, path4) {
+        function addOrUpdate(fileName, path5) {
           const packageJsonInfo = Debug.checkDefined(createPackageJsonInfo(fileName, host.host));
-          packageJsons.set(path4, packageJsonInfo);
-          directoriesWithoutPackageJson.delete(getDirectoryPath(path4));
+          packageJsons.set(path5, packageJsonInfo);
+          directoriesWithoutPackageJson.delete(getDirectoryPath(path5));
         }
-        function invalidate(path4) {
-          packageJsons.delete(path4);
-          directoriesWithoutPackageJson.delete(getDirectoryPath(path4));
+        function invalidate(path5) {
+          packageJsons.delete(path5);
+          directoriesWithoutPackageJson.delete(getDirectoryPath(path5));
         }
         function directoryHasPackageJson(directory) {
           return packageJsons.has(combinePaths(directory, "package.json")) ? -1 : directoriesWithoutPackageJson.has(directory) ? 0 : 3;
@@ -205980,8 +205980,8 @@ ${json}${newLine}`;
       function combineProjectOutput(defaultValue, getValue, projects, action) {
         const outputs = flatMapToMutable(isArray(projects) ? projects : projects.projects, (project) => action(project, defaultValue));
         if (!isArray(projects) && projects.symLinkedProjects) {
-          projects.symLinkedProjects.forEach((projects2, path4) => {
-            const value = getValue(path4);
+          projects.symLinkedProjects.forEach((projects2, path5) => {
+            const value = getValue(path5);
             outputs.push(...flatMap(projects2, (project) => action(project, value)));
           });
         }
@@ -206127,9 +206127,9 @@ ${json}${newLine}`;
         });
         return results.filter((o) => o.references.length !== 0);
       }
-      function forEachProjectInProjects(projects, path4, cb) {
+      function forEachProjectInProjects(projects, path5, cb) {
         for (const project of isArray(projects) ? projects : projects.projects) {
-          cb(project, path4);
+          cb(project, path5);
         }
         if (!isArray(projects) && projects.symLinkedProjects) {
           projects.symLinkedProjects.forEach((symlinkedProjects, symlinkedPath) => {
@@ -206143,8 +206143,8 @@ ${json}${newLine}`;
         const resultsMap = /* @__PURE__ */ new Map();
         const queue = createQueue();
         queue.enqueue({ project: defaultProject, location: initialLocation });
-        forEachProjectInProjects(projects, initialLocation.fileName, (project, path4) => {
-          const location = { fileName: path4, pos: initialLocation.pos };
+        forEachProjectInProjects(projects, initialLocation.fileName, (project, path5) => {
+          const location = { fileName: path5, pos: initialLocation.pos };
           queue.enqueue({ project, location });
         });
         const projectService = defaultProject.projectService;
@@ -206326,7 +206326,7 @@ ${json}${newLine}`;
               "status"
               /* Status */
             ]: () => {
-              const response = { version };
+              const response = { version: version2 };
               return this.requiredResponse(response);
             },
             [
@@ -207986,8 +207986,8 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
                 nodeModulesPathParts.packageRootIndex
               );
               const packageName = getPackageNameFromTypesPackageName(unmangleScopedPackageName(packageNamePathPart));
-              const path4 = project.toPath(fileName);
-              if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path4)) {
+              const path5 = project.toPath(fileName);
+              if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path5)) {
                 return (_b = auxiliaryProject.resolutionCache.resolveSingleModuleNameWithoutWatching(packageName, resolveFromFile).resolvedModule) == null ? void 0 : _b.resolvedFileName;
               } else {
                 const pathToFileInPackage = fileName.substring(nodeModulesPathParts.packageRootIndex + 1);
@@ -208767,7 +208767,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           }
           return combineProjectOutput(
             info,
-            (path4) => this.projectService.getScriptInfoForPath(path4),
+            (path5) => this.projectService.getScriptInfoForPath(path5),
             projects,
             (project, info2) => {
               if (!project.compileOnSaveEnabled || !project.languageServiceEnabled || project.isOrphan()) {
@@ -208794,7 +208794,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
             return args.richResponse ? { emitSkipped: true, diagnostics: [] } : false;
           }
           const scriptInfo = project.getScriptInfo(file);
-          const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path4, data, writeByteOrderMark) => this.host.writeFile(path4, data, writeByteOrderMark));
+          const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path5, data, writeByteOrderMark) => this.host.writeFile(path5, data, writeByteOrderMark));
           return args.richResponse ? {
             emitSkipped,
             diagnostics: args.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics) : diagnostics.map((d) => formatDiagnosticToProtocol(
@@ -209884,11 +209884,11 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
           this.minVersion = 0;
           this.currentVersion = 0;
         }
-        versionToIndex(version2) {
-          if (version2 < this.minVersion || version2 > this.currentVersion) {
+        versionToIndex(version22) {
+          if (version22 < this.minVersion || version22 > this.currentVersion) {
             return void 0;
           }
-          return version2 % _ScriptVersionCache2.maxVersions;
+          return version22 % _ScriptVersionCache2.maxVersions;
         }
         currentVersionToIndex() {
           return this.currentVersion % _ScriptVersionCache2.maxVersions;
@@ -209973,8 +209973,8 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
       _ScriptVersionCache.maxVersions = 8;
       var ScriptVersionCache = _ScriptVersionCache;
       var LineIndexSnapshot = class _LineIndexSnapshot {
-        constructor(version2, cache, index, changesSincePreviousVersion = emptyArray2) {
-          this.version = version2;
+        constructor(version22, cache, index, changesSincePreviousVersion = emptyArray2) {
+          this.version = version22;
           this.cache = cache;
           this.index = index;
           this.changesSincePreviousVersion = changesSincePreviousVersion;
@@ -210450,8 +210450,8 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
         installPackage(options) {
           this.packageInstallId++;
           const request = { kind: "installPackage", ...options, id: this.packageInstallId };
-          const promise = new Promise((resolve3, reject) => {
-            (this.packageInstalledPromise ?? (this.packageInstalledPromise = /* @__PURE__ */ new Map())).set(this.packageInstallId, { resolve: resolve3, reject });
+          const promise = new Promise((resolve4, reject) => {
+            (this.packageInstalledPromise ?? (this.packageInstalledPromise = /* @__PURE__ */ new Map())).set(this.packageInstallId, { resolve: resolve4, reject });
           });
           this.installer.send(request);
           return promise;
@@ -210855,8 +210855,8 @@ var require_dist4 = __commonJS({
     });
     module.exports = __toCommonJS(index_exports);
     var import_typescript = __toESM2(require_typescript());
-    var fs4 = __toESM2(__require("fs"));
-    var path4 = __toESM2(__require("path"));
+    var fs5 = __toESM2(__require("fs"));
+    var path5 = __toESM2(__require("path"));
     var import_crypto = __toESM2(__require("crypto"));
     var FALLBACK_KEYWORD_BLOCKLIST = /* @__PURE__ */ new Set([
       "if",
@@ -210885,7 +210885,7 @@ var require_dist4 = __commonJS({
       "throw"
     ]);
     function chunkFile(filePath) {
-      const source = fs4.readFileSync(
+      const source = fs5.readFileSync(
         filePath,
         "utf-8"
       );
@@ -210897,7 +210897,7 @@ var require_dist4 = __commonJS({
       );
       const chunks = [];
       function getLanguage(file) {
-        return path4.extname(file).replace(".", "");
+        return path5.extname(file).replace(".", "");
       }
       function getLine(pos) {
         return sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
@@ -211155,8 +211155,8 @@ var require_dist4 = __commonJS({
       }
       visit(sourceFile);
       if (chunks.length === 0 && source.trim().length > 0) {
-        const filename = path4.basename(filePath);
-        const basename2 = path4.basename(filePath, path4.extname(filePath));
+        const filename = path5.basename(filePath);
+        const basename2 = path5.basename(filePath, path5.extname(filePath));
         const hash = getHash(source);
         const deps = /* @__PURE__ */ new Set();
         const pyRegex = /(?:^|\n)\s*(?:from|import)\s+([a-zA-Z0-9_.]+)/g;
@@ -213734,8 +213734,8 @@ ${lines.join("\n")}${output.split("\n").length > 15 ? `
         }
       }
     };
-    var fs4 = __toESM2(__require("fs"));
-    var path4 = __toESM2(__require("path"));
+    var fs5 = __toESM2(__require("fs"));
+    var path5 = __toESM2(__require("path"));
     var FileReadTool4 = class {
       name = "read_file";
       description = 'Read the contents of a file from the codebase. Args: {"path": "relative file path", "startLine": "optional start line", "endLine": "optional end line"}. Returns file contents.';
@@ -213748,19 +213748,19 @@ ${lines.join("\n")}${output.split("\n").length > 15 ? `
         if (!filePath) {
           return "Error: 'path' argument is required.";
         }
-        const absolutePath = path4.resolve(this.cwd, filePath);
+        const absolutePath = path5.resolve(this.cwd, filePath);
         if (!absolutePath.startsWith(this.cwd)) {
           return "Error: Cannot read files outside the workspace directory.";
         }
-        const basename3 = path4.basename(absolutePath);
+        const basename3 = path5.basename(absolutePath);
         if (basename3.startsWith(".env") || basename3 === ".vortexenv") {
           return "Error: Cannot read environment/secret files.";
         }
-        if (!fs4.existsSync(absolutePath)) {
+        if (!fs5.existsSync(absolutePath)) {
           return `Error: File not found: ${filePath}`;
         }
         try {
-          const content = fs4.readFileSync(absolutePath, "utf8");
+          const content = fs5.readFileSync(absolutePath, "utf8");
           const lines = content.split("\n");
           const startLine = args.startLine ? Math.max(1, parseInt(args.startLine, 10)) : 1;
           const endLine = args.endLine ? Math.min(lines.length, parseInt(args.endLine, 10)) : Math.min(lines.length, 100);
@@ -214290,11 +214290,66 @@ var require_dist6 = __commonJS({
   }
 });
 
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@vortex-ai/cli",
+      version: "0.1.41",
+      description: "Vortex CLI - The main entry point",
+      main: "./dist/index.js",
+      bin: {
+        vortex: "./dist/index.js"
+      },
+      scripts: {
+        build: "tsup src/index.ts --format cjs,esm --external @xenova/transformers && cp ../db/prisma/schema.prisma ./schema.prisma",
+        dev: "tsx src/index.ts",
+        watch: "tsup src/index.ts --format cjs,esm --watch",
+        lint: "eslint .",
+        "check-types": "tsc --noEmit",
+        postinstall: `node -e "const fs=require('fs'); if(fs.existsSync('./schema.prisma')){require('child_process').execSync('npx prisma generate --schema=./schema.prisma', {stdio:'inherit'})}"`
+      },
+      dependencies: {
+        "@octokit/rest": "^22.0.1",
+        "@types/marked-terminal": "^6.1.1",
+        "@google/genai": "^2.5.0",
+        "groq-sdk": "^1.2.1",
+        "@prisma/client": "^5.14.0",
+        prisma: "^5.14.0",
+        ignore: "^7.0.5",
+        minisearch: "^7.2.0",
+        "@xenova/transformers": "^2.17.2",
+        boxen: "7",
+        chalk: "^5.6.2",
+        commander: "^12.1.0",
+        dotenv: "^17.4.2",
+        marked: "^15.0.12",
+        "marked-terminal": "^7.3.0",
+        ora: "^9.4.0",
+        "parse-diff": "^0.12.0",
+        zod: "^4.4.3"
+      },
+      devDependencies: {
+        "@vortex/engine": "workspace:*",
+        "@vortex/github": "workspace:*",
+        "@vortex/git": "workspace:*",
+        "@vortex/shared": "workspace:*",
+        "@vortex/retrieval": "workspace:*",
+        "@vortex/db": "workspace:*",
+        "@vortex/typescript-config": "workspace:*",
+        tsup: "^8.0.2",
+        tsx: "^4.21.0",
+        typescript: "5.9.2"
+      }
+    };
+  }
+});
+
 // src/index.ts
 import { Command as Command2 } from "commander";
-import * as path3 from "path";
-import * as dotenv from "dotenv";
-import * as os from "os";
+import * as path4 from "path";
+import * as dotenv2 from "dotenv";
+import * as os2 from "os";
 
 // src/commands/init.ts
 var import_engine = __toESM(require_dist5());
@@ -215062,26 +215117,93 @@ cacheCommand.command("clear").description("Clear all entries from the LLM cache"
   }
 });
 
+// src/commands/config.ts
+import * as fs4 from "fs";
+import * as os from "os";
+import * as path3 from "path";
+import * as dotenv from "dotenv";
+var envPath = path3.resolve(os.homedir(), ".vortexenv");
+function readEnv() {
+  if (!fs4.existsSync(envPath)) return {};
+  const content = fs4.readFileSync(envPath, "utf-8");
+  return dotenv.parse(content);
+}
+function writeEnv(env) {
+  const content = Object.entries(env).map(([k, v]) => `${k}="${v.replace(/"/g, '\\"')}"`).join("\n");
+  fs4.writeFileSync(envPath, content + "\n", { mode: 384 });
+}
+async function configSet(provider, value) {
+  const { default: chalk2 } = await import("chalk");
+  const providerUpper = provider.toUpperCase();
+  let envKey = "";
+  if (providerUpper === "GEMINI") {
+    envKey = "GEMINI_API_KEY";
+  } else if (providerUpper === "GROQ") {
+    envKey = "GROQ_API_KEY";
+  } else {
+    console.log(chalk2.red(`Invalid option: ${chalk2.bold(provider)}. Supported options are 'gemini' and 'groq'.`));
+    console.log(chalk2.gray(`Usage: vortex config set gemini <your-key>`));
+    process.exit(1);
+  }
+  const env = readEnv();
+  env[envKey] = value;
+  writeEnv(env);
+  console.log(chalk2.green(`\u2713 Successfully set ${chalk2.bold(envKey)}`));
+}
+async function configGet(key) {
+  const { default: chalk2 } = await import("chalk");
+  const env = readEnv();
+  if (env[key]) {
+    console.log(env[key]);
+  } else {
+    console.log(chalk2.gray(`Key ${chalk2.bold(key)} is not set.`));
+  }
+}
+async function configList() {
+  const { default: chalk2 } = await import("chalk");
+  const env = readEnv();
+  const keys = Object.keys(env);
+  if (keys.length === 0) {
+    console.log(chalk2.gray("No configuration values set in ~/.vortexenv"));
+    return;
+  }
+  console.log(chalk2.blue.bold("\nVortex Global Configuration:\n"));
+  for (const [k, v] of Object.entries(env)) {
+    let masked = "***";
+    if (v.length > 10) {
+      masked = `${v.substring(0, 4)}...${v.substring(v.length - 4)}`;
+    } else if (v.length > 0) {
+      masked = v;
+    }
+    console.log(`  ${chalk2.cyan.bold(k)}: ${chalk2.gray(masked)}`);
+  }
+  console.log(`
+Location: ${chalk2.gray(envPath)}
+`);
+}
+
 // src/index.ts
-var monorepoEnv = path3.resolve(__dirname, "../../../.env");
+process.env.DOTENV_CONFIG_QUIET = "true";
+var monorepoEnv = path4.resolve(__dirname, "../../../.env");
 if (__require("fs").existsSync(monorepoEnv)) {
-  const envConfig = dotenv.parse(__require("fs").readFileSync(monorepoEnv));
+  const envConfig = dotenv2.parse(__require("fs").readFileSync(monorepoEnv));
   for (const k in envConfig) {
     if (k === "NODE_ENV") continue;
     if (!process.env[k]) process.env[k] = envConfig[k];
   }
 }
-dotenv.config({ path: path3.resolve(os.homedir(), ".vortexenv"), override: true });
-var cwdEnv = path3.resolve(process.cwd(), ".env");
+dotenv2.config({ path: path4.resolve(os2.homedir(), ".vortexenv"), override: true });
+var cwdEnv = path4.resolve(process.cwd(), ".env");
 if (__require("fs").existsSync(cwdEnv)) {
-  const envConfig = dotenv.parse(__require("fs").readFileSync(cwdEnv));
+  const envConfig = dotenv2.parse(__require("fs").readFileSync(cwdEnv));
   for (const k in envConfig) {
     if (k === "NODE_ENV") continue;
     process.env[k] = envConfig[k];
   }
 }
 var program = new Command2();
-program.name("vortex").description("Developer Intelligence & PR Review Engine").version("0.1.0");
+var { version } = require_package();
+program.name("vortex").description("Developer Intelligence & PR Review Engine").version(version);
 program.hook("preAction", (thisCommand, actionCommand) => {
   if (actionCommand.opts().cache === false) {
     process.env.VORTEX_DISABLE_CACHE = "true";
@@ -215097,6 +215219,10 @@ program.command("solve-issue").description("Autonomously solve a GitHub issue us
 program.command("suggest").description("Generate AI-powered code suggestions using repository patterns and historical intelligence").requiredOption("--file <path>", "Target file path").option("--apply", "Apply suggestions automatically").option("--deep", "Enable advanced contextual suggestions").option("--no-cache", "Disable LLM response caching").action(suggestCommand);
 program.command("fix-nitbits").description("Automatically fix formatting, comments, tests, CI issues, and repository-specific patterns").option("--safe", "Apply only deterministic safe fixes").option("--dry-run", "Preview fixes without modifying files").option("--files <paths>", "Comma-separated list of target files").action(fixNitbitsCommand);
 program.command("analyze").description("Analyze other contributors' PRs using repository history and architectural intelligence").requiredOption("--pr <number>", "Pull request number", Number).option("--deep", "Enable advanced PR intelligence analysis").option("--no-cache", "Disable LLM response caching").action(analyzeCommand);
+var configCmd = program.command("config").description("Manage global configuration and API keys");
+configCmd.command("set <provider> <key>").description("Set an API key for a specific provider (gemini or groq)").action(configSet);
+configCmd.command("get <key>").description("Get a global configuration value").action(configGet);
+configCmd.command("list").description("List all global configuration values").action(configList);
 program.addCommand(cacheCommand);
 program.parse();
 /*! Bundled license information: