claude-use 0.5.0 → 1.0.0

package/dist/cli.cjs

@@ -38,7 +38,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var require_resolve_from = __commonJS({
   "node_modules/.pnpm/resolve-from@4.0.0/node_modules/resolve-from/index.js"(exports2, module2) {
     "use strict";
-    var path21 = require("path");
+    var path22 = require("path");
     var Module = require("module");
     var fs9 = require("fs");
     var resolveFrom = (fromDir, moduleId, silent) => {
@@ -52,14 +52,14 @@ var require_resolve_from = __commonJS({
         fromDir = fs9.realpathSync(fromDir);
       } catch (err) {
         if (err.code === "ENOENT") {
-          fromDir = path21.resolve(fromDir);
+          fromDir = path22.resolve(fromDir);
         } else if (silent) {
           return null;
         } else {
           throw err;
         }
       }
-      const fromFile = path21.join(fromDir, "noop.js");
+      const fromFile = path22.join(fromDir, "noop.js");
       const resolveFileName = () => Module._resolveFilename(moduleId, {
         id: fromFile,
         filename: fromFile,
@@ -131,7 +131,7 @@ var require_parent_module = __commonJS({
 var require_import_fresh = __commonJS({
   "node_modules/.pnpm/import-fresh@3.3.1/node_modules/import-fresh/index.js"(exports2, module2) {
     "use strict";
-    var path21 = require("path");
+    var path22 = require("path");
     var resolveFrom = require_resolve_from();
     var parentModule = require_parent_module();
     module2.exports = (moduleId) => {
@@ -139,7 +139,7 @@ var require_import_fresh = __commonJS({
         throw new TypeError("Expected a string");
       }
       const parentPath = parentModule(__filename);
-      const cwd = parentPath ? path21.dirname(parentPath) : __dirname;
+      const cwd = parentPath ? path22.dirname(parentPath) : __dirname;
       const filePath = resolveFrom(cwd, moduleId);
       const oldModule = require.cache[filePath];
       if (oldModule && oldModule.parent) {
@@ -11893,17 +11893,17 @@ ${lanes.join("\n")}
       }
       function createSingleWatcherPerName(cache, useCaseSensitiveFileNames2, name, callback, createWatcher) {
         const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
-        const path21 = toCanonicalFileName(name);
-        const existing = cache.get(path21);
+        const path22 = toCanonicalFileName(name);
+        const existing = cache.get(path22);
         if (existing) {
           existing.callbacks.push(callback);
         } else {
-          cache.set(path21, {
+          cache.set(path22, {
             watcher: createWatcher(
               // Cant infer types correctly so lets satisfy checker
               ((param1, param2, param3) => {
                 var _a3;
-                return (_a3 = cache.get(path21)) == null ? void 0 : _a3.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
+                return (_a3 = cache.get(path22)) == null ? void 0 : _a3.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
               })
             ),
             callbacks: [callback]
@@ -11911,10 +11911,10 @@ ${lanes.join("\n")}
         }
         return {
           close: () => {
-            const watcher = cache.get(path21);
+            const watcher = cache.get(path22);
             if (!watcher) return;
             if (!orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length) return;
-            cache.delete(path21);
+            cache.delete(path22);
             closeFileWatcherOf(watcher);
           }
         };
@@ -12166,13 +12166,13 @@ ${lanes.join("\n")}
             (newChildWatches || (newChildWatches = [])).push(childWatcher);
           }
         }
-        function isIgnoredPath(path21, options) {
-          return some(ignoredPaths, (searchPath) => isInPath(path21, searchPath)) || isIgnoredByWatchOptions(path21, options, useCaseSensitiveFileNames2, getCurrentDirectory);
+        function isIgnoredPath(path22, options) {
+          return some(ignoredPaths, (searchPath) => isInPath(path22, searchPath)) || isIgnoredByWatchOptions(path22, options, useCaseSensitiveFileNames2, getCurrentDirectory);
         }
-        function isInPath(path21, searchPath) {
-          if (path21.includes(searchPath)) return true;
+        function isInPath(path22, searchPath) {
+          if (path22.includes(searchPath)) return true;
           if (useCaseSensitiveFileNames2) return false;
-          return toCanonicalFilePath(path21).includes(searchPath);
+          return toCanonicalFilePath(path22).includes(searchPath);
         }
       }
       var FileSystemEntryKind = /* @__PURE__ */ ((FileSystemEntryKind2) => {
@@ -12550,13 +12550,13 @@ ${lanes.join("\n")}
       }
       function patchWriteFileEnsuringDirectory(sys2) {
         const originalWriteFile = sys2.writeFile;
-        sys2.writeFile = (path21, data, writeBom) => writeFileEnsuringDirectories(
-          path21,
+        sys2.writeFile = (path22, data, writeBom) => writeFileEnsuringDirectories(
+          path22,
           data,
           !!writeBom,
-          (path22, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path22, data2, writeByteOrderMark),
-          (path22) => sys2.createDirectory(path22),
-          (path22) => sys2.directoryExists(path22)
+          (path23, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path23, data2, writeByteOrderMark),
+          (path23) => sys2.createDirectory(path23),
+          (path23) => sys2.directoryExists(path23)
         );
       }
       var sys = (() => {
@@ -12595,7 +12595,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: (path21) => getAccessibleFileSystemEntries(path21).directories,
+            getAccessibleSortedChildDirectories: (path22) => getAccessibleFileSystemEntries(path22).directories,
             realpath,
             tscWatchFile: process.env.TSC_WATCHFILE,
             useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER,
@@ -12622,7 +12622,7 @@ ${lanes.join("\n")}
             watchFile: watchFile2,
             watchDirectory,
             preferNonRecursiveWatch: !fsSupportsRecursiveFsWatch,
-            resolvePath: (path21) => _path.resolve(path21),
+            resolvePath: (path22) => _path.resolve(path22),
             fileExists,
             directoryExists,
             getAccessibleFileSystemEntries,
@@ -12657,8 +12657,8 @@ ${lanes.join("\n")}
               }
               return process.memoryUsage().heapUsed;
             },
-            getFileSize(path21) {
-              const stat = statSync(path21);
+            getFileSize(path22) {
+              const stat = statSync(path22);
               if (stat == null ? void 0 : stat.isFile()) {
                 return stat.size;
               }
@@ -12702,14 +12702,14 @@ ${lanes.join("\n")}
             }
           };
           return nodeSystem;
-          function statSync(path21) {
+          function statSync(path22) {
             try {
-              return _fs.statSync(path21, statSyncOptions);
+              return _fs.statSync(path22, statSyncOptions);
             } catch {
               return void 0;
             }
           }
-          function enableCPUProfiler(path21, cb) {
+          function enableCPUProfiler(path22, cb) {
             if (activeSession) {
               cb();
               return false;
@@ -12724,7 +12724,7 @@ ${lanes.join("\n")}
             session.post("Profiler.enable", () => {
               session.post("Profiler.start", () => {
                 activeSession = session;
-                profilePath = path21;
+                profilePath = path22;
                 cb();
               });
             });
@@ -12868,9 +12868,9 @@ ${lanes.join("\n")}
               }
             }
           }
-          function getAccessibleFileSystemEntries(path21) {
+          function getAccessibleFileSystemEntries(path22) {
             try {
-              const entries = _fs.readdirSync(path21 || ".", { withFileTypes: true });
+              const entries = _fs.readdirSync(path22 || ".", { withFileTypes: true });
               const files = [];
               const directories = [];
               for (const dirent of entries) {
@@ -12880,7 +12880,7 @@ ${lanes.join("\n")}
                 }
                 let stat;
                 if (typeof dirent === "string" || dirent.isSymbolicLink()) {
-                  const name = combinePaths(path21, entry);
+                  const name = combinePaths(path22, entry);
                   stat = statSync(name);
                   if (!stat) {
                     continue;
@@ -12901,11 +12901,11 @@ ${lanes.join("\n")}
               return emptyFileSystemEntries;
             }
           }
-          function readDirectory(path21, extensions, excludes, includes, depth) {
-            return matchFiles(path21, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
+          function readDirectory(path22, extensions, excludes, includes, depth) {
+            return matchFiles(path22, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
-          function fileSystemEntryExists(path21, entryKind) {
-            const stat = statSync(path21);
+          function fileSystemEntryExists(path22, entryKind) {
+            const stat = statSync(path22);
             if (!stat) {
               return false;
             }
@@ -12918,47 +12918,47 @@ ${lanes.join("\n")}
                 return false;
             }
           }
-          function fileExists(path21) {
+          function fileExists(path22) {
             return fileSystemEntryExists(
-              path21,
+              path22,
               0
               /* File */
             );
           }
-          function directoryExists(path21) {
+          function directoryExists(path22) {
             return fileSystemEntryExists(
-              path21,
+              path22,
               1
               /* Directory */
             );
           }
-          function getDirectories(path21) {
-            return getAccessibleFileSystemEntries(path21).directories.slice();
+          function getDirectories(path22) {
+            return getAccessibleFileSystemEntries(path22).directories.slice();
           }
-          function fsRealPathHandlingLongPath(path21) {
-            return path21.length < 260 ? _fs.realpathSync.native(path21) : _fs.realpathSync(path21);
+          function fsRealPathHandlingLongPath(path22) {
+            return path22.length < 260 ? _fs.realpathSync.native(path22) : _fs.realpathSync(path22);
           }
-          function realpath(path21) {
+          function realpath(path22) {
             try {
-              return fsRealpath(path21);
+              return fsRealpath(path22);
             } catch {
-              return path21;
+              return path22;
             }
           }
-          function getModifiedTime3(path21) {
+          function getModifiedTime3(path22) {
             var _a3;
-            return (_a3 = statSync(path21)) == null ? void 0 : _a3.mtime;
+            return (_a3 = statSync(path22)) == null ? void 0 : _a3.mtime;
           }
-          function setModifiedTime(path21, time3) {
+          function setModifiedTime(path22, time3) {
             try {
-              _fs.utimesSync(path21, time3, time3);
+              _fs.utimesSync(path22, time3, time3);
             } catch {
               return;
             }
           }
-          function deleteFile(path21) {
+          function deleteFile(path22) {
             try {
-              return _fs.unlinkSync(path21);
+              return _fs.unlinkSync(path22);
             } catch {
               return;
             }
@@ -12998,41 +12998,41 @@ ${lanes.join("\n")}
       function isAnyDirectorySeparator(charCode) {
         return charCode === 47 || charCode === 92;
       }
-      function isUrl(path21) {
-        return getEncodedRootLength(path21) < 0;
+      function isUrl(path22) {
+        return getEncodedRootLength(path22) < 0;
       }
-      function isRootedDiskPath(path21) {
-        return getEncodedRootLength(path21) > 0;
+      function isRootedDiskPath(path22) {
+        return getEncodedRootLength(path22) > 0;
       }
-      function isDiskPathRoot(path21) {
-        const rootLength = getEncodedRootLength(path21);
-        return rootLength > 0 && rootLength === path21.length;
+      function isDiskPathRoot(path22) {
+        const rootLength = getEncodedRootLength(path22);
+        return rootLength > 0 && rootLength === path22.length;
       }
-      function pathIsAbsolute(path21) {
-        return getEncodedRootLength(path21) !== 0;
+      function pathIsAbsolute(path22) {
+        return getEncodedRootLength(path22) !== 0;
       }
-      function pathIsRelative(path21) {
-        return /^\.\.?(?:$|[\\/])/.test(path21);
+      function pathIsRelative(path22) {
+        return /^\.\.?(?:$|[\\/])/.test(path22);
       }
-      function pathIsBareSpecifier(path21) {
-        return !pathIsAbsolute(path21) && !pathIsRelative(path21);
+      function pathIsBareSpecifier(path22) {
+        return !pathIsAbsolute(path22) && !pathIsRelative(path22);
       }
       function hasExtension(fileName) {
         return getBaseFileName(fileName).includes(".");
       }
-      function fileExtensionIs(path21, extension) {
-        return path21.length > extension.length && endsWith(path21, extension);
+      function fileExtensionIs(path22, extension) {
+        return path22.length > extension.length && endsWith(path22, extension);
       }
-      function fileExtensionIsOneOf(path21, extensions) {
+      function fileExtensionIsOneOf(path22, extensions) {
         for (const extension of extensions) {
-          if (fileExtensionIs(path21, extension)) {
+          if (fileExtensionIs(path22, extension)) {
             return true;
           }
         }
         return false;
       }
-      function hasTrailingDirectorySeparator(path21) {
-        return path21.length > 0 && isAnyDirectorySeparator(path21.charCodeAt(path21.length - 1));
+      function hasTrailingDirectorySeparator(path22) {
+        return path22.length > 0 && isAnyDirectorySeparator(path22.charCodeAt(path22.length - 1));
       }
       function isVolumeCharacter(charCode) {
         return charCode >= 97 && charCode <= 122 || charCode >= 65 && charCode <= 90;
@@ -13046,111 +13046,111 @@ ${lanes.join("\n")}
         }
         return -1;
       }
-      function getEncodedRootLength(path21) {
-        if (!path21) return 0;
-        const ch0 = path21.charCodeAt(0);
+      function getEncodedRootLength(path22) {
+        if (!path22) return 0;
+        const ch0 = path22.charCodeAt(0);
         if (ch0 === 47 || ch0 === 92) {
-          if (path21.charCodeAt(1) !== ch0) return 1;
-          const p1 = path21.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
-          if (p1 < 0) return path21.length;
+          if (path22.charCodeAt(1) !== ch0) return 1;
+          const p1 = path22.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
+          if (p1 < 0) return path22.length;
           return p1 + 1;
         }
-        if (isVolumeCharacter(ch0) && path21.charCodeAt(1) === 58) {
-          const ch2 = path21.charCodeAt(2);
+        if (isVolumeCharacter(ch0) && path22.charCodeAt(1) === 58) {
+          const ch2 = path22.charCodeAt(2);
           if (ch2 === 47 || ch2 === 92) return 3;
-          if (path21.length === 2) return 2;
+          if (path22.length === 2) return 2;
         }
-        const schemeEnd = path21.indexOf(urlSchemeSeparator);
+        const schemeEnd = path22.indexOf(urlSchemeSeparator);
         if (schemeEnd !== -1) {
           const authorityStart = schemeEnd + urlSchemeSeparator.length;
-          const authorityEnd = path21.indexOf(directorySeparator, authorityStart);
+          const authorityEnd = path22.indexOf(directorySeparator, authorityStart);
           if (authorityEnd !== -1) {
-            const scheme = path21.slice(0, schemeEnd);
-            const authority = path21.slice(authorityStart, authorityEnd);
-            if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path21.charCodeAt(authorityEnd + 1))) {
-              const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path21, authorityEnd + 2);
+            const scheme = path22.slice(0, schemeEnd);
+            const authority = path22.slice(authorityStart, authorityEnd);
+            if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path22.charCodeAt(authorityEnd + 1))) {
+              const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path22, authorityEnd + 2);
               if (volumeSeparatorEnd !== -1) {
-                if (path21.charCodeAt(volumeSeparatorEnd) === 47) {
+                if (path22.charCodeAt(volumeSeparatorEnd) === 47) {
                   return ~(volumeSeparatorEnd + 1);
                 }
-                if (volumeSeparatorEnd === path21.length) {
+                if (volumeSeparatorEnd === path22.length) {
                   return ~volumeSeparatorEnd;
                 }
               }
             }
             return ~(authorityEnd + 1);
           }
-          return ~path21.length;
+          return ~path22.length;
         }
         return 0;
       }
-      function getRootLength(path21) {
-        const rootLength = getEncodedRootLength(path21);
+      function getRootLength(path22) {
+        const rootLength = getEncodedRootLength(path22);
         return rootLength < 0 ? ~rootLength : rootLength;
       }
-      function getDirectoryPath(path21) {
-        path21 = normalizeSlashes(path21);
-        const rootLength = getRootLength(path21);
-        if (rootLength === path21.length) return path21;
-        path21 = removeTrailingDirectorySeparator(path21);
-        return path21.slice(0, Math.max(rootLength, path21.lastIndexOf(directorySeparator)));
-      }
-      function getBaseFileName(path21, extensions, ignoreCase) {
-        path21 = normalizeSlashes(path21);
-        const rootLength = getRootLength(path21);
-        if (rootLength === path21.length) return "";
-        path21 = removeTrailingDirectorySeparator(path21);
-        const name = path21.slice(Math.max(getRootLength(path21), path21.lastIndexOf(directorySeparator) + 1));
+      function getDirectoryPath(path22) {
+        path22 = normalizeSlashes(path22);
+        const rootLength = getRootLength(path22);
+        if (rootLength === path22.length) return path22;
+        path22 = removeTrailingDirectorySeparator(path22);
+        return path22.slice(0, Math.max(rootLength, path22.lastIndexOf(directorySeparator)));
+      }
+      function getBaseFileName(path22, extensions, ignoreCase) {
+        path22 = normalizeSlashes(path22);
+        const rootLength = getRootLength(path22);
+        if (rootLength === path22.length) return "";
+        path22 = removeTrailingDirectorySeparator(path22);
+        const name = path22.slice(Math.max(getRootLength(path22), path22.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(path21, extension, stringEqualityComparer) {
+      function tryGetExtensionFromPath(path22, extension, stringEqualityComparer) {
         if (!startsWith(extension, ".")) extension = "." + extension;
-        if (path21.length >= extension.length && path21.charCodeAt(path21.length - extension.length) === 46) {
-          const pathExtension = path21.slice(path21.length - extension.length);
+        if (path22.length >= extension.length && path22.charCodeAt(path22.length - extension.length) === 46) {
+          const pathExtension = path22.slice(path22.length - extension.length);
           if (stringEqualityComparer(pathExtension, extension)) {
             return pathExtension;
           }
         }
       }
-      function getAnyExtensionFromPathWorker(path21, extensions, stringEqualityComparer) {
+      function getAnyExtensionFromPathWorker(path22, extensions, stringEqualityComparer) {
         if (typeof extensions === "string") {
-          return tryGetExtensionFromPath(path21, extensions, stringEqualityComparer) || "";
+          return tryGetExtensionFromPath(path22, extensions, stringEqualityComparer) || "";
         }
         for (const extension of extensions) {
-          const result = tryGetExtensionFromPath(path21, extension, stringEqualityComparer);
+          const result = tryGetExtensionFromPath(path22, extension, stringEqualityComparer);
           if (result) return result;
         }
         return "";
       }
-      function getAnyExtensionFromPath(path21, extensions, ignoreCase) {
+      function getAnyExtensionFromPath(path22, extensions, ignoreCase) {
         if (extensions) {
-          return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path21), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
+          return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path22), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
         }
-        const baseFileName = getBaseFileName(path21);
+        const baseFileName = getBaseFileName(path22);
         const extensionIndex = baseFileName.lastIndexOf(".");
         if (extensionIndex >= 0) {
           return baseFileName.substring(extensionIndex);
         }
         return "";
       }
-      function pathComponents(path21, rootLength) {
-        const root = path21.substring(0, rootLength);
-        const rest = path21.substring(rootLength).split(directorySeparator);
+      function pathComponents(path22, rootLength) {
+        const root = path22.substring(0, rootLength);
+        const rest = path22.substring(rootLength).split(directorySeparator);
         if (rest.length && !lastOrUndefined(rest)) rest.pop();
         return [root, ...rest];
       }
-      function getPathComponents(path21, currentDirectory = "") {
-        path21 = combinePaths(currentDirectory, path21);
-        return pathComponents(path21, getRootLength(path21));
+      function getPathComponents(path22, currentDirectory = "") {
+        path22 = combinePaths(currentDirectory, path22);
+        return pathComponents(path22, getRootLength(path22));
       }
       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(path21) {
-        return path21.includes("\\") ? path21.replace(backslashRegExp, directorySeparator) : path21;
+      function normalizeSlashes(path22) {
+        return path22.includes("\\") ? path22.replace(backslashRegExp, directorySeparator) : path22;
       }
       function reducePathComponents(components) {
         if (!some(components)) return [];
@@ -13171,39 +13171,39 @@ ${lanes.join("\n")}
         }
         return reduced;
       }
-      function combinePaths(path21, ...paths) {
-        if (path21) path21 = normalizeSlashes(path21);
+      function combinePaths(path22, ...paths) {
+        if (path22) path22 = normalizeSlashes(path22);
         for (let relativePath of paths) {
           if (!relativePath) continue;
           relativePath = normalizeSlashes(relativePath);
-          if (!path21 || getRootLength(relativePath) !== 0) {
-            path21 = relativePath;
+          if (!path22 || getRootLength(relativePath) !== 0) {
+            path22 = relativePath;
           } else {
-            path21 = ensureTrailingDirectorySeparator(path21) + relativePath;
+            path22 = ensureTrailingDirectorySeparator(path22) + relativePath;
           }
         }
-        return path21;
+        return path22;
       }
-      function resolvePath(path21, ...paths) {
-        return normalizePath(some(paths) ? combinePaths(path21, ...paths) : normalizeSlashes(path21));
+      function resolvePath(path22, ...paths) {
+        return normalizePath(some(paths) ? combinePaths(path22, ...paths) : normalizeSlashes(path22));
       }
-      function getNormalizedPathComponents(path21, currentDirectory) {
-        return reducePathComponents(getPathComponents(path21, currentDirectory));
+      function getNormalizedPathComponents(path22, currentDirectory) {
+        return reducePathComponents(getPathComponents(path22, currentDirectory));
       }
-      function getNormalizedAbsolutePath(path21, currentDirectory) {
-        let rootLength = getRootLength(path21);
+      function getNormalizedAbsolutePath(path22, currentDirectory) {
+        let rootLength = getRootLength(path22);
         if (rootLength === 0 && currentDirectory) {
-          path21 = combinePaths(currentDirectory, path21);
-          rootLength = getRootLength(path21);
+          path22 = combinePaths(currentDirectory, path22);
+          rootLength = getRootLength(path22);
         } else {
-          path21 = normalizeSlashes(path21);
+          path22 = normalizeSlashes(path22);
         }
-        const simpleNormalized = simpleNormalizePath(path21);
+        const simpleNormalized = simpleNormalizePath(path22);
         if (simpleNormalized !== void 0) {
           return simpleNormalized.length > rootLength ? removeTrailingDirectorySeparator(simpleNormalized) : simpleNormalized;
         }
-        const length2 = path21.length;
-        const root = path21.substring(0, rootLength);
+        const length2 = path22.length;
+        const root = path22.substring(0, rootLength);
         let normalized;
         let index = rootLength;
         let segmentStart = index;
@@ -13211,23 +13211,23 @@ ${lanes.join("\n")}
         let seenNonDotDotSegment = rootLength !== 0;
         while (index < length2) {
           segmentStart = index;
-          let ch = path21.charCodeAt(index);
+          let ch = path22.charCodeAt(index);
           while (ch === 47 && index + 1 < length2) {
             index++;
-            ch = path21.charCodeAt(index);
+            ch = path22.charCodeAt(index);
           }
           if (index > segmentStart) {
-            normalized ?? (normalized = path21.substring(0, segmentStart - 1));
+            normalized ?? (normalized = path22.substring(0, segmentStart - 1));
             segmentStart = index;
           }
-          let segmentEnd = path21.indexOf(directorySeparator, index + 1);
+          let segmentEnd = path22.indexOf(directorySeparator, index + 1);
           if (segmentEnd === -1) {
             segmentEnd = length2;
           }
           const segmentLength = segmentEnd - segmentStart;
-          if (segmentLength === 1 && path21.charCodeAt(index) === 46) {
-            normalized ?? (normalized = path21.substring(0, normalizedUpTo));
-          } else if (segmentLength === 2 && path21.charCodeAt(index) === 46 && path21.charCodeAt(index + 1) === 46) {
+          if (segmentLength === 1 && path22.charCodeAt(index) === 46) {
+            normalized ?? (normalized = path22.substring(0, normalizedUpTo));
+          } else if (segmentLength === 2 && path22.charCodeAt(index) === 46 && path22.charCodeAt(index + 1) === 46) {
             if (!seenNonDotDotSegment) {
               if (normalized !== void 0) {
                 normalized += normalized.length === rootLength ? ".." : "/..";
@@ -13236,9 +13236,9 @@ ${lanes.join("\n")}
               }
             } else if (normalized === void 0) {
               if (normalizedUpTo - 2 >= 0) {
-                normalized = path21.substring(0, Math.max(rootLength, path21.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
+                normalized = path22.substring(0, Math.max(rootLength, path22.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
               } else {
-                normalized = path21.substring(0, normalizedUpTo);
+                normalized = path22.substring(0, normalizedUpTo);
               }
             } else {
               const lastSlash = normalized.lastIndexOf(directorySeparator);
@@ -13256,36 +13256,36 @@ ${lanes.join("\n")}
               normalized += directorySeparator;
             }
             seenNonDotDotSegment = true;
-            normalized += path21.substring(segmentStart, segmentEnd);
+            normalized += path22.substring(segmentStart, segmentEnd);
           } else {
             seenNonDotDotSegment = true;
             normalizedUpTo = segmentEnd;
           }
           index = segmentEnd + 1;
         }
-        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path21) : path21);
+        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path22) : path22);
       }
-      function normalizePath(path21) {
-        path21 = normalizeSlashes(path21);
-        let normalized = simpleNormalizePath(path21);
+      function normalizePath(path22) {
+        path22 = normalizeSlashes(path22);
+        let normalized = simpleNormalizePath(path22);
         if (normalized !== void 0) {
           return normalized;
         }
-        normalized = getNormalizedAbsolutePath(path21, "");
-        return normalized && hasTrailingDirectorySeparator(path21) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+        normalized = getNormalizedAbsolutePath(path22, "");
+        return normalized && hasTrailingDirectorySeparator(path22) ? ensureTrailingDirectorySeparator(normalized) : normalized;
       }
-      function simpleNormalizePath(path21) {
-        if (!relativePathSegmentRegExp.test(path21)) {
-          return path21;
+      function simpleNormalizePath(path22) {
+        if (!relativePathSegmentRegExp.test(path22)) {
+          return path22;
         }
-        let simplified = path21.replace(/\/\.\//g, "/");
+        let simplified = path22.replace(/\/\.\//g, "/");
         if (simplified.startsWith("./")) {
           simplified = simplified.slice(2);
         }
-        if (simplified !== path21) {
-          path21 = simplified;
-          if (!relativePathSegmentRegExp.test(path21)) {
-            return path21;
+        if (simplified !== path22) {
+          path22 = simplified;
+          if (!relativePathSegmentRegExp.test(path22)) {
+            return path22;
           }
         }
         return void 0;
@@ -13301,31 +13301,31 @@ ${lanes.join("\n")}
         const nonCanonicalizedPath = isRootedDiskPath(fileName) ? normalizePath(fileName) : getNormalizedAbsolutePath(fileName, basePath);
         return getCanonicalFileName(nonCanonicalizedPath);
       }
-      function removeTrailingDirectorySeparator(path21) {
-        if (hasTrailingDirectorySeparator(path21)) {
-          return path21.substr(0, path21.length - 1);
+      function removeTrailingDirectorySeparator(path22) {
+        if (hasTrailingDirectorySeparator(path22)) {
+          return path22.substr(0, path22.length - 1);
         }
-        return path21;
+        return path22;
       }
-      function ensureTrailingDirectorySeparator(path21) {
-        if (!hasTrailingDirectorySeparator(path21)) {
-          return path21 + directorySeparator;
+      function ensureTrailingDirectorySeparator(path22) {
+        if (!hasTrailingDirectorySeparator(path22)) {
+          return path22 + directorySeparator;
         }
-        return path21;
+        return path22;
       }
-      function ensurePathIsNonModuleName(path21) {
-        return !pathIsAbsolute(path21) && !pathIsRelative(path21) ? "./" + path21 : path21;
+      function ensurePathIsNonModuleName(path22) {
+        return !pathIsAbsolute(path22) && !pathIsRelative(path22) ? "./" + path22 : path22;
       }
-      function changeAnyExtension(path21, ext, extensions, ignoreCase) {
-        const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path21, extensions, ignoreCase) : getAnyExtensionFromPath(path21);
-        return pathext ? path21.slice(0, path21.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path21;
+      function changeAnyExtension(path22, ext, extensions, ignoreCase) {
+        const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path22, extensions, ignoreCase) : getAnyExtensionFromPath(path22);
+        return pathext ? path22.slice(0, path22.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path22;
       }
-      function changeFullExtension(path21, newExtension) {
-        const declarationExtension = getDeclarationFileExtension(path21);
+      function changeFullExtension(path22, newExtension) {
+        const declarationExtension = getDeclarationFileExtension(path22);
         if (declarationExtension) {
-          return path21.slice(0, path21.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
+          return path22.slice(0, path22.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
         }
-        return changeAnyExtension(path21, newExtension);
+        return changeAnyExtension(path22, newExtension);
       }
       var relativePathSegmentRegExp = /\/\/|(?:^|\/)\.\.?(?:$|\/)/;
       function comparePathsWorker(a2, b, componentComparer) {
@@ -24848,8 +24848,8 @@ ${lanes.join("\n")}
       function getResolvedExternalModuleName(host, file2, referenceFile) {
         return file2.moduleName || getExternalModuleNameFromPath(host, file2.fileName, referenceFile && referenceFile.fileName);
       }
-      function getCanonicalAbsolutePath(host, path21) {
-        return host.getCanonicalFileName(getNormalizedAbsolutePath(path21, host.getCurrentDirectory()));
+      function getCanonicalAbsolutePath(host, path22) {
+        return host.getCanonicalFileName(getNormalizedAbsolutePath(path22, host.getCurrentDirectory()));
       }
       function getExternalModuleNameFromDeclaration(host, resolver, declaration) {
         const file2 = resolver.getExternalModuleFileFromDeclaration(declaration);
@@ -24892,20 +24892,20 @@ ${lanes.join("\n")}
       }
       function getDeclarationEmitOutputFilePathWorker(fileName, options, host) {
         const outputDir = options.declarationDir || options.outDir;
-        const path21 = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f)) : fileName;
-        const declarationExtension = getDeclarationEmitExtensionForPath(path21);
-        return removeFileExtension(path21) + declarationExtension;
+        const path22 = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f)) : fileName;
+        const declarationExtension = getDeclarationEmitExtensionForPath(path22);
+        return removeFileExtension(path22) + declarationExtension;
       }
-      function getDeclarationEmitExtensionForPath(path21) {
-        return fileExtensionIsOneOf(path21, [
+      function getDeclarationEmitExtensionForPath(path22) {
+        return fileExtensionIsOneOf(path22, [
           ".mjs",
           ".mts"
           /* Mts */
-        ]) ? ".d.mts" : fileExtensionIsOneOf(path21, [
+        ]) ? ".d.mts" : fileExtensionIsOneOf(path22, [
           ".cjs",
           ".cts"
           /* Cts */
-        ]) ? ".d.cts" : fileExtensionIsOneOf(path21, [
+        ]) ? ".d.cts" : fileExtensionIsOneOf(path22, [
           ".json"
           /* Json */
         ]) ? `.d.json.ts` : (
@@ -24913,8 +24913,8 @@ ${lanes.join("\n")}
           ".d.ts"
         );
       }
-      function getPossibleOriginalInputExtensionForExtension(path21) {
-        return fileExtensionIsOneOf(path21, [
+      function getPossibleOriginalInputExtensionForExtension(path22) {
+        return fileExtensionIsOneOf(path22, [
           ".d.mts",
           ".mjs",
           ".mts"
@@ -24923,7 +24923,7 @@ ${lanes.join("\n")}
           ".mts",
           ".mjs"
           /* Mjs */
-        ] : fileExtensionIsOneOf(path21, [
+        ] : fileExtensionIsOneOf(path22, [
           ".d.cts",
           ".cjs",
           ".cts"
@@ -24932,7 +24932,7 @@ ${lanes.join("\n")}
           ".cts",
           ".cjs"
           /* Cjs */
-        ] : fileExtensionIsOneOf(path21, [`.d.json.ts`]) ? [
+        ] : fileExtensionIsOneOf(path22, [`.d.json.ts`]) ? [
           ".json"
           /* Json */
         ] : [
@@ -25017,12 +25017,12 @@ ${lanes.join("\n")}
           createDirectory(directoryPath);
         }
       }
-      function writeFileEnsuringDirectories(path21, data, writeByteOrderMark, writeFile2, createDirectory, directoryExists) {
+      function writeFileEnsuringDirectories(path22, data, writeByteOrderMark, writeFile2, createDirectory, directoryExists) {
         try {
-          writeFile2(path21, data, writeByteOrderMark);
+          writeFile2(path22, data, writeByteOrderMark);
         } catch {
-          ensureDirectoriesExist(getDirectoryPath(normalizePath(path21)), createDirectory, directoryExists);
-          writeFile2(path21, data, writeByteOrderMark);
+          ensureDirectoriesExist(getDirectoryPath(normalizePath(path22)), createDirectory, directoryExists);
+          writeFile2(path22, data, writeByteOrderMark);
         }
       }
       function getLineOfLocalPosition(sourceFile, pos) {
@@ -25722,20 +25722,20 @@ ${lanes.join("\n")}
         }
         return getStringFromExpandedCharCodes(expandedCharCodes);
       }
-      function readJsonOrUndefined(path21, hostOrText) {
-        const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path21);
+      function readJsonOrUndefined(path22, hostOrText) {
+        const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path22);
         if (!jsonText) return void 0;
         let result = tryParseJson(jsonText);
         if (result === void 0) {
-          const looseResult = parseConfigFileTextToJson(path21, jsonText);
+          const looseResult = parseConfigFileTextToJson(path22, jsonText);
           if (!looseResult.error) {
             result = looseResult.config;
           }
         }
         return result;
       }
-      function readJson2(path21, host) {
-        return readJsonOrUndefined(path21, host) || {};
+      function readJson2(path22, host) {
+        return readJsonOrUndefined(path22, host) || {};
       }
       function tryParseJson(text) {
         try {
@@ -26886,7 +26886,7 @@ ${lanes.join("\n")}
           getSymlinkedFiles: () => symlinkedFiles,
           getSymlinkedDirectories: () => symlinkedDirectories,
           getSymlinkedDirectoriesByRealpath: () => symlinkedDirectoriesByRealpath,
-          setSymlinkedFile: (path21, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path21, real),
+          setSymlinkedFile: (path22, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path22, real),
           setSymlinkedDirectory: (symlink, real) => {
             let symlinkPath = toPath(symlink, cwd, getCanonicalFileName);
             if (!containsIgnoredPath(symlinkPath)) {
@@ -26946,8 +26946,8 @@ ${lanes.join("\n")}
       function stripLeadingDirectorySeparator(s) {
         return isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : void 0;
       }
-      function tryRemoveDirectoryPrefix(path21, dirPath, getCanonicalFileName) {
-        const withoutPrefix = tryRemovePrefix(path21, dirPath, getCanonicalFileName);
+      function tryRemoveDirectoryPrefix(path22, dirPath, getCanonicalFileName) {
+        const withoutPrefix = tryRemovePrefix(path22, dirPath, getCanonicalFileName);
         return withoutPrefix === void 0 ? void 0 : stripLeadingDirectorySeparator(withoutPrefix);
       }
       var reservedCharacterPattern = /[^\w\s/]/g;
@@ -27073,25 +27073,25 @@ ${lanes.join("\n")}
       function replaceWildcardCharacter(match, singleAsteriskRegexFragment) {
         return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match;
       }
-      function getFileMatcherPatterns(path21, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
-        path21 = normalizePath(path21);
+      function getFileMatcherPatterns(path22, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
+        path22 = normalizePath(path22);
         currentDirectory = normalizePath(currentDirectory);
-        const absolutePath = combinePaths(currentDirectory, path21);
+        const absolutePath = combinePaths(currentDirectory, path22);
         return {
           includeFilePatterns: map2(getRegularExpressionsForWildcards(includes, absolutePath, "files"), (pattern) => `^${pattern}$`),
           includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
           includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
           excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-          basePaths: getBasePaths(path21, includes, useCaseSensitiveFileNames2)
+          basePaths: getBasePaths(path22, includes, useCaseSensitiveFileNames2)
         };
       }
       function getRegexFromPattern(pattern, useCaseSensitiveFileNames2) {
         return new RegExp(pattern, useCaseSensitiveFileNames2 ? "" : "i");
       }
-      function matchFiles(path21, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
-        path21 = normalizePath(path21);
+      function matchFiles(path22, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
+        path22 = normalizePath(path22);
         currentDirectory = normalizePath(currentDirectory);
-        const patterns = getFileMatcherPatterns(path21, excludes, includes, useCaseSensitiveFileNames2, currentDirectory);
+        const patterns = getFileMatcherPatterns(path22, 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);
@@ -27102,13 +27102,13 @@ ${lanes.join("\n")}
           visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
         }
         return flatten(results);
-        function visitDirectory(path22, absolutePath, depth2) {
+        function visitDirectory(path23, absolutePath, depth2) {
           const canonicalPath = toCanonical(realpath(absolutePath));
           if (visited.has(canonicalPath)) return;
           visited.set(canonicalPath, true);
-          const { files, directories } = getFileSystemEntries(path22);
+          const { files, directories } = getFileSystemEntries(path23);
           for (const current of toSorted(files, compareStringsCaseSensitive)) {
-            const name = combinePaths(path22, current);
+            const name = combinePaths(path23, current);
             const absoluteName = combinePaths(absolutePath, current);
             if (extensions && !fileExtensionIsOneOf(name, extensions)) continue;
             if (excludeRegex && excludeRegex.test(absoluteName)) continue;
@@ -27128,7 +27128,7 @@ ${lanes.join("\n")}
             }
           }
           for (const current of toSorted(directories, compareStringsCaseSensitive)) {
-            const name = combinePaths(path22, current);
+            const name = combinePaths(path23, current);
             const absoluteName = combinePaths(absolutePath, current);
             if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) && (!excludeRegex || !excludeRegex.test(absoluteName))) {
               visitDirectory(name, absoluteName, depth2);
@@ -27136,17 +27136,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function getBasePaths(path21, includes, useCaseSensitiveFileNames2) {
-        const basePaths = [path21];
+      function getBasePaths(path22, includes, useCaseSensitiveFileNames2) {
+        const basePaths = [path22];
         if (includes) {
           const includeBasePaths = [];
           for (const include of includes) {
-            const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path21, include));
+            const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path22, include));
             includeBasePaths.push(getIncludeBasePath(absolute));
           }
           includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames2));
           for (const includeBasePath of includeBasePaths) {
-            if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path21, !useCaseSensitiveFileNames2))) {
+            if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path22, !useCaseSensitiveFileNames2))) {
               basePaths.push(includeBasePath);
             }
           }
@@ -27410,24 +27410,24 @@ ${lanes.join("\n")}
         ".json"
         /* Json */
       ];
-      function removeFileExtension(path21) {
+      function removeFileExtension(path22) {
         for (const ext of extensionsToRemove) {
-          const extensionless = tryRemoveExtension(path21, ext);
+          const extensionless = tryRemoveExtension(path22, ext);
           if (extensionless !== void 0) {
             return extensionless;
           }
         }
-        return path21;
+        return path22;
       }
-      function tryRemoveExtension(path21, extension) {
-        return fileExtensionIs(path21, extension) ? removeExtension(path21, extension) : void 0;
+      function tryRemoveExtension(path22, extension) {
+        return fileExtensionIs(path22, extension) ? removeExtension(path22, extension) : void 0;
       }
-      function removeExtension(path21, extension) {
-        return path21.substring(0, path21.length - extension.length);
+      function removeExtension(path22, extension) {
+        return path22.substring(0, path22.length - extension.length);
       }
-      function changeExtension(path21, newExtension) {
+      function changeExtension(path22, newExtension) {
         return changeAnyExtension(
-          path21,
+          path22,
           newExtension,
           extensionsToRemove,
           /*ignoreCase*/
@@ -27453,8 +27453,8 @@ ${lanes.join("\n")}
         let matchableStringSet;
         let patterns;
         const pathList = getOwnKeys(paths);
-        for (const path21 of pathList) {
-          const patternOrStr = tryParsePattern(path21);
+        for (const path22 of pathList) {
+          const patternOrStr = tryParsePattern(path22);
           if (patternOrStr === void 0) {
             continue;
           } else if (typeof patternOrStr === "string") {
@@ -27481,15 +27481,15 @@ ${lanes.join("\n")}
       function resolutionExtensionIsTSOrJson(ext) {
         return extensionIsTS(ext) || ext === ".json";
       }
-      function extensionFromPath(path21) {
-        const ext = tryGetExtensionFromPath2(path21);
-        return ext !== void 0 ? ext : Debug.fail(`File ${path21} has unknown extension.`);
+      function extensionFromPath(path22) {
+        const ext = tryGetExtensionFromPath2(path22);
+        return ext !== void 0 ? ext : Debug.fail(`File ${path22} has unknown extension.`);
       }
-      function isAnySupportedFileExtension(path21) {
-        return tryGetExtensionFromPath2(path21) !== void 0;
+      function isAnySupportedFileExtension(path22) {
+        return tryGetExtensionFromPath2(path22) !== void 0;
       }
-      function tryGetExtensionFromPath2(path21) {
-        return find(extensionsToRemove, (e) => fileExtensionIs(path21, e));
+      function tryGetExtensionFromPath2(path22) {
+        return find(extensionsToRemove, (e) => fileExtensionIs(path22, e));
       }
       function isCheckJsEnabledForFile(sourceFile, compilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
@@ -27798,8 +27798,8 @@ ${lanes.join("\n")}
           return false;
         }
       }
-      function containsIgnoredPath(path21) {
-        return some(ignoredPaths, (p) => path21.includes(p));
+      function containsIgnoredPath(path22) {
+        return some(ignoredPaths, (p) => path22.includes(p));
       }
       function getContainingNodeArray(node) {
         if (!node.parent) return void 0;
@@ -47634,7 +47634,7 @@ ${lanes.join("\n")}
               const typeReferenceDirectives = context.typeReferenceDirectives;
               const libReferenceDirectives = context.libReferenceDirectives;
               forEach(toArray(entryOrList), (arg) => {
-                const { types, lib, path: path21, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
+                const { types, lib, path: path22, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
                 const preserve = _preserve === "true" ? true : void 0;
                 if (arg.arguments["no-default-lib"] === "true") {
                 } else if (types) {
@@ -47642,8 +47642,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 (path21) {
-                  referencedFiles.push({ pos: path21.pos, end: path21.end, fileName: path21.value, ...preserve ? { preserve } : {} });
+                } else if (path22) {
+                  referencedFiles.push({ pos: path22.pos, end: path22.end, fileName: path22.value, ...preserve ? { preserve } : {} });
                 } else {
                   reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);
                 }
@@ -50102,19 +50102,19 @@ ${lanes.join("\n")}
         if (specs[0] === defaultIncludeSpec) return void 0;
         return specs;
       }
-      function matchesSpecs(path21, includeSpecs, excludeSpecs, host) {
+      function matchesSpecs(path22, includeSpecs, excludeSpecs, host) {
         if (!includeSpecs) return returnTrue;
-        const patterns = getFileMatcherPatterns(path21, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
+        const patterns = getFileMatcherPatterns(path22, 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) {
           if (excludeRe) {
-            return (path22) => !(includeRe.test(path22) && !excludeRe.test(path22));
+            return (path23) => !(includeRe.test(path23) && !excludeRe.test(path23));
           }
-          return (path22) => !includeRe.test(path22);
+          return (path23) => !includeRe.test(path23);
         }
         if (excludeRe) {
-          return (path22) => excludeRe.test(path22);
+          return (path23) => excludeRe.test(path23);
         }
         return returnTrue;
       }
@@ -50749,9 +50749,9 @@ ${lanes.join("\n")}
             const setPropertyInResultIfNotUndefined = (propertyName) => {
               if (ownConfig.raw[propertyName]) return;
               if (extendsRaw[propertyName]) {
-                result[propertyName] = map2(extendsRaw[propertyName], (path21) => startsWithConfigDirTemplate(path21) || isRootedDiskPath(path21) ? path21 : combinePaths(
+                result[propertyName] = map2(extendsRaw[propertyName], (path22) => startsWithConfigDirTemplate(path22) || isRootedDiskPath(path22) ? path22 : combinePaths(
                   relativeDifference || (relativeDifference = convertToRelativePath(getDirectoryPath(extendedConfigPath), basePath, createGetCanonicalFileName(host.useCaseSensitiveFileNames))),
-                  path21
+                  path22
                 ));
               }
             };
@@ -50905,14 +50905,14 @@ ${lanes.join("\n")}
         return void 0;
       }
       function getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache, result) {
-        const path21 = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
+        const path22 = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
         let value;
         let extendedResult;
         let extendedConfig;
-        if (extendedConfigCache && (value = extendedConfigCache.get(path21))) {
+        if (extendedConfigCache && (value = extendedConfigCache.get(path22))) {
           ({ extendedResult, extendedConfig } = value);
         } else {
-          extendedResult = readJsonConfigFile(extendedConfigPath, (path22) => host.readFile(path22));
+          extendedResult = readJsonConfigFile(extendedConfigPath, (path23) => host.readFile(path23));
           if (!extendedResult.parseDiagnostics.length) {
             extendedConfig = parseConfig(
               /*json*/
@@ -50927,7 +50927,7 @@ ${lanes.join("\n")}
             );
           }
           if (extendedConfigCache) {
-            extendedConfigCache.set(path21, { extendedResult, extendedConfig });
+            extendedConfigCache.set(path22, { extendedResult, extendedConfig });
           }
         }
         if (sourceFile) {
@@ -51195,24 +51195,24 @@ ${lanes.join("\n")}
             }
             const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2);
             if (match) {
-              const { key, path: path21, flags } = match;
+              const { key, path: path22, 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 : path21] = flags;
-                if (existingPath === void 0) wildCardKeyToPath.set(key, path21);
+                wildcardDirectories[existingPath !== void 0 ? existingPath : path22] = flags;
+                if (existingPath === void 0) wildCardKeyToPath.set(key, path22);
                 if (flags === 1) {
                   recursiveKeys.push(key);
                 }
               }
             }
           }
-          for (const path21 in wildcardDirectories) {
-            if (hasProperty(wildcardDirectories, path21)) {
+          for (const path22 in wildcardDirectories) {
+            if (hasProperty(wildcardDirectories, path22)) {
               for (const recursiveKey of recursiveKeys) {
-                const key = toCanonicalKey(path21, useCaseSensitiveFileNames2);
+                const key = toCanonicalKey(path22, useCaseSensitiveFileNames2);
                 if (key !== recursiveKey && containsPath(recursiveKey, key, basePath, !useCaseSensitiveFileNames2)) {
-                  delete wildcardDirectories[path21];
+                  delete wildcardDirectories[path22];
                 }
               }
             }
@@ -51220,8 +51220,8 @@ ${lanes.join("\n")}
         }
         return wildcardDirectories;
       }
-      function toCanonicalKey(path21, useCaseSensitiveFileNames2) {
-        return useCaseSensitiveFileNames2 ? path21 : toFileNameLowerCase(path21);
+      function toCanonicalKey(path22, useCaseSensitiveFileNames2) {
+        return useCaseSensitiveFileNames2 ? path22 : toFileNameLowerCase(path22);
       }
       function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2) {
         const match = wildcardDirectoryPattern.exec(spec);
@@ -51237,10 +51237,10 @@ ${lanes.join("\n")}
           };
         }
         if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
-          const path21 = removeTrailingDirectorySeparator(spec);
+          const path22 = removeTrailingDirectorySeparator(spec);
           return {
-            key: toCanonicalKey(path21, useCaseSensitiveFileNames2),
-            path: path21,
+            key: toCanonicalKey(path22, useCaseSensitiveFileNames2),
+            path: path22,
             flags: 1
             /* Recursive */
           };
@@ -51479,11 +51479,11 @@ ${lanes.join("\n")}
           }
           return;
         }
-        const path21 = normalizePath(combinePaths(baseDirectory, fileName));
+        const path22 = normalizePath(combinePaths(baseDirectory, fileName));
         if (state.traceEnabled) {
-          trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path21);
+          trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path22);
         }
-        return path21;
+        return path22;
       }
       function readPackageJsonTypesFields(jsonContent, baseDirectory, state) {
         return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state) || readPackageJsonPathField(jsonContent, "types", baseDirectory, state);
@@ -51997,13 +51997,13 @@ ${lanes.join("\n")}
           directoryToModuleNameMap.update(options2);
         }
         function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
-          const path21 = toPath(directoryName, currentDirectory, getCanonicalFileName);
-          return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path21, () => createModeAwareCache());
+          const path22 = toPath(directoryName, currentDirectory, getCanonicalFileName);
+          return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path22, () => createModeAwareCache());
         }
         function getFromDirectoryCache(name, mode, directoryName, redirectedReference) {
           var _a3, _b;
-          const path21 = toPath(directoryName, currentDirectory, getCanonicalFileName);
-          return (_b = (_a3 = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a3.get(path21)) == null ? void 0 : _b.get(name, mode);
+          const path22 = toPath(directoryName, currentDirectory, getCanonicalFileName);
+          return (_b = (_a3 = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a3.get(path22)) == null ? void 0 : _b.get(name, mode);
         }
       }
       function createModeAwareCacheKey(specifier, mode) {
@@ -52080,14 +52080,14 @@ ${lanes.join("\n")}
             return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName));
           }
           function set2(directory, result) {
-            const path21 = toPath(directory, currentDirectory, getCanonicalFileName);
-            if (directoryPathMap.has(path21)) {
+            const path22 = toPath(directory, currentDirectory, getCanonicalFileName);
+            if (directoryPathMap.has(path22)) {
               return;
             }
-            directoryPathMap.set(path21, result);
+            directoryPathMap.set(path22, result);
             const resolvedFileName = getResolvedFileName(result);
-            const commonPrefix = resolvedFileName && getCommonPrefix(path21, resolvedFileName);
-            let current = path21;
+            const commonPrefix = resolvedFileName && getCommonPrefix(path22, resolvedFileName);
+            let current = path22;
             while (current !== commonPrefix) {
               const parent2 = getDirectoryPath(current);
               if (parent2 === current || directoryPathMap.has(parent2)) {
@@ -52652,16 +52652,16 @@ ${lanes.join("\n")}
         const combined = combinePaths(containingDirectory, moduleName);
         const parts = getPathComponents(combined);
         const lastPart = lastOrUndefined(parts);
-        const path21 = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
-        return { path: path21, parts };
+        const path22 = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
+        return { path: path22, parts };
       }
-      function realPath(path21, host, traceEnabled) {
+      function realPath(path22, host, traceEnabled) {
         if (!host.realpath) {
-          return path21;
+          return path22;
         }
-        const real = normalizePath(host.realpath(path21));
+        const real = normalizePath(host.realpath(path22));
         if (traceEnabled) {
-          trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path21, real);
+          trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path22, real);
         }
         return real;
       }
@@ -52706,25 +52706,25 @@ ${lanes.join("\n")}
         return void 0;
       }
       var nodeModulesPathPart = "/node_modules/";
-      function pathContainsNodeModules(path21) {
-        return path21.includes(nodeModulesPathPart);
+      function pathContainsNodeModules(path22) {
+        return path22.includes(nodeModulesPathPart);
       }
       function parseNodeModuleFromPath(resolved, isFolder) {
-        const path21 = normalizePath(resolved);
-        const idx = path21.lastIndexOf(nodeModulesPathPart);
+        const path22 = normalizePath(resolved);
+        const idx = path22.lastIndexOf(nodeModulesPathPart);
         if (idx === -1) {
           return void 0;
         }
         const indexAfterNodeModules = idx + nodeModulesPathPart.length;
-        let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path21, indexAfterNodeModules, isFolder);
-        if (path21.charCodeAt(indexAfterNodeModules) === 64) {
-          indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path21, indexAfterPackageName, isFolder);
+        let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path22, indexAfterNodeModules, isFolder);
+        if (path22.charCodeAt(indexAfterNodeModules) === 64) {
+          indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path22, indexAfterPackageName, isFolder);
         }
-        return path21.slice(0, indexAfterPackageName);
+        return path22.slice(0, indexAfterPackageName);
       }
-      function moveToNextDirectorySeparatorIfAvailable(path21, prevSeparatorIndex, isFolder) {
-        const nextSeparatorIndex = path21.indexOf(directorySeparator, prevSeparatorIndex + 1);
-        return nextSeparatorIndex === -1 ? isFolder ? path21.length : prevSeparatorIndex : nextSeparatorIndex;
+      function moveToNextDirectorySeparatorIfAvailable(path22, prevSeparatorIndex, isFolder) {
+        const nextSeparatorIndex = path22.indexOf(directorySeparator, prevSeparatorIndex + 1);
+        return nextSeparatorIndex === -1 ? isFolder ? path22.length : prevSeparatorIndex : nextSeparatorIndex;
       }
       function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) {
         return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
@@ -52866,8 +52866,8 @@ ${lanes.join("\n")}
             return extensions & 4 && !isDeclarationFileName(candidate + originalExtension) && tryExtension(`.d${originalExtension}.ts`) || void 0;
         }
         function tryExtension(ext, resolvedUsingTsExtension) {
-          const path21 = tryFile(candidate + ext, onlyRecordFailures, state);
-          return path21 === void 0 ? void 0 : { path: path21, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
+          const path22 = tryFile(candidate + ext, onlyRecordFailures, state);
+          return path22 === void 0 ? void 0 : { path: path22, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
         }
       }
       function tryFile(fileName, onlyRecordFailures, state) {
@@ -53562,10 +53562,10 @@ ${lanes.join("\n")}
             /*value*/
             void 0
           );
-          function toAbsolutePath(path21) {
+          function toAbsolutePath(path22) {
             var _a22, _b2;
-            if (path21 === void 0) return path21;
-            return getNormalizedAbsolutePath(path21, (_b2 = (_a22 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a22));
+            if (path22 === void 0) return path22;
+            return getNormalizedAbsolutePath(path22, (_b2 = (_a22 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a22));
           }
           function combineDirectoryPath(root, dir) {
             return ensureTrailingDirectorySeparator(combinePaths(root, dir));
@@ -53816,16 +53816,16 @@ ${lanes.join("\n")}
             trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
           }
           const resolved = forEach(paths[matchedPatternText], (subst) => {
-            const path21 = matchedStar ? replaceFirstStar(subst, matchedStar) : subst;
-            const candidate = normalizePath(combinePaths(baseDirectory, path21));
+            const path22 = matchedStar ? replaceFirstStar(subst, matchedStar) : subst;
+            const candidate = normalizePath(combinePaths(baseDirectory, path22));
             if (state.traceEnabled) {
-              trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path21);
+              trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path22);
             }
             const extension = tryGetExtensionFromPath2(subst);
             if (extension !== void 0) {
-              const path22 = tryFile(candidate, onlyRecordFailures, state);
-              if (path22 !== void 0) {
-                return noPackageId({ path: path22, ext: extension, resolvedUsingTsExtension: void 0 });
+              const path23 = tryFile(candidate, onlyRecordFailures, state);
+              if (path23 !== void 0) {
+                return noPackageId({ path: path23, ext: extension, resolvedUsingTsExtension: void 0 });
               }
             }
             return loader(extensions, candidate, onlyRecordFailures || !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
@@ -57911,10 +57911,10 @@ ${lanes.join("\n")}
         if (a2 === void 0 || b === void 0) return false;
         return comparePaths(a2, b, ignoreCase) === 0;
       }
-      function countPathComponents(path21) {
+      function countPathComponents(path22) {
         let count = 0;
-        for (let i2 = startsWith(path21, "./") ? 2 : 0; i2 < path21.length; i2++) {
-          if (path21.charCodeAt(i2) === 47) count++;
+        for (let i2 = startsWith(path22, "./") ? 2 : 0; i2 < path22.length; i2++) {
+          if (path22.charCodeAt(i2) === 47) count++;
         }
         return count;
       }
@@ -58031,9 +58031,9 @@ ${lanes.join("\n")}
           host,
           /*preferSymlinks*/
           true,
-          (path21, isRedirect) => {
-            const isInNodeModules = pathContainsNodeModules(path21);
-            allFileNames.set(path21, { path: info.getCanonicalFileName(path21), isRedirect, isInNodeModules });
+          (path22, isRedirect) => {
+            const isInNodeModules = pathContainsNodeModules(path22);
+            allFileNames.set(path22, { path: info.getCanonicalFileName(path22), isRedirect, isInNodeModules });
             importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules;
           }
         );
@@ -58041,8 +58041,8 @@ ${lanes.join("\n")}
         for (let directory = info.canonicalSourceDirectory; allFileNames.size !== 0; ) {
           const directoryStart = ensureTrailingDirectorySeparator(directory);
           let pathsInDirectory;
-          allFileNames.forEach(({ path: path21, isRedirect, isInNodeModules }, fileName) => {
-            if (startsWith(path21, directoryStart)) {
+          allFileNames.forEach(({ path: path22, isRedirect, isInNodeModules }, fileName) => {
+            if (startsWith(path22, directoryStart)) {
               (pathsInDirectory || (pathsInDirectory = [])).push({ path: fileName, isRedirect, isInNodeModules });
               allFileNames.delete(fileName);
             }
@@ -58345,17 +58345,17 @@ ${lanes.join("\n")}
         }
         return processEnding(shortest, allowedEndings, compilerOptions);
       }
-      function tryGetModuleNameAsNodeModule({ path: path21, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
+      function tryGetModuleNameAsNodeModule({ path: path22, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
         if (!host.fileExists || !host.readFile) {
           return void 0;
         }
-        const parts = getNodeModulePathParts(path21);
+        const parts = getNodeModulePathParts(path22);
         if (!parts) {
           return void 0;
         }
         const preferences = getModuleSpecifierPreferences(userPreferences, host, options, importingSourceFile);
         const allowedEndings = preferences.getAllowedEndingsInPreferredOrder();
-        let moduleSpecifier = path21;
+        let moduleSpecifier = path22;
         let isPackageRootPath = false;
         if (!packageNameOnly) {
           let packageRootIndex = parts.packageRootIndex;
@@ -58376,7 +58376,7 @@ ${lanes.join("\n")}
               break;
             }
             if (!moduleFileName) moduleFileName = moduleFileToTry;
-            packageRootIndex = path21.indexOf(directorySeparator, packageRootIndex + 1);
+            packageRootIndex = path22.indexOf(directorySeparator, packageRootIndex + 1);
             if (packageRootIndex === -1) {
               moduleSpecifier = processEnding(moduleFileName, allowedEndings, options, host);
               break;
@@ -58396,9 +58396,9 @@ ${lanes.join("\n")}
         return getEmitModuleResolutionKind(options) === 1 && packageName === nodeModulesDirectoryName ? void 0 : packageName;
         function tryDirectoryWithPackageJson(packageRootIndex) {
           var _a3, _b;
-          const packageRootPath = path21.substring(0, packageRootIndex);
+          const packageRootPath = path22.substring(0, packageRootIndex);
           const packageJsonPath = combinePaths(packageRootPath, "package.json");
-          let moduleFileToTry = path21;
+          let moduleFileToTry = path22;
           let maybeBlockedByTypesVersions = false;
           const cachedPackageJson = (_b = (_a3 = host.getPackageJsonInfoCache) == null ? void 0 : _a3.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
           if (isPackageJsonInfo(cachedPackageJson) || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
@@ -58411,7 +58411,7 @@ ${lanes.join("\n")}
               const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(
                 options,
                 host,
-                path21,
+                path22,
                 packageRootPath,
                 packageName2,
                 packageJsonContent.exports,
@@ -58421,12 +58421,12 @@ ${lanes.join("\n")}
                 return { ...fromExports, verbatimFromExports: true };
               }
               if (packageJsonContent == null ? void 0 : packageJsonContent.exports) {
-                return { moduleFileToTry: path21, blockedByExports: true };
+                return { moduleFileToTry: path22, blockedByExports: true };
               }
             }
             const versionPaths = (packageJsonContent == null ? void 0 : packageJsonContent.typesVersions) ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) : void 0;
             if (versionPaths) {
-              const subModuleName = path21.slice(packageRootPath.length + 1);
+              const subModuleName = path22.slice(packageRootPath.length + 1);
               const fromPaths = tryGetModuleNameFromPaths(
                 subModuleName,
                 versionPaths.paths,
@@ -58461,7 +58461,7 @@ ${lanes.join("\n")}
           return { moduleFileToTry };
         }
       }
-      function tryGetAnyFileFromPath(host, path21) {
+      function tryGetAnyFileFromPath(host, path22) {
         if (!host.fileExists) return;
         const extensions = flatten(getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, {
           extension: "json",
@@ -58470,15 +58470,15 @@ ${lanes.join("\n")}
           /* JSON */
         }]));
         for (const e of extensions) {
-          const fullPath = path21 + e;
+          const fullPath = path22 + e;
           if (host.fileExists(fullPath)) {
             return fullPath;
           }
         }
       }
-      function getPathsRelativeToRootDirs(path21, rootDirs, getCanonicalFileName) {
+      function getPathsRelativeToRootDirs(path22, rootDirs, getCanonicalFileName) {
         return mapDefined(rootDirs, (rootDir) => {
-          const relativePath = getRelativePathIfInSameVolume(path21, rootDir, getCanonicalFileName);
+          const relativePath = getRelativePathIfInSameVolume(path22, rootDir, getCanonicalFileName);
           return relativePath !== void 0 && isPathRelativeToParent(relativePath) ? void 0 : relativePath;
         });
       }
@@ -58595,10 +58595,10 @@ ${lanes.join("\n")}
             return void 0;
         }
       }
-      function getRelativePathIfInSameVolume(path21, directoryPath, getCanonicalFileName) {
+      function getRelativePathIfInSameVolume(path22, directoryPath, getCanonicalFileName) {
         const relativePath = getRelativePathToDirectoryOrUrl(
           directoryPath,
-          path21,
+          path22,
           directoryPath,
           getCanonicalFileName,
           /*isAbsolutePathAnUrl*/
@@ -58606,8 +58606,8 @@ ${lanes.join("\n")}
         );
         return isRootedDiskPath(relativePath) ? void 0 : relativePath;
       }
-      function isPathRelativeToParent(path21) {
-        return startsWith(path21, "..");
+      function isPathRelativeToParent(path22) {
+        return startsWith(path22, "..");
       }
       function getDefaultResolutionModeForFile(file2, host, compilerOptions) {
         return isFullSourceFile(file2) ? host.getDefaultResolutionModeForFile(file2) : getDefaultResolutionModeForFileWorker(file2, compilerOptions);
@@ -73703,10 +73703,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 path21 = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
-            let result = unresolvedSymbols.get(path21);
+            const path22 = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
+            let result = unresolvedSymbols.get(path22);
             if (!result) {
-              unresolvedSymbols.set(path21, result = createSymbol(
+              unresolvedSymbols.set(path22, result = createSymbol(
                 524288,
                 text,
                 1048576
@@ -78514,24 +78514,24 @@ ${lanes.join("\n")}
               }
               return;
             }
-            let path21 = "";
+            let path22 = "";
             const secondaryRootErrors = [];
             while (stack.length) {
               const [msg, ...args] = stack.pop();
               switch (msg.code) {
                 case Diagnostics.Types_of_property_0_are_incompatible.code: {
-                  if (path21.indexOf("new ") === 0) {
-                    path21 = `(${path21})`;
+                  if (path22.indexOf("new ") === 0) {
+                    path22 = `(${path22})`;
                   }
                   const str = "" + args[0];
-                  if (path21.length === 0) {
-                    path21 = `${str}`;
+                  if (path22.length === 0) {
+                    path22 = `${str}`;
                   } else if (isIdentifierText(str, getEmitScriptTarget(compilerOptions))) {
-                    path21 = `${path21}.${str}`;
+                    path22 = `${path22}.${str}`;
                   } else if (str[0] === "[" && str[str.length - 1] === "]") {
-                    path21 = `${path21}${str}`;
+                    path22 = `${path22}${str}`;
                   } else {
-                    path21 = `${path21}[${str}]`;
+                    path22 = `${path22}[${str}]`;
                   }
                   break;
                 }
@@ -78539,7 +78539,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 (path21.length === 0) {
+                  if (path22.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;
@@ -78550,7 +78550,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 ? "" : "...";
-                    path21 = `${prefix}${path21}(${params})`;
+                    path22 = `${prefix}${path22}(${params})`;
                   }
                   break;
                 }
@@ -78566,10 +78566,10 @@ ${lanes.join("\n")}
                   return Debug.fail(`Unhandled Diagnostic: ${msg.code}`);
               }
             }
-            if (path21) {
+            if (path22) {
               reportError(
-                path21[path21.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
-                path21
+                path22[path22.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
+                path22
               );
             } else {
               secondaryRootErrors.shift();
@@ -134087,9 +134087,9 @@ ${lanes.join("\n")}
       function createAddOutput() {
         let outputs;
         return { addOutput, getOutputs };
-        function addOutput(path21) {
-          if (path21) {
-            (outputs || (outputs = [])).push(path21);
+        function addOutput(path22) {
+          if (path22) {
+            (outputs || (outputs = [])).push(path22);
           }
         }
         function getOutputs() {
@@ -139318,7 +139318,7 @@ ${lanes.join("\n")}
         return {
           useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
           fileExists,
-          readFile: (path21, encoding) => host.readFile(path21, encoding),
+          readFile: (path22, encoding) => host.readFile(path22, encoding),
           directoryExists: host.directoryExists && directoryExists,
           getDirectories,
           readDirectory,
@@ -139335,8 +139335,8 @@ ${lanes.join("\n")}
         function getCachedFileSystemEntries(rootDirPath) {
           return cachedReadDirectoryResult.get(ensureTrailingDirectorySeparator(rootDirPath));
         }
-        function getCachedFileSystemEntriesForBaseDir(path21) {
-          const entries = getCachedFileSystemEntries(getDirectoryPath(path21));
+        function getCachedFileSystemEntriesForBaseDir(path22) {
+          const entries = getCachedFileSystemEntries(getDirectoryPath(path22));
           if (!entries) {
             return entries;
           }
@@ -139391,8 +139391,8 @@ ${lanes.join("\n")}
           return index >= 0;
         }
         function writeFile2(fileName, data, writeByteOrderMark) {
-          const path21 = toPath3(fileName);
-          const result = getCachedFileSystemEntriesForBaseDir(path21);
+          const path22 = toPath3(fileName);
+          const result = getCachedFileSystemEntriesForBaseDir(path22);
           if (result) {
             updateFilesOfFileSystemEntry(
               result,
@@ -139404,17 +139404,17 @@ ${lanes.join("\n")}
           return host.writeFile(fileName, data, writeByteOrderMark);
         }
         function fileExists(fileName) {
-          const path21 = toPath3(fileName);
-          const result = getCachedFileSystemEntriesForBaseDir(path21);
+          const path22 = toPath3(fileName);
+          const result = getCachedFileSystemEntriesForBaseDir(path22);
           return result && hasEntry(result.sortedAndCanonicalizedFiles, getCanonicalFileName(getBaseNameOfFileName(fileName))) || host.fileExists(fileName);
         }
         function directoryExists(dirPath) {
-          const path21 = toPath3(dirPath);
-          return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path21)) || host.directoryExists(dirPath);
+          const path22 = toPath3(dirPath);
+          return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path22)) || host.directoryExists(dirPath);
         }
         function createDirectory(dirPath) {
-          const path21 = toPath3(dirPath);
-          const result = getCachedFileSystemEntriesForBaseDir(path21);
+          const path22 = toPath3(dirPath);
+          const result = getCachedFileSystemEntriesForBaseDir(path22);
           if (result) {
             const baseName = getBaseNameOfFileName(dirPath);
             const canonicalizedBaseName = getCanonicalFileName(baseName);
@@ -139442,15 +139442,15 @@ ${lanes.join("\n")}
           }
           return host.readDirectory(rootDir, extensions, excludes, includes, depth);
           function getFileSystemEntries(dir) {
-            const path21 = toPath3(dir);
-            if (path21 === rootDirPath) {
-              return rootResult || getFileSystemEntriesFromHost(dir, path21);
+            const path22 = toPath3(dir);
+            if (path22 === rootDirPath) {
+              return rootResult || getFileSystemEntriesFromHost(dir, path22);
             }
-            const result = tryReadDirectory2(dir, path21);
-            return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path21) : emptyFileSystemEntries;
+            const result = tryReadDirectory2(dir, path22);
+            return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path22) : emptyFileSystemEntries;
           }
-          function getFileSystemEntriesFromHost(dir, path21) {
-            if (rootSymLinkResult && path21 === rootDirPath) return rootSymLinkResult;
+          function getFileSystemEntriesFromHost(dir, path22) {
+            if (rootSymLinkResult && path22 === rootDirPath) return rootSymLinkResult;
             const result = {
               files: map2(host.readDirectory(
                 dir,
@@ -139463,7 +139463,7 @@ ${lanes.join("\n")}
               ), getBaseNameOfFileName) || emptyArray,
               directories: host.getDirectories(dir) || emptyArray
             };
-            if (path21 === rootDirPath) rootSymLinkResult = result;
+            if (path22 === rootDirPath) rootSymLinkResult = result;
             return result;
           }
         }
@@ -139922,15 +139922,15 @@ ${lanes.join("\n")}
           return getDirectoryPath(normalizePath(system.getExecutingFilePath()));
         }
         const newLine = getNewLineCharacter(options);
-        const realpath = system.realpath && ((path21) => system.realpath(path21));
+        const realpath = system.realpath && ((path22) => system.realpath(path22));
         const compilerHost = {
           getSourceFile: createGetSourceFile((fileName) => compilerHost.readFile(fileName), setParentNodes),
           getDefaultLibLocation,
           getDefaultLibFileName: (options2) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options2)),
           writeFile: createWriteFileMeasuringIO(
-            (path21, data, writeByteOrderMark) => system.writeFile(path21, data, writeByteOrderMark),
-            (path21) => (compilerHost.createDirectory || system.createDirectory)(path21),
-            (path21) => directoryExists(path21)
+            (path22, data, writeByteOrderMark) => system.writeFile(path22, data, writeByteOrderMark),
+            (path22) => (compilerHost.createDirectory || system.createDirectory)(path22),
+            (path22) => directoryExists(path22)
           ),
           getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
           useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
@@ -139941,9 +139941,9 @@ ${lanes.join("\n")}
           trace: (s) => system.write(s + newLine),
           directoryExists: (directoryName) => system.directoryExists(directoryName),
           getEnvironmentVariable: (name) => system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : "",
-          getDirectories: (path21) => system.getDirectories(path21),
+          getDirectories: (path22) => system.getDirectories(path22),
           realpath,
-          readDirectory: (path21, extensions, include, exclude, depth) => system.readDirectory(path21, extensions, include, exclude, depth),
+          readDirectory: (path22, extensions, include, exclude, depth) => system.readDirectory(path22, extensions, include, exclude, depth),
           createDirectory: (d) => system.createDirectory(d),
           createHash: maybeBind(system, system.createHash)
         };
@@ -140382,13 +140382,13 @@ ${lanes.join("\n")}
       }
       function getLibraryNameFromLibFileName(libFileName) {
         const components = libFileName.split(".");
-        let path21 = components[1];
+        let path22 = components[1];
         let i2 = 2;
         while (components[i2] && components[i2] !== "d") {
-          path21 += (i2 === 2 ? "/" : "-") + components[i2];
+          path22 += (i2 === 2 ? "/" : "-") + components[i2];
           i2++;
         }
-        return "@typescript/lib-" + path21;
+        return "@typescript/lib-" + path22;
       }
       function isReferencedFile(reason) {
         switch (reason == null ? void 0 : reason.kind) {
@@ -141460,18 +141460,18 @@ ${lanes.join("\n")}
             }
           }
           const oldFilesByNameMap = oldProgram.getFilesByNameMap();
-          oldFilesByNameMap.forEach((oldFile, path21) => {
+          oldFilesByNameMap.forEach((oldFile, path22) => {
             if (!oldFile) {
-              filesByName.set(path21, oldFile);
+              filesByName.set(path22, oldFile);
               return;
             }
-            if (oldFile.path === path21) {
+            if (oldFile.path === path22) {
               if (oldProgram.isSourceFileFromExternalLibrary(oldFile)) {
                 sourceFilesFoundSearchingNodeModules.set(oldFile.path, true);
               }
               return;
             }
-            filesByName.set(path21, filesByName.get(oldFile.path));
+            filesByName.set(path22, 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);
@@ -141509,9 +141509,9 @@ ${lanes.join("\n")}
             getModeForResolutionAtIndex: getModeForResolutionAtIndex2,
             readFile: (f) => host.readFile(f),
             fileExists: (f) => {
-              const path21 = toPath3(f);
-              if (getSourceFileByPath(path21)) return true;
-              if (missingFileNames.has(path21)) return false;
+              const path22 = toPath3(f);
+              if (getSourceFileByPath(path22)) return true;
+              if (missingFileNames.has(path22)) return false;
               return host.fileExists(f);
             },
             realpath: maybeBind(host, host.realpath),
@@ -141634,8 +141634,8 @@ ${lanes.join("\n")}
         function getSourceFile(fileName) {
           return getSourceFileByPath(toPath3(fileName));
         }
-        function getSourceFileByPath(path21) {
-          return filesByName.get(path21) || void 0;
+        function getSourceFileByPath(path22) {
+          return filesByName.get(path22) || void 0;
         }
         function getDiagnosticsHelper(sourceFile, getDiagnostics2, cancellationToken) {
           if (sourceFile) {
@@ -142275,16 +142275,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, path21, resolvedPath, originalFileName, sourceFileOptions) {
+        function createRedirectedSourceFile(redirectTarget, unredirected, fileName, path22, resolvedPath, originalFileName, sourceFileOptions) {
           var _a22;
           const redirect = parseNodeFactory.createRedirectedSourceFile({ redirectTarget, unredirected });
           redirect.fileName = fileName;
-          redirect.path = path21;
+          redirect.path = path22;
           redirect.resolvedPath = resolvedPath;
           redirect.originalFileName = originalFileName;
           redirect.packageJsonLocations = ((_a22 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _a22.length) ? sourceFileOptions.packageJsonLocations : void 0;
           redirect.packageJsonScope = sourceFileOptions.packageJsonScope;
-          sourceFilesFoundSearchingNodeModules.set(path21, currentNodeModulesDepth > 0);
+          sourceFilesFoundSearchingNodeModules.set(path22, currentNodeModulesDepth > 0);
           return redirect;
         }
         function findSourceFile(fileName, isDefaultLib, reason, packageId) {
@@ -142306,18 +142306,18 @@ ${lanes.join("\n")}
         }
         function findSourceFileWorker(fileName, isDefaultLib, reason, packageId) {
           var _a22, _b2;
-          const path21 = toPath3(fileName);
+          const path22 = toPath3(fileName);
           if (useSourceOfProjectReferenceRedirect) {
-            let source = getRedirectFromOutput(path21);
+            let source = getRedirectFromOutput(path22);
             if (!source && host.realpath && options.preserveSymlinks && isDeclarationFileName(fileName) && fileName.includes(nodeModulesPathPart)) {
               const realPath2 = toPath3(host.realpath(fileName));
-              if (realPath2 !== path21) source = getRedirectFromOutput(realPath2);
+              if (realPath2 !== path22) source = getRedirectFromOutput(realPath2);
             }
             if (source == null ? void 0 : source.source) {
               const file22 = findSourceFile(source.source, isDefaultLib, reason, packageId);
               if (file22) addFileToFilesByName(
                 file22,
-                path21,
+                path22,
                 fileName,
                 /*redirectedPath*/
                 void 0
@@ -142326,8 +142326,8 @@ ${lanes.join("\n")}
             }
           }
           const originalFileName = fileName;
-          if (filesByName.has(path21)) {
-            const file22 = filesByName.get(path21);
+          if (filesByName.has(path22)) {
+            const file22 = filesByName.get(path22);
             const addedReason = addFileIncludeReason(
               file22 || void 0,
               reason,
@@ -142393,28 +142393,28 @@ ${lanes.join("\n")}
             const packageIdKey = packageIdToString(packageId);
             const fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
             if (fileFromPackageId) {
-              const dupFile = createRedirectedSourceFile(fileFromPackageId, file2, fileName, path21, toPath3(fileName), originalFileName, sourceFileOptions);
+              const dupFile = createRedirectedSourceFile(fileFromPackageId, file2, fileName, path22, toPath3(fileName), originalFileName, sourceFileOptions);
               redirectTargetsMap.add(fileFromPackageId.path, fileName);
-              addFileToFilesByName(dupFile, path21, fileName, redirectedPath);
+              addFileToFilesByName(dupFile, path22, fileName, redirectedPath);
               addFileIncludeReason(
                 dupFile,
                 reason,
                 /*checkExisting*/
                 false
               );
-              sourceFileToPackageName.set(path21, packageIdToPackageName(packageId));
+              sourceFileToPackageName.set(path22, packageIdToPackageName(packageId));
               processingOtherFiles.push(dupFile);
               return dupFile;
             } else if (file2) {
               packageIdToSourceFile.set(packageIdKey, file2);
-              sourceFileToPackageName.set(path21, packageIdToPackageName(packageId));
+              sourceFileToPackageName.set(path22, packageIdToPackageName(packageId));
             }
           }
-          addFileToFilesByName(file2, path21, fileName, redirectedPath);
+          addFileToFilesByName(file2, path22, fileName, redirectedPath);
           if (file2) {
-            sourceFilesFoundSearchingNodeModules.set(path21, currentNodeModulesDepth > 0);
+            sourceFilesFoundSearchingNodeModules.set(path22, currentNodeModulesDepth > 0);
             file2.fileName = fileName;
-            file2.path = path21;
+            file2.path = path22;
             file2.resolvedPath = toPath3(fileName);
             file2.originalFileName = originalFileName;
             file2.packageJsonLocations = ((_b2 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _b2.length) ? sourceFileOptions.packageJsonLocations : void 0;
@@ -142426,7 +142426,7 @@ ${lanes.join("\n")}
               false
             );
             if (host.useCaseSensitiveFileNames()) {
-              const pathLowerCase = toFileNameLowerCase(path21);
+              const pathLowerCase = toFileNameLowerCase(path22);
               const existingFile = filesByNameIgnoreCase.get(pathLowerCase);
               if (existingFile) {
                 reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason);
@@ -142458,18 +142458,18 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function addFileToFilesByName(file2, path21, fileName, redirectedPath) {
+        function addFileToFilesByName(file2, path22, fileName, redirectedPath) {
           if (redirectedPath) {
             updateFilesByNameMap(fileName, redirectedPath, file2);
-            updateFilesByNameMap(fileName, path21, file2 || false);
+            updateFilesByNameMap(fileName, path22, file2 || false);
           } else {
-            updateFilesByNameMap(fileName, path21, file2);
+            updateFilesByNameMap(fileName, path22, file2);
           }
         }
-        function updateFilesByNameMap(fileName, path21, file2) {
-          filesByName.set(path21, file2);
-          if (file2 !== void 0) missingFileNames.delete(path21);
-          else missingFileNames.set(path21, fileName);
+        function updateFilesByNameMap(fileName, path22, file2) {
+          filesByName.set(path22, file2);
+          if (file2 !== void 0) missingFileNames.delete(path22);
+          else missingFileNames.set(path22, fileName);
         }
         function getRedirectFromSourceFile(fileName) {
           return mapSourceFileToResolvedRef == null ? void 0 : mapSourceFileToResolvedRef.get(toPath3(fileName));
@@ -142477,8 +142477,8 @@ ${lanes.join("\n")}
         function forEachResolvedProjectReference2(cb) {
           return forEachResolvedProjectReference(resolvedProjectReferences, cb);
         }
-        function getRedirectFromOutput(path21) {
-          return mapOutputFileToResolvedRef == null ? void 0 : mapOutputFileToResolvedRef.get(path21);
+        function getRedirectFromOutput(path22) {
+          return mapOutputFileToResolvedRef == null ? void 0 : mapOutputFileToResolvedRef.get(path22);
         }
         function isSourceOfProjectReferenceRedirect(fileName) {
           return useSourceOfProjectReferenceRedirect && !!getRedirectFromSourceFile(fileName);
@@ -142770,7 +142770,7 @@ ${lanes.join("\n")}
             }
             const getCommonSourceDirectory3 = memoize(() => getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()));
             commandLine.fileNames.forEach((fileName) => {
-              const path21 = toPath3(fileName);
+              const path22 = toPath3(fileName);
               let outputDts;
               if (!isDeclarationFileName(fileName) && !fileExtensionIs(
                 fileName,
@@ -142784,7 +142784,7 @@ ${lanes.join("\n")}
                   outputDts = outDts;
                 }
               }
-              mapSourceFileToResolvedRef.set(path21, { resolvedRef, outputDts });
+              mapSourceFileToResolvedRef.set(path22, { resolvedRef, outputDts });
             });
           }
           if (commandLine.projectReferences) {
@@ -143583,9 +143583,9 @@ ${lanes.join("\n")}
         host.compilerHost.fileExists = fileExists;
         let directoryExists;
         if (originalDirectoryExists) {
-          directoryExists = host.compilerHost.directoryExists = (path21) => {
-            if (originalDirectoryExists.call(host.compilerHost, path21)) {
-              handleDirectoryCouldBeSymlink(path21);
+          directoryExists = host.compilerHost.directoryExists = (path22) => {
+            if (originalDirectoryExists.call(host.compilerHost, path22)) {
+              handleDirectoryCouldBeSymlink(path22);
               return true;
             }
             if (!host.getResolvedProjectReferences()) return false;
@@ -143604,14 +143604,14 @@ ${lanes.join("\n")}
               });
             }
             return fileOrDirectoryExistsUsingSource(
-              path21,
+              path22,
               /*isFile*/
               false
             );
           };
         }
         if (originalGetDirectories) {
-          host.compilerHost.getDirectories = (path21) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path21) ? originalGetDirectories.call(host.compilerHost, path21) : [];
+          host.compilerHost.getDirectories = (path22) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path22) ? originalGetDirectories.call(host.compilerHost, path22) : [];
         }
         if (originalRealpath) {
           host.compilerHost.realpath = (s) => {
@@ -144277,12 +144277,12 @@ ${lanes.join("\n")}
           state.allFileNames = void 0;
         }
         BuilderState2.releaseCache = releaseCache2;
-        function getFilesAffectedBy(state, programOfThisState, path21, cancellationToken, host) {
+        function getFilesAffectedBy(state, programOfThisState, path22, cancellationToken, host) {
           var _a3;
           const result = getFilesAffectedByWithOldState(
             state,
             programOfThisState,
-            path21,
+            path22,
             cancellationToken,
             host
           );
@@ -144290,8 +144290,8 @@ ${lanes.join("\n")}
           return result;
         }
         BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
-        function getFilesAffectedByWithOldState(state, programOfThisState, path21, cancellationToken, host) {
-          const sourceFile = programOfThisState.getSourceFileByPath(path21);
+        function getFilesAffectedByWithOldState(state, programOfThisState, path22, cancellationToken, host) {
+          const sourceFile = programOfThisState.getSourceFileByPath(path22);
           if (!sourceFile) {
             return emptyArray;
           }
@@ -144301,9 +144301,9 @@ ${lanes.join("\n")}
           return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
         }
         BuilderState2.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
-        function updateSignatureOfFile(state, signature, path21) {
-          state.fileInfos.get(path21).signature = signature;
-          (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path21);
+        function updateSignatureOfFile(state, signature, path22) {
+          state.fileInfos.get(path22).signature = signature;
+          (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path22);
         }
         BuilderState2.updateSignatureOfFile = updateSignatureOfFile;
         function computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, onNewSignature) {
@@ -144372,10 +144372,10 @@ ${lanes.join("\n")}
           const seenMap = /* @__PURE__ */ new Set();
           const queue = [sourceFile.resolvedPath];
           while (queue.length) {
-            const path21 = queue.pop();
-            if (!seenMap.has(path21)) {
-              seenMap.add(path21);
-              const references = state.referencedMap.getValues(path21);
+            const path22 = queue.pop();
+            if (!seenMap.has(path22)) {
+              seenMap.add(path22);
+              const references = state.referencedMap.getValues(path22);
               if (references) {
                 for (const key of references.keys()) {
                   queue.push(key);
@@ -144383,9 +144383,9 @@ ${lanes.join("\n")}
               }
             }
           }
-          return arrayFrom(mapDefinedIterator(seenMap.keys(), (path21) => {
+          return arrayFrom(mapDefinedIterator(seenMap.keys(), (path22) => {
             var _a3;
-            return ((_a3 = programOfThisState.getSourceFileByPath(path21)) == null ? void 0 : _a3.fileName) ?? path21;
+            return ((_a3 = programOfThisState.getSourceFileByPath(path22)) == null ? void 0 : _a3.fileName) ?? path22;
           }));
         }
         BuilderState2.getAllDependencies = getAllDependencies;
@@ -144564,7 +144564,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, (path21) => !state.fileInfos.has(path21) && oldState.fileInfos.has(path21))) {
+          newReferences && forEachKey(newReferences, (path22) => !state.fileInfos.has(path22) && oldState.fileInfos.has(path22))) {
             addFileToChangeSet(sourceFilePath);
           } else {
             const sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
@@ -144630,8 +144630,8 @@ ${lanes.join("\n")}
         }
         if (useOldState && state.semanticDiagnosticsPerFile.size !== state.fileInfos.size && oldState.checkPending !== state.checkPending) state.buildInfoEmitPending = true;
         return state;
-        function addFileToChangeSet(path21) {
-          state.changedFilesSet.add(path21);
+        function addFileToChangeSet(path22) {
+          state.changedFilesSet.add(path22);
           if (outFilePath) {
             canCopySemanticDiagnostics = false;
             canCopyEmitDiagnostics = false;
@@ -144695,9 +144695,9 @@ ${lanes.join("\n")}
           result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r2) => convertToDiagnosticRelatedInformation(r2, diagnosticFilePath, newProgram, toPathInBuildInfoDirectory)) : [] : void 0;
           return result;
         });
-        function toPathInBuildInfoDirectory(path21) {
+        function toPathInBuildInfoDirectory(path22) {
           buildInfoDirectory ?? (buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory())));
-          return toPath(path21, buildInfoDirectory, newProgram.getCanonicalFileName);
+          return toPath(path22, buildInfoDirectory, newProgram.getCanonicalFileName);
         }
       }
       function convertToDiagnosticRelatedInformation(diagnostic, diagnosticFilePath, newProgram, toPath3) {
@@ -144772,10 +144772,10 @@ ${lanes.join("\n")}
           state.affectedFilesPendingEmit = void 0;
           state.programEmitPending = void 0;
         }
-        (_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.forEach((emitKind, path21) => {
+        (_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.forEach((emitKind, path22) => {
           const pending = !isForDtsErrors ? emitKind & 7 : emitKind & (7 | 48);
-          if (!pending) state.affectedFilesPendingEmit.delete(path21);
-          else state.affectedFilesPendingEmit.set(path21, pending);
+          if (!pending) state.affectedFilesPendingEmit.delete(path22);
+          else state.affectedFilesPendingEmit.set(path22, pending);
         });
         if (state.programEmitPending) {
           const pending = !isForDtsErrors ? state.programEmitPending & 7 : state.programEmitPending & (7 | 48);
@@ -144795,11 +144795,11 @@ ${lanes.join("\n")}
       function getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles, isForDtsErrors) {
         var _a3;
         if (!((_a3 = state.affectedFilesPendingEmit) == null ? void 0 : _a3.size)) return void 0;
-        return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path21) => {
+        return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path22) => {
           var _a22;
-          const affectedFile = state.program.getSourceFileByPath(path21);
+          const affectedFile = state.program.getSourceFileByPath(path22);
           if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
-            state.affectedFilesPendingEmit.delete(path21);
+            state.affectedFilesPendingEmit.delete(path22);
             return void 0;
           }
           const seenKind = (_a22 = state.seenEmittedFiles) == null ? void 0 : _a22.get(affectedFile.resolvedPath);
@@ -144815,11 +144815,11 @@ ${lanes.join("\n")}
       function getNextPendingEmitDiagnosticsFile(state, isForDtsErrors) {
         var _a3;
         if (!((_a3 = state.emitDiagnosticsPerFile) == null ? void 0 : _a3.size)) return void 0;
-        return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path21) => {
+        return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path22) => {
           var _a22;
-          const affectedFile = state.program.getSourceFileByPath(path21);
+          const affectedFile = state.program.getSourceFileByPath(path22);
           if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
-            state.emitDiagnosticsPerFile.delete(path21);
+            state.emitDiagnosticsPerFile.delete(path22);
             return void 0;
           }
           const seenKind = ((_a22 = state.seenEmittedFiles) == null ? void 0 : _a22.get(affectedFile.resolvedPath)) || 0;
@@ -144854,10 +144854,10 @@ ${lanes.join("\n")}
           host
         );
       }
-      function handleDtsMayChangeOf(state, path21, invalidateJsFiles, cancellationToken, host) {
-        removeSemanticDiagnosticsOf(state, path21);
-        if (!state.changedFilesSet.has(path21)) {
-          const sourceFile = state.program.getSourceFileByPath(path21);
+      function handleDtsMayChangeOf(state, path22, invalidateJsFiles, cancellationToken, host) {
+        removeSemanticDiagnosticsOf(state, path22);
+        if (!state.changedFilesSet.has(path22)) {
+          const sourceFile = state.program.getSourceFileByPath(path22);
           if (sourceFile) {
             BuilderState.updateShapeSignature(
               state,
@@ -144871,13 +144871,13 @@ ${lanes.join("\n")}
             if (invalidateJsFiles) {
               addToAffectedFilesPendingEmit(
                 state,
-                path21,
+                path22,
                 getBuilderFileEmit(state.compilerOptions)
               );
             } else if (getEmitDeclarations(state.compilerOptions)) {
               addToAffectedFilesPendingEmit(
                 state,
-                path21,
+                path22,
                 state.compilerOptions.declarationMap ? 56 : 24
                 /* Dts */
               );
@@ -144885,17 +144885,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function removeSemanticDiagnosticsOf(state, path21) {
+      function removeSemanticDiagnosticsOf(state, path22) {
         if (!state.semanticDiagnosticsFromOldState) {
           return true;
         }
-        state.semanticDiagnosticsFromOldState.delete(path21);
-        state.semanticDiagnosticsPerFile.delete(path21);
+        state.semanticDiagnosticsFromOldState.delete(path22);
+        state.semanticDiagnosticsPerFile.delete(path22);
         return !state.semanticDiagnosticsFromOldState.size;
       }
-      function isChangedSignature(state, path21) {
-        const oldSignature = Debug.checkDefined(state.oldSignatures).get(path21) || void 0;
-        const newSignature = Debug.checkDefined(state.fileInfos.get(path21)).signature;
+      function isChangedSignature(state, path22) {
+        const oldSignature = Debug.checkDefined(state.oldSignatures).get(path22) || void 0;
+        const newSignature = Debug.checkDefined(state.fileInfos.get(path22)).signature;
         return newSignature !== oldSignature;
       }
       function handleDtsMayChangeOfGlobalScope(state, filePath, invalidateJsFiles, cancellationToken, host) {
@@ -145002,13 +145002,13 @@ ${lanes.join("\n")}
       }
       function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken, semanticDiagnosticsPerFile) {
         semanticDiagnosticsPerFile ?? (semanticDiagnosticsPerFile = state.semanticDiagnosticsPerFile);
-        const path21 = sourceFile.resolvedPath;
-        const cachedDiagnostics = semanticDiagnosticsPerFile.get(path21);
+        const path22 = sourceFile.resolvedPath;
+        const cachedDiagnostics = semanticDiagnosticsPerFile.get(path22);
         if (cachedDiagnostics) {
           return filterSemanticDiagnostics(cachedDiagnostics, state.compilerOptions);
         }
         const diagnostics = state.program.getBindAndCheckDiagnostics(sourceFile, cancellationToken);
-        semanticDiagnosticsPerFile.set(path21, diagnostics);
+        semanticDiagnosticsPerFile.set(path22, diagnostics);
         state.buildInfoEmitPending = true;
         return filterSemanticDiagnostics(diagnostics, state.compilerOptions);
       }
@@ -145156,11 +145156,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 path21 of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
-            if (tryAddToSet(seenFiles, path21)) {
-              const file2 = state.program.getSourceFileByPath(path21);
+          for (const path22 of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
+            if (tryAddToSet(seenFiles, path22)) {
+              const file2 = state.program.getSourceFileByPath(path22);
               if (!file2 || !sourceFileMayBeEmitted(file2, state.program)) continue;
-              const fileId = toFileId(path21), pendingEmit = state.affectedFilesPendingEmit.get(path21);
+              const fileId = toFileId(path22), pendingEmit = state.affectedFilesPendingEmit.get(path22);
               affectedFilesPendingEmit = append(
                 affectedFilesPendingEmit,
                 pendingEmit === fullEmitForOptions ? fileId : (
@@ -145194,17 +145194,17 @@ ${lanes.join("\n")}
           version: version2
         };
         return buildInfo;
-        function relativeToBuildInfoEnsuringAbsolutePath(path21) {
-          return relativeToBuildInfo(getNormalizedAbsolutePath(path21, currentDirectory));
+        function relativeToBuildInfoEnsuringAbsolutePath(path22) {
+          return relativeToBuildInfo(getNormalizedAbsolutePath(path22, currentDirectory));
         }
-        function relativeToBuildInfo(path21) {
-          return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path21, state.program.getCanonicalFileName));
+        function relativeToBuildInfo(path22) {
+          return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path22, state.program.getCanonicalFileName));
         }
-        function toFileId(path21) {
-          let fileId = fileNameToFileId.get(path21);
+        function toFileId(path22) {
+          let fileId = fileNameToFileId.get(path22);
           if (fileId === void 0) {
-            fileNames.push(relativeToBuildInfo(path21));
-            fileNameToFileId.set(path21, fileId = fileNames.length);
+            fileNames.push(relativeToBuildInfo(path22));
+            fileNameToFileId.set(path22, fileId = fileNames.length);
           }
           return fileId;
         }
@@ -145218,8 +145218,8 @@ ${lanes.join("\n")}
           }
           return fileIdListId;
         }
-        function tryAddRoot(path21, fileId) {
-          const file2 = state.program.getSourceFile(path21);
+        function tryAddRoot(path22, fileId) {
+          const file2 = state.program.getSourceFile(path22);
           if (!state.program.getFileIncludeReasons().get(file2.path).some(
             (r2) => r2.kind === 0
             /* RootFile */
@@ -145236,10 +145236,10 @@ ${lanes.join("\n")}
         }
         function toResolvedRoot() {
           let result;
-          rootFileNames.forEach((path21) => {
-            const file2 = state.program.getSourceFileByPath(path21);
-            if (file2 && path21 !== file2.resolvedPath) {
-              result = append(result, [toFileId(file2.resolvedPath), toFileId(path21)]);
+          rootFileNames.forEach((path22) => {
+            const file2 = state.program.getSourceFileByPath(path22);
+            if (file2 && path22 !== file2.resolvedPath) {
+              result = append(result, [toFileId(file2.resolvedPath), toFileId(path22)]);
             }
           });
           return result;
@@ -145347,8 +145347,8 @@ ${lanes.join("\n")}
         function toChangeFileSet() {
           let changeFileSet;
           if (state.changedFilesSet.size) {
-            for (const path21 of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
-              changeFileSet = append(changeFileSet, toFileId(path21));
+            for (const path22 of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
+              changeFileSet = append(changeFileSet, toFileId(path22));
             }
           }
           return changeFileSet;
@@ -145847,8 +145847,8 @@ ${lanes.join("\n")}
         const changedFilesSet = new Set(map2(buildInfo.changeFileSet, toFilePath));
         if (isIncrementalBundleEmitBuildInfo(buildInfo)) {
           buildInfo.fileInfos.forEach((fileInfo, index) => {
-            const path21 = toFilePath(index + 1);
-            fileInfos.set(path21, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
+            const path22 = toFilePath(index + 1);
+            fileInfos.set(path22, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
           });
           state = {
             fileInfos,
@@ -145867,10 +145867,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 path21 = toFilePath(index + 1);
+            const path22 = toFilePath(index + 1);
             const stateFileInfo = toBuilderStateFileInfoForMultiEmit(fileInfo);
-            fileInfos.set(path21, stateFileInfo);
-            if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path21, stateFileInfo.signature);
+            fileInfos.set(path22, stateFileInfo);
+            if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path22, stateFileInfo.signature);
           });
           (_d = buildInfo.emitSignatures) == null ? void 0 : _d.forEach((value) => {
             if (isNumber(value)) emitSignatures.delete(toFilePath(value));
@@ -145924,11 +145924,11 @@ ${lanes.join("\n")}
           close: noop,
           hasChangedEmitSignature: returnFalse
         };
-        function toPathInBuildInfoDirectory(path21) {
-          return toPath(path21, buildInfoDirectory, getCanonicalFileName);
+        function toPathInBuildInfoDirectory(path22) {
+          return toPath(path22, buildInfoDirectory, getCanonicalFileName);
         }
-        function toAbsolutePath(path21) {
-          return getNormalizedAbsolutePath(path21, buildInfoDirectory);
+        function toAbsolutePath(path22) {
+          return getNormalizedAbsolutePath(path22, buildInfoDirectory);
         }
         function toFilePath(fileId) {
           return filePaths[fileId - 1];
@@ -145967,30 +145967,30 @@ ${lanes.join("\n")}
         const roots = /* @__PURE__ */ new Map();
         const resolvedRoots = new Map(program2.resolvedRoot);
         program2.fileInfos.forEach((fileInfo, index) => {
-          const path21 = toPath(program2.fileNames[index], buildInfoDirectory, getCanonicalFileName);
+          const path22 = toPath(program2.fileNames[index], buildInfoDirectory, getCanonicalFileName);
           const version22 = isString(fileInfo) ? fileInfo : fileInfo.version;
-          fileInfos.set(path21, version22);
+          fileInfos.set(path22, 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, path21);
+                addRoot(fileId, path22);
                 if (current[1] === fileId) rootIndex++;
               }
             } else if (current === fileId) {
-              addRoot(fileId, path21);
+              addRoot(fileId, path22);
               rootIndex++;
             }
           }
         });
         return { fileInfos, roots };
-        function addRoot(fileId, path21) {
+        function addRoot(fileId, path22) {
           const root = resolvedRoots.get(fileId);
           if (root) {
-            roots.set(toPath(program2.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path21);
+            roots.set(toPath(program2.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path22);
           } else {
-            roots.set(path21, void 0);
+            roots.set(path22, void 0);
           }
         }
       }
@@ -146065,11 +146065,11 @@ ${lanes.join("\n")}
           newConfigFileParsingDiagnostics
         );
       }
-      function removeIgnoredPath(path21) {
-        if (endsWith(path21, "/node_modules/.staging")) {
-          return removeSuffix(path21, "/.staging");
+      function removeIgnoredPath(path22) {
+        if (endsWith(path22, "/node_modules/.staging")) {
+          return removeSuffix(path22, "/.staging");
         }
-        return some(ignoredPaths, (searchPath) => path21.includes(searchPath)) ? void 0 : path21;
+        return some(ignoredPaths, (searchPath) => path22.includes(searchPath)) ? void 0 : path22;
       }
       function perceivedOsRootLengthForWatching(pathComponents2, length2) {
         if (length2 <= 1) return 1;
@@ -146095,8 +146095,8 @@ ${lanes.join("\n")}
         const perceivedOsRootLength = perceivedOsRootLengthForWatching(pathComponents2, length2);
         return length2 > perceivedOsRootLength + 1;
       }
-      function canWatchDirectoryOrFilePath(path21) {
-        return canWatchDirectoryOrFile(getPathComponents(path21));
+      function canWatchDirectoryOrFilePath(path22) {
+        return canWatchDirectoryOrFile(getPathComponents(path22));
       }
       function canWatchAtTypes(atTypes) {
         return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(getDirectoryPath(atTypes));
@@ -146390,11 +146390,11 @@ ${lanes.join("\n")}
           filesWithChangedSetOfUnresolvedImports = void 0;
           return collected;
         }
-        function isFileWithInvalidatedNonRelativeUnresolvedImports(path21) {
+        function isFileWithInvalidatedNonRelativeUnresolvedImports(path22) {
           if (!filesWithInvalidatedNonRelativeUnresolvedImports) {
             return false;
           }
-          const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path21);
+          const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path22);
           return !!value && !!value.length;
         }
         function createHasInvalidatedResolutions(customHasInvalidatedResolutions, customHasInvalidatedLibResolutions) {
@@ -146402,7 +146402,7 @@ ${lanes.join("\n")}
           const collected = filesWithInvalidatedResolutions;
           filesWithInvalidatedResolutions = void 0;
           return {
-            hasInvalidatedResolutions: (path21) => customHasInvalidatedResolutions(path21) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path21)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path21),
+            hasInvalidatedResolutions: (path22) => customHasInvalidatedResolutions(path22) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path22)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path22),
             hasInvalidatedLibResolutions: (libFileName) => {
               var _a3;
               return customHasInvalidatedLibResolutions(libFileName) || !!((_a3 = resolvedLibraries == null ? void 0 : resolvedLibraries.get(libFileName)) == null ? void 0 : _a3.isInvalidated);
@@ -146458,11 +146458,11 @@ ${lanes.join("\n")}
               if (expected) impliedFormatPackageJsons.set(newFile.resolvedPath, newFile.packageJsonLocations);
               else impliedFormatPackageJsons.delete(newFile.resolvedPath);
             });
-            impliedFormatPackageJsons.forEach((existing, path21) => {
-              const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path21);
-              if (!newFile || newFile.resolvedPath !== path21) {
+            impliedFormatPackageJsons.forEach((existing, path22) => {
+              const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path22);
+              if (!newFile || newFile.resolvedPath !== path22) {
                 existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
-                impliedFormatPackageJsons.delete(path21);
+                impliedFormatPackageJsons.delete(path22);
               }
             });
           }
@@ -146481,16 +146481,16 @@ ${lanes.join("\n")}
             packageDirWatchers.delete(packageDirPath);
           }
         }
-        function closeDirectoryWatchesOfFailedLookup(watcher, path21) {
+        function closeDirectoryWatchesOfFailedLookup(watcher, path22) {
           if (watcher.refCount === 0) {
-            directoryWatchesOfFailedLookups.delete(path21);
+            directoryWatchesOfFailedLookups.delete(path22);
             watcher.watcher.close();
           }
         }
-        function closeFileWatcherOfAffectingLocation(watcher, path21) {
+        function closeFileWatcherOfAffectingLocation(watcher, path22) {
           var _a3;
           if (watcher.files === 0 && watcher.resolutions === 0 && !((_a3 = watcher.symlinks) == null ? void 0 : _a3.size)) {
-            fileWatchesOfAffectingLocations.delete(path21);
+            fileWatchesOfAffectingLocations.delete(path22);
             watcher.watcher.close();
           }
         }
@@ -146509,10 +146509,10 @@ ${lanes.join("\n")}
           logChanges
         }) {
           var _a3, _b;
-          const path21 = resolutionHost.toPath(containingFile);
-          const resolutionsInFile = perFileCache.get(path21) || perFileCache.set(path21, createModeAwareCache()).get(path21);
+          const path22 = resolutionHost.toPath(containingFile);
+          const resolutionsInFile = perFileCache.get(path22) || perFileCache.set(path22, createModeAwareCache()).get(path22);
           const resolvedModules = [];
-          const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path21);
+          const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path22);
           const program2 = resolutionHost.getCurrentProgram();
           const oldRedirect = program2 && ((_a3 = program2.getRedirectFromSourceFile(containingFile)) == null ? void 0 : _a3.resolvedRef);
           const unmatchedRedirects = oldRedirect ? !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : !!redirectedReference;
@@ -146529,14 +146529,14 @@ ${lanes.join("\n")}
                 resolutionHost.onDiscoveredSymlink();
               }
               resolutionsInFile.set(name, mode, resolution);
-              if (resolution !== existingResolution && !((_b = resolutionHost.skipWatchingFailedLookups) == null ? void 0 : _b.call(resolutionHost, path21))) {
-                watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path21, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
+              if (resolution !== existingResolution && !((_b = resolutionHost.skipWatchingFailedLookups) == null ? void 0 : _b.call(resolutionHost, path22))) {
+                watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path22, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
                 if (existingResolution) {
-                  stopWatchFailedLookupLocationOfResolution(existingResolution, path21, getResolutionWithResolvedFileName);
+                  stopWatchFailedLookupLocationOfResolution(existingResolution, path22, getResolutionWithResolvedFileName);
                 }
               }
               if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
-                filesWithChangedSetOfUnresolvedImports.push(path21);
+                filesWithChangedSetOfUnresolvedImports.push(path22);
                 logChanges = false;
               }
             } else {
@@ -146568,8 +146568,8 @@ ${lanes.join("\n")}
             resolutionsInFile.forEach((resolution, name, mode) => {
               var _a22;
               if (!seenNamesInFile.has(name, mode)) {
-                if (!((_a22 = resolutionHost.skipWatchingFailedLookups) == null ? void 0 : _a22.call(resolutionHost, path21))) {
-                  stopWatchFailedLookupLocationOfResolution(resolution, path21, getResolutionWithResolvedFileName);
+                if (!((_a22 = resolutionHost.skipWatchingFailedLookups) == null ? void 0 : _a22.call(resolutionHost, path22))) {
+                  stopWatchFailedLookupLocationOfResolution(resolution, path22, getResolutionWithResolvedFileName);
                 }
                 resolutionsInFile.delete(name, mode);
               }
@@ -146644,18 +146644,18 @@ ${lanes.join("\n")}
           if (!resolution || resolution.isInvalidated) {
             const existingResolution = resolution;
             resolution = resolveLibrary(libraryName, resolveFrom, options, host, libraryResolutionCache);
-            const path21 = resolutionHost.toPath(resolveFrom);
+            const path22 = resolutionHost.toPath(resolveFrom);
             watchFailedLookupLocationsOfExternalModuleResolutions(
               libraryName,
               resolution,
-              path21,
+              path22,
               getResolvedModuleFromResolution,
               /*deferWatchingNonRelativeResolution*/
               false
             );
             resolvedLibraries.set(libFileName, resolution);
             if (existingResolution) {
-              stopWatchFailedLookupLocationOfResolution(existingResolution, path21, getResolvedModuleFromResolution);
+              stopWatchFailedLookupLocationOfResolution(existingResolution, path22, getResolvedModuleFromResolution);
             }
           } else {
             if (isTraceEnabled(options, host)) {
@@ -146674,8 +146674,8 @@ ${lanes.join("\n")}
         }
         function resolveSingleModuleNameWithoutWatching(moduleName, containingFile) {
           var _a3, _b;
-          const path21 = resolutionHost.toPath(containingFile);
-          const resolutionsInFile = resolvedModuleNames.get(path21);
+          const path22 = resolutionHost.toPath(containingFile);
+          const resolutionsInFile = resolvedModuleNames.get(path22);
           const resolution = resolutionsInFile == null ? void 0 : resolutionsInFile.get(
             moduleName,
             /*mode*/
@@ -146832,13 +146832,13 @@ ${lanes.join("\n")}
             (symlinkWatcher.symlinks ?? (symlinkWatcher.symlinks = /* @__PURE__ */ new Set())).add(affectingLocation);
           }
         }
-        function invalidateAffectingFileWatcher(path21, packageJsonMap) {
+        function invalidateAffectingFileWatcher(path22, packageJsonMap) {
           var _a3;
-          const watcher = fileWatchesOfAffectingLocations.get(path21);
-          if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path21);
-          if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path21);
-          (_a3 = watcher == null ? void 0 : watcher.symlinks) == null ? void 0 : _a3.forEach((path22) => invalidateAffectingFileWatcher(path22, packageJsonMap));
-          packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path21));
+          const watcher = fileWatchesOfAffectingLocations.get(path22);
+          if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path22);
+          if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path22);
+          (_a3 = watcher == null ? void 0 : watcher.symlinks) == null ? void 0 : _a3.forEach((path23) => invalidateAffectingFileWatcher(path23, packageJsonMap));
+          packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path22));
         }
         function watchFailedLookupLocationOfNonRelativeModuleResolutions() {
           nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfResolution);
@@ -147080,7 +147080,7 @@ ${lanes.join("\n")}
         function invalidatePackageJsonMap() {
           const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
           if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) {
-            packageJsonMap.forEach((_value, path21) => isInvalidatedFailedLookup(path21) ? packageJsonMap.delete(path21) : void 0);
+            packageJsonMap.forEach((_value, path22) => isInvalidatedFailedLookup(path22) ? packageJsonMap.delete(path22) : void 0);
           }
         }
         function invalidateResolutionsOfFailedLookupLocations() {
@@ -147703,9 +147703,9 @@ ${lanes.join("\n")}
           getDefaultLibLocation: maybeBind(host, host.getDefaultLibLocation),
           getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
           writeFile: createWriteFileMeasuringIO(
-            (path21, data, writeByteOrderMark) => host.writeFile(path21, data, writeByteOrderMark),
-            (path21) => host.createDirectory(path21),
-            (path21) => host.directoryExists(path21)
+            (path22, data, writeByteOrderMark) => host.writeFile(path22, data, writeByteOrderMark),
+            (path22) => host.createDirectory(path22),
+            (path22) => host.directoryExists(path22)
           ),
           getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
           useCaseSensitiveFileNames: () => useCaseSensitiveFileNames2,
@@ -147776,16 +147776,16 @@ ${lanes.join("\n")}
           getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
           getDefaultLibLocation,
           getDefaultLibFileName: (options) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
-          fileExists: (path21) => system.fileExists(path21),
-          readFile: (path21, encoding) => system.readFile(path21, encoding),
-          directoryExists: (path21) => system.directoryExists(path21),
-          getDirectories: (path21) => system.getDirectories(path21),
-          readDirectory: (path21, extensions, exclude, include, depth) => system.readDirectory(path21, extensions, exclude, include, depth),
+          fileExists: (path22) => system.fileExists(path22),
+          readFile: (path22, encoding) => system.readFile(path22, encoding),
+          directoryExists: (path22) => system.directoryExists(path22),
+          getDirectories: (path22) => system.getDirectories(path22),
+          readDirectory: (path22, extensions, exclude, include, depth) => system.readDirectory(path22, extensions, exclude, include, depth),
           realpath: maybeBind(system, system.realpath),
           getEnvironmentVariable: maybeBind(system, system.getEnvironmentVariable),
           trace: (s) => system.write(s + system.newLine),
-          createDirectory: (path21) => system.createDirectory(path21),
-          writeFile: (path21, data, writeByteOrderMark) => system.writeFile(path21, data, writeByteOrderMark),
+          createDirectory: (path22) => system.createDirectory(path22),
+          writeFile: (path22, data, writeByteOrderMark) => system.writeFile(path22, data, writeByteOrderMark),
           createHash: maybeBind(system, system.createHash),
           createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
           storeSignatureInfo: system.storeSignatureInfo,
@@ -148098,7 +148098,7 @@ ${lanes.join("\n")}
             originalWriteFile,
             readFileWithCache
           } = changeCompilerHostLikeToUseCache(compilerHost, toPath3);
-          if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path21) => getSourceVersion(path21, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+          if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path22) => getSourceVersion(path22, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
             if (hasChangedConfigFileParsingErrors) {
               if (reportFileChangeDetectedOnCreateProgram) {
                 reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
@@ -148192,14 +148192,14 @@ ${lanes.join("\n")}
           return typeof hostSourceFile.version === "boolean";
         }
         function fileExists(fileName) {
-          const path21 = toPath3(fileName);
-          if (isFileMissingOnHost(sourceFilesCache.get(path21))) {
+          const path22 = toPath3(fileName);
+          if (isFileMissingOnHost(sourceFilesCache.get(path22))) {
             return false;
           }
           return directoryStructureHost.fileExists(fileName);
         }
-        function getVersionedSourceFileByPath(fileName, path21, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
-          const hostSourceFile = sourceFilesCache.get(path21);
+        function getVersionedSourceFileByPath(fileName, path22, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
+          const hostSourceFile = sourceFilesCache.get(path22);
           if (isFileMissingOnHost(hostSourceFile)) {
             return void 0;
           }
@@ -148211,41 +148211,41 @@ ${lanes.join("\n")}
                 hostSourceFile.sourceFile = sourceFile;
                 hostSourceFile.version = sourceFile.version;
                 if (!hostSourceFile.fileWatcher) {
-                  hostSourceFile.fileWatcher = watchFilePath(path21, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
+                  hostSourceFile.fileWatcher = watchFilePath(path22, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
                 }
               } else {
                 if (hostSourceFile.fileWatcher) {
                   hostSourceFile.fileWatcher.close();
                 }
-                sourceFilesCache.set(path21, false);
+                sourceFilesCache.set(path22, false);
               }
             } else {
               if (sourceFile) {
-                const fileWatcher = watchFilePath(path21, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
-                sourceFilesCache.set(path21, { sourceFile, version: sourceFile.version, fileWatcher });
+                const fileWatcher = watchFilePath(path22, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
+                sourceFilesCache.set(path22, { sourceFile, version: sourceFile.version, fileWatcher });
               } else {
-                sourceFilesCache.set(path21, false);
+                sourceFilesCache.set(path22, false);
               }
             }
             return sourceFile;
           }
           return hostSourceFile.sourceFile;
         }
-        function nextSourceFileVersion(path21) {
-          const hostSourceFile = sourceFilesCache.get(path21);
+        function nextSourceFileVersion(path22) {
+          const hostSourceFile = sourceFilesCache.get(path22);
           if (hostSourceFile !== void 0) {
             if (isFileMissingOnHost(hostSourceFile)) {
-              sourceFilesCache.set(path21, { version: false });
+              sourceFilesCache.set(path22, { version: false });
             } else {
               hostSourceFile.version = false;
             }
           }
         }
-        function getSourceVersion(path21, readFileWithCache) {
-          const hostSourceFile = sourceFilesCache.get(path21);
+        function getSourceVersion(path22, readFileWithCache) {
+          const hostSourceFile = sourceFilesCache.get(path22);
           if (!hostSourceFile) return void 0;
           if (hostSourceFile.version) return hostSourceFile.version;
-          const text = readFileWithCache(path21);
+          const text = readFileWithCache(path22);
           return text !== void 0 ? getSourceFileVersionAsHashFromText(compilerHost, text) : void 0;
         }
         function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) {
@@ -148424,28 +148424,28 @@ ${lanes.join("\n")}
         }
         function onReleaseParsedCommandLine(fileName) {
           var _a3;
-          const path21 = toPath3(fileName);
-          const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(path21);
+          const path22 = toPath3(fileName);
+          const config2 = parsedConfigs == null ? void 0 : parsedConfigs.get(path22);
           if (!config2) return;
-          parsedConfigs.delete(path21);
+          parsedConfigs.delete(path22);
           if (config2.watchedDirectories) clearMap(config2.watchedDirectories, closeFileWatcherOf);
           (_a3 = config2.watcher) == null ? void 0 : _a3.close();
-          clearSharedExtendedConfigFileWatcher(path21, sharedExtendedConfigFileWatchers);
+          clearSharedExtendedConfigFileWatcher(path22, sharedExtendedConfigFileWatchers);
         }
-        function watchFilePath(path21, file2, callback, pollingInterval, options, watchType) {
-          return watchFile2(file2, (fileName, eventKind) => callback(fileName, eventKind, path21), pollingInterval, options, watchType);
+        function watchFilePath(path22, file2, callback, pollingInterval, options, watchType) {
+          return watchFile2(file2, (fileName, eventKind) => callback(fileName, eventKind, path22), pollingInterval, options, watchType);
         }
-        function onSourceFileChange(fileName, eventKind, path21) {
-          updateCachedSystemWithFile(fileName, path21, eventKind);
-          if (eventKind === 2 && sourceFilesCache.has(path21)) {
-            resolutionCache.invalidateResolutionOfFile(path21);
+        function onSourceFileChange(fileName, eventKind, path22) {
+          updateCachedSystemWithFile(fileName, path22, eventKind);
+          if (eventKind === 2 && sourceFilesCache.has(path22)) {
+            resolutionCache.invalidateResolutionOfFile(path22);
           }
-          nextSourceFileVersion(path21);
+          nextSourceFileVersion(path22);
           scheduleProgramUpdate();
         }
-        function updateCachedSystemWithFile(fileName, path21, eventKind) {
+        function updateCachedSystemWithFile(fileName, path22, eventKind) {
           if (cachedDirectoryStructureHost) {
-            cachedDirectoryStructureHost.addOrDeleteFile(fileName, path21, eventKind);
+            cachedDirectoryStructureHost.addOrDeleteFile(fileName, path22, eventKind);
           }
         }
         function watchMissingFilePath(missingFilePath, missingFileName) {
@@ -148666,9 +148666,9 @@ ${lanes.join("\n")}
       }
       function createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus) {
         const host = createProgramHost(system, createProgram2);
-        host.getModifiedTime = system.getModifiedTime ? (path21) => system.getModifiedTime(path21) : returnUndefined;
-        host.setModifiedTime = system.setModifiedTime ? (path21, date5) => system.setModifiedTime(path21, date5) : noop;
-        host.deleteFile = system.deleteFile ? (path21) => system.deleteFile(path21) : noop;
+        host.getModifiedTime = system.getModifiedTime ? (path22) => system.getModifiedTime(path22) : returnUndefined;
+        host.setModifiedTime = system.setModifiedTime ? (path22, date5) => system.setModifiedTime(path22, date5) : noop;
+        host.deleteFile = system.deleteFile ? (path22) => system.deleteFile(path22) : noop;
         host.reportDiagnostic = reportDiagnostic || createDiagnosticReporter(system);
         host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system);
         host.now = maybeBind(system, system.now);
@@ -148839,8 +148839,8 @@ ${lanes.join("\n")}
       }
       function toResolvedConfigFilePath(state, fileName) {
         const { resolvedConfigFilePaths } = state;
-        const path21 = resolvedConfigFilePaths.get(fileName);
-        if (path21 !== void 0) return path21;
+        const path22 = resolvedConfigFilePaths.get(fileName);
+        if (path22 !== void 0) return path22;
         const resolvedPath = toPath2(state, fileName);
         resolvedConfigFilePaths.set(fileName, resolvedPath);
         return resolvedPath;
@@ -149228,7 +149228,7 @@ ${lanes.join("\n")}
             void 0,
             (name, text, writeByteOrderMark, onError, sourceFiles, data) => {
               var _a22;
-              const path21 = toPath2(state, name);
+              const path22 = toPath2(state, name);
               emittedOutputs.set(toPath2(state, name), name);
               if (data == null ? void 0 : data.buildInfo) {
                 now || (now = getCurrentTime(state.host));
@@ -149258,7 +149258,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(path21, now || (now = getCurrentTime(state.host)));
+                (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path22, now || (now = getCurrentTime(state.host)));
               }
             },
             cancellationToken,
@@ -149442,8 +149442,8 @@ ${lanes.join("\n")}
         return !!value.watcher;
       }
       function getModifiedTime2(state, fileName) {
-        const path21 = toPath2(state, fileName);
-        const existing = state.filesWatched.get(path21);
+        const path22 = toPath2(state, fileName);
+        const existing = state.filesWatched.get(path22);
         if (state.watch && !!existing) {
           if (!isFileWatcherWithModifiedTime(existing)) return existing;
           if (existing.modifiedTime) return existing.modifiedTime;
@@ -149451,20 +149451,20 @@ ${lanes.join("\n")}
         const result = getModifiedTime(state.host, fileName);
         if (state.watch) {
           if (existing) existing.modifiedTime = result;
-          else state.filesWatched.set(path21, result);
+          else state.filesWatched.set(path22, result);
         }
         return result;
       }
       function watchFile(state, file2, callback, pollingInterval, options, watchType, project) {
-        const path21 = toPath2(state, file2);
-        const existing = state.filesWatched.get(path21);
+        const path22 = toPath2(state, file2);
+        const existing = state.filesWatched.get(path22);
         if (existing && isFileWatcherWithModifiedTime(existing)) {
           existing.callbacks.push(callback);
         } else {
           const watcher = state.watchFile(
             file2,
             (fileName, eventKind, modifiedTime) => {
-              const existing2 = Debug.checkDefined(state.filesWatched.get(path21));
+              const existing2 = Debug.checkDefined(state.filesWatched.get(path22));
               Debug.assert(isFileWatcherWithModifiedTime(existing2));
               existing2.modifiedTime = modifiedTime;
               existing2.callbacks.forEach((cb) => cb(fileName, eventKind, modifiedTime));
@@ -149474,14 +149474,14 @@ ${lanes.join("\n")}
             watchType,
             project
           );
-          state.filesWatched.set(path21, { callbacks: [callback], watcher, modifiedTime: existing });
+          state.filesWatched.set(path22, { callbacks: [callback], watcher, modifiedTime: existing });
         }
         return {
           close: () => {
-            const existing2 = Debug.checkDefined(state.filesWatched.get(path21));
+            const existing2 = Debug.checkDefined(state.filesWatched.get(path22));
             Debug.assert(isFileWatcherWithModifiedTime(existing2));
             if (existing2.callbacks.length === 1) {
-              state.filesWatched.delete(path21);
+              state.filesWatched.delete(path22);
               closeFileWatcherOf(existing2);
             } else {
               unorderedRemoveItem(existing2.callbacks, callback);
@@ -149496,19 +149496,19 @@ ${lanes.join("\n")}
         return result;
       }
       function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
-        const path21 = toPath2(state, buildInfoPath);
+        const path22 = toPath2(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
-        return (existing == null ? void 0 : existing.path) === path21 ? existing : void 0;
+        return (existing == null ? void 0 : existing.path) === path22 ? existing : void 0;
       }
       function getBuildInfo3(state, buildInfoPath, resolvedConfigPath, modifiedTime) {
-        const path21 = toPath2(state, buildInfoPath);
+        const path22 = toPath2(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
-        if (existing !== void 0 && existing.path === path21) {
+        if (existing !== void 0 && existing.path === path22) {
           return existing.buildInfo || void 0;
         }
         const value = state.readFileWithCache(buildInfoPath);
         const buildInfo = value ? getBuildInfo(buildInfoPath, value) : void 0;
-        state.buildInfoCache.set(resolvedConfigPath, { path: path21, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
+        state.buildInfoCache.set(resolvedConfigPath, { path: path22, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
         return buildInfo;
       }
       function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) {
@@ -149689,11 +149689,11 @@ ${lanes.join("\n")}
           const outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
           for (const output of outputs) {
             if (output === buildInfoPath) continue;
-            const path21 = toPath2(state, output);
-            let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path21);
+            const path22 = toPath2(state, output);
+            let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path22);
             if (!outputTime) {
               outputTime = getModifiedTime(state.host, output);
-              outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path21, outputTime);
+              outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path22, outputTime);
             }
             if (outputTime === missingFileModifiedTime) {
               return {
@@ -149747,7 +149747,7 @@ ${lanes.join("\n")}
         const packageJsonLookups = state.lastCachedPackageJsonLookups.get(resolvedPath);
         const dependentPackageFileStatus = packageJsonLookups && forEachKey(
           packageJsonLookups,
-          (path21) => checkConfigFileUpToDateStatus(state, path21, oldestOutputFileTime, oldestOutputFileName)
+          (path22) => checkConfigFileUpToDateStatus(state, path22, oldestOutputFileTime, oldestOutputFileName)
         );
         if (dependentPackageFileStatus) return dependentPackageFileStatus;
         return {
@@ -149797,8 +149797,8 @@ ${lanes.join("\n")}
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
           let reportVerbose = !!state.options.verbose;
           for (const file2 of outputs) {
-            const path21 = toPath2(state, file2);
-            if (skipOutputs == null ? void 0 : skipOutputs.has(path21)) continue;
+            const path22 = toPath2(state, file2);
+            if (skipOutputs == null ? void 0 : skipOutputs.has(path22)) continue;
             if (reportVerbose) {
               reportVerbose = false;
               reportStatus(state, verboseMessage, proj.options.configFilePath);
@@ -149806,8 +149806,8 @@ ${lanes.join("\n")}
             host.setModifiedTime(file2, now || (now = getCurrentTime(state.host)));
             if (file2 === buildInfoPath) getBuildInfoCacheEntry(state, buildInfoPath, projectPath).modifiedTime = now;
             else if (outputTimeStampMap) {
-              outputTimeStampMap.set(path21, now);
-              modifiedOutputs.add(path21);
+              outputTimeStampMap.set(path22, now);
+              modifiedOutputs.add(path22);
             }
           }
         }
@@ -150235,8 +150235,8 @@ ${lanes.join("\n")}
           close: () => stopWatching(state)
         };
       }
-      function relName(state, path21) {
-        return convertToRelativePath(path21, state.compilerHost.getCurrentDirectory(), state.compilerHost.getCanonicalFileName);
+      function relName(state, path22) {
+        return convertToRelativePath(path22, state.compilerHost.getCurrentDirectory(), state.compilerHost.getCanonicalFileName);
       }
       function reportStatus(state, message, ...args) {
         state.host.reportSolutionBuilderStatus(createCompilerDiagnostic(message, ...args));
@@ -150455,13 +150455,13 @@ ${lanes.join("\n")}
         } else if (file2.isDeclarationFile) {
           return "Definitions";
         }
-        const path21 = file2.path;
-        if (fileExtensionIsOneOf(path21, supportedTSExtensionsFlat)) {
+        const path22 = file2.path;
+        if (fileExtensionIsOneOf(path22, supportedTSExtensionsFlat)) {
           return "TypeScript";
-        } else if (fileExtensionIsOneOf(path21, supportedJSExtensionsFlat)) {
+        } else if (fileExtensionIsOneOf(path22, supportedJSExtensionsFlat)) {
           return "JavaScript";
         } else if (fileExtensionIs(
-          path21,
+          path22,
           ".json"
           /* Json */
         )) {
@@ -151088,7 +151088,7 @@ ${lanes.join("\n")}
             );
           }
         }
-        const commandLine = parseCommandLine(commandLineArgs, (path21) => system.readFile(path21));
+        const commandLine = parseCommandLine(commandLineArgs, (path22) => system.readFile(path22));
         if (commandLine.options.generateCpuProfile && system.enableCPUProfiler) {
           system.enableCPUProfiler(commandLine.options.generateCpuProfile, () => executeCommandLineWorker(
             system,
@@ -152964,12 +152964,12 @@ ${lanes.join("\n")}
         return nodeCoreModules.has(moduleName) ? "node" : moduleName;
       }
       function loadSafeList(host, safeListPath) {
-        const result = readConfigFile(safeListPath, (path21) => host.readFile(path21));
+        const result = readConfigFile(safeListPath, (path22) => host.readFile(path22));
         return new Map(Object.entries(result.config));
       }
       function loadTypesMap(host, typesMapPath) {
         var _a3;
-        const result = readConfigFile(typesMapPath, (path21) => host.readFile(path21));
+        const result = readConfigFile(typesMapPath, (path22) => host.readFile(path22));
         if ((_a3 = result.config) == null ? void 0 : _a3.simpleMap) {
           return new Map(Object.entries(result.config.simpleMap));
         }
@@ -152981,9 +152981,9 @@ ${lanes.join("\n")}
         }
         const inferredTypings = /* @__PURE__ */ new Map();
         fileNames = mapDefined(fileNames, (fileName) => {
-          const path21 = normalizePath(fileName);
-          if (hasJSFileExtension(path21)) {
-            return path21;
+          const path22 = normalizePath(fileName);
+          if (hasJSFileExtension(path22)) {
+            return path22;
           }
         });
         const filesToWatch = [];
@@ -153045,7 +153045,7 @@ ${lanes.join("\n")}
           let manifestTypingNames;
           if (host.fileExists(manifestPath)) {
             filesToWatch2.push(manifestPath);
-            manifest = readConfigFile(manifestPath, (path21) => host.readFile(path21)).config;
+            manifest = readConfigFile(manifestPath, (path22) => host.readFile(path22)).config;
             manifestTypingNames = flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], getOwnKeys);
             addInferredTypings(manifestTypingNames, `Typing names in '${manifestPath}' dependencies`);
           }
@@ -153079,7 +153079,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, (path21) => host.readFile(path21));
+            const result2 = readConfigFile(normalizedFileName, (path22) => host.readFile(path22));
             const manifest2 = result2.config;
             if (!manifest2.name) {
               continue;
@@ -155863,14 +155863,14 @@ ${lanes.join("\n")}
       function tryGetDirectories(host, directoryName) {
         return tryIOAndConsumeErrors(host, host.getDirectories, directoryName) || [];
       }
-      function tryReadDirectory(host, path21, extensions, exclude, include) {
-        return tryIOAndConsumeErrors(host, host.readDirectory, path21, extensions, exclude, include) || emptyArray;
+      function tryReadDirectory(host, path22, extensions, exclude, include) {
+        return tryIOAndConsumeErrors(host, host.readDirectory, path22, extensions, exclude, include) || emptyArray;
       }
-      function tryFileExists(host, path21) {
-        return tryIOAndConsumeErrors(host, host.fileExists, path21);
+      function tryFileExists(host, path22) {
+        return tryIOAndConsumeErrors(host, host.fileExists, path22);
       }
-      function tryDirectoryExists(host, path21) {
-        return tryAndIgnoreErrors(() => directoryProbablyExists(path21, host)) || false;
+      function tryDirectoryExists(host, path22) {
+        return tryAndIgnoreErrors(() => directoryProbablyExists(path22, host)) || false;
       }
       function tryAndIgnoreErrors(cb) {
         try {
@@ -156712,13 +156712,13 @@ ${lanes.join("\n")}
       function getIsExcluded(excludePatterns, host) {
         var _a3;
         const realpathsWithSymlinks = (_a3 = host.getSymlinkCache) == null ? void 0 : _a3.call(host).getSymlinkedDirectoriesByRealpath();
-        return (({ fileName, path: path21 }) => {
+        return (({ fileName, path: path22 }) => {
           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(path21),
+              getDirectoryPath(path22),
               (dirPath) => {
                 const symlinks = realpathsWithSymlinks.get(ensureTrailingDirectorySeparator(dirPath));
                 if (symlinks) {
@@ -158374,14 +158374,14 @@ ${lanes.join("\n")}
           return settingsOrHost;
         }
         function acquireDocument(fileName, compilationSettings, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
-          const path21 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path22 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-          return acquireDocumentWithKey(fileName, path21, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
+          return acquireDocumentWithKey(fileName, path22, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
         }
-        function acquireDocumentWithKey(fileName, path21, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
+        function acquireDocumentWithKey(fileName, path22, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
           return acquireOrUpdateDocument(
             fileName,
-            path21,
+            path22,
             compilationSettings,
             key,
             scriptSnapshot,
@@ -158393,14 +158393,14 @@ ${lanes.join("\n")}
           );
         }
         function updateDocument(fileName, compilationSettings, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
-          const path21 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path22 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-          return updateDocumentWithKey(fileName, path21, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
+          return updateDocumentWithKey(fileName, path22, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
         }
-        function updateDocumentWithKey(fileName, path21, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
+        function updateDocumentWithKey(fileName, path22, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
           return acquireOrUpdateDocument(
             fileName,
-            path21,
+            path22,
             getCompilationSettings(compilationSettings),
             key,
             scriptSnapshot,
@@ -158416,7 +158416,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, path21, compilationSettingsOrHost, key, scriptSnapshot, version22, acquiring, scriptKind, languageVersionOrOptions) {
+        function acquireOrUpdateDocument(fileName, path22, compilationSettingsOrHost, key, scriptSnapshot, version22, acquiring, scriptKind, languageVersionOrOptions) {
           var _a3, _b, _c, _d;
           scriptKind = ensureScriptKind(fileName, scriptKind);
           const compilationSettings = getCompilationSettings(compilationSettingsOrHost);
@@ -158424,7 +158424,7 @@ ${lanes.join("\n")}
           const scriptTarget = scriptKind === 6 ? 100 : getEmitScriptTarget(compilationSettings);
           const sourceFileOptions = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : {
             languageVersion: scriptTarget,
-            impliedNodeFormat: host && getImpliedNodeFormatForFile(path21, (_d = (_c = (_b = (_a3 = host.getCompilerHost) == null ? void 0 : _a3.call(host)) == null ? void 0 : _b.getModuleResolutionCache) == null ? void 0 : _c.call(_b)) == null ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
+            impliedNodeFormat: host && getImpliedNodeFormatForFile(path22, (_d = (_c = (_b = (_a3 = host.getCompilerHost) == null ? void 0 : _a3.call(host)) == null ? void 0 : _b.getModuleResolutionCache) == null ? void 0 : _c.call(_b)) == null ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
             setExternalModuleIndicator: getSetExternalModuleIndicator(compilationSettings),
             jsDocParsingMode
           };
@@ -158437,15 +158437,15 @@ ${lanes.join("\n")}
             if (buckets.size > oldBucketCount) {
               tracing.instant(tracing.Phase.Session, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: keyWithMode });
             }
-            const otherBucketKey = !isDeclarationFileName(path21) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path21) && bucketKey);
+            const otherBucketKey = !isDeclarationFileName(path22) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path22) && bucketKey);
             if (otherBucketKey) {
-              tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path: path21, key1: otherBucketKey, key2: keyWithMode });
+              tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path: path22, key1: otherBucketKey, key2: keyWithMode });
             }
           }
-          const bucketEntry = bucket.get(path21);
+          const bucketEntry = bucket.get(path22);
           let entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind);
           if (!entry && externalCache) {
-            const sourceFile = externalCache.getDocument(keyWithMode, path21);
+            const sourceFile = externalCache.getDocument(keyWithMode, path22);
             if (sourceFile && sourceFile.scriptKind === scriptKind && sourceFile.text === getSnapshotText(scriptSnapshot)) {
               Debug.assert(acquiring);
               entry = {
@@ -158466,7 +158466,7 @@ ${lanes.join("\n")}
               scriptKind
             );
             if (externalCache) {
-              externalCache.setDocument(keyWithMode, path21, sourceFile);
+              externalCache.setDocument(keyWithMode, path22, sourceFile);
             }
             entry = {
               sourceFile,
@@ -158477,7 +158477,7 @@ ${lanes.join("\n")}
             if (entry.sourceFile.version !== version22) {
               entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version22, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot));
               if (externalCache) {
-                externalCache.setDocument(keyWithMode, path21, entry.sourceFile);
+                externalCache.setDocument(keyWithMode, path22, entry.sourceFile);
               }
             }
             if (acquiring) {
@@ -158488,35 +158488,35 @@ ${lanes.join("\n")}
           return entry.sourceFile;
           function setBucketEntry() {
             if (!bucketEntry) {
-              bucket.set(path21, entry);
+              bucket.set(path22, entry);
             } else if (isDocumentRegistryEntry(bucketEntry)) {
               const scriptKindMap = /* @__PURE__ */ new Map();
               scriptKindMap.set(bucketEntry.sourceFile.scriptKind, bucketEntry);
               scriptKindMap.set(scriptKind, entry);
-              bucket.set(path21, scriptKindMap);
+              bucket.set(path22, scriptKindMap);
             } else {
               bucketEntry.set(scriptKind, entry);
             }
           }
         }
         function releaseDocument(fileName, compilationSettings, scriptKind, impliedNodeFormat) {
-          const path21 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path22 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(compilationSettings);
-          return releaseDocumentWithKey(path21, key, scriptKind, impliedNodeFormat);
+          return releaseDocumentWithKey(path22, key, scriptKind, impliedNodeFormat);
         }
-        function releaseDocumentWithKey(path21, key, scriptKind, impliedNodeFormat) {
+        function releaseDocumentWithKey(path22, key, scriptKind, impliedNodeFormat) {
           const bucket = Debug.checkDefined(buckets.get(getDocumentRegistryBucketKeyWithMode(key, impliedNodeFormat)));
-          const bucketEntry = bucket.get(path21);
+          const bucketEntry = bucket.get(path22);
           const entry = getDocumentRegistryEntry(bucketEntry, scriptKind);
           entry.languageServiceRefCount--;
           Debug.assert(entry.languageServiceRefCount >= 0);
           if (entry.languageServiceRefCount === 0) {
             if (isDocumentRegistryEntry(bucketEntry)) {
-              bucket.delete(path21);
+              bucket.delete(path22);
             } else {
               bucketEntry.delete(scriptKind);
               if (bucketEntry.size === 1) {
-                bucket.set(path21, firstDefinedIterator(bucketEntry.values(), identity));
+                bucket.set(path22, firstDefinedIterator(bucketEntry.values(), identity));
               }
             }
           }
@@ -158552,10 +158552,10 @@ ${lanes.join("\n")}
       }
       function getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper) {
         const canonicalOldPath = getCanonicalFileName(oldFileOrDirPath);
-        return (path21) => {
-          const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path21, pos: 0 });
-          const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path21);
-          return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path21, getCanonicalFileName) : updatedPath;
+        return (path22) => {
+          const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path22, pos: 0 });
+          const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path22);
+          return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path22, getCanonicalFileName) : updatedPath;
         };
         function getUpdatedPath(pathToUpdate) {
           if (getCanonicalFileName(pathToUpdate) === canonicalOldPath) return newFileOrDirPath;
@@ -158631,10 +158631,10 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function relativePath(path21) {
+        function relativePath(path22) {
           return getRelativePathFromDirectory(
             configDir,
-            path21,
+            path22,
             /*ignoreCase*/
             !useCaseSensitiveFileNames2
           );
@@ -159441,8 +159441,8 @@ ${lanes.join("\n")}
           return toPath(fileName, currentDirectory, getCanonicalFileName);
         }
         function getDocumentPositionMapper2(generatedFileName, sourceFileName) {
-          const path21 = toPath3(generatedFileName);
-          const value = documentPositionMappers.get(path21);
+          const path22 = toPath3(generatedFileName);
+          const value = documentPositionMappers.get(path22);
           if (value) return value;
           let mapper;
           if (host.getDocumentPositionMapper) {
@@ -159456,7 +159456,7 @@ ${lanes.join("\n")}
               (f) => !host.fileExists || host.fileExists(f) ? host.readFile(f) : void 0
             );
           }
-          documentPositionMappers.set(path21, mapper || identitySourceMapConsumer);
+          documentPositionMappers.set(path22, mapper || identitySourceMapConsumer);
           return mapper || identitySourceMapConsumer;
         }
         function tryGetSourcePosition(info) {
@@ -159484,21 +159484,21 @@ ${lanes.join("\n")}
         function getSourceFile(fileName) {
           const program2 = host.getProgram();
           if (!program2) return void 0;
-          const path21 = toPath3(fileName);
-          const file2 = program2.getSourceFileByPath(path21);
-          return file2 && file2.resolvedPath === path21 ? file2 : void 0;
+          const path22 = toPath3(fileName);
+          const file2 = program2.getSourceFileByPath(path22);
+          return file2 && file2.resolvedPath === path22 ? file2 : void 0;
         }
         function getOrCreateSourceFileLike(fileName) {
-          const path21 = toPath3(fileName);
-          const fileFromCache = sourceFileLike.get(path21);
+          const path22 = toPath3(fileName);
+          const fileFromCache = sourceFileLike.get(path22);
           if (fileFromCache !== void 0) return fileFromCache ? fileFromCache : void 0;
           if (!host.readFile || host.fileExists && !host.fileExists(fileName)) {
-            sourceFileLike.set(path21, false);
+            sourceFileLike.set(path22, false);
             return void 0;
           }
           const text = host.readFile(fileName);
           const file2 = text ? createSourceFileLike(text) : false;
-          sourceFileLike.set(path21, file2);
+          sourceFileLike.set(path22, file2);
           return file2 ? file2 : void 0;
         }
         function getSourceFileLike(fileName) {
@@ -167583,12 +167583,12 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             directoryExists: (directoryName) => {
               return directoryProbablyExists(directoryName, host);
             },
-            getDirectories: (path21) => {
-              return host.getDirectories ? host.getDirectories(path21) : [];
+            getDirectories: (path22) => {
+              return host.getDirectories ? host.getDirectories(path22) : [];
             },
-            readDirectory: (path21, extensions, exclude, include, depth) => {
+            readDirectory: (path22, extensions, exclude, include, depth) => {
               Debug.checkDefined(host.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'");
-              return host.readDirectory(path21, extensions, exclude, include, depth);
+              return host.readDirectory(path22, extensions, exclude, include, depth);
             },
             onReleaseOldSourceFile,
             onReleaseParsedCommandLine,
@@ -167651,11 +167651,11 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           program2.getTypeChecker();
           return;
           function getParsedCommandLine(fileName) {
-            const path21 = toPath(fileName, currentDirectory, getCanonicalFileName);
-            const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path21);
+            const path22 = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path22);
             if (existing !== void 0) return existing || void 0;
             const result = host.getParsedCommandLine ? host.getParsedCommandLine(fileName) : getParsedCommandLineOfConfigFileUsingSourceFile(fileName);
-            (parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path21, result || false);
+            (parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path22, result || false);
             return result;
           }
           function getParsedCommandLineOfConfigFileUsingSourceFile(configFileName) {
@@ -167697,7 +167697,7 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           function getOrCreateSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
             return getOrCreateSourceFileByPath(fileName, toPath(fileName, currentDirectory, getCanonicalFileName), languageVersionOrOptions, onError, shouldCreateNewSourceFile);
           }
-          function getOrCreateSourceFileByPath(fileName, path21, languageVersionOrOptions, _onError, shouldCreateNewSourceFile) {
+          function getOrCreateSourceFileByPath(fileName, path22, 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) {
@@ -167706,17 +167706,17 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             const scriptKind = getScriptKind(fileName, host);
             const scriptVersion = host.getScriptVersion(fileName);
             if (!shouldCreateNewSourceFile) {
-              const oldSourceFile = program2 && program2.getSourceFileByPath(path21);
+              const oldSourceFile = program2 && program2.getSourceFileByPath(path22);
               if (oldSourceFile) {
                 if (scriptKind === oldSourceFile.scriptKind || releasedScriptKinds.has(oldSourceFile.resolvedPath)) {
-                  return documentRegistry.updateDocumentWithKey(fileName, path21, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
+                  return documentRegistry.updateDocumentWithKey(fileName, path22, 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, path21, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
+            return documentRegistry.acquireDocumentWithKey(fileName, path22, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
           }
         }
         function getProgram() {
@@ -168322,7 +168322,7 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           return isArray(action) ? Promise.all(action.map((a2) => applySingleCodeActionCommand(a2))) : applySingleCodeActionCommand(action);
         }
         function applySingleCodeActionCommand(action) {
-          const getPath = (path21) => toPath(path21, currentDirectory, getCanonicalFileName);
+          const getPath = (path22) => toPath(path22, 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`");
         }
@@ -168666,8 +168666,8 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           function isLetterOrDigit(char) {
             return char >= 97 && char <= 122 || char >= 65 && char <= 90 || char >= 48 && char <= 57;
           }
-          function isNodeModulesFile(path21) {
-            return path21.includes("/node_modules/");
+          function isNodeModulesFile(path22) {
+            return path22.includes("/node_modules/");
           }
         }
         function getRenameInfo2(fileName, position, preferences) {
@@ -182311,11 +182311,11 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           }
         });
       }
-      function generateJSDocParamTagsForDestructuring(path21, pattern, initializer3, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
+      function generateJSDocParamTagsForDestructuring(path22, pattern, initializer3, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
         if (!isJs) {
           return [
             getJSDocParamAnnotation(
-              path21,
+              path22,
               initializer3,
               dotDotDotToken,
               isJs,
@@ -182329,13 +182329,13 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             )
           ];
         }
-        return patternWorker(path21, pattern, initializer3, dotDotDotToken, { tabstop: 1 });
-        function patternWorker(path22, pattern2, initializer22, dotDotDotToken2, counter) {
+        return patternWorker(path22, pattern, initializer3, dotDotDotToken, { tabstop: 1 });
+        function patternWorker(path23, pattern2, initializer22, dotDotDotToken2, counter) {
           if (isObjectBindingPattern(pattern2) && !dotDotDotToken2) {
             const oldTabstop = counter.tabstop;
             const childCounter = { tabstop: oldTabstop };
             const rootParam = getJSDocParamAnnotation(
-              path22,
+              path23,
               initializer22,
               dotDotDotToken2,
               isJs,
@@ -182349,7 +182349,7 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             );
             let childTags = [];
             for (const element of pattern2.elements) {
-              const elementTags = elementWorker(path22, element, childCounter);
+              const elementTags = elementWorker(path23, element, childCounter);
               if (!elementTags) {
                 childTags = void 0;
                 break;
@@ -182364,7 +182364,7 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           }
           return [
             getJSDocParamAnnotation(
-              path22,
+              path23,
               initializer22,
               dotDotDotToken2,
               isJs,
@@ -182378,13 +182378,13 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             )
           ];
         }
-        function elementWorker(path22, element, counter) {
+        function elementWorker(path23, element, counter) {
           if (!element.propertyName && isIdentifier(element.name) || isIdentifier(element.name)) {
             const propertyName = element.propertyName ? tryGetTextOfPropertyName(element.propertyName) : element.name.text;
             if (!propertyName) {
               return void 0;
             }
-            const paramName = `${path22}.${propertyName}`;
+            const paramName = `${path23}.${propertyName}`;
             return [
               getJSDocParamAnnotation(
                 paramName,
@@ -182402,7 +182402,7 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
             ];
           } else if (element.propertyName) {
             const propertyName = tryGetTextOfPropertyName(element.propertyName);
-            return propertyName && patternWorker(`${path22}.${propertyName}`, element.name, element.initializer, element.dotDotDotToken, counter);
+            return propertyName && patternWorker(`${path23}.${propertyName}`, element.name, element.initializer, element.dotDotDotToken, counter);
           }
           return void 0;
         }
@@ -186984,21 +186984,21 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
       function getFragmentDirectory(fragment) {
         return containsSlash(fragment) ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
       }
-      function getCompletionsForPathMapping(path21, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program2, host, moduleSpecifierResolutionHost) {
-        const parsedPath = tryParsePattern(path21);
+      function getCompletionsForPathMapping(path22, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program2, host, moduleSpecifierResolutionHost) {
+        const parsedPath = tryParsePattern(path22);
         if (!parsedPath) {
           return emptyArray;
         }
         if (typeof parsedPath === "string") {
           return justPathMappingName(
-            path21,
+            path22,
             "script"
             /* scriptElement */
           );
         }
         const remainingFragment = tryRemovePrefix(fragment, parsedPath.prefix);
         if (remainingFragment === void 0) {
-          const starIsFullPathComponent = endsWith(path21, "/*");
+          const starIsFullPathComponent = endsWith(path22, "/*");
           return starIsFullPathComponent ? justPathMappingName(
             parsedPath.prefix,
             "directory"
@@ -187084,9 +187084,9 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
         function getDirectoryMatches(directoryName) {
           return mapDefined(tryGetDirectories(host, directoryName), (dir) => dir === "node_modules" ? void 0 : directoryResult(dir));
         }
-        function trimPrefixAndSuffix(path21, prefix) {
+        function trimPrefixAndSuffix(path22, prefix) {
           return firstDefined(matchingSuffixes, (suffix) => {
-            const inner = withoutStartAndEnd(normalizePath(path21), prefix, suffix);
+            const inner = withoutStartAndEnd(normalizePath(path22), prefix, suffix);
             return inner === void 0 ? void 0 : removeLeadingDirectorySeparator(inner);
           });
         }
@@ -187094,8 +187094,8 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).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(path21) {
-        return path21[0] === directorySeparator ? path21.slice(1) : path21;
+      function removeLeadingDirectorySeparator(path22) {
+        return path22[0] === directorySeparator ? path22.slice(1) : path22;
       }
       function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) {
         const ambientModules = checker.getAmbientModules().map((sym) => stripQuotes(sym.name));
@@ -187210,10 +187210,10 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           /* ESNext */
         ) ? void 0 : createTextSpan(textStart + offset, length2);
       }
-      function isPathRelativeToScript(path21) {
-        if (path21 && path21.length >= 2 && path21.charCodeAt(0) === 46) {
-          const slashIndex = path21.length >= 3 && path21.charCodeAt(1) === 46 ? 2 : 1;
-          const slashCharCode = path21.charCodeAt(slashIndex);
+      function isPathRelativeToScript(path22) {
+        if (path22 && path22.length >= 2 && path22.charCodeAt(0) === 46) {
+          const slashIndex = path22.length >= 3 && path22.charCodeAt(1) === 46 ? 2 : 1;
+          const slashCharCode = path22.charCodeAt(slashIndex);
           return slashCharCode === 47 || slashCharCode === 92;
         }
         return false;
@@ -203226,17 +203226,17 @@ ${options.prefix}` : "\n" : options.prefix
       function createNormalizedPathMap() {
         const map22 = /* @__PURE__ */ new Map();
         return {
-          get(path21) {
-            return map22.get(path21);
+          get(path22) {
+            return map22.get(path22);
           },
-          set(path21, value) {
-            map22.set(path21, value);
+          set(path22, value) {
+            map22.set(path22, value);
           },
-          contains(path21) {
-            return map22.has(path21);
+          contains(path22) {
+            return map22.has(path22);
           },
-          remove(path21) {
-            map22.delete(path21);
+          remove(path22) {
+            map22.delete(path22);
           }
         };
       }
@@ -203751,12 +203751,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, path21, initialVersion) {
+        constructor(host, fileName, scriptKind, hasMixedContent, path22, initialVersion) {
           this.host = host;
           this.fileName = fileName;
           this.scriptKind = scriptKind;
           this.hasMixedContent = hasMixedContent;
-          this.path = path21;
+          this.path = path22;
           this.containingProjects = [];
           this.isDynamic = isDynamicFileName(fileName);
           this.textStorage = new TextStorage(host, this, initialVersion);
@@ -204391,8 +204391,8 @@ ${options.prefix}` : "\n" : options.prefix
         useCaseSensitiveFileNames() {
           return this.projectService.host.useCaseSensitiveFileNames;
         }
-        readDirectory(path21, extensions, exclude, include, depth) {
-          return this.directoryStructureHost.readDirectory(path21, extensions, exclude, include, depth);
+        readDirectory(path22, extensions, exclude, include, depth) {
+          return this.directoryStructureHost.readDirectory(path22, extensions, exclude, include, depth);
         }
         readFile(fileName) {
           return this.projectService.host.readFile(fileName);
@@ -204401,8 +204401,8 @@ ${options.prefix}` : "\n" : options.prefix
           return this.projectService.host.writeFile(fileName, content);
         }
         fileExists(file2) {
-          const path21 = this.toPath(file2);
-          return !!this.projectService.getScriptInfoForPath(path21) || !this.isWatchedMissingFile(path21) && this.directoryStructureHost.fileExists(file2);
+          const path22 = this.toPath(file2);
+          return !!this.projectService.getScriptInfoForPath(path22) || !this.isWatchedMissingFile(path22) && this.directoryStructureHost.fileExists(file2);
         }
         /** @internal */
         resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
@@ -204427,11 +204427,11 @@ ${options.prefix}` : "\n" : options.prefix
         resolveLibrary(libraryName, resolveFrom, options, libFileName) {
           return this.resolutionCache.resolveLibrary(libraryName, resolveFrom, options, libFileName);
         }
-        directoryExists(path21) {
-          return this.directoryStructureHost.directoryExists(path21);
+        directoryExists(path22) {
+          return this.directoryStructureHost.directoryExists(path22);
         }
-        getDirectories(path21) {
-          return this.directoryStructureHost.getDirectories(path21);
+        getDirectories(path22) {
+          return this.directoryStructureHost.getDirectories(path22);
         }
         /** @internal */
         getCachedDirectoryStructureHost() {
@@ -204694,16 +204694,16 @@ ${options.prefix}` : "\n" : options.prefix
             }
           }));
         }
-        getSourceFile(path21) {
+        getSourceFile(path22) {
           if (!this.program) {
             return void 0;
           }
-          return this.program.getSourceFileByPath(path21);
+          return this.program.getSourceFileByPath(path22);
         }
         /** @internal */
-        getSourceFileOrConfigFile(path21) {
+        getSourceFileOrConfigFile(path22) {
           const options = this.program.getCompilerOptions();
-          return path21 === options.configFilePath ? options.configFile : this.getSourceFile(path21);
+          return path22 === options.configFilePath ? options.configFile : this.getSourceFile(path22);
         }
         close() {
           var _a3;
@@ -204880,8 +204880,8 @@ ${options.prefix}` : "\n" : options.prefix
         }
         // add a root file that doesnt exist on host
         addMissingFileRoot(fileName) {
-          const path21 = this.projectService.toPath(fileName);
-          this.rootFilesMap.set(path21, { fileName });
+          const path22 = this.projectService.toPath(fileName);
+          this.rootFilesMap.set(path22, { fileName });
           this.markAsDirty();
         }
         removeFile(info, fileExists, detachFromProject) {
@@ -205050,22 +205050,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 = (path21, typingsWatcherType) => {
-            const canonicalPath = this.toPath(path21);
+          const createProjectWatcher = (path22, typingsWatcherType) => {
+            const canonicalPath = this.toPath(path22);
             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(
-                  path21,
+                  path22,
                   () => !this.typingWatchers.isInvoked ? this.onTypingInstallerWatchInvoke() : this.writeLog(`TypingWatchers already invoked`),
                   2e3,
                   this.projectService.getWatchOptions(this),
                   watchType,
                   this
                 ) : this.projectService.watchFactory.watchDirectory(
-                  path21,
+                  path22,
                   (f) => {
                     if (this.typingWatchers.isInvoked) return this.writeLog(`TypingWatchers already invoked`);
                     if (!fileExtensionIs(
@@ -205080,7 +205080,7 @@ ${options.prefix}` : "\n" : options.prefix
                   this.projectService.getWatchOptions(this),
                   watchType,
                   this
-                ) : (this.writeLog(`Skipping watcher creation at ${path21}:: ${getDetailWatchInfo(watchType, this)}`), noopFileWatcher)
+                ) : (this.writeLog(`Skipping watcher creation at ${path22}:: ${getDetailWatchInfo(watchType, this)}`), noopFileWatcher)
               );
             }
           };
@@ -205125,14 +205125,14 @@ ${options.prefix}` : "\n" : options.prefix
               /* DirectoryWatcher */
             );
           }
-          toRemove.forEach((watch, path21) => {
+          toRemove.forEach((watch, path22) => {
             watch.close();
-            this.typingWatchers.delete(path21);
+            this.typingWatchers.delete(path22);
           });
         }
         /** @internal */
-        skipWatchingFailedLookups(path21) {
-          const info = this.projectService.getScriptInfoForPath(path21);
+        skipWatchingFailedLookups(path22) {
+          const info = this.projectService.getScriptInfoForPath(path22);
           return info == null ? void 0 : info.isDynamic;
         }
         /** @internal */
@@ -205170,9 +205170,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, path21) => {
+            this.rootFilesMap.forEach((value, path22) => {
               var _a22;
-              const file2 = this.program.getSourceFileByPath(path21);
+              const file2 = this.program.getSourceFileByPath(path22);
               const info = value.info;
               if (!file2 || ((_a22 = value.info) == null ? void 0 : _a22.path) === file2.resolvedPath) return;
               value.info = this.projectService.getScriptInfo(file2.fileName);
@@ -205328,8 +205328,8 @@ ${options.prefix}` : "\n" : options.prefix
           );
           return fileWatcher;
         }
-        isWatchedMissingFile(path21) {
-          return !!this.missingFilesMap && this.missingFilesMap.has(path21);
+        isWatchedMissingFile(path22) {
+          return !!this.missingFilesMap && this.missingFilesMap.has(path22);
         }
         /** @internal */
         addGeneratedFileWatch(generatedFile, sourceFile) {
@@ -205338,17 +205338,17 @@ ${options.prefix}` : "\n" : options.prefix
               this.generatedFilesMap = this.createGeneratedFileWatcher(generatedFile);
             }
           } else {
-            const path21 = this.toPath(sourceFile);
+            const path22 = 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(path21)) return;
+              if (this.generatedFilesMap.has(path22)) return;
             } else {
               this.generatedFilesMap = /* @__PURE__ */ new Map();
             }
-            this.generatedFilesMap.set(path21, this.createGeneratedFileWatcher(generatedFile));
+            this.generatedFilesMap.set(path22, this.createGeneratedFileWatcher(generatedFile));
           }
         }
         createGeneratedFileWatcher(generatedFile) {
@@ -205748,7 +205748,7 @@ ${options.prefix}` : "\n" : options.prefix
         isDefaultProjectForOpenFiles() {
           return !!forEachEntry(
             this.projectService.openFiles,
-            (_projectRootPath, path21) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path21)) === this
+            (_projectRootPath, path22) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path22)) === this
           );
         }
         /** @internal */
@@ -206925,33 +206925,33 @@ ${options.prefix}` : "\n" : options.prefix
           getCurrentDirectory: () => service.host.getCurrentDirectory(),
           useCaseSensitiveFileNames: service.host.useCaseSensitiveFileNames
         };
-        function watchFile2(path21, callback) {
+        function watchFile2(path22, callback) {
           return getOrCreateFileWatcher(
             watchedFiles,
-            path21,
+            path22,
             callback,
-            (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path: path21 } })
+            (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path: path22 } })
           );
         }
-        function watchDirectory(path21, callback, recursive) {
+        function watchDirectory(path22, callback, recursive) {
           return getOrCreateFileWatcher(
             recursive ? watchedDirectoriesRecursive : watchedDirectories,
-            path21,
+            path22,
             callback,
             (id) => ({
               eventName: CreateDirectoryWatcherEvent,
               data: {
                 id,
-                path: path21,
+                path: path22,
                 recursive: !!recursive,
                 // Special case node_modules as we watch it for changes to closed script infos as well
-                ignoreUpdate: !path21.endsWith("/node_modules") ? true : void 0
+                ignoreUpdate: !path22.endsWith("/node_modules") ? true : void 0
               }
             })
           );
         }
-        function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path21, callback, event) {
-          const key = service.toPath(path21);
+        function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path22, callback, event) {
+          const key = service.toPath(path22);
           let id = pathToId.get(key);
           if (!id) pathToId.set(key, id = ids++);
           let callbacks = idToCallbacks.get(id);
@@ -207120,13 +207120,13 @@ ${options.prefix}` : "\n" : options.prefix
           return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());
         }
         /** @internal */
-        setDocument(key, path21, sourceFile) {
-          const info = Debug.checkDefined(this.getScriptInfoForPath(path21));
+        setDocument(key, path22, sourceFile) {
+          const info = Debug.checkDefined(this.getScriptInfoForPath(path22));
           info.cacheSourceFile = { key, sourceFile };
         }
         /** @internal */
-        getDocument(key, path21) {
-          const info = this.getScriptInfoForPath(path21);
+        getDocument(key, path22) {
+          const info = this.getScriptInfoForPath(path22);
           return info && info.cacheSourceFile && info.cacheSourceFile.key === key ? info.cacheSourceFile.sourceFile : void 0;
         }
         /** @internal */
@@ -207248,7 +207248,7 @@ ${options.prefix}` : "\n" : options.prefix
           const event = {
             eventName: ProjectsUpdatedInBackgroundEvent,
             data: {
-              openFiles: arrayFrom(this.openFiles.keys(), (path21) => this.getScriptInfoForPath(path21).fileName)
+              openFiles: arrayFrom(this.openFiles.keys(), (path22) => this.getScriptInfoForPath(path22).fileName)
             }
           };
           this.eventHandler(event);
@@ -207470,11 +207470,11 @@ ${options.prefix}` : "\n" : options.prefix
         }
         delayUpdateSourceInfoProjects(sourceInfos) {
           if (sourceInfos) {
-            sourceInfos.forEach((_value, path21) => this.delayUpdateProjectsOfScriptInfoPath(path21));
+            sourceInfos.forEach((_value, path22) => this.delayUpdateProjectsOfScriptInfoPath(path22));
           }
         }
-        delayUpdateProjectsOfScriptInfoPath(path21) {
-          const info = this.getScriptInfoForPath(path21);
+        delayUpdateProjectsOfScriptInfoPath(path22) {
+          const info = this.getScriptInfoForPath(path22);
           if (info) {
             this.delayUpdateProjectGraphs(
               info.containingProjects,
@@ -207568,8 +207568,8 @@ ${options.prefix}` : "\n" : options.prefix
             const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath);
             if (!project) return;
             if (configuredProjectForConfig !== project && this.getHostPreferences().includeCompletionsForModuleExports) {
-              const path21 = this.toPath(configFileName);
-              if (find((_a3 = project.getCurrentProgram()) == null ? void 0 : _a3.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path21)) {
+              const path22 = this.toPath(configFileName);
+              if (find((_a3 = project.getCurrentProgram()) == null ? void 0 : _a3.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path22)) {
                 project.markAutoImportProviderAsDirty();
               }
             }
@@ -207613,21 +207613,21 @@ ${options.prefix}` : "\n" : options.prefix
               project.markAutoImportProviderAsDirty();
             } else {
               if (project.initialLoadPending) {
-                (_b = (_a3 = this.configFileExistenceInfoCache.get(projectCanonicalPath)) == null ? void 0 : _a3.openFilesImpactedByConfigFile) == null ? void 0 : _b.forEach((path22) => {
+                (_b = (_a3 = this.configFileExistenceInfoCache.get(projectCanonicalPath)) == null ? void 0 : _a3.openFilesImpactedByConfigFile) == null ? void 0 : _b.forEach((path23) => {
                   var _a22;
-                  if (!((_a22 = this.pendingOpenFileProjectUpdates) == null ? void 0 : _a22.has(path22))) {
+                  if (!((_a22 = this.pendingOpenFileProjectUpdates) == null ? void 0 : _a22.has(path23))) {
                     (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(
-                      path22,
-                      this.configFileForOpenFiles.get(path22)
+                      path23,
+                      this.configFileForOpenFiles.get(path23)
                     );
                   }
                 });
                 return;
               }
-              const path21 = this.toPath(canonicalConfigFilePath);
-              project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path21);
+              const path22 = this.toPath(canonicalConfigFilePath);
+              project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path22);
               this.delayUpdateProjectGraph(project);
-              if (this.getHostPreferences().includeCompletionsForModuleExports && find((_c = project.getCurrentProgram()) == null ? void 0 : _c.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path21)) {
+              if (this.getHostPreferences().includeCompletionsForModuleExports && find((_c = project.getCurrentProgram()) == null ? void 0 : _c.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path22)) {
                 project.markAutoImportProviderAsDirty();
               }
             }
@@ -207652,20 +207652,20 @@ ${options.prefix}` : "\n" : options.prefix
             canonicalConfigFilePath,
             "Change in config file detected"
           );
-          this.openFiles.forEach((_projectRootPath, path21) => {
+          this.openFiles.forEach((_projectRootPath, path22) => {
             var _a3, _b;
-            const configFileForOpenFile = this.configFileForOpenFiles.get(path21);
-            if (!((_a3 = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a3.has(path21))) return;
-            this.configFileForOpenFiles.delete(path21);
-            const info = this.getScriptInfoForPath(path21);
+            const configFileForOpenFile = this.configFileForOpenFiles.get(path22);
+            if (!((_a3 = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a3.has(path22))) return;
+            this.configFileForOpenFiles.delete(path22);
+            const info = this.getScriptInfoForPath(path22);
             const newConfigFileNameForInfo = this.getConfigFileNameForFile(
               info,
               /*findFromCacheOnly*/
               false
             );
             if (!newConfigFileNameForInfo) return;
-            if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path21))) {
-              (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path21, configFileForOpenFile);
+            if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path22))) {
+              (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path22, configFileForOpenFile);
             }
           });
           this.delayEnsureProjectForOpenFiles();
@@ -207760,8 +207760,8 @@ ${options.prefix}` : "\n" : options.prefix
           return project;
         }
         assignOrphanScriptInfosToInferredProject() {
-          this.openFiles.forEach((projectRootPath, path21) => {
-            const info = this.getScriptInfoForPath(path21);
+          this.openFiles.forEach((projectRootPath, path22) => {
+            const info = this.getScriptInfoForPath(path22);
             if (info.isOrphan()) {
               this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             }
@@ -208073,8 +208073,8 @@ ${options.prefix}` : "\n" : options.prefix
           this.configuredProjects.forEach(printProjectWithoutFileNames);
           this.inferredProjects.forEach(printProjectWithoutFileNames);
           this.logger.info("Open files: ");
-          this.openFiles.forEach((projectRootPath, path21) => {
-            const info = this.getScriptInfoForPath(path21);
+          this.openFiles.forEach((projectRootPath, path22) => {
+            const info = this.getScriptInfoForPath(path22);
             this.logger.info(`	FileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`);
             this.logger.info(`		Projects: ${info.containingProjects.map((p) => p.getProjectName())}`);
           });
@@ -208400,12 +208400,12 @@ ${options.prefix}` : "\n" : options.prefix
             const newRootFile = propertyReader.getFileName(f);
             const fileName = toNormalizedPath(newRootFile);
             const isDynamic = isDynamicFileName(fileName);
-            let path21;
+            let path22;
             if (!isDynamic && !project.fileExists(newRootFile)) {
-              path21 = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
-              const existingValue = projectRootFilesMap.get(path21);
+              path22 = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
+              const existingValue = projectRootFilesMap.get(path22);
               if (existingValue) {
-                if (((_a3 = existingValue.info) == null ? void 0 : _a3.path) === path21) {
+                if (((_a3 = existingValue.info) == null ? void 0 : _a3.path) === path22) {
                   project.removeFile(
                     existingValue.info,
                     /*fileExists*/
@@ -208417,7 +208417,7 @@ ${options.prefix}` : "\n" : options.prefix
                 }
                 existingValue.fileName = fileName;
               } else {
-                projectRootFilesMap.set(path21, { fileName });
+                projectRootFilesMap.set(path22, { fileName });
               }
             } else {
               const scriptKind = propertyReader.getScriptKind(f, this.hostConfiguration.extraFileExtensions);
@@ -208431,8 +208431,8 @@ ${options.prefix}` : "\n" : options.prefix
                 /*deferredDeleteOk*/
                 false
               ));
-              path21 = scriptInfo.path;
-              const existingValue = projectRootFilesMap.get(path21);
+              path22 = scriptInfo.path;
+              const existingValue = projectRootFilesMap.get(path22);
               if (!existingValue || existingValue.info !== scriptInfo) {
                 project.addRoot(scriptInfo, fileName);
                 if (scriptInfo.isScriptOpen()) {
@@ -208442,11 +208442,11 @@ ${options.prefix}` : "\n" : options.prefix
                 existingValue.fileName = fileName;
               }
             }
-            newRootScriptInfoMap.set(path21, true);
+            newRootScriptInfoMap.set(path22, true);
           }
           if (projectRootFilesMap.size > newRootScriptInfoMap.size) {
-            projectRootFilesMap.forEach((value, path21) => {
-              if (!newRootScriptInfoMap.has(path21)) {
+            projectRootFilesMap.forEach((value, path22) => {
+              if (!newRootScriptInfoMap.has(path22)) {
                 if (value.info) {
                   project.removeFile(
                     value.info,
@@ -208455,7 +208455,7 @@ ${options.prefix}` : "\n" : options.prefix
                     true
                   );
                 } else {
-                  projectRootFilesMap.delete(path21);
+                  projectRootFilesMap.delete(path22);
                 }
               }
             });
@@ -208692,8 +208692,8 @@ ${options.prefix}` : "\n" : options.prefix
         }
         /** @internal */
         getScriptInfoOrConfig(uncheckedFileName) {
-          const path21 = toNormalizedPath(uncheckedFileName);
-          const info = this.getScriptInfoForNormalizedPath(path21);
+          const path22 = toNormalizedPath(uncheckedFileName);
+          const info = this.getScriptInfoForNormalizedPath(path22);
           if (info) return info;
           const configProject = this.configuredProjects.get(this.toPath(uncheckedFileName));
           return configProject && configProject.getCompilerOptions().configFile;
@@ -208705,7 +208705,7 @@ ${options.prefix}` : "\n" : options.prefix
               this.filenameToScriptInfo.entries(),
               (entry) => entry[1].deferredDelete ? void 0 : entry
             ),
-            ([path21, scriptInfo]) => ({ path: path21, fileName: scriptInfo.fileName })
+            ([path22, scriptInfo]) => ({ path: path22, fileName: scriptInfo.fileName })
           );
           this.logger.msg(
             `Could not find file ${JSON.stringify(fileName)}.
@@ -208737,7 +208737,7 @@ All files are: ${JSON.stringify(names)}`,
                   if (!projects) {
                     projects = createMultiMap();
                     projects.add(toAddInfo.path, project);
-                  } else if (!forEachEntry(projects, (projs, path21) => path21 === toAddInfo.path ? false : contains(projs, project))) {
+                  } else if (!forEachEntry(projects, (projs, path22) => path22 === toAddInfo.path ? false : contains(projs, project))) {
                     projects.add(toAddInfo.path, project);
                   }
                 }
@@ -208899,8 +208899,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 path21 = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
-          let info = this.filenameToScriptInfo.get(path21);
+          const path22 = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
+          let info = this.filenameToScriptInfo.get(path22);
           if (!info) {
             const isDynamic = isDynamicFileName(fileName);
             Debug.assert(isRootedDiskPath(fileName) || isDynamic || openedByClient, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })}
@@ -208912,7 +208912,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, path21, this.filenameToScriptInfoVersion.get(path21));
+            info = new ScriptInfo(this.host, fileName, scriptKind, hasMixedContent, path22, this.filenameToScriptInfoVersion.get(path22));
             this.filenameToScriptInfo.set(info.path, info);
             this.filenameToScriptInfoVersion.delete(info.path);
             if (!openedByClient) {
@@ -209059,9 +209059,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 path21 = project.toPath(fileName);
-            const sourceFile = project.getSourceFile(path21);
-            if (sourceFile && sourceFile.resolvedPath === path21) return sourceFile;
+            const path22 = project.toPath(fileName);
+            const sourceFile = project.getSourceFile(path22);
+            if (sourceFile && sourceFile.resolvedPath === path22) return sourceFile;
           }
           const info = this.getOrCreateScriptInfoNotOpenedByClient(
             fileName,
@@ -209227,8 +209227,8 @@ Dynamic files must always be opened with service's current directory or service
               }
             });
           });
-          this.openFiles.forEach((_projectRootPath, path21) => {
-            const info = this.getScriptInfoForPath(path21);
+          this.openFiles.forEach((_projectRootPath, path22) => {
+            const info = this.getScriptInfoForPath(path22);
             if (find(info.containingProjects, isExternalProject)) return;
             this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
               info,
@@ -209281,14 +209281,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, path21) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
-              this.getScriptInfoForPath(path21),
+            (_config, path22) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+              this.getScriptInfoForPath(path22),
               5
               /* Create */
             )
           );
-          this.openFiles.forEach((projectRootPath, path21) => {
-            const info = this.getScriptInfoForPath(path21);
+          this.openFiles.forEach((projectRootPath, path22) => {
+            const info = this.getScriptInfoForPath(path22);
             if (info.isOrphan()) {
               this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             } else {
@@ -209799,9 +209799,9 @@ Dynamic files must always be opened with service's current directory or service
             }
           });
           if (!toRemoveConfiguredProjects.size) return toRemoveConfiguredProjects;
-          forEachEntry(this.openFiles, (_projectRootPath, path21) => {
-            if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path21)) return;
-            const info = this.getScriptInfoForPath(path21);
+          forEachEntry(this.openFiles, (_projectRootPath, path22) => {
+            if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path22)) return;
+            const info = this.getScriptInfoForPath(path22);
             if (find(info.containingProjects, isExternalProject)) return;
             const result = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
               info,
@@ -209850,8 +209850,8 @@ Dynamic files must always be opened with service's current directory or service
                 sourceInfos = info.sourceMapFilePath.sourceInfos;
               }
               if (!sourceInfos) return;
-              if (!forEachKey(sourceInfos, (path21) => {
-                const info2 = this.getScriptInfoForPath(path21);
+              if (!forEachKey(sourceInfos, (path22) => {
+                const info2 = this.getScriptInfoForPath(path22);
                 return !!info2 && (info2.isScriptOpen() || !info2.isOrphan());
               })) {
                 return;
@@ -209875,7 +209875,7 @@ Dynamic files must always be opened with service's current directory or service
                 sourceInfos = info.sourceMapFilePath.sourceInfos;
               }
               if (sourceInfos) {
-                sourceInfos.forEach((_value, path21) => toRemoveScriptInfos.delete(path21));
+                sourceInfos.forEach((_value, path22) => toRemoveScriptInfos.delete(path22));
               }
             }
           });
@@ -210358,9 +210358,9 @@ Dynamic files must always be opened with service's current directory or service
             }
           );
         }
-        watchPackageJsonFile(file2, path21, project) {
+        watchPackageJsonFile(file2, path22, project) {
           Debug.assert(project !== void 0);
-          let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path21);
+          let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path22);
           if (!result) {
             let watcher = this.watchFactory.watchFile(
               file2,
@@ -210368,11 +210368,11 @@ Dynamic files must always be opened with service's current directory or service
                 switch (eventKind) {
                   case 0:
                   case 1:
-                    this.packageJsonCache.addOrUpdate(fileName, path21);
+                    this.packageJsonCache.addOrUpdate(fileName, path22);
                     this.onPackageJsonChange(result);
                     break;
                   case 2:
-                    this.packageJsonCache.delete(path21);
+                    this.packageJsonCache.delete(path22);
                     this.onPackageJsonChange(result);
                     result.projects.clear();
                     result.close();
@@ -210389,11 +210389,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;
-                (_a3 = this.packageJsonFilesMap) == null ? void 0 : _a3.delete(path21);
-                this.packageJsonCache.invalidate(path21);
+                (_a3 = this.packageJsonFilesMap) == null ? void 0 : _a3.delete(path22);
+                this.packageJsonCache.invalidate(path22);
               }
             };
-            this.packageJsonFilesMap.set(path21, result);
+            this.packageJsonFilesMap.set(path22, result);
           }
           result.projects.add(project);
           (project.packageJsonWatches ?? (project.packageJsonWatches = /* @__PURE__ */ new Set())).add(result);
@@ -210583,14 +210583,14 @@ Dynamic files must always be opened with service's current directory or service
             );
           }
         };
-        function addOrUpdate(fileName, path21) {
+        function addOrUpdate(fileName, path22) {
           const packageJsonInfo = Debug.checkDefined(createPackageJsonInfo(fileName, host.host));
-          packageJsons.set(path21, packageJsonInfo);
-          directoriesWithoutPackageJson.delete(getDirectoryPath(path21));
+          packageJsons.set(path22, packageJsonInfo);
+          directoriesWithoutPackageJson.delete(getDirectoryPath(path22));
         }
-        function invalidate(path21) {
-          packageJsons.delete(path21);
-          directoriesWithoutPackageJson.delete(getDirectoryPath(path21));
+        function invalidate(path22) {
+          packageJsons.delete(path22);
+          directoriesWithoutPackageJson.delete(getDirectoryPath(path22));
         }
         function directoryHasPackageJson(directory) {
           return packageJsons.has(combinePaths(directory, "package.json")) ? -1 : directoriesWithoutPackageJson.has(directory) ? 0 : 3;
@@ -210787,8 +210787,8 @@ ${json2}${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, path21) => {
-            const value = getValue(path21);
+          projects.symLinkedProjects.forEach((projects2, path22) => {
+            const value = getValue(path22);
             outputs.push(...flatMap(projects2, (project) => action(project, value)));
           });
         }
@@ -210934,9 +210934,9 @@ ${json2}${newLine}`;
         });
         return results.filter((o) => o.references.length !== 0);
       }
-      function forEachProjectInProjects(projects, path21, cb) {
+      function forEachProjectInProjects(projects, path22, cb) {
         for (const project of isArray(projects) ? projects : projects.projects) {
-          cb(project, path21);
+          cb(project, path22);
         }
         if (!isArray(projects) && projects.symLinkedProjects) {
           projects.symLinkedProjects.forEach((symlinkedProjects, symlinkedPath) => {
@@ -210950,8 +210950,8 @@ ${json2}${newLine}`;
         const resultsMap = /* @__PURE__ */ new Map();
         const queue = createQueue();
         queue.enqueue({ project: defaultProject, location: initialLocation });
-        forEachProjectInProjects(projects, initialLocation.fileName, (project, path21) => {
-          const location = { fileName: path21, pos: initialLocation.pos };
+        forEachProjectInProjects(projects, initialLocation.fileName, (project, path22) => {
+          const location = { fileName: path22, pos: initialLocation.pos };
           queue.enqueue({ project, location });
         });
         const projectService = defaultProject.projectService;
@@ -212793,8 +212793,8 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
                 nodeModulesPathParts.packageRootIndex
               );
               const packageName = getPackageNameFromTypesPackageName(unmangleScopedPackageName(packageNamePathPart));
-              const path21 = project.toPath(fileName);
-              if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path21)) {
+              const path22 = project.toPath(fileName);
+              if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path22)) {
                 return (_b = auxiliaryProject.resolutionCache.resolveSingleModuleNameWithoutWatching(packageName, resolveFromFile).resolvedModule) == null ? void 0 : _b.resolvedFileName;
               } else {
                 const pathToFileInPackage = fileName.substring(nodeModulesPathParts.packageRootIndex + 1);
@@ -213574,7 +213574,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           }
           return combineProjectOutput(
             info,
-            (path21) => this.projectService.getScriptInfoForPath(path21),
+            (path22) => this.projectService.getScriptInfoForPath(path22),
             projects,
             (project, info2) => {
               if (!project.compileOnSaveEnabled || !project.languageServiceEnabled || project.isOrphan()) {
@@ -213601,7 +213601,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
             return args.richResponse ? { emitSkipped: true, diagnostics: [] } : false;
           }
           const scriptInfo = project.getScriptInfo(file2);
-          const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path21, data, writeByteOrderMark) => this.host.writeFile(path21, data, writeByteOrderMark));
+          const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path22, data, writeByteOrderMark) => this.host.writeFile(path22, data, writeByteOrderMark));
           return args.richResponse ? {
             emitSkipped,
             diagnostics: args.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics) : diagnostics.map((d) => formatDiagnosticToProtocol(
@@ -215671,7 +215671,7 @@ ${error51.message}`;
         return typescript.sys.fileExists(fileName);
       });
       if (filePath !== void 0) {
-        const { config: config2, error: error51 } = typescript.readConfigFile(filePath, (path21) => typescript.sys.readFile(path21));
+        const { config: config2, error: error51 } = typescript.readConfigFile(filePath, (path22) => typescript.sys.readFile(path22));
         if (error51) {
           throw new Error(`Error in ${filePath}: ${error51.messageText.toString()}`);
         }
@@ -215794,42 +215794,42 @@ var require_defaults = __commonJS({
 var require_env_paths = __commonJS({
   "node_modules/.pnpm/env-paths@2.2.1/node_modules/env-paths/index.js"(exports2, module2) {
     "use strict";
-    var path21 = require("path");
+    var path22 = require("path");
     var os7 = require("os");
     var homedir = os7.homedir();
     var tmpdir = os7.tmpdir();
     var { env } = process;
     var macos = (name) => {
-      const library = path21.join(homedir, "Library");
+      const library = path22.join(homedir, "Library");
       return {
-        data: path21.join(library, "Application Support", name),
-        config: path21.join(library, "Preferences", name),
-        cache: path21.join(library, "Caches", name),
-        log: path21.join(library, "Logs", name),
-        temp: path21.join(tmpdir, name)
+        data: path22.join(library, "Application Support", name),
+        config: path22.join(library, "Preferences", name),
+        cache: path22.join(library, "Caches", name),
+        log: path22.join(library, "Logs", name),
+        temp: path22.join(tmpdir, name)
       };
     };
     var windows = (name) => {
-      const appData = env.APPDATA || path21.join(homedir, "AppData", "Roaming");
-      const localAppData = env.LOCALAPPDATA || path21.join(homedir, "AppData", "Local");
+      const appData = env.APPDATA || path22.join(homedir, "AppData", "Roaming");
+      const localAppData = env.LOCALAPPDATA || path22.join(homedir, "AppData", "Local");
       return {
         // Data/config/cache/log are invented by me as Windows isn't opinionated about this
-        data: path21.join(localAppData, name, "Data"),
-        config: path21.join(appData, name, "Config"),
-        cache: path21.join(localAppData, name, "Cache"),
-        log: path21.join(localAppData, name, "Log"),
-        temp: path21.join(tmpdir, name)
+        data: path22.join(localAppData, name, "Data"),
+        config: path22.join(appData, name, "Config"),
+        cache: path22.join(localAppData, name, "Cache"),
+        log: path22.join(localAppData, name, "Log"),
+        temp: path22.join(tmpdir, name)
       };
     };
     var linux = (name) => {
-      const username = path21.basename(homedir);
+      const username = path22.basename(homedir);
       return {
-        data: path21.join(env.XDG_DATA_HOME || path21.join(homedir, ".local", "share"), name),
-        config: path21.join(env.XDG_CONFIG_HOME || path21.join(homedir, ".config"), name),
-        cache: path21.join(env.XDG_CACHE_HOME || path21.join(homedir, ".cache"), name),
+        data: path22.join(env.XDG_DATA_HOME || path22.join(homedir, ".local", "share"), name),
+        config: path22.join(env.XDG_CONFIG_HOME || path22.join(homedir, ".config"), name),
+        cache: path22.join(env.XDG_CACHE_HOME || path22.join(homedir, ".cache"), name),
         // https://wiki.debian.org/XDGBaseDirectorySpecification#state
-        log: path21.join(env.XDG_STATE_HOME || path21.join(homedir, ".local", "state"), name),
-        temp: path21.join(tmpdir, username, name)
+        log: path22.join(env.XDG_STATE_HOME || path22.join(homedir, ".local", "state"), name),
+        temp: path22.join(tmpdir, username, name)
       };
     };
     var envPaths = (name, options) => {
@@ -215910,11 +215910,11 @@ var require_util = __commonJS({
       map2.set(key, result);
       return result;
     }
-    function getPropertyByPath(source, path21) {
-      if (typeof path21 === "string" && Object.prototype.hasOwnProperty.call(source, path21)) {
-        return source[path21];
+    function getPropertyByPath(source, path22) {
+      if (typeof path22 === "string" && Object.prototype.hasOwnProperty.call(source, path22)) {
+        return source[path22];
       }
-      const parsedPath = typeof path21 === "string" ? path21.split(".") : path21;
+      const parsedPath = typeof path22 === "string" ? path22.split(".") : path22;
       return parsedPath.reduce((previous, key) => {
         if (previous === void 0) {
           return previous;
@@ -215925,9 +215925,9 @@ var require_util = __commonJS({
     function removeUndefinedValuesFromObject(options) {
       return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== void 0));
     }
-    async function isDirectory(path21) {
+    async function isDirectory(path22) {
       try {
-        const stat = await fs_1.promises.stat(path21);
+        const stat = await fs_1.promises.stat(path22);
         return stat.isDirectory();
       } catch (e) {
         if (e.code === "ENOENT") {
@@ -215936,9 +215936,9 @@ var require_util = __commonJS({
         throw e;
       }
     }
-    function isDirectorySync(path21) {
+    function isDirectorySync(path22) {
       try {
-        const stat = fs_1.default.statSync(path21);
+        const stat = fs_1.default.statSync(path22);
         return stat.isDirectory();
       } catch (e) {
         if (e.code === "ENOENT") {
@@ -216036,7 +216036,7 @@ var require_ExplorerBase = __commonJS({
           const idx = importStack.indexOf(fullPath);
           if (idx !== -1) {
             throw new Error(`Circular import detected:
-${[...importStack, fullPath].map((path21, i2) => `${i2 + 1}. ${path21}`).join("\n")} (same as ${idx + 1}.)`);
+${[...importStack, fullPath].map((path22, i2) => `${i2 + 1}. ${path22}`).join("\n")} (same as ${idx + 1}.)`);
           }
         }
       }
@@ -216223,9 +216223,9 @@ var require_Explorer = __commonJS({
           throw error51;
         }
       }
-      async #fileExists(path21) {
+      async #fileExists(path22) {
         try {
-          await promises_1.default.stat(path21);
+          await promises_1.default.stat(path22);
           return true;
         } catch (e) {
           return false;
@@ -216385,9 +216385,9 @@ var require_ExplorerSync = __commonJS({
           throw error51;
         }
       }
-      #fileExists(path21) {
+      #fileExists(path22) {
         try {
-          fs_1.default.statSync(path21);
+          fs_1.default.statSync(path22);
           return true;
         } catch (e) {
           return false;
@@ -216513,7 +216513,7 @@ var require_dist = __commonJS({
       };
     }
     function getResolvedSearchPlaces(moduleName, toolDefinedSearchPlaces, userConfiguredOptions) {
-      const userConfiguredSearchPlaces = userConfiguredOptions.searchPlaces?.map((path21) => path21.replace("{name}", moduleName));
+      const userConfiguredSearchPlaces = userConfiguredOptions.searchPlaces?.map((path22) => path22.replace("{name}", moduleName));
       if (userConfiguredOptions.mergeSearchPlaces) {
         return [...userConfiguredSearchPlaces ?? [], ...toolDefinedSearchPlaces];
       }
@@ -216863,8 +216863,8 @@ var require_utils = __commonJS({
       }
       return output;
     };
-    exports2.basename = (path21, { windows } = {}) => {
-      const segs = path21.split(windows ? /[\\/]/ : "/");
+    exports2.basename = (path22, { windows } = {}) => {
+      const segs = path22.split(windows ? /[\\/]/ : "/");
       const last = segs[segs.length - 1];
       if (last === "") {
         return segs[segs.length - 2];
@@ -218433,7 +218433,7 @@ var require_src = __commonJS({
 
 // src/cli.ts
 var import_node_os6 = __toESM(require("node:os"), 1);
-var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_path21 = __toESM(require("node:path"), 1);
 var import_node_crypto4 = require("node:crypto");
 
 // node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/error.js
@@ -221547,9 +221547,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path21) {
-    if (path21 === void 0) return this._executableDir;
-    this._executableDir = path21;
+  executableDir(path22) {
+    if (path22 === void 0) return this._executableDir;
+    this._executableDir = path22;
     return this;
   }
   /**
@@ -221857,7 +221857,7 @@ var categories_default_default = {
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "0.5.0",
+  version: "1.0.0",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "Apache-2.0",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -222775,10 +222775,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path21) {
-  if (!path21)
+function getElementAtPath(obj, path22) {
+  if (!path22)
     return obj;
-  return path21.reduce((acc, key) => acc?.[key], obj);
+  return path22.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -223187,11 +223187,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path21, issues) {
+function prefixIssues(path22, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path21);
+    iss.path.unshift(path22);
     return iss;
   });
 }
@@ -223338,16 +223338,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path21 = []) => {
+  const processError = (error52, path22 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path21, ...issue2.path];
+        const fullpath = [...path22, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -223374,17 +223374,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path21 = []) => {
+  const processError = (error52, path22 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path21, ...issue2.path];
+        const fullpath = [...path22, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -223416,8 +223416,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path21 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path21) {
+  const path22 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path22) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -236109,13 +236109,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path21 = ref.slice(1).split("/").filter(Boolean);
-  if (path21.length === 0) {
+  const path22 = ref.slice(1).split("/").filter(Boolean);
+  if (path22.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path21[0] === defsKey) {
-    const key = path21[1];
+  if (path22[0] === defsKey) {
+    const key = path22[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -238311,7 +238311,7 @@ function resyncFarm(params) {
       ...resolved.diagnostics,
       ...reconciliation.diagnostics,
       ...outcome.diagnostics,
-      ...recoveryDiagnostics(recovery)
+      ...recoveryDiagnostics(recovery, params.identity)
     ];
     const farmExists = params.fs.lstat(farmRoot) !== void 0;
     const nothingAdopted = outcome.adopted.length === 0 && outcome.conflicts.length === 0;
@@ -238334,7 +238334,7 @@ function resyncFarm(params) {
       diagnostics.push({
         code: "FARM_PREVIOUS_RETAINED",
         severity: "warning",
-        message: `The superseded farm was left at ${swap.retainedPrevious} because it still holds ${swap.collided.join(", ")}, which the new farm has its own entry for. Nothing was overwritten in either direction; review it and remove the directory once you are satisfied.`,
+        message: `The superseded farm was left at ${swap.retainedPrevious} because it still holds ${swap.collided.join(", ")}, which the new farm has its own entry for. Nothing was overwritten in either direction; run \`claude-use identity resolve ${params.identity}\` to resolve it interactively.`,
         subject: swap.retainedPrevious
       });
     }
@@ -238352,7 +238352,7 @@ function resyncFarm(params) {
     lock.release();
   }
 }
-function recoveryDiagnostics(recovery) {
+function recoveryDiagnostics(recovery, identity) {
   if (!recovery.recovered) {
     return [];
   }
@@ -238367,7 +238367,9 @@ function recoveryDiagnostics(recovery) {
     parts.push(`finished carrying local state out of ${recovery.completed.length} superseded farm(s)`);
   }
   if (recovery.retained.length > 0) {
-    parts.push(`kept ${recovery.retained.join(", ")}, which still holds data the current farm also has an entry for`);
+    parts.push(
+      `kept ${recovery.retained.join(", ")}, which still holds data the current farm also has an entry for \u2014 run \`claude-use identity resolve ${identity}\` to resolve it interactively`
+    );
   }
   return [
     {
@@ -239110,7 +239112,7 @@ function registerCheckCommand(program2, paths) {
 // src/configure.ts
 var import_node_fs6 = __toESM(require("node:fs"), 1);
 var import_node_os4 = __toESM(require("node:os"), 1);
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 
 // node_modules/.pnpm/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
 var import_node_process2 = require("node:process");
@@ -240155,7 +240157,45 @@ var i = `${(0, import_node_util3.styleText)("gray", S_BAR)}  `;
 
 // src/identityManager.ts
 var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path15 = __toESM(require("node:path"), 1);
+
+// src/launcher/farmResolve.ts
 var import_node_path14 = __toESM(require("node:path"), 1);
+async function resolveFarmConflicts(params) {
+  const farmRoot = import_node_path14.default.join(params.identitiesDir, params.identity);
+  const previousPrefix = `.${params.identity}.previous.`;
+  const previousRoots = [...params.fs.readdir(params.identitiesDir)].filter((name) => name.startsWith(previousPrefix)).sort().map((name) => import_node_path14.default.join(params.identitiesDir, name));
+  const resolved = [];
+  const removed = [];
+  const retained = [];
+  for (const previousRoot of previousRoots) {
+    const { collided } = carryOver({ fs: params.fs, previousRoot, farmRoot });
+    let anySkipped = false;
+    for (const name of collided) {
+      const choice = await params.decide({ previousRoot, farmRoot, name });
+      resolved.push({ previousRoot, farmRoot, name, choice });
+      if (choice === "skip") {
+        anySkipped = true;
+        continue;
+      }
+      if (choice === "keep-new") {
+        params.fs.removeRecursive(import_node_path14.default.join(previousRoot, name));
+        continue;
+      }
+      params.fs.removeRecursive(import_node_path14.default.join(farmRoot, name));
+      params.fs.rename(import_node_path14.default.join(previousRoot, name), import_node_path14.default.join(farmRoot, name));
+    }
+    if (anySkipped) {
+      retained.push(previousRoot);
+    } else {
+      params.fs.removeRecursive(previousRoot);
+      removed.push(previousRoot);
+    }
+  }
+  return { resolved, removed, retained };
+}
+
+// src/identityManager.ts
 var IdentityNotFoundError = class extends Error {
   constructor(name) {
     super(`No identity named "${name}" \u2014 run \`claude-use identity add ${name}\` first.`);
@@ -240173,7 +240213,7 @@ var IdentityAlreadyExistsError = class extends Error {
   identityName;
 };
 function identityJsonPath(paths, name) {
-  return import_node_path14.default.join(paths.identitiesDir, name, "identity.json");
+  return import_node_path15.default.join(paths.identitiesDir, name, "identity.json");
 }
 function identityExists(paths, name) {
   return import_node_fs4.default.existsSync(identityJsonPath(paths, name));
@@ -240257,6 +240297,34 @@ function registerIdentityCommand(program2, paths) {
     useIdentity(paths, name);
     console.log(`Active identity is now "${name}".`);
   });
+  identity.command("resolve <name>").description("Interactively resolve a superseded farm's colliding data left behind by a prior launch.").action(async (name) => {
+    const result = await resolveFarmConflicts({
+      fs: realFarmFs,
+      identitiesDir: paths.identitiesDir,
+      identity: name,
+      decide: async (conflict) => {
+        const choice = await realPromptsPort.select({
+          message: `"${conflict.name}" exists both in the superseded farm (${conflict.previousRoot}) and the current one (${conflict.farmRoot}). Which should be kept?`,
+          options: [
+            { value: "keep-new", label: "Keep the current farm's copy", hint: "discards the superseded one" },
+            { value: "keep-old", label: "Keep the superseded farm's copy", hint: "replaces the current one" },
+            { value: "skip", label: "Skip for now", hint: "leaves both copies, asks again next time" }
+          ]
+        });
+        return realPromptsPort.isCancel(choice) ? "skip" : choice;
+      }
+    });
+    if (result.resolved.length === 0) {
+      console.log(`No superseded farm data to resolve for identity "${name}".`);
+      return;
+    }
+    for (const conflict of result.resolved) {
+      console.log(`  ${conflict.name}: ${conflict.choice}`);
+    }
+    console.log(
+      `Resolved ${result.resolved.length} conflict(s) \u2014 ${result.removed.length} superseded director(ies) fully cleared, ${result.retained.length} still retained pending a skipped conflict.`
+    );
+  });
   identity.command("list").description("List every identity, marking the active one.").action(() => {
     const entries = listIdentities(paths);
     if (entries.length === 0) {
@@ -240288,7 +240356,7 @@ function registerIdentityCommand(program2, paths) {
 
 // src/configProfiles.ts
 var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 
 // src/cli/parsers.ts
 function splitTopLevelCommas(input) {
@@ -240356,7 +240424,7 @@ var InvalidCategoryNameError = class extends Error {
   categoryName;
 };
 function profileJsonPath(paths, name) {
-  return import_node_path15.default.join(paths.configProfilesDir, `${name}.json`);
+  return import_node_path16.default.join(paths.configProfilesDir, `${name}.json`);
 }
 function profileExists(paths, name) {
   return import_node_fs5.default.existsSync(profileJsonPath(paths, name));
@@ -240614,7 +240682,7 @@ function chooseWriteTarget(params) {
   for (let index = params.levels.length - 1; index >= 0; index -= 1) {
     const level = params.levels[index];
     if (level !== void 0 && (level.hasPortable || level.hasPortableLocal)) {
-      return { tier: "portable-local", localConfigPath: import_node_path16.default.join(level.dir, PORTABLE_LOCAL_CONFIG_FILENAME) };
+      return { tier: "portable-local", localConfigPath: import_node_path17.default.join(level.dir, PORTABLE_LOCAL_CONFIG_FILENAME) };
     }
   }
   const normalisedCwd = normaliseRulePath(params.cwd, params.home);
@@ -240706,8 +240774,8 @@ function buildWriteTargetLevels(cwd, home, walkUpLimit) {
   const dirs = walkDirectoryAncestors(cwd, { home, ...limit === void 0 ? {} : { limit } });
   return dirs.map((dir) => ({
     dir,
-    hasPortable: import_node_fs6.default.existsSync(import_node_path16.default.join(dir, PORTABLE_CONFIG_FILENAME)),
-    hasPortableLocal: import_node_fs6.default.existsSync(import_node_path16.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME))
+    hasPortable: import_node_fs6.default.existsSync(import_node_path17.default.join(dir, PORTABLE_CONFIG_FILENAME)),
+    hasPortableLocal: import_node_fs6.default.existsSync(import_node_path17.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME))
   }));
 }
 function resolveWriteTarget(context) {
@@ -240964,7 +241032,7 @@ function registerConfigureCommand(program2, paths) {
 
 // src/claudeShim.ts
 var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var ClaudeShimStateSchema = external_exports.strictObject({
   targetPath: external_exports.string().min(1),
   method: external_exports.enum(["hardlink", "copy"]),
@@ -240999,15 +241067,15 @@ function isInvokedAsClaude(invokedName) {
   return invokedName === "claude" || invokedName.toLowerCase() === "claude.exe";
 }
 function resolveOwnInstallDirs(paths, ownExecutablePath) {
-  const dirs = [import_node_path17.default.dirname(ownExecutablePath)];
+  const dirs = [import_node_path18.default.dirname(ownExecutablePath)];
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
   if (state !== void 0) {
-    dirs.push(import_node_path17.default.dirname(state.targetPath));
+    dirs.push(import_node_path18.default.dirname(state.targetPath));
   }
   return dirs;
 }
 function resolveClaudeTargetPath(ownExecutablePath, dir) {
-  return import_node_path17.default.join(dir ?? import_node_path17.default.dirname(ownExecutablePath), claudeTargetFilename(ownExecutablePath));
+  return import_node_path18.default.join(dir ?? import_node_path18.default.dirname(ownExecutablePath), claudeTargetFilename(ownExecutablePath));
 }
 function isEnoent3(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
@@ -241032,13 +241100,13 @@ function enableClaudeShim(params, linkFs = nodeLinkFs) {
     throw new UnsupportedShimSourceError(realContentPath);
   }
   const targetPath = resolveClaudeTargetPath(params.ownExecutablePath, params.dir);
-  import_node_fs7.default.mkdirSync(import_node_path17.default.dirname(targetPath), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path18.default.dirname(targetPath), { recursive: true });
   const existing = lstatOrUndefined(targetPath);
   if (existing !== void 0) {
     const ownStat = import_node_fs7.default.statSync(realContentPath);
     const state = readJson(params.paths.claudeShimFile, ClaudeShimStateSchema);
     const sameInode = existing.dev === ownStat.dev && existing.ino === ownStat.ino;
-    const markerMatches = state !== void 0 && import_node_path17.default.resolve(state.targetPath) === targetPath;
+    const markerMatches = state !== void 0 && import_node_path18.default.resolve(state.targetPath) === targetPath;
     if (!sameInode && !markerMatches && !params.force) {
       throw new ForeignClaudeEntryError(targetPath, "enable");
     }
@@ -241063,7 +241131,7 @@ function enableClaudeShim(params, linkFs = nodeLinkFs) {
 function disableClaudeShim(params) {
   const realContentPath = import_node_fs7.default.realpathSync(params.contentSourcePath);
   const state = readJson(params.paths.claudeShimFile, ClaudeShimStateSchema);
-  const targetPath = params.dir !== void 0 ? import_node_path17.default.join(params.dir, claudeTargetFilename(params.ownExecutablePath)) : state?.targetPath ?? resolveClaudeTargetPath(params.ownExecutablePath);
+  const targetPath = params.dir !== void 0 ? import_node_path18.default.join(params.dir, claudeTargetFilename(params.ownExecutablePath)) : state?.targetPath ?? resolveClaudeTargetPath(params.ownExecutablePath);
   const existing = lstatOrUndefined(targetPath);
   if (existing === void 0) {
     if (state !== void 0) {
@@ -241073,7 +241141,7 @@ function disableClaudeShim(params) {
   }
   const ownStat = import_node_fs7.default.statSync(realContentPath);
   const sameInode = existing.dev === ownStat.dev && existing.ino === ownStat.ino;
-  const markerMatches = state !== void 0 && import_node_path17.default.resolve(state.targetPath) === targetPath;
+  const markerMatches = state !== void 0 && import_node_path18.default.resolve(state.targetPath) === targetPath;
   if (!sameInode && !markerMatches && !params.force) {
     throw new ForeignClaudeEntryError(targetPath, "disable");
   }
@@ -241082,15 +241150,15 @@ function disableClaudeShim(params) {
   return { action: "disabled", targetPath };
 }
 function findPathShadow(params) {
-  const resolvedTargetDir = import_node_path17.default.resolve(params.targetDir);
+  const resolvedTargetDir = import_node_path18.default.resolve(params.targetDir);
   for (const dir of params.pathDirs) {
     const found = params.findExecutableInDir(dir, params.targetFilename);
     if (found === void 0) {
       continue;
     }
-    return import_node_path17.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return import_node_path18.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => import_node_path17.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => import_node_path18.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
 function registerShimCommand(program2, paths) {
   const shim = program2.command("shim").description(
@@ -241104,21 +241172,21 @@ function registerShimCommand(program2, paths) {
       ownExecutablePath,
       contentSourcePath,
       platform: process.platform,
-      ...options.dir === void 0 ? {} : { dir: import_node_path17.default.resolve(options.dir) },
+      ...options.dir === void 0 ? {} : { dir: import_node_path18.default.resolve(options.dir) },
       force: options.force ?? false
     });
     console.log(`${result.action === "enabled" ? "Installed" : "Reinstalled"} \`claude\` at ${result.targetPath} (${result.method}).`);
     const shadow = findPathShadow({
-      pathDirs: (process.env.PATH ?? "").split(import_node_path17.default.delimiter).filter((dir) => dir !== ""),
-      targetDir: import_node_path17.default.dirname(result.targetPath),
-      targetFilename: import_node_path17.default.basename(result.targetPath),
+      pathDirs: (process.env.PATH ?? "").split(import_node_path18.default.delimiter).filter((dir) => dir !== ""),
+      targetDir: import_node_path18.default.dirname(result.targetPath),
+      targetFilename: import_node_path18.default.basename(result.targetPath),
       findExecutableInDir
     });
     if (shadow.status === "not-on-path") {
-      console.warn(`warning: ${import_node_path17.default.dirname(result.targetPath)} is not on PATH \u2014 add it, or use \`claude-use run\` instead.`);
+      console.warn(`warning: ${import_node_path18.default.dirname(result.targetPath)} is not on PATH \u2014 add it, or use \`claude-use run\` instead.`);
     } else if (shadow.status === "shadowed") {
       console.warn(
-        `warning: 'claude' on PATH currently resolves to ${shadow.by}, not ${result.targetPath}. Put ${import_node_path17.default.dirname(result.targetPath)} ahead of it on PATH.`
+        `warning: 'claude' on PATH currently resolves to ${shadow.by}, not ${result.targetPath}. Put ${import_node_path18.default.dirname(result.targetPath)} ahead of it on PATH.`
       );
     }
   });
@@ -241129,7 +241197,7 @@ function registerShimCommand(program2, paths) {
       paths,
       ownExecutablePath,
       contentSourcePath,
-      ...options.dir === void 0 ? {} : { dir: import_node_path17.default.resolve(options.dir) },
+      ...options.dir === void 0 ? {} : { dir: import_node_path18.default.resolve(options.dir) },
       force: options.force ?? false
     });
     console.log(
@@ -241140,7 +241208,7 @@ function registerShimCommand(program2, paths) {
 
 // src/doctor.ts
 var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 function validateJson(schema, input) {
   if (input.raw === void 0) {
     return { ok: false, message: `${input.path} is missing.` };
@@ -241363,13 +241431,13 @@ function registerDoctorCommand(program2, paths) {
   ).action(() => {
     const identityNames = import_node_fs8.default.existsSync(paths.identitiesDir) ? import_node_fs8.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort() : [];
     const identities = identityNames.map((name) => {
-      const farmRoot = import_node_path18.default.join(paths.identitiesDir, name);
-      const identityPath = import_node_path18.default.join(farmRoot, "identity.json");
+      const farmRoot = import_node_path19.default.join(paths.identitiesDir, name);
+      const identityPath = import_node_path19.default.join(farmRoot, "identity.json");
       return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot };
     });
     const profileNames = import_node_fs8.default.existsSync(paths.configProfilesDir) ? import_node_fs8.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
     const configProfiles = profileNames.map((name) => {
-      const profilePath = import_node_path18.default.join(paths.configProfilesDir, `${name}.json`);
+      const profilePath = import_node_path19.default.join(paths.configProfilesDir, `${name}.json`);
       return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
     });
     const ownExecutablePath = realOwnExecutablePath();
@@ -241513,13 +241581,13 @@ function buildCliOverride(params) {
     entryPairs = { ...entryPairs, ...parseBoolPairList(params.env.CLAUDE_USE_ENTRY_OVERRIDE) };
   }
   for (const flagValue of params.shareFlags) {
-    for (const path21 of splitTopLevelCommas(flagValue)) {
-      entryPairs[path21] = true;
+    for (const path22 of splitTopLevelCommas(flagValue)) {
+      entryPairs[path22] = true;
     }
   }
   for (const flagValue of params.hideFlags) {
-    for (const path21 of splitTopLevelCommas(flagValue)) {
-      entryPairs[path21] = false;
+    for (const path22 of splitTopLevelCommas(flagValue)) {
+      entryPairs[path22] = false;
     }
   }
   const hasCategories = Object.keys(categoryPairs).length > 0;
@@ -241534,7 +241602,7 @@ function buildCliOverride(params) {
 }
 
 // src/launcher/flags.ts
-var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
 function isEnvFlagSet(value) {
   return value === "1";
 }
@@ -241563,7 +241631,7 @@ function buildEnv(params) {
   }
   return {
     ...params.baseEnv,
-    CLAUDE_CONFIG_DIR: import_node_path19.default.join(params.identitiesDir, params.resolvedIdentityName)
+    CLAUDE_CONFIG_DIR: import_node_path20.default.join(params.identitiesDir, params.resolvedIdentityName)
   };
 }
 
@@ -241643,7 +241711,7 @@ function runLauncher(params) {
       }
       throw error51;
     }
-    for (const diagnostic of recoveryDiagnostics(recovery)) {
+    for (const diagnostic of recoveryDiagnostics(recovery, farmIdentity)) {
       log.warn(`claude-use: ${diagnostic.code}: ${diagnostic.message}`);
     }
   }
@@ -241806,7 +241874,7 @@ function runClaude(argvOverride) {
   });
 }
 function main() {
-  const invokedName = import_node_path20.default.basename(process.argv[1] ?? "claude-use");
+  const invokedName = import_node_path21.default.basename(process.argv[1] ?? "claude-use");
   if (isInvokedAsClaude(invokedName)) {
     runClaude();
   } else if (!tryRunAtIdentityShortcut(resolveLayoutPaths(), process.argv.slice(2))) {