prisma-to-zod-v4 0.5.8 → 0.6.0

package/dist/index.js

@@ -174,16 +174,16 @@ var require_util = __commonJS({
     }
     exports2.urlGenerate = urlGenerate;
     function normalize(aPath) {
-      var path2 = aPath;
+      var path3 = aPath;
       var url = urlParse(aPath);
       if (url) {
         if (!url.path) {
           return aPath;
         }
-        path2 = url.path;
+        path3 = url.path;
       }
-      var isAbsolute = exports2.isAbsolute(path2);
-      var parts = path2.split(/\/+/);
+      var isAbsolute = exports2.isAbsolute(path3);
+      var parts = path3.split(/\/+/);
       for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
         part = parts[i];
         if (part === ".") {
@@ -200,15 +200,15 @@ var require_util = __commonJS({
           }
         }
       }
-      path2 = parts.join("/");
-      if (path2 === "") {
-        path2 = isAbsolute ? "/" : ".";
+      path3 = parts.join("/");
+      if (path3 === "") {
+        path3 = isAbsolute ? "/" : ".";
       }
       if (url) {
-        url.path = path2;
+        url.path = path3;
         return urlGenerate(url);
       }
-      return path2;
+      return path3;
     }
     exports2.normalize = normalize;
     function join(aRoot, aPath) {
@@ -1838,7 +1838,7 @@ var require_source_map_support = __commonJS({
   "node_modules/source-map-support/source-map-support.js"(exports2, module2) {
     "use strict";
     var SourceMapConsumer = require_source_map().SourceMapConsumer;
-    var path2 = require("path");
+    var path3 = require("path");
     var fs;
     try {
       fs = require("fs");
@@ -1899,18 +1899,18 @@ var require_source_map_support = __commonJS({
       };
     }
     var retrieveFile = handlerExec(retrieveFileHandlers);
-    retrieveFileHandlers.push(function(path3) {
-      path3 = path3.trim();
-      if (/^file:/.test(path3)) {
-        path3 = path3.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
+    retrieveFileHandlers.push(function(path4) {
+      path4 = path4.trim();
+      if (/^file:/.test(path4)) {
+        path4 = path4.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
           return drive ? "" : (
             // file:///C:/dir/file -> C:/dir/file
             "/"
           );
         });
       }
-      if (path3 in fileContentsCache) {
-        return fileContentsCache[path3];
+      if (path4 in fileContentsCache) {
+        return fileContentsCache[path4];
       }
       var contents = "";
       try {
@@ -1918,7 +1918,7 @@ var require_source_map_support = __commonJS({
           var xhr = new XMLHttpRequest();
           xhr.open(
             "GET",
-            path3,
+            path4,
             /** async */
             false
           );
@@ -1926,24 +1926,24 @@ var require_source_map_support = __commonJS({
           if (xhr.readyState === 4 && xhr.status === 200) {
             contents = xhr.responseText;
           }
-        } else if (fs.existsSync(path3)) {
-          contents = fs.readFileSync(path3, "utf8");
+        } else if (fs.existsSync(path4)) {
+          contents = fs.readFileSync(path4, "utf8");
         }
       } catch (er) {
       }
-      return fileContentsCache[path3] = contents;
+      return fileContentsCache[path4] = contents;
     });
     function supportRelativeURL(file, url) {
       if (!file) return url;
-      var dir = path2.dirname(file);
+      var dir = path3.dirname(file);
       var match = /^\w+:\/\/[^\/]*/.exec(dir);
       var protocol = match ? match[0] : "";
       var startPath = dir.slice(protocol.length);
       if (protocol && /^\/\w\:/.test(startPath)) {
         protocol += "/";
-        return protocol + path2.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
+        return protocol + path3.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
       }
-      return protocol + path2.resolve(dir.slice(protocol.length), url);
+      return protocol + path3.resolve(dir.slice(protocol.length), url);
     }
     function retrieveSourceMapURL(source) {
       var fileData;
@@ -10179,17 +10179,17 @@ ${lanes.join("\n")}
       }
       function createSingleWatcherPerName(cache, useCaseSensitiveFileNames2, name, callback, createWatcher) {
         const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
-        const path2 = toCanonicalFileName(name);
-        const existing = cache.get(path2);
+        const path3 = toCanonicalFileName(name);
+        const existing = cache.get(path3);
         if (existing) {
           existing.callbacks.push(callback);
         } else {
-          cache.set(path2, {
+          cache.set(path3, {
             watcher: createWatcher(
               // Cant infer types correctly so lets satisfy checker
               (param1, param2, param3) => {
                 var _a;
-                return (_a = cache.get(path2)) == null ? void 0 : _a.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
+                return (_a = cache.get(path3)) == null ? void 0 : _a.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
               }
             ),
             callbacks: [callback]
@@ -10197,10 +10197,10 @@ ${lanes.join("\n")}
         }
         return {
           close: () => {
-            const watcher = cache.get(path2);
+            const watcher = cache.get(path3);
             if (!watcher) return;
             if (!orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length) return;
-            cache.delete(path2);
+            cache.delete(path3);
             closeFileWatcherOf(watcher);
           }
         };
@@ -10452,13 +10452,13 @@ ${lanes.join("\n")}
             (newChildWatches || (newChildWatches = [])).push(childWatcher);
           }
         }
-        function isIgnoredPath(path2, options) {
-          return some(ignoredPaths, (searchPath) => isInPath(path2, searchPath)) || isIgnoredByWatchOptions(path2, options, useCaseSensitiveFileNames2, getCurrentDirectory);
+        function isIgnoredPath(path3, options) {
+          return some(ignoredPaths, (searchPath) => isInPath(path3, searchPath)) || isIgnoredByWatchOptions(path3, options, useCaseSensitiveFileNames2, getCurrentDirectory);
         }
-        function isInPath(path2, searchPath) {
-          if (path2.includes(searchPath)) return true;
+        function isInPath(path3, searchPath) {
+          if (path3.includes(searchPath)) return true;
           if (useCaseSensitiveFileNames2) return false;
-          return toCanonicalFilePath(path2).includes(searchPath);
+          return toCanonicalFilePath(path3).includes(searchPath);
         }
       }
       var FileSystemEntryKind = /* @__PURE__ */ ((FileSystemEntryKind2) => {
@@ -10836,8 +10836,8 @@ ${lanes.join("\n")}
       }
       function patchWriteFileEnsuringDirectory(sys2) {
         const originalWriteFile = sys2.writeFile;
-        sys2.writeFile = (path2, data, writeBom) => writeFileEnsuringDirectories(
-          path2,
+        sys2.writeFile = (path3, data, writeBom) => writeFileEnsuringDirectories(
+          path3,
           data,
           !!writeBom,
           (path22, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path22, data2, writeByteOrderMark),
@@ -10881,7 +10881,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: (path2) => getAccessibleFileSystemEntries(path2).directories,
+            getAccessibleSortedChildDirectories: (path3) => getAccessibleFileSystemEntries(path3).directories,
             realpath,
             tscWatchFile: process.env.TSC_WATCHFILE,
             useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER,
@@ -10908,7 +10908,7 @@ ${lanes.join("\n")}
             watchFile: watchFile2,
             watchDirectory,
             preferNonRecursiveWatch: !fsSupportsRecursiveFsWatch,
-            resolvePath: (path2) => _path.resolve(path2),
+            resolvePath: (path3) => _path.resolve(path3),
             fileExists,
             directoryExists,
             getAccessibleFileSystemEntries,
@@ -10943,8 +10943,8 @@ ${lanes.join("\n")}
               }
               return process.memoryUsage().heapUsed;
             },
-            getFileSize(path2) {
-              const stat = statSync(path2);
+            getFileSize(path3) {
+              const stat = statSync2(path3);
               if (stat == null ? void 0 : stat.isFile()) {
                 return stat.size;
               }
@@ -10988,14 +10988,14 @@ ${lanes.join("\n")}
             }
           };
           return nodeSystem;
-          function statSync(path2) {
+          function statSync2(path3) {
             try {
-              return _fs.statSync(path2, statSyncOptions);
+              return _fs.statSync(path3, statSyncOptions);
             } catch {
               return void 0;
             }
           }
-          function enableCPUProfiler(path2, cb) {
+          function enableCPUProfiler(path3, cb) {
             if (activeSession) {
               cb();
               return false;
@@ -11010,7 +11010,7 @@ ${lanes.join("\n")}
             session.post("Profiler.enable", () => {
               session.post("Profiler.start", () => {
                 activeSession = session;
-                profilePath = path2;
+                profilePath = path3;
                 cb();
               });
             });
@@ -11047,7 +11047,7 @@ ${lanes.join("\n")}
               activeSession.post("Profiler.stop", (err, { profile }) => {
                 var _a;
                 if (!err) {
-                  if ((_a = statSync(profilePath)) == null ? void 0 : _a.isDirectory()) {
+                  if ((_a = statSync2(profilePath)) == null ? void 0 : _a.isDirectory()) {
                     profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                   }
                   try {
@@ -11154,9 +11154,9 @@ ${lanes.join("\n")}
               }
             }
           }
-          function getAccessibleFileSystemEntries(path2) {
+          function getAccessibleFileSystemEntries(path3) {
             try {
-              const entries = _fs.readdirSync(path2 || ".", { withFileTypes: true });
+              const entries = _fs.readdirSync(path3 || ".", { withFileTypes: true });
               const files = [];
               const directories = [];
               for (const dirent of entries) {
@@ -11166,8 +11166,8 @@ ${lanes.join("\n")}
                 }
                 let stat;
                 if (typeof dirent === "string" || dirent.isSymbolicLink()) {
-                  const name = combinePaths(path2, entry);
-                  stat = statSync(name);
+                  const name = combinePaths(path3, entry);
+                  stat = statSync2(name);
                   if (!stat) {
                     continue;
                   }
@@ -11187,11 +11187,11 @@ ${lanes.join("\n")}
               return emptyFileSystemEntries;
             }
           }
-          function readDirectory(path2, extensions, excludes, includes, depth) {
-            return matchFiles(path2, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
+          function readDirectory(path3, extensions, excludes, includes, depth) {
+            return matchFiles(path3, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
-          function fileSystemEntryExists(path2, entryKind) {
-            const stat = statSync(path2);
+          function fileSystemEntryExists(path3, entryKind) {
+            const stat = statSync2(path3);
             if (!stat) {
               return false;
             }
@@ -11204,47 +11204,47 @@ ${lanes.join("\n")}
                 return false;
             }
           }
-          function fileExists(path2) {
+          function fileExists(path3) {
             return fileSystemEntryExists(
-              path2,
+              path3,
               0
               /* File */
             );
           }
-          function directoryExists(path2) {
+          function directoryExists(path3) {
             return fileSystemEntryExists(
-              path2,
+              path3,
               1
               /* Directory */
             );
           }
-          function getDirectories(path2) {
-            return getAccessibleFileSystemEntries(path2).directories.slice();
+          function getDirectories(path3) {
+            return getAccessibleFileSystemEntries(path3).directories.slice();
           }
-          function fsRealPathHandlingLongPath(path2) {
-            return path2.length < 260 ? _fs.realpathSync.native(path2) : _fs.realpathSync(path2);
+          function fsRealPathHandlingLongPath(path3) {
+            return path3.length < 260 ? _fs.realpathSync.native(path3) : _fs.realpathSync(path3);
           }
-          function realpath(path2) {
+          function realpath(path3) {
             try {
-              return fsRealpath(path2);
+              return fsRealpath(path3);
             } catch {
-              return path2;
+              return path3;
             }
           }
-          function getModifiedTime3(path2) {
+          function getModifiedTime3(path3) {
             var _a;
-            return (_a = statSync(path2)) == null ? void 0 : _a.mtime;
+            return (_a = statSync2(path3)) == null ? void 0 : _a.mtime;
           }
-          function setModifiedTime(path2, time) {
+          function setModifiedTime(path3, time) {
             try {
-              _fs.utimesSync(path2, time, time);
+              _fs.utimesSync(path3, time, time);
             } catch {
               return;
             }
           }
-          function deleteFile(path2) {
+          function deleteFile(path3) {
             try {
-              return _fs.unlinkSync(path2);
+              return _fs.unlinkSync(path3);
             } catch {
               return;
             }
@@ -11284,41 +11284,41 @@ ${lanes.join("\n")}
       function isAnyDirectorySeparator(charCode) {
         return charCode === 47 || charCode === 92;
       }
-      function isUrl(path2) {
-        return getEncodedRootLength(path2) < 0;
+      function isUrl(path3) {
+        return getEncodedRootLength(path3) < 0;
       }
-      function isRootedDiskPath(path2) {
-        return getEncodedRootLength(path2) > 0;
+      function isRootedDiskPath(path3) {
+        return getEncodedRootLength(path3) > 0;
       }
-      function isDiskPathRoot(path2) {
-        const rootLength = getEncodedRootLength(path2);
-        return rootLength > 0 && rootLength === path2.length;
+      function isDiskPathRoot(path3) {
+        const rootLength = getEncodedRootLength(path3);
+        return rootLength > 0 && rootLength === path3.length;
       }
-      function pathIsAbsolute(path2) {
-        return getEncodedRootLength(path2) !== 0;
+      function pathIsAbsolute(path3) {
+        return getEncodedRootLength(path3) !== 0;
       }
-      function pathIsRelative(path2) {
-        return /^\.\.?(?:$|[\\/])/.test(path2);
+      function pathIsRelative(path3) {
+        return /^\.\.?(?:$|[\\/])/.test(path3);
       }
-      function pathIsBareSpecifier(path2) {
-        return !pathIsAbsolute(path2) && !pathIsRelative(path2);
+      function pathIsBareSpecifier(path3) {
+        return !pathIsAbsolute(path3) && !pathIsRelative(path3);
       }
       function hasExtension(fileName) {
         return getBaseFileName(fileName).includes(".");
       }
-      function fileExtensionIs(path2, extension) {
-        return path2.length > extension.length && endsWith(path2, extension);
+      function fileExtensionIs(path3, extension) {
+        return path3.length > extension.length && endsWith(path3, extension);
       }
-      function fileExtensionIsOneOf(path2, extensions) {
+      function fileExtensionIsOneOf(path3, extensions) {
         for (const extension of extensions) {
-          if (fileExtensionIs(path2, extension)) {
+          if (fileExtensionIs(path3, extension)) {
             return true;
           }
         }
         return false;
       }
-      function hasTrailingDirectorySeparator(path2) {
-        return path2.length > 0 && isAnyDirectorySeparator(path2.charCodeAt(path2.length - 1));
+      function hasTrailingDirectorySeparator(path3) {
+        return path3.length > 0 && isAnyDirectorySeparator(path3.charCodeAt(path3.length - 1));
       }
       function isVolumeCharacter(charCode) {
         return charCode >= 97 && charCode <= 122 || charCode >= 65 && charCode <= 90;
@@ -11332,111 +11332,111 @@ ${lanes.join("\n")}
         }
         return -1;
       }
-      function getEncodedRootLength(path2) {
-        if (!path2) return 0;
-        const ch0 = path2.charCodeAt(0);
+      function getEncodedRootLength(path3) {
+        if (!path3) return 0;
+        const ch0 = path3.charCodeAt(0);
         if (ch0 === 47 || ch0 === 92) {
-          if (path2.charCodeAt(1) !== ch0) return 1;
-          const p1 = path2.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
-          if (p1 < 0) return path2.length;
+          if (path3.charCodeAt(1) !== ch0) return 1;
+          const p1 = path3.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
+          if (p1 < 0) return path3.length;
           return p1 + 1;
         }
-        if (isVolumeCharacter(ch0) && path2.charCodeAt(1) === 58) {
-          const ch2 = path2.charCodeAt(2);
+        if (isVolumeCharacter(ch0) && path3.charCodeAt(1) === 58) {
+          const ch2 = path3.charCodeAt(2);
           if (ch2 === 47 || ch2 === 92) return 3;
-          if (path2.length === 2) return 2;
+          if (path3.length === 2) return 2;
         }
-        const schemeEnd = path2.indexOf(urlSchemeSeparator);
+        const schemeEnd = path3.indexOf(urlSchemeSeparator);
         if (schemeEnd !== -1) {
           const authorityStart = schemeEnd + urlSchemeSeparator.length;
-          const authorityEnd = path2.indexOf(directorySeparator, authorityStart);
+          const authorityEnd = path3.indexOf(directorySeparator, authorityStart);
           if (authorityEnd !== -1) {
-            const scheme = path2.slice(0, schemeEnd);
-            const authority = path2.slice(authorityStart, authorityEnd);
-            if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path2.charCodeAt(authorityEnd + 1))) {
-              const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path2, authorityEnd + 2);
+            const scheme = path3.slice(0, schemeEnd);
+            const authority = path3.slice(authorityStart, authorityEnd);
+            if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path3.charCodeAt(authorityEnd + 1))) {
+              const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path3, authorityEnd + 2);
               if (volumeSeparatorEnd !== -1) {
-                if (path2.charCodeAt(volumeSeparatorEnd) === 47) {
+                if (path3.charCodeAt(volumeSeparatorEnd) === 47) {
                   return ~(volumeSeparatorEnd + 1);
                 }
-                if (volumeSeparatorEnd === path2.length) {
+                if (volumeSeparatorEnd === path3.length) {
                   return ~volumeSeparatorEnd;
                 }
               }
             }
             return ~(authorityEnd + 1);
           }
-          return ~path2.length;
+          return ~path3.length;
         }
         return 0;
       }
-      function getRootLength(path2) {
-        const rootLength = getEncodedRootLength(path2);
+      function getRootLength(path3) {
+        const rootLength = getEncodedRootLength(path3);
         return rootLength < 0 ? ~rootLength : rootLength;
       }
-      function getDirectoryPath(path2) {
-        path2 = normalizeSlashes(path2);
-        const rootLength = getRootLength(path2);
-        if (rootLength === path2.length) return path2;
-        path2 = removeTrailingDirectorySeparator(path2);
-        return path2.slice(0, Math.max(rootLength, path2.lastIndexOf(directorySeparator)));
-      }
-      function getBaseFileName(path2, extensions, ignoreCase) {
-        path2 = normalizeSlashes(path2);
-        const rootLength = getRootLength(path2);
-        if (rootLength === path2.length) return "";
-        path2 = removeTrailingDirectorySeparator(path2);
-        const name = path2.slice(Math.max(getRootLength(path2), path2.lastIndexOf(directorySeparator) + 1));
+      function getDirectoryPath(path3) {
+        path3 = normalizeSlashes(path3);
+        const rootLength = getRootLength(path3);
+        if (rootLength === path3.length) return path3;
+        path3 = removeTrailingDirectorySeparator(path3);
+        return path3.slice(0, Math.max(rootLength, path3.lastIndexOf(directorySeparator)));
+      }
+      function getBaseFileName(path3, extensions, ignoreCase) {
+        path3 = normalizeSlashes(path3);
+        const rootLength = getRootLength(path3);
+        if (rootLength === path3.length) return "";
+        path3 = removeTrailingDirectorySeparator(path3);
+        const name = path3.slice(Math.max(getRootLength(path3), path3.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(path2, extension, stringEqualityComparer) {
+      function tryGetExtensionFromPath(path3, extension, stringEqualityComparer) {
         if (!startsWith(extension, ".")) extension = "." + extension;
-        if (path2.length >= extension.length && path2.charCodeAt(path2.length - extension.length) === 46) {
-          const pathExtension = path2.slice(path2.length - extension.length);
+        if (path3.length >= extension.length && path3.charCodeAt(path3.length - extension.length) === 46) {
+          const pathExtension = path3.slice(path3.length - extension.length);
           if (stringEqualityComparer(pathExtension, extension)) {
             return pathExtension;
           }
         }
       }
-      function getAnyExtensionFromPathWorker(path2, extensions, stringEqualityComparer) {
+      function getAnyExtensionFromPathWorker(path3, extensions, stringEqualityComparer) {
         if (typeof extensions === "string") {
-          return tryGetExtensionFromPath(path2, extensions, stringEqualityComparer) || "";
+          return tryGetExtensionFromPath(path3, extensions, stringEqualityComparer) || "";
         }
         for (const extension of extensions) {
-          const result = tryGetExtensionFromPath(path2, extension, stringEqualityComparer);
+          const result = tryGetExtensionFromPath(path3, extension, stringEqualityComparer);
           if (result) return result;
         }
         return "";
       }
-      function getAnyExtensionFromPath(path2, extensions, ignoreCase) {
+      function getAnyExtensionFromPath(path3, extensions, ignoreCase) {
         if (extensions) {
-          return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path2), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
+          return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path3), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
         }
-        const baseFileName = getBaseFileName(path2);
+        const baseFileName = getBaseFileName(path3);
         const extensionIndex = baseFileName.lastIndexOf(".");
         if (extensionIndex >= 0) {
           return baseFileName.substring(extensionIndex);
         }
         return "";
       }
-      function pathComponents(path2, rootLength) {
-        const root = path2.substring(0, rootLength);
-        const rest = path2.substring(rootLength).split(directorySeparator);
+      function pathComponents(path3, rootLength) {
+        const root = path3.substring(0, rootLength);
+        const rest = path3.substring(rootLength).split(directorySeparator);
         if (rest.length && !lastOrUndefined(rest)) rest.pop();
         return [root, ...rest];
       }
-      function getPathComponents(path2, currentDirectory = "") {
-        path2 = combinePaths(currentDirectory, path2);
-        return pathComponents(path2, getRootLength(path2));
+      function getPathComponents(path3, currentDirectory = "") {
+        path3 = combinePaths(currentDirectory, path3);
+        return pathComponents(path3, getRootLength(path3));
       }
       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(path2) {
-        return path2.includes("\\") ? path2.replace(backslashRegExp, directorySeparator) : path2;
+      function normalizeSlashes(path3) {
+        return path3.includes("\\") ? path3.replace(backslashRegExp, directorySeparator) : path3;
       }
       function reducePathComponents(components) {
         if (!some(components)) return [];
@@ -11457,39 +11457,39 @@ ${lanes.join("\n")}
         }
         return reduced;
       }
-      function combinePaths(path2, ...paths) {
-        if (path2) path2 = normalizeSlashes(path2);
+      function combinePaths(path3, ...paths) {
+        if (path3) path3 = normalizeSlashes(path3);
         for (let relativePath of paths) {
           if (!relativePath) continue;
           relativePath = normalizeSlashes(relativePath);
-          if (!path2 || getRootLength(relativePath) !== 0) {
-            path2 = relativePath;
+          if (!path3 || getRootLength(relativePath) !== 0) {
+            path3 = relativePath;
           } else {
-            path2 = ensureTrailingDirectorySeparator(path2) + relativePath;
+            path3 = ensureTrailingDirectorySeparator(path3) + relativePath;
           }
         }
-        return path2;
+        return path3;
       }
-      function resolvePath(path2, ...paths) {
-        return normalizePath(some(paths) ? combinePaths(path2, ...paths) : normalizeSlashes(path2));
+      function resolvePath(path3, ...paths) {
+        return normalizePath(some(paths) ? combinePaths(path3, ...paths) : normalizeSlashes(path3));
       }
-      function getNormalizedPathComponents(path2, currentDirectory) {
-        return reducePathComponents(getPathComponents(path2, currentDirectory));
+      function getNormalizedPathComponents(path3, currentDirectory) {
+        return reducePathComponents(getPathComponents(path3, currentDirectory));
       }
-      function getNormalizedAbsolutePath(path2, currentDirectory) {
-        let rootLength = getRootLength(path2);
+      function getNormalizedAbsolutePath(path3, currentDirectory) {
+        let rootLength = getRootLength(path3);
         if (rootLength === 0 && currentDirectory) {
-          path2 = combinePaths(currentDirectory, path2);
-          rootLength = getRootLength(path2);
+          path3 = combinePaths(currentDirectory, path3);
+          rootLength = getRootLength(path3);
         } else {
-          path2 = normalizeSlashes(path2);
+          path3 = normalizeSlashes(path3);
         }
-        const simpleNormalized = simpleNormalizePath(path2);
+        const simpleNormalized = simpleNormalizePath(path3);
         if (simpleNormalized !== void 0) {
           return simpleNormalized.length > rootLength ? removeTrailingDirectorySeparator(simpleNormalized) : simpleNormalized;
         }
-        const length2 = path2.length;
-        const root = path2.substring(0, rootLength);
+        const length2 = path3.length;
+        const root = path3.substring(0, rootLength);
         let normalized;
         let index = rootLength;
         let segmentStart = index;
@@ -11497,23 +11497,23 @@ ${lanes.join("\n")}
         let seenNonDotDotSegment = rootLength !== 0;
         while (index < length2) {
           segmentStart = index;
-          let ch = path2.charCodeAt(index);
+          let ch = path3.charCodeAt(index);
           while (ch === 47 && index + 1 < length2) {
             index++;
-            ch = path2.charCodeAt(index);
+            ch = path3.charCodeAt(index);
           }
           if (index > segmentStart) {
-            normalized ?? (normalized = path2.substring(0, segmentStart - 1));
+            normalized ?? (normalized = path3.substring(0, segmentStart - 1));
             segmentStart = index;
           }
-          let segmentEnd = path2.indexOf(directorySeparator, index + 1);
+          let segmentEnd = path3.indexOf(directorySeparator, index + 1);
           if (segmentEnd === -1) {
             segmentEnd = length2;
           }
           const segmentLength = segmentEnd - segmentStart;
-          if (segmentLength === 1 && path2.charCodeAt(index) === 46) {
-            normalized ?? (normalized = path2.substring(0, normalizedUpTo));
-          } else if (segmentLength === 2 && path2.charCodeAt(index) === 46 && path2.charCodeAt(index + 1) === 46) {
+          if (segmentLength === 1 && path3.charCodeAt(index) === 46) {
+            normalized ?? (normalized = path3.substring(0, normalizedUpTo));
+          } else if (segmentLength === 2 && path3.charCodeAt(index) === 46 && path3.charCodeAt(index + 1) === 46) {
             if (!seenNonDotDotSegment) {
               if (normalized !== void 0) {
                 normalized += normalized.length === rootLength ? ".." : "/..";
@@ -11522,9 +11522,9 @@ ${lanes.join("\n")}
               }
             } else if (normalized === void 0) {
               if (normalizedUpTo - 2 >= 0) {
-                normalized = path2.substring(0, Math.max(rootLength, path2.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
+                normalized = path3.substring(0, Math.max(rootLength, path3.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
               } else {
-                normalized = path2.substring(0, normalizedUpTo);
+                normalized = path3.substring(0, normalizedUpTo);
               }
             } else {
               const lastSlash = normalized.lastIndexOf(directorySeparator);
@@ -11542,36 +11542,36 @@ ${lanes.join("\n")}
               normalized += directorySeparator;
             }
             seenNonDotDotSegment = true;
-            normalized += path2.substring(segmentStart, segmentEnd);
+            normalized += path3.substring(segmentStart, segmentEnd);
           } else {
             seenNonDotDotSegment = true;
             normalizedUpTo = segmentEnd;
           }
           index = segmentEnd + 1;
         }
-        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path2) : path2);
+        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path3) : path3);
       }
-      function normalizePath(path2) {
-        path2 = normalizeSlashes(path2);
-        let normalized = simpleNormalizePath(path2);
+      function normalizePath(path3) {
+        path3 = normalizeSlashes(path3);
+        let normalized = simpleNormalizePath(path3);
         if (normalized !== void 0) {
           return normalized;
         }
-        normalized = getNormalizedAbsolutePath(path2, "");
-        return normalized && hasTrailingDirectorySeparator(path2) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+        normalized = getNormalizedAbsolutePath(path3, "");
+        return normalized && hasTrailingDirectorySeparator(path3) ? ensureTrailingDirectorySeparator(normalized) : normalized;
       }
-      function simpleNormalizePath(path2) {
-        if (!relativePathSegmentRegExp.test(path2)) {
-          return path2;
+      function simpleNormalizePath(path3) {
+        if (!relativePathSegmentRegExp.test(path3)) {
+          return path3;
         }
-        let simplified = path2.replace(/\/\.\//g, "/");
+        let simplified = path3.replace(/\/\.\//g, "/");
         if (simplified.startsWith("./")) {
           simplified = simplified.slice(2);
         }
-        if (simplified !== path2) {
-          path2 = simplified;
-          if (!relativePathSegmentRegExp.test(path2)) {
-            return path2;
+        if (simplified !== path3) {
+          path3 = simplified;
+          if (!relativePathSegmentRegExp.test(path3)) {
+            return path3;
           }
         }
         return void 0;
@@ -11587,31 +11587,31 @@ ${lanes.join("\n")}
         const nonCanonicalizedPath = isRootedDiskPath(fileName) ? normalizePath(fileName) : getNormalizedAbsolutePath(fileName, basePath);
         return getCanonicalFileName(nonCanonicalizedPath);
       }
-      function removeTrailingDirectorySeparator(path2) {
-        if (hasTrailingDirectorySeparator(path2)) {
-          return path2.substr(0, path2.length - 1);
+      function removeTrailingDirectorySeparator(path3) {
+        if (hasTrailingDirectorySeparator(path3)) {
+          return path3.substr(0, path3.length - 1);
         }
-        return path2;
+        return path3;
       }
-      function ensureTrailingDirectorySeparator(path2) {
-        if (!hasTrailingDirectorySeparator(path2)) {
-          return path2 + directorySeparator;
+      function ensureTrailingDirectorySeparator(path3) {
+        if (!hasTrailingDirectorySeparator(path3)) {
+          return path3 + directorySeparator;
         }
-        return path2;
+        return path3;
       }
-      function ensurePathIsNonModuleName(path2) {
-        return !pathIsAbsolute(path2) && !pathIsRelative(path2) ? "./" + path2 : path2;
+      function ensurePathIsNonModuleName(path3) {
+        return !pathIsAbsolute(path3) && !pathIsRelative(path3) ? "./" + path3 : path3;
       }
-      function changeAnyExtension(path2, ext, extensions, ignoreCase) {
-        const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path2, extensions, ignoreCase) : getAnyExtensionFromPath(path2);
-        return pathext ? path2.slice(0, path2.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path2;
+      function changeAnyExtension(path3, ext, extensions, ignoreCase) {
+        const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path3, extensions, ignoreCase) : getAnyExtensionFromPath(path3);
+        return pathext ? path3.slice(0, path3.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path3;
       }
-      function changeFullExtension(path2, newExtension) {
-        const declarationExtension = getDeclarationFileExtension(path2);
+      function changeFullExtension(path3, newExtension) {
+        const declarationExtension = getDeclarationFileExtension(path3);
         if (declarationExtension) {
-          return path2.slice(0, path2.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
+          return path3.slice(0, path3.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
         }
-        return changeAnyExtension(path2, newExtension);
+        return changeAnyExtension(path3, newExtension);
       }
       var relativePathSegmentRegExp = /\/\/|(?:^|\/)\.\.?(?:$|\/)/;
       function comparePathsWorker(a, b, componentComparer) {
@@ -23064,8 +23064,8 @@ ${lanes.join("\n")}
       function getResolvedExternalModuleName(host, file, referenceFile) {
         return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName);
       }
-      function getCanonicalAbsolutePath(host, path2) {
-        return host.getCanonicalFileName(getNormalizedAbsolutePath(path2, host.getCurrentDirectory()));
+      function getCanonicalAbsolutePath(host, path3) {
+        return host.getCanonicalFileName(getNormalizedAbsolutePath(path3, host.getCurrentDirectory()));
       }
       function getExternalModuleNameFromDeclaration(host, resolver, declaration) {
         const file = resolver.getExternalModuleFileFromDeclaration(declaration);
@@ -23108,20 +23108,20 @@ ${lanes.join("\n")}
       }
       function getDeclarationEmitOutputFilePathWorker(fileName, options, host) {
         const outputDir = options.declarationDir || options.outDir;
-        const path2 = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f)) : fileName;
-        const declarationExtension = getDeclarationEmitExtensionForPath(path2);
-        return removeFileExtension(path2) + declarationExtension;
+        const path3 = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f)) : fileName;
+        const declarationExtension = getDeclarationEmitExtensionForPath(path3);
+        return removeFileExtension(path3) + declarationExtension;
       }
-      function getDeclarationEmitExtensionForPath(path2) {
-        return fileExtensionIsOneOf(path2, [
+      function getDeclarationEmitExtensionForPath(path3) {
+        return fileExtensionIsOneOf(path3, [
           ".mjs",
           ".mts"
           /* Mts */
-        ]) ? ".d.mts" : fileExtensionIsOneOf(path2, [
+        ]) ? ".d.mts" : fileExtensionIsOneOf(path3, [
           ".cjs",
           ".cts"
           /* Cts */
-        ]) ? ".d.cts" : fileExtensionIsOneOf(path2, [
+        ]) ? ".d.cts" : fileExtensionIsOneOf(path3, [
           ".json"
           /* Json */
         ]) ? `.d.json.ts` : (
@@ -23129,8 +23129,8 @@ ${lanes.join("\n")}
           ".d.ts"
         );
       }
-      function getPossibleOriginalInputExtensionForExtension(path2) {
-        return fileExtensionIsOneOf(path2, [
+      function getPossibleOriginalInputExtensionForExtension(path3) {
+        return fileExtensionIsOneOf(path3, [
           ".d.mts",
           ".mjs",
           ".mts"
@@ -23139,7 +23139,7 @@ ${lanes.join("\n")}
           ".mts",
           ".mjs"
           /* Mjs */
-        ] : fileExtensionIsOneOf(path2, [
+        ] : fileExtensionIsOneOf(path3, [
           ".d.cts",
           ".cjs",
           ".cts"
@@ -23148,7 +23148,7 @@ ${lanes.join("\n")}
           ".cts",
           ".cjs"
           /* Cjs */
-        ] : fileExtensionIsOneOf(path2, [`.d.json.ts`]) ? [
+        ] : fileExtensionIsOneOf(path3, [`.d.json.ts`]) ? [
           ".json"
           /* Json */
         ] : [
@@ -23233,12 +23233,12 @@ ${lanes.join("\n")}
           createDirectory(directoryPath);
         }
       }
-      function writeFileEnsuringDirectories(path2, data, writeByteOrderMark, writeFile2, createDirectory, directoryExists) {
+      function writeFileEnsuringDirectories(path3, data, writeByteOrderMark, writeFile2, createDirectory, directoryExists) {
         try {
-          writeFile2(path2, data, writeByteOrderMark);
+          writeFile2(path3, data, writeByteOrderMark);
         } catch {
-          ensureDirectoriesExist(getDirectoryPath(normalizePath(path2)), createDirectory, directoryExists);
-          writeFile2(path2, data, writeByteOrderMark);
+          ensureDirectoriesExist(getDirectoryPath(normalizePath(path3)), createDirectory, directoryExists);
+          writeFile2(path3, data, writeByteOrderMark);
         }
       }
       function getLineOfLocalPosition(sourceFile, pos) {
@@ -23938,20 +23938,20 @@ ${lanes.join("\n")}
         }
         return getStringFromExpandedCharCodes(expandedCharCodes);
       }
-      function readJsonOrUndefined(path2, hostOrText) {
-        const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path2);
+      function readJsonOrUndefined(path3, hostOrText) {
+        const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path3);
         if (!jsonText) return void 0;
         let result = tryParseJson(jsonText);
         if (result === void 0) {
-          const looseResult = parseConfigFileTextToJson(path2, jsonText);
+          const looseResult = parseConfigFileTextToJson(path3, jsonText);
           if (!looseResult.error) {
             result = looseResult.config;
           }
         }
         return result;
       }
-      function readJson(path2, host) {
-        return readJsonOrUndefined(path2, host) || {};
+      function readJson(path3, host) {
+        return readJsonOrUndefined(path3, host) || {};
       }
       function tryParseJson(text) {
         try {
@@ -25101,7 +25101,7 @@ ${lanes.join("\n")}
           getSymlinkedFiles: () => symlinkedFiles,
           getSymlinkedDirectories: () => symlinkedDirectories,
           getSymlinkedDirectoriesByRealpath: () => symlinkedDirectoriesByRealpath,
-          setSymlinkedFile: (path2, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path2, real),
+          setSymlinkedFile: (path3, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path3, real),
           setSymlinkedDirectory: (symlink, real) => {
             let symlinkPath = toPath(symlink, cwd, getCanonicalFileName);
             if (!containsIgnoredPath(symlinkPath)) {
@@ -25161,8 +25161,8 @@ ${lanes.join("\n")}
       function stripLeadingDirectorySeparator(s) {
         return isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : void 0;
       }
-      function tryRemoveDirectoryPrefix(path2, dirPath, getCanonicalFileName) {
-        const withoutPrefix = tryRemovePrefix(path2, dirPath, getCanonicalFileName);
+      function tryRemoveDirectoryPrefix(path3, dirPath, getCanonicalFileName) {
+        const withoutPrefix = tryRemovePrefix(path3, dirPath, getCanonicalFileName);
         return withoutPrefix === void 0 ? void 0 : stripLeadingDirectorySeparator(withoutPrefix);
       }
       var reservedCharacterPattern = /[^\w\s/]/g;
@@ -25288,25 +25288,25 @@ ${lanes.join("\n")}
       function replaceWildcardCharacter(match, singleAsteriskRegexFragment) {
         return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match;
       }
-      function getFileMatcherPatterns(path2, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
-        path2 = normalizePath(path2);
+      function getFileMatcherPatterns(path3, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
+        path3 = normalizePath(path3);
         currentDirectory = normalizePath(currentDirectory);
-        const absolutePath = combinePaths(currentDirectory, path2);
+        const absolutePath = combinePaths(currentDirectory, path3);
         return {
           includeFilePatterns: map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), (pattern) => `^${pattern}$`),
           includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
           includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
           excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-          basePaths: getBasePaths(path2, includes, useCaseSensitiveFileNames2)
+          basePaths: getBasePaths(path3, includes, useCaseSensitiveFileNames2)
         };
       }
       function getRegexFromPattern(pattern, useCaseSensitiveFileNames2) {
         return new RegExp(pattern, useCaseSensitiveFileNames2 ? "" : "i");
       }
-      function matchFiles(path2, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
-        path2 = normalizePath(path2);
+      function matchFiles(path3, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
+        path3 = normalizePath(path3);
         currentDirectory = normalizePath(currentDirectory);
-        const patterns = getFileMatcherPatterns(path2, excludes, includes, useCaseSensitiveFileNames2, currentDirectory);
+        const patterns = getFileMatcherPatterns(path3, 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);
@@ -25351,17 +25351,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function getBasePaths(path2, includes, useCaseSensitiveFileNames2) {
-        const basePaths = [path2];
+      function getBasePaths(path3, includes, useCaseSensitiveFileNames2) {
+        const basePaths = [path3];
         if (includes) {
           const includeBasePaths = [];
           for (const include of includes) {
-            const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path2, include));
+            const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path3, include));
             includeBasePaths.push(getIncludeBasePath(absolute));
           }
           includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames2));
           for (const includeBasePath of includeBasePaths) {
-            if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path2, !useCaseSensitiveFileNames2))) {
+            if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path3, !useCaseSensitiveFileNames2))) {
               basePaths.push(includeBasePath);
             }
           }
@@ -25604,10 +25604,10 @@ ${lanes.join("\n")}
         const match = str.match(/\//g);
         return match ? match.length : 0;
       }
-      function compareNumberOfDirectorySeparators(path1, path2) {
+      function compareNumberOfDirectorySeparators(path1, path22) {
         return compareValues(
           numberOfDirectorySeparators(path1),
-          numberOfDirectorySeparators(path2)
+          numberOfDirectorySeparators(path22)
         );
       }
       var extensionsToRemove = [
@@ -25625,24 +25625,24 @@ ${lanes.join("\n")}
         ".json"
         /* Json */
       ];
-      function removeFileExtension(path2) {
+      function removeFileExtension(path3) {
         for (const ext of extensionsToRemove) {
-          const extensionless = tryRemoveExtension(path2, ext);
+          const extensionless = tryRemoveExtension(path3, ext);
           if (extensionless !== void 0) {
             return extensionless;
           }
         }
-        return path2;
+        return path3;
       }
-      function tryRemoveExtension(path2, extension) {
-        return fileExtensionIs(path2, extension) ? removeExtension(path2, extension) : void 0;
+      function tryRemoveExtension(path3, extension) {
+        return fileExtensionIs(path3, extension) ? removeExtension(path3, extension) : void 0;
       }
-      function removeExtension(path2, extension) {
-        return path2.substring(0, path2.length - extension.length);
+      function removeExtension(path3, extension) {
+        return path3.substring(0, path3.length - extension.length);
       }
-      function changeExtension(path2, newExtension) {
+      function changeExtension(path3, newExtension) {
         return changeAnyExtension(
-          path2,
+          path3,
           newExtension,
           extensionsToRemove,
           /*ignoreCase*/
@@ -25668,8 +25668,8 @@ ${lanes.join("\n")}
         let matchableStringSet;
         let patterns;
         const pathList = getOwnKeys(paths);
-        for (const path2 of pathList) {
-          const patternOrStr = tryParsePattern(path2);
+        for (const path3 of pathList) {
+          const patternOrStr = tryParsePattern(path3);
           if (patternOrStr === void 0) {
             continue;
           } else if (typeof patternOrStr === "string") {
@@ -25696,15 +25696,15 @@ ${lanes.join("\n")}
       function resolutionExtensionIsTSOrJson(ext) {
         return extensionIsTS(ext) || ext === ".json";
       }
-      function extensionFromPath(path2) {
-        const ext = tryGetExtensionFromPath2(path2);
-        return ext !== void 0 ? ext : Debug.fail(`File ${path2} has unknown extension.`);
+      function extensionFromPath(path3) {
+        const ext = tryGetExtensionFromPath2(path3);
+        return ext !== void 0 ? ext : Debug.fail(`File ${path3} has unknown extension.`);
       }
-      function isAnySupportedFileExtension(path2) {
-        return tryGetExtensionFromPath2(path2) !== void 0;
+      function isAnySupportedFileExtension(path3) {
+        return tryGetExtensionFromPath2(path3) !== void 0;
       }
-      function tryGetExtensionFromPath2(path2) {
-        return find(extensionsToRemove, (e) => fileExtensionIs(path2, e));
+      function tryGetExtensionFromPath2(path3) {
+        return find(extensionsToRemove, (e) => fileExtensionIs(path3, e));
       }
       function isCheckJsEnabledForFile(sourceFile, compilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
@@ -26013,8 +26013,8 @@ ${lanes.join("\n")}
           return false;
         }
       }
-      function containsIgnoredPath(path2) {
-        return some(ignoredPaths, (p) => path2.includes(p));
+      function containsIgnoredPath(path3) {
+        return some(ignoredPaths, (p) => path3.includes(p));
       }
       function getContainingNodeArray(node) {
         if (!node.parent) return void 0;
@@ -45822,7 +45822,7 @@ ${lanes.join("\n")}
               const typeReferenceDirectives = context.typeReferenceDirectives;
               const libReferenceDirectives = context.libReferenceDirectives;
               forEach(toArray(entryOrList), (arg) => {
-                const { types, lib, path: path2, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
+                const { types, lib, path: path3, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
                 const preserve = _preserve === "true" ? true : void 0;
                 if (arg.arguments["no-default-lib"] === "true") {
                   context.hasNoDefaultLib = true;
@@ -45831,8 +45831,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 (path2) {
-                  referencedFiles.push({ pos: path2.pos, end: path2.end, fileName: path2.value, ...preserve ? { preserve } : {} });
+                } else if (path3) {
+                  referencedFiles.push({ pos: path3.pos, end: path3.end, fileName: path3.value, ...preserve ? { preserve } : {} });
                 } else {
                   reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);
                 }
@@ -48261,9 +48261,9 @@ ${lanes.join("\n")}
         if (specs[0] === defaultIncludeSpec) return void 0;
         return specs;
       }
-      function matchesSpecs(path2, includeSpecs, excludeSpecs, host) {
+      function matchesSpecs(path3, includeSpecs, excludeSpecs, host) {
         if (!includeSpecs) return returnTrue;
-        const patterns = getFileMatcherPatterns(path2, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
+        const patterns = getFileMatcherPatterns(path3, 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) {
@@ -48908,9 +48908,9 @@ ${lanes.join("\n")}
             const setPropertyInResultIfNotUndefined = (propertyName) => {
               if (ownConfig.raw[propertyName]) return;
               if (extendsRaw[propertyName]) {
-                result[propertyName] = map(extendsRaw[propertyName], (path2) => startsWithConfigDirTemplate(path2) || isRootedDiskPath(path2) ? path2 : combinePaths(
+                result[propertyName] = map(extendsRaw[propertyName], (path3) => startsWithConfigDirTemplate(path3) || isRootedDiskPath(path3) ? path3 : combinePaths(
                   relativeDifference || (relativeDifference = convertToRelativePath(getDirectoryPath(extendedConfigPath), basePath, createGetCanonicalFileName(host.useCaseSensitiveFileNames))),
-                  path2
+                  path3
                 ));
               }
             };
@@ -49064,11 +49064,11 @@ ${lanes.join("\n")}
         return void 0;
       }
       function getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache, result) {
-        const path2 = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
+        const path3 = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
         let value;
         let extendedResult;
         let extendedConfig;
-        if (extendedConfigCache && (value = extendedConfigCache.get(path2))) {
+        if (extendedConfigCache && (value = extendedConfigCache.get(path3))) {
           ({ extendedResult, extendedConfig } = value);
         } else {
           extendedResult = readJsonConfigFile(extendedConfigPath, (path22) => host.readFile(path22));
@@ -49086,7 +49086,7 @@ ${lanes.join("\n")}
             );
           }
           if (extendedConfigCache) {
-            extendedConfigCache.set(path2, { extendedResult, extendedConfig });
+            extendedConfigCache.set(path3, { extendedResult, extendedConfig });
           }
         }
         if (sourceFile) {
@@ -49354,24 +49354,24 @@ ${lanes.join("\n")}
             }
             const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2);
             if (match) {
-              const { key, path: path2, flags } = match;
+              const { key, path: path3, 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 : path2] = flags;
-                if (existingPath === void 0) wildCardKeyToPath.set(key, path2);
+                wildcardDirectories[existingPath !== void 0 ? existingPath : path3] = flags;
+                if (existingPath === void 0) wildCardKeyToPath.set(key, path3);
                 if (flags === 1) {
                   recursiveKeys.push(key);
                 }
               }
             }
           }
-          for (const path2 in wildcardDirectories) {
-            if (hasProperty(wildcardDirectories, path2)) {
+          for (const path3 in wildcardDirectories) {
+            if (hasProperty(wildcardDirectories, path3)) {
               for (const recursiveKey of recursiveKeys) {
-                const key = toCanonicalKey(path2, useCaseSensitiveFileNames2);
+                const key = toCanonicalKey(path3, useCaseSensitiveFileNames2);
                 if (key !== recursiveKey && containsPath(recursiveKey, key, basePath, !useCaseSensitiveFileNames2)) {
-                  delete wildcardDirectories[path2];
+                  delete wildcardDirectories[path3];
                 }
               }
             }
@@ -49379,8 +49379,8 @@ ${lanes.join("\n")}
         }
         return wildcardDirectories;
       }
-      function toCanonicalKey(path2, useCaseSensitiveFileNames2) {
-        return useCaseSensitiveFileNames2 ? path2 : toFileNameLowerCase(path2);
+      function toCanonicalKey(path3, useCaseSensitiveFileNames2) {
+        return useCaseSensitiveFileNames2 ? path3 : toFileNameLowerCase(path3);
       }
       function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2) {
         const match = wildcardDirectoryPattern.exec(spec);
@@ -49396,10 +49396,10 @@ ${lanes.join("\n")}
           };
         }
         if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
-          const path2 = removeTrailingDirectorySeparator(spec);
+          const path3 = removeTrailingDirectorySeparator(spec);
           return {
-            key: toCanonicalKey(path2, useCaseSensitiveFileNames2),
-            path: path2,
+            key: toCanonicalKey(path3, useCaseSensitiveFileNames2),
+            path: path3,
             flags: 1
             /* Recursive */
           };
@@ -49638,11 +49638,11 @@ ${lanes.join("\n")}
           }
           return;
         }
-        const path2 = normalizePath(combinePaths(baseDirectory, fileName));
+        const path3 = normalizePath(combinePaths(baseDirectory, fileName));
         if (state.traceEnabled) {
-          trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path2);
+          trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path3);
         }
-        return path2;
+        return path3;
       }
       function readPackageJsonTypesFields(jsonContent, baseDirectory, state) {
         return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state) || readPackageJsonPathField(jsonContent, "types", baseDirectory, state);
@@ -49724,9 +49724,9 @@ ${lanes.join("\n")}
         return typeRoots;
       }
       var nodeModulesAtTypes = combinePaths("node_modules", "@types");
-      function arePathsEqual(path1, path2, host) {
+      function arePathsEqual(path1, path22, host) {
         const useCaseSensitiveFileNames2 = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;
-        return comparePaths(path1, path2, !useCaseSensitiveFileNames2) === 0;
+        return comparePaths(path1, path22, !useCaseSensitiveFileNames2) === 0;
       }
       function getOriginalAndResolvedFileName(fileName, host, traceEnabled) {
         const resolvedFileName = realPath(fileName, host, traceEnabled);
@@ -50156,13 +50156,13 @@ ${lanes.join("\n")}
           directoryToModuleNameMap.update(options2);
         }
         function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
-          const path2 = toPath(directoryName, currentDirectory, getCanonicalFileName);
-          return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path2, () => createModeAwareCache());
+          const path3 = toPath(directoryName, currentDirectory, getCanonicalFileName);
+          return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path3, () => createModeAwareCache());
         }
         function getFromDirectoryCache(name, mode, directoryName, redirectedReference) {
           var _a, _b;
-          const path2 = toPath(directoryName, currentDirectory, getCanonicalFileName);
-          return (_b = (_a = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a.get(path2)) == null ? void 0 : _b.get(name, mode);
+          const path3 = toPath(directoryName, currentDirectory, getCanonicalFileName);
+          return (_b = (_a = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a.get(path3)) == null ? void 0 : _b.get(name, mode);
         }
       }
       function createModeAwareCacheKey(specifier, mode) {
@@ -50239,14 +50239,14 @@ ${lanes.join("\n")}
             return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName));
           }
           function set(directory, result) {
-            const path2 = toPath(directory, currentDirectory, getCanonicalFileName);
-            if (directoryPathMap.has(path2)) {
+            const path3 = toPath(directory, currentDirectory, getCanonicalFileName);
+            if (directoryPathMap.has(path3)) {
               return;
             }
-            directoryPathMap.set(path2, result);
+            directoryPathMap.set(path3, result);
             const resolvedFileName = getResolvedFileName(result);
-            const commonPrefix = resolvedFileName && getCommonPrefix(path2, resolvedFileName);
-            let current = path2;
+            const commonPrefix = resolvedFileName && getCommonPrefix(path3, resolvedFileName);
+            let current = path3;
             while (current !== commonPrefix) {
               const parent2 = getDirectoryPath(current);
               if (parent2 === current || directoryPathMap.has(parent2)) {
@@ -50810,16 +50810,16 @@ ${lanes.join("\n")}
         const combined = combinePaths(containingDirectory, moduleName);
         const parts = getPathComponents(combined);
         const lastPart = lastOrUndefined(parts);
-        const path2 = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
-        return { path: path2, parts };
+        const path3 = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
+        return { path: path3, parts };
       }
-      function realPath(path2, host, traceEnabled) {
+      function realPath(path3, host, traceEnabled) {
         if (!host.realpath) {
-          return path2;
+          return path3;
         }
-        const real = normalizePath(host.realpath(path2));
+        const real = normalizePath(host.realpath(path3));
         if (traceEnabled) {
-          trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path2, real);
+          trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path3, real);
         }
         return real;
       }
@@ -50864,25 +50864,25 @@ ${lanes.join("\n")}
         return void 0;
       }
       var nodeModulesPathPart = "/node_modules/";
-      function pathContainsNodeModules(path2) {
-        return path2.includes(nodeModulesPathPart);
+      function pathContainsNodeModules(path3) {
+        return path3.includes(nodeModulesPathPart);
       }
       function parseNodeModuleFromPath(resolved, isFolder) {
-        const path2 = normalizePath(resolved);
-        const idx = path2.lastIndexOf(nodeModulesPathPart);
+        const path3 = normalizePath(resolved);
+        const idx = path3.lastIndexOf(nodeModulesPathPart);
         if (idx === -1) {
           return void 0;
         }
         const indexAfterNodeModules = idx + nodeModulesPathPart.length;
-        let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path2, indexAfterNodeModules, isFolder);
-        if (path2.charCodeAt(indexAfterNodeModules) === 64) {
-          indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path2, indexAfterPackageName, isFolder);
+        let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path3, indexAfterNodeModules, isFolder);
+        if (path3.charCodeAt(indexAfterNodeModules) === 64) {
+          indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path3, indexAfterPackageName, isFolder);
         }
-        return path2.slice(0, indexAfterPackageName);
+        return path3.slice(0, indexAfterPackageName);
       }
-      function moveToNextDirectorySeparatorIfAvailable(path2, prevSeparatorIndex, isFolder) {
-        const nextSeparatorIndex = path2.indexOf(directorySeparator, prevSeparatorIndex + 1);
-        return nextSeparatorIndex === -1 ? isFolder ? path2.length : prevSeparatorIndex : nextSeparatorIndex;
+      function moveToNextDirectorySeparatorIfAvailable(path3, prevSeparatorIndex, isFolder) {
+        const nextSeparatorIndex = path3.indexOf(directorySeparator, prevSeparatorIndex + 1);
+        return nextSeparatorIndex === -1 ? isFolder ? path3.length : prevSeparatorIndex : nextSeparatorIndex;
       }
       function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) {
         return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
@@ -51024,8 +51024,8 @@ ${lanes.join("\n")}
             return extensions & 4 && !isDeclarationFileName(candidate + originalExtension) && tryExtension(`.d${originalExtension}.ts`) || void 0;
         }
         function tryExtension(ext, resolvedUsingTsExtension) {
-          const path2 = tryFile(candidate + ext, onlyRecordFailures, state);
-          return path2 === void 0 ? void 0 : { path: path2, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
+          const path3 = tryFile(candidate + ext, onlyRecordFailures, state);
+          return path3 === void 0 ? void 0 : { path: path3, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
         }
       }
       function tryFile(fileName, onlyRecordFailures, state) {
@@ -51721,10 +51721,10 @@ ${lanes.join("\n")}
             /*value*/
             void 0
           );
-          function toAbsolutePath(path2) {
+          function toAbsolutePath(path3) {
             var _a2, _b2;
-            if (path2 === void 0) return path2;
-            return getNormalizedAbsolutePath(path2, (_b2 = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a2));
+            if (path3 === void 0) return path3;
+            return getNormalizedAbsolutePath(path3, (_b2 = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a2));
           }
           function combineDirectoryPath(root, dir) {
             return ensureTrailingDirectorySeparator(combinePaths(root, dir));
@@ -51975,10 +51975,10 @@ ${lanes.join("\n")}
             trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
           }
           const resolved = forEach(paths[matchedPatternText], (subst) => {
-            const path2 = matchedStar ? replaceFirstStar(subst, matchedStar) : subst;
-            const candidate = normalizePath(combinePaths(baseDirectory, path2));
+            const path3 = matchedStar ? replaceFirstStar(subst, matchedStar) : subst;
+            const candidate = normalizePath(combinePaths(baseDirectory, path3));
             if (state.traceEnabled) {
-              trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path2);
+              trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path3);
             }
             const extension = tryGetExtensionFromPath2(subst);
             if (extension !== void 0) {
@@ -56131,10 +56131,10 @@ ${lanes.join("\n")}
         if (a === void 0 || b === void 0) return false;
         return comparePaths(a, b, ignoreCase) === 0;
       }
-      function countPathComponents(path2) {
+      function countPathComponents(path3) {
         let count = 0;
-        for (let i = startsWith(path2, "./") ? 2 : 0; i < path2.length; i++) {
-          if (path2.charCodeAt(i) === 47) count++;
+        for (let i = startsWith(path3, "./") ? 2 : 0; i < path3.length; i++) {
+          if (path3.charCodeAt(i) === 47) count++;
         }
         return count;
       }
@@ -56251,9 +56251,9 @@ ${lanes.join("\n")}
           host,
           /*preferSymlinks*/
           true,
-          (path2, isRedirect) => {
-            const isInNodeModules = pathContainsNodeModules(path2);
-            allFileNames.set(path2, { path: info.getCanonicalFileName(path2), isRedirect, isInNodeModules });
+          (path3, isRedirect) => {
+            const isInNodeModules = pathContainsNodeModules(path3);
+            allFileNames.set(path3, { path: info.getCanonicalFileName(path3), isRedirect, isInNodeModules });
             importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules;
           }
         );
@@ -56261,8 +56261,8 @@ ${lanes.join("\n")}
         for (let directory = info.canonicalSourceDirectory; allFileNames.size !== 0; ) {
           const directoryStart = ensureTrailingDirectorySeparator(directory);
           let pathsInDirectory;
-          allFileNames.forEach(({ path: path2, isRedirect, isInNodeModules }, fileName) => {
-            if (startsWith(path2, directoryStart)) {
+          allFileNames.forEach(({ path: path3, isRedirect, isInNodeModules }, fileName) => {
+            if (startsWith(path3, directoryStart)) {
               (pathsInDirectory || (pathsInDirectory = [])).push({ path: fileName, isRedirect, isInNodeModules });
               allFileNames.delete(fileName);
             }
@@ -56565,17 +56565,17 @@ ${lanes.join("\n")}
         }
         return processEnding(shortest, allowedEndings, compilerOptions);
       }
-      function tryGetModuleNameAsNodeModule({ path: path2, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
+      function tryGetModuleNameAsNodeModule({ path: path3, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
         if (!host.fileExists || !host.readFile) {
           return void 0;
         }
-        const parts = getNodeModulePathParts(path2);
+        const parts = getNodeModulePathParts(path3);
         if (!parts) {
           return void 0;
         }
         const preferences = getModuleSpecifierPreferences(userPreferences, host, options, importingSourceFile);
         const allowedEndings = preferences.getAllowedEndingsInPreferredOrder();
-        let moduleSpecifier = path2;
+        let moduleSpecifier = path3;
         let isPackageRootPath = false;
         if (!packageNameOnly) {
           let packageRootIndex = parts.packageRootIndex;
@@ -56596,7 +56596,7 @@ ${lanes.join("\n")}
               break;
             }
             if (!moduleFileName) moduleFileName = moduleFileToTry;
-            packageRootIndex = path2.indexOf(directorySeparator, packageRootIndex + 1);
+            packageRootIndex = path3.indexOf(directorySeparator, packageRootIndex + 1);
             if (packageRootIndex === -1) {
               moduleSpecifier = processEnding(moduleFileName, allowedEndings, options, host);
               break;
@@ -56616,9 +56616,9 @@ ${lanes.join("\n")}
         return getEmitModuleResolutionKind(options) === 1 && packageName === nodeModulesDirectoryName ? void 0 : packageName;
         function tryDirectoryWithPackageJson(packageRootIndex) {
           var _a, _b;
-          const packageRootPath = path2.substring(0, packageRootIndex);
+          const packageRootPath = path3.substring(0, packageRootIndex);
           const packageJsonPath = combinePaths(packageRootPath, "package.json");
-          let moduleFileToTry = path2;
+          let moduleFileToTry = path3;
           let maybeBlockedByTypesVersions = false;
           const cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
           if (isPackageJsonInfo(cachedPackageJson) || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
@@ -56631,7 +56631,7 @@ ${lanes.join("\n")}
               const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(
                 options,
                 host,
-                path2,
+                path3,
                 packageRootPath,
                 packageName2,
                 packageJsonContent.exports,
@@ -56641,12 +56641,12 @@ ${lanes.join("\n")}
                 return { ...fromExports, verbatimFromExports: true };
               }
               if (packageJsonContent == null ? void 0 : packageJsonContent.exports) {
-                return { moduleFileToTry: path2, blockedByExports: true };
+                return { moduleFileToTry: path3, blockedByExports: true };
               }
             }
             const versionPaths = (packageJsonContent == null ? void 0 : packageJsonContent.typesVersions) ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) : void 0;
             if (versionPaths) {
-              const subModuleName = path2.slice(packageRootPath.length + 1);
+              const subModuleName = path3.slice(packageRootPath.length + 1);
               const fromPaths = tryGetModuleNameFromPaths(
                 subModuleName,
                 versionPaths.paths,
@@ -56681,7 +56681,7 @@ ${lanes.join("\n")}
           return { moduleFileToTry };
         }
       }
-      function tryGetAnyFileFromPath(host, path2) {
+      function tryGetAnyFileFromPath(host, path3) {
         if (!host.fileExists) return;
         const extensions = flatten(getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, {
           extension: "json",
@@ -56690,15 +56690,15 @@ ${lanes.join("\n")}
           /* JSON */
         }]));
         for (const e of extensions) {
-          const fullPath = path2 + e;
+          const fullPath = path3 + e;
           if (host.fileExists(fullPath)) {
             return fullPath;
           }
         }
       }
-      function getPathsRelativeToRootDirs(path2, rootDirs, getCanonicalFileName) {
+      function getPathsRelativeToRootDirs(path3, rootDirs, getCanonicalFileName) {
         return mapDefined(rootDirs, (rootDir) => {
-          const relativePath = getRelativePathIfInSameVolume(path2, rootDir, getCanonicalFileName);
+          const relativePath = getRelativePathIfInSameVolume(path3, rootDir, getCanonicalFileName);
           return relativePath !== void 0 && isPathRelativeToParent(relativePath) ? void 0 : relativePath;
         });
       }
@@ -56815,10 +56815,10 @@ ${lanes.join("\n")}
             return void 0;
         }
       }
-      function getRelativePathIfInSameVolume(path2, directoryPath, getCanonicalFileName) {
+      function getRelativePathIfInSameVolume(path3, directoryPath, getCanonicalFileName) {
         const relativePath = getRelativePathToDirectoryOrUrl(
           directoryPath,
-          path2,
+          path3,
           directoryPath,
           getCanonicalFileName,
           /*isAbsolutePathAnUrl*/
@@ -56826,8 +56826,8 @@ ${lanes.join("\n")}
         );
         return isRootedDiskPath(relativePath) ? void 0 : relativePath;
       }
-      function isPathRelativeToParent(path2) {
-        return startsWith(path2, "..");
+      function isPathRelativeToParent(path3) {
+        return startsWith(path3, "..");
       }
       function getDefaultResolutionModeForFile(file, host, compilerOptions) {
         return isFullSourceFile(file) ? host.getDefaultResolutionModeForFile(file) : getDefaultResolutionModeForFileWorker(file, compilerOptions);
@@ -71876,10 +71876,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 path2 = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
-            let result = unresolvedSymbols.get(path2);
+            const path3 = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
+            let result = unresolvedSymbols.get(path3);
             if (!result) {
-              unresolvedSymbols.set(path2, result = createSymbol(
+              unresolvedSymbols.set(path3, result = createSymbol(
                 524288,
                 text,
                 1048576
@@ -76680,24 +76680,24 @@ ${lanes.join("\n")}
               }
               return;
             }
-            let path2 = "";
+            let path3 = "";
             const secondaryRootErrors = [];
             while (stack.length) {
               const [msg, ...args] = stack.pop();
               switch (msg.code) {
                 case Diagnostics.Types_of_property_0_are_incompatible.code: {
-                  if (path2.indexOf("new ") === 0) {
-                    path2 = `(${path2})`;
+                  if (path3.indexOf("new ") === 0) {
+                    path3 = `(${path3})`;
                   }
                   const str = "" + args[0];
-                  if (path2.length === 0) {
-                    path2 = `${str}`;
+                  if (path3.length === 0) {
+                    path3 = `${str}`;
                   } else if (isIdentifierText(str, getEmitScriptTarget(compilerOptions))) {
-                    path2 = `${path2}.${str}`;
+                    path3 = `${path3}.${str}`;
                   } else if (str[0] === "[" && str[str.length - 1] === "]") {
-                    path2 = `${path2}${str}`;
+                    path3 = `${path3}${str}`;
                   } else {
-                    path2 = `${path2}[${str}]`;
+                    path3 = `${path3}[${str}]`;
                   }
                   break;
                 }
@@ -76705,7 +76705,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 (path2.length === 0) {
+                  if (path3.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;
@@ -76716,7 +76716,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 ? "" : "...";
-                    path2 = `${prefix}${path2}(${params})`;
+                    path3 = `${prefix}${path3}(${params})`;
                   }
                   break;
                 }
@@ -76732,10 +76732,10 @@ ${lanes.join("\n")}
                   return Debug.fail(`Unhandled Diagnostic: ${msg.code}`);
               }
             }
-            if (path2) {
+            if (path3) {
               reportError(
-                path2[path2.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
-                path2
+                path3[path3.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
+                path3
               );
             } else {
               secondaryRootErrors.shift();
@@ -131803,9 +131803,9 @@ ${lanes.join("\n")}
       function createAddOutput() {
         let outputs;
         return { addOutput, getOutputs };
-        function addOutput(path2) {
-          if (path2) {
-            (outputs || (outputs = [])).push(path2);
+        function addOutput(path3) {
+          if (path3) {
+            (outputs || (outputs = [])).push(path3);
           }
         }
         function getOutputs() {
@@ -137031,7 +137031,7 @@ ${lanes.join("\n")}
         return {
           useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
           fileExists,
-          readFile: (path2, encoding) => host.readFile(path2, encoding),
+          readFile: (path3, encoding) => host.readFile(path3, encoding),
           directoryExists: host.directoryExists && directoryExists,
           getDirectories,
           readDirectory,
@@ -137048,8 +137048,8 @@ ${lanes.join("\n")}
         function getCachedFileSystemEntries(rootDirPath) {
           return cachedReadDirectoryResult.get(ensureTrailingDirectorySeparator(rootDirPath));
         }
-        function getCachedFileSystemEntriesForBaseDir(path2) {
-          const entries = getCachedFileSystemEntries(getDirectoryPath(path2));
+        function getCachedFileSystemEntriesForBaseDir(path3) {
+          const entries = getCachedFileSystemEntries(getDirectoryPath(path3));
           if (!entries) {
             return entries;
           }
@@ -137104,8 +137104,8 @@ ${lanes.join("\n")}
           return index >= 0;
         }
         function writeFile2(fileName, data, writeByteOrderMark) {
-          const path2 = toPath3(fileName);
-          const result = getCachedFileSystemEntriesForBaseDir(path2);
+          const path3 = toPath3(fileName);
+          const result = getCachedFileSystemEntriesForBaseDir(path3);
           if (result) {
             updateFilesOfFileSystemEntry(
               result,
@@ -137117,17 +137117,17 @@ ${lanes.join("\n")}
           return host.writeFile(fileName, data, writeByteOrderMark);
         }
         function fileExists(fileName) {
-          const path2 = toPath3(fileName);
-          const result = getCachedFileSystemEntriesForBaseDir(path2);
+          const path3 = toPath3(fileName);
+          const result = getCachedFileSystemEntriesForBaseDir(path3);
           return result && hasEntry(result.sortedAndCanonicalizedFiles, getCanonicalFileName(getBaseNameOfFileName(fileName))) || host.fileExists(fileName);
         }
         function directoryExists(dirPath) {
-          const path2 = toPath3(dirPath);
-          return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path2)) || host.directoryExists(dirPath);
+          const path3 = toPath3(dirPath);
+          return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path3)) || host.directoryExists(dirPath);
         }
         function createDirectory(dirPath) {
-          const path2 = toPath3(dirPath);
-          const result = getCachedFileSystemEntriesForBaseDir(path2);
+          const path3 = toPath3(dirPath);
+          const result = getCachedFileSystemEntriesForBaseDir(path3);
           if (result) {
             const baseName = getBaseNameOfFileName(dirPath);
             const canonicalizedBaseName = getCanonicalFileName(baseName);
@@ -137155,15 +137155,15 @@ ${lanes.join("\n")}
           }
           return host.readDirectory(rootDir, extensions, excludes, includes, depth);
           function getFileSystemEntries(dir) {
-            const path2 = toPath3(dir);
-            if (path2 === rootDirPath) {
-              return rootResult || getFileSystemEntriesFromHost(dir, path2);
+            const path3 = toPath3(dir);
+            if (path3 === rootDirPath) {
+              return rootResult || getFileSystemEntriesFromHost(dir, path3);
             }
-            const result = tryReadDirectory2(dir, path2);
-            return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path2) : emptyFileSystemEntries;
+            const result = tryReadDirectory2(dir, path3);
+            return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path3) : emptyFileSystemEntries;
           }
-          function getFileSystemEntriesFromHost(dir, path2) {
-            if (rootSymLinkResult && path2 === rootDirPath) return rootSymLinkResult;
+          function getFileSystemEntriesFromHost(dir, path3) {
+            if (rootSymLinkResult && path3 === rootDirPath) return rootSymLinkResult;
             const result = {
               files: map(host.readDirectory(
                 dir,
@@ -137176,7 +137176,7 @@ ${lanes.join("\n")}
               ), getBaseNameOfFileName) || emptyArray,
               directories: host.getDirectories(dir) || emptyArray
             };
-            if (path2 === rootDirPath) rootSymLinkResult = result;
+            if (path3 === rootDirPath) rootSymLinkResult = result;
             return result;
           }
         }
@@ -137635,15 +137635,15 @@ ${lanes.join("\n")}
           return getDirectoryPath(normalizePath(system.getExecutingFilePath()));
         }
         const newLine = getNewLineCharacter(options);
-        const realpath = system.realpath && ((path2) => system.realpath(path2));
+        const realpath = system.realpath && ((path3) => system.realpath(path3));
         const compilerHost = {
           getSourceFile: createGetSourceFile((fileName) => compilerHost.readFile(fileName), setParentNodes),
           getDefaultLibLocation,
           getDefaultLibFileName: (options2) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options2)),
           writeFile: createWriteFileMeasuringIO(
-            (path2, data, writeByteOrderMark) => system.writeFile(path2, data, writeByteOrderMark),
-            (path2) => (compilerHost.createDirectory || system.createDirectory)(path2),
-            (path2) => directoryExists(path2)
+            (path3, data, writeByteOrderMark) => system.writeFile(path3, data, writeByteOrderMark),
+            (path3) => (compilerHost.createDirectory || system.createDirectory)(path3),
+            (path3) => directoryExists(path3)
           ),
           getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
           useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
@@ -137654,9 +137654,9 @@ ${lanes.join("\n")}
           trace: (s) => system.write(s + newLine),
           directoryExists: (directoryName) => system.directoryExists(directoryName),
           getEnvironmentVariable: (name) => system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : "",
-          getDirectories: (path2) => system.getDirectories(path2),
+          getDirectories: (path3) => system.getDirectories(path3),
           realpath,
-          readDirectory: (path2, extensions, include, exclude, depth) => system.readDirectory(path2, extensions, include, exclude, depth),
+          readDirectory: (path3, extensions, include, exclude, depth) => system.readDirectory(path3, extensions, include, exclude, depth),
           createDirectory: (d) => system.createDirectory(d),
           createHash: maybeBind(system, system.createHash)
         };
@@ -138095,13 +138095,13 @@ ${lanes.join("\n")}
       }
       function getLibraryNameFromLibFileName(libFileName) {
         const components = libFileName.split(".");
-        let path2 = components[1];
+        let path3 = components[1];
         let i = 2;
         while (components[i] && components[i] !== "d") {
-          path2 += (i === 2 ? "/" : "-") + components[i];
+          path3 += (i === 2 ? "/" : "-") + components[i];
           i++;
         }
-        return "@typescript/lib-" + path2;
+        return "@typescript/lib-" + path3;
       }
       function isReferencedFile(reason) {
         switch (reason == null ? void 0 : reason.kind) {
@@ -139177,18 +139177,18 @@ ${lanes.join("\n")}
             filesByName.set(newSourceFile.path, newSourceFile);
           }
           const oldFilesByNameMap = oldProgram.getFilesByNameMap();
-          oldFilesByNameMap.forEach((oldFile, path2) => {
+          oldFilesByNameMap.forEach((oldFile, path3) => {
             if (!oldFile) {
-              filesByName.set(path2, oldFile);
+              filesByName.set(path3, oldFile);
               return;
             }
-            if (oldFile.path === path2) {
+            if (oldFile.path === path3) {
               if (oldProgram.isSourceFileFromExternalLibrary(oldFile)) {
                 sourceFilesFoundSearchingNodeModules.set(oldFile.path, true);
               }
               return;
             }
-            filesByName.set(path2, filesByName.get(oldFile.path));
+            filesByName.set(path3, 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);
@@ -139226,9 +139226,9 @@ ${lanes.join("\n")}
             getModeForResolutionAtIndex: getModeForResolutionAtIndex2,
             readFile: (f) => host.readFile(f),
             fileExists: (f) => {
-              const path2 = toPath3(f);
-              if (getSourceFileByPath(path2)) return true;
-              if (missingFileNames.has(path2)) return false;
+              const path3 = toPath3(f);
+              if (getSourceFileByPath(path3)) return true;
+              if (missingFileNames.has(path3)) return false;
               return host.fileExists(f);
             },
             realpath: maybeBind(host, host.realpath),
@@ -139368,8 +139368,8 @@ ${lanes.join("\n")}
         function getSourceFile(fileName) {
           return getSourceFileByPath(toPath3(fileName));
         }
-        function getSourceFileByPath(path2) {
-          return filesByName.get(path2) || void 0;
+        function getSourceFileByPath(path3) {
+          return filesByName.get(path3) || void 0;
         }
         function getDiagnosticsHelper(sourceFile, getDiagnostics2, cancellationToken) {
           if (sourceFile) {
@@ -140012,16 +140012,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, path2, resolvedPath, originalFileName, sourceFileOptions) {
+        function createRedirectedSourceFile(redirectTarget, unredirected, fileName, path3, resolvedPath, originalFileName, sourceFileOptions) {
           var _a2;
           const redirect = parseNodeFactory.createRedirectedSourceFile({ redirectTarget, unredirected });
           redirect.fileName = fileName;
-          redirect.path = path2;
+          redirect.path = path3;
           redirect.resolvedPath = resolvedPath;
           redirect.originalFileName = originalFileName;
           redirect.packageJsonLocations = ((_a2 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _a2.length) ? sourceFileOptions.packageJsonLocations : void 0;
           redirect.packageJsonScope = sourceFileOptions.packageJsonScope;
-          sourceFilesFoundSearchingNodeModules.set(path2, currentNodeModulesDepth > 0);
+          sourceFilesFoundSearchingNodeModules.set(path3, currentNodeModulesDepth > 0);
           return redirect;
         }
         function findSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
@@ -140043,18 +140043,18 @@ ${lanes.join("\n")}
         }
         function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
           var _a2, _b2;
-          const path2 = toPath3(fileName);
+          const path3 = toPath3(fileName);
           if (useSourceOfProjectReferenceRedirect) {
-            let source = getRedirectFromOutput(path2);
+            let source = getRedirectFromOutput(path3);
             if (!source && host.realpath && options.preserveSymlinks && isDeclarationFileName(fileName) && fileName.includes(nodeModulesPathPart)) {
               const realPath2 = toPath3(host.realpath(fileName));
-              if (realPath2 !== path2) source = getRedirectFromOutput(realPath2);
+              if (realPath2 !== path3) source = getRedirectFromOutput(realPath2);
             }
             if (source == null ? void 0 : source.source) {
               const file2 = findSourceFile(source.source, isDefaultLib, ignoreNoDefaultLib, reason, packageId);
               if (file2) addFileToFilesByName(
                 file2,
-                path2,
+                path3,
                 fileName,
                 /*redirectedPath*/
                 void 0
@@ -140063,8 +140063,8 @@ ${lanes.join("\n")}
             }
           }
           const originalFileName = fileName;
-          if (filesByName.has(path2)) {
-            const file2 = filesByName.get(path2);
+          if (filesByName.has(path3)) {
+            const file2 = filesByName.get(path3);
             const addedReason = addFileIncludeReason(
               file2 || void 0,
               reason,
@@ -140130,28 +140130,28 @@ ${lanes.join("\n")}
             const packageIdKey = packageIdToString(packageId);
             const fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
             if (fileFromPackageId) {
-              const dupFile = createRedirectedSourceFile(fileFromPackageId, file, fileName, path2, toPath3(fileName), originalFileName, sourceFileOptions);
+              const dupFile = createRedirectedSourceFile(fileFromPackageId, file, fileName, path3, toPath3(fileName), originalFileName, sourceFileOptions);
               redirectTargetsMap.add(fileFromPackageId.path, fileName);
-              addFileToFilesByName(dupFile, path2, fileName, redirectedPath);
+              addFileToFilesByName(dupFile, path3, fileName, redirectedPath);
               addFileIncludeReason(
                 dupFile,
                 reason,
                 /*checkExisting*/
                 false
               );
-              sourceFileToPackageName.set(path2, packageIdToPackageName(packageId));
+              sourceFileToPackageName.set(path3, packageIdToPackageName(packageId));
               processingOtherFiles.push(dupFile);
               return dupFile;
             } else if (file) {
               packageIdToSourceFile.set(packageIdKey, file);
-              sourceFileToPackageName.set(path2, packageIdToPackageName(packageId));
+              sourceFileToPackageName.set(path3, packageIdToPackageName(packageId));
             }
           }
-          addFileToFilesByName(file, path2, fileName, redirectedPath);
+          addFileToFilesByName(file, path3, fileName, redirectedPath);
           if (file) {
-            sourceFilesFoundSearchingNodeModules.set(path2, currentNodeModulesDepth > 0);
+            sourceFilesFoundSearchingNodeModules.set(path3, currentNodeModulesDepth > 0);
             file.fileName = fileName;
-            file.path = path2;
+            file.path = path3;
             file.resolvedPath = toPath3(fileName);
             file.originalFileName = originalFileName;
             file.packageJsonLocations = ((_b2 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _b2.length) ? sourceFileOptions.packageJsonLocations : void 0;
@@ -140163,7 +140163,7 @@ ${lanes.join("\n")}
               false
             );
             if (host.useCaseSensitiveFileNames()) {
-              const pathLowerCase = toFileNameLowerCase(path2);
+              const pathLowerCase = toFileNameLowerCase(path3);
               const existingFile = filesByNameIgnoreCase.get(pathLowerCase);
               if (existingFile) {
                 reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason);
@@ -140196,18 +140196,18 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function addFileToFilesByName(file, path2, fileName, redirectedPath) {
+        function addFileToFilesByName(file, path3, fileName, redirectedPath) {
           if (redirectedPath) {
             updateFilesByNameMap(fileName, redirectedPath, file);
-            updateFilesByNameMap(fileName, path2, file || false);
+            updateFilesByNameMap(fileName, path3, file || false);
           } else {
-            updateFilesByNameMap(fileName, path2, file);
+            updateFilesByNameMap(fileName, path3, file);
           }
         }
-        function updateFilesByNameMap(fileName, path2, file) {
-          filesByName.set(path2, file);
-          if (file !== void 0) missingFileNames.delete(path2);
-          else missingFileNames.set(path2, fileName);
+        function updateFilesByNameMap(fileName, path3, file) {
+          filesByName.set(path3, file);
+          if (file !== void 0) missingFileNames.delete(path3);
+          else missingFileNames.set(path3, fileName);
         }
         function getRedirectFromSourceFile(fileName) {
           return mapSourceFileToResolvedRef == null ? void 0 : mapSourceFileToResolvedRef.get(toPath3(fileName));
@@ -140215,8 +140215,8 @@ ${lanes.join("\n")}
         function forEachResolvedProjectReference2(cb) {
           return forEachResolvedProjectReference(resolvedProjectReferences, cb);
         }
-        function getRedirectFromOutput(path2) {
-          return mapOutputFileToResolvedRef == null ? void 0 : mapOutputFileToResolvedRef.get(path2);
+        function getRedirectFromOutput(path3) {
+          return mapOutputFileToResolvedRef == null ? void 0 : mapOutputFileToResolvedRef.get(path3);
         }
         function isSourceOfProjectReferenceRedirect(fileName) {
           return useSourceOfProjectReferenceRedirect && !!getRedirectFromSourceFile(fileName);
@@ -140515,7 +140515,7 @@ ${lanes.join("\n")}
             }
             const getCommonSourceDirectory3 = memoize(() => getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()));
             commandLine.fileNames.forEach((fileName) => {
-              const path2 = toPath3(fileName);
+              const path3 = toPath3(fileName);
               let outputDts;
               if (!isDeclarationFileName(fileName) && !fileExtensionIs(
                 fileName,
@@ -140529,7 +140529,7 @@ ${lanes.join("\n")}
                   outputDts = outDts;
                 }
               }
-              mapSourceFileToResolvedRef.set(path2, { resolvedRef, outputDts });
+              mapSourceFileToResolvedRef.set(path3, { resolvedRef, outputDts });
             });
           }
           if (commandLine.projectReferences) {
@@ -141217,9 +141217,9 @@ ${lanes.join("\n")}
         host.compilerHost.fileExists = fileExists;
         let directoryExists;
         if (originalDirectoryExists) {
-          directoryExists = host.compilerHost.directoryExists = (path2) => {
-            if (originalDirectoryExists.call(host.compilerHost, path2)) {
-              handleDirectoryCouldBeSymlink(path2);
+          directoryExists = host.compilerHost.directoryExists = (path3) => {
+            if (originalDirectoryExists.call(host.compilerHost, path3)) {
+              handleDirectoryCouldBeSymlink(path3);
               return true;
             }
             if (!host.getResolvedProjectReferences()) return false;
@@ -141238,14 +141238,14 @@ ${lanes.join("\n")}
               });
             }
             return fileOrDirectoryExistsUsingSource(
-              path2,
+              path3,
               /*isFile*/
               false
             );
           };
         }
         if (originalGetDirectories) {
-          host.compilerHost.getDirectories = (path2) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path2) ? originalGetDirectories.call(host.compilerHost, path2) : [];
+          host.compilerHost.getDirectories = (path3) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path3) ? originalGetDirectories.call(host.compilerHost, path3) : [];
         }
         if (originalRealpath) {
           host.compilerHost.realpath = (s) => {
@@ -141912,12 +141912,12 @@ ${lanes.join("\n")}
           state.allFileNames = void 0;
         }
         BuilderState2.releaseCache = releaseCache2;
-        function getFilesAffectedBy(state, programOfThisState, path2, cancellationToken, host) {
+        function getFilesAffectedBy(state, programOfThisState, path3, cancellationToken, host) {
           var _a;
           const result = getFilesAffectedByWithOldState(
             state,
             programOfThisState,
-            path2,
+            path3,
             cancellationToken,
             host
           );
@@ -141925,8 +141925,8 @@ ${lanes.join("\n")}
           return result;
         }
         BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
-        function getFilesAffectedByWithOldState(state, programOfThisState, path2, cancellationToken, host) {
-          const sourceFile = programOfThisState.getSourceFileByPath(path2);
+        function getFilesAffectedByWithOldState(state, programOfThisState, path3, cancellationToken, host) {
+          const sourceFile = programOfThisState.getSourceFileByPath(path3);
           if (!sourceFile) {
             return emptyArray;
           }
@@ -141936,9 +141936,9 @@ ${lanes.join("\n")}
           return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
         }
         BuilderState2.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
-        function updateSignatureOfFile(state, signature, path2) {
-          state.fileInfos.get(path2).signature = signature;
-          (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path2);
+        function updateSignatureOfFile(state, signature, path3) {
+          state.fileInfos.get(path3).signature = signature;
+          (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path3);
         }
         BuilderState2.updateSignatureOfFile = updateSignatureOfFile;
         function computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, onNewSignature) {
@@ -142007,10 +142007,10 @@ ${lanes.join("\n")}
           const seenMap = /* @__PURE__ */ new Set();
           const queue = [sourceFile.resolvedPath];
           while (queue.length) {
-            const path2 = queue.pop();
-            if (!seenMap.has(path2)) {
-              seenMap.add(path2);
-              const references = state.referencedMap.getValues(path2);
+            const path3 = queue.pop();
+            if (!seenMap.has(path3)) {
+              seenMap.add(path3);
+              const references = state.referencedMap.getValues(path3);
               if (references) {
                 for (const key of references.keys()) {
                   queue.push(key);
@@ -142018,9 +142018,9 @@ ${lanes.join("\n")}
               }
             }
           }
-          return arrayFrom(mapDefinedIterator(seenMap.keys(), (path2) => {
+          return arrayFrom(mapDefinedIterator(seenMap.keys(), (path3) => {
             var _a;
-            return ((_a = programOfThisState.getSourceFileByPath(path2)) == null ? void 0 : _a.fileName) ?? path2;
+            return ((_a = programOfThisState.getSourceFileByPath(path3)) == null ? void 0 : _a.fileName) ?? path3;
           }));
         }
         BuilderState2.getAllDependencies = getAllDependencies;
@@ -142199,7 +142199,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, (path2) => !state.fileInfos.has(path2) && oldState.fileInfos.has(path2))) {
+          newReferences && forEachKey(newReferences, (path3) => !state.fileInfos.has(path3) && oldState.fileInfos.has(path3))) {
             addFileToChangeSet(sourceFilePath);
           } else {
             const sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
@@ -142265,8 +142265,8 @@ ${lanes.join("\n")}
         }
         if (useOldState && state.semanticDiagnosticsPerFile.size !== state.fileInfos.size && oldState.checkPending !== state.checkPending) state.buildInfoEmitPending = true;
         return state;
-        function addFileToChangeSet(path2) {
-          state.changedFilesSet.add(path2);
+        function addFileToChangeSet(path3) {
+          state.changedFilesSet.add(path3);
           if (outFilePath) {
             canCopySemanticDiagnostics = false;
             canCopyEmitDiagnostics = false;
@@ -142330,9 +142330,9 @@ ${lanes.join("\n")}
           result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, diagnosticFilePath, newProgram, toPathInBuildInfoDirectory)) : [] : void 0;
           return result;
         });
-        function toPathInBuildInfoDirectory(path2) {
+        function toPathInBuildInfoDirectory(path3) {
           buildInfoDirectory ?? (buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory())));
-          return toPath(path2, buildInfoDirectory, newProgram.getCanonicalFileName);
+          return toPath(path3, buildInfoDirectory, newProgram.getCanonicalFileName);
         }
       }
       function convertToDiagnosticRelatedInformation(diagnostic, diagnosticFilePath, newProgram, toPath3) {
@@ -142407,10 +142407,10 @@ ${lanes.join("\n")}
           state.affectedFilesPendingEmit = void 0;
           state.programEmitPending = void 0;
         }
-        (_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.forEach((emitKind, path2) => {
+        (_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.forEach((emitKind, path3) => {
           const pending = !isForDtsErrors ? emitKind & 7 : emitKind & (7 | 48);
-          if (!pending) state.affectedFilesPendingEmit.delete(path2);
-          else state.affectedFilesPendingEmit.set(path2, pending);
+          if (!pending) state.affectedFilesPendingEmit.delete(path3);
+          else state.affectedFilesPendingEmit.set(path3, pending);
         });
         if (state.programEmitPending) {
           const pending = !isForDtsErrors ? state.programEmitPending & 7 : state.programEmitPending & (7 | 48);
@@ -142430,11 +142430,11 @@ ${lanes.join("\n")}
       function getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles, isForDtsErrors) {
         var _a;
         if (!((_a = state.affectedFilesPendingEmit) == null ? void 0 : _a.size)) return void 0;
-        return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path2) => {
+        return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path3) => {
           var _a2;
-          const affectedFile = state.program.getSourceFileByPath(path2);
+          const affectedFile = state.program.getSourceFileByPath(path3);
           if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
-            state.affectedFilesPendingEmit.delete(path2);
+            state.affectedFilesPendingEmit.delete(path3);
             return void 0;
           }
           const seenKind = (_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedFile.resolvedPath);
@@ -142450,11 +142450,11 @@ ${lanes.join("\n")}
       function getNextPendingEmitDiagnosticsFile(state, isForDtsErrors) {
         var _a;
         if (!((_a = state.emitDiagnosticsPerFile) == null ? void 0 : _a.size)) return void 0;
-        return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path2) => {
+        return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path3) => {
           var _a2;
-          const affectedFile = state.program.getSourceFileByPath(path2);
+          const affectedFile = state.program.getSourceFileByPath(path3);
           if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
-            state.emitDiagnosticsPerFile.delete(path2);
+            state.emitDiagnosticsPerFile.delete(path3);
             return void 0;
           }
           const seenKind = ((_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedFile.resolvedPath)) || 0;
@@ -142489,10 +142489,10 @@ ${lanes.join("\n")}
           host
         );
       }
-      function handleDtsMayChangeOf(state, path2, invalidateJsFiles, cancellationToken, host) {
-        removeSemanticDiagnosticsOf(state, path2);
-        if (!state.changedFilesSet.has(path2)) {
-          const sourceFile = state.program.getSourceFileByPath(path2);
+      function handleDtsMayChangeOf(state, path3, invalidateJsFiles, cancellationToken, host) {
+        removeSemanticDiagnosticsOf(state, path3);
+        if (!state.changedFilesSet.has(path3)) {
+          const sourceFile = state.program.getSourceFileByPath(path3);
           if (sourceFile) {
             BuilderState.updateShapeSignature(
               state,
@@ -142506,13 +142506,13 @@ ${lanes.join("\n")}
             if (invalidateJsFiles) {
               addToAffectedFilesPendingEmit(
                 state,
-                path2,
+                path3,
                 getBuilderFileEmit(state.compilerOptions)
               );
             } else if (getEmitDeclarations(state.compilerOptions)) {
               addToAffectedFilesPendingEmit(
                 state,
-                path2,
+                path3,
                 state.compilerOptions.declarationMap ? 56 : 24
                 /* Dts */
               );
@@ -142520,17 +142520,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function removeSemanticDiagnosticsOf(state, path2) {
+      function removeSemanticDiagnosticsOf(state, path3) {
         if (!state.semanticDiagnosticsFromOldState) {
           return true;
         }
-        state.semanticDiagnosticsFromOldState.delete(path2);
-        state.semanticDiagnosticsPerFile.delete(path2);
+        state.semanticDiagnosticsFromOldState.delete(path3);
+        state.semanticDiagnosticsPerFile.delete(path3);
         return !state.semanticDiagnosticsFromOldState.size;
       }
-      function isChangedSignature(state, path2) {
-        const oldSignature = Debug.checkDefined(state.oldSignatures).get(path2) || void 0;
-        const newSignature = Debug.checkDefined(state.fileInfos.get(path2)).signature;
+      function isChangedSignature(state, path3) {
+        const oldSignature = Debug.checkDefined(state.oldSignatures).get(path3) || void 0;
+        const newSignature = Debug.checkDefined(state.fileInfos.get(path3)).signature;
         return newSignature !== oldSignature;
       }
       function handleDtsMayChangeOfGlobalScope(state, filePath, invalidateJsFiles, cancellationToken, host) {
@@ -142637,13 +142637,13 @@ ${lanes.join("\n")}
       }
       function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken, semanticDiagnosticsPerFile) {
         semanticDiagnosticsPerFile ?? (semanticDiagnosticsPerFile = state.semanticDiagnosticsPerFile);
-        const path2 = sourceFile.resolvedPath;
-        const cachedDiagnostics = semanticDiagnosticsPerFile.get(path2);
+        const path3 = sourceFile.resolvedPath;
+        const cachedDiagnostics = semanticDiagnosticsPerFile.get(path3);
         if (cachedDiagnostics) {
           return filterSemanticDiagnostics(cachedDiagnostics, state.compilerOptions);
         }
         const diagnostics = state.program.getBindAndCheckDiagnostics(sourceFile, cancellationToken);
-        semanticDiagnosticsPerFile.set(path2, diagnostics);
+        semanticDiagnosticsPerFile.set(path3, diagnostics);
         state.buildInfoEmitPending = true;
         return filterSemanticDiagnostics(diagnostics, state.compilerOptions);
       }
@@ -142791,11 +142791,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 path2 of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
-            if (tryAddToSet(seenFiles, path2)) {
-              const file = state.program.getSourceFileByPath(path2);
+          for (const path3 of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
+            if (tryAddToSet(seenFiles, path3)) {
+              const file = state.program.getSourceFileByPath(path3);
               if (!file || !sourceFileMayBeEmitted(file, state.program)) continue;
-              const fileId = toFileId(path2), pendingEmit = state.affectedFilesPendingEmit.get(path2);
+              const fileId = toFileId(path3), pendingEmit = state.affectedFilesPendingEmit.get(path3);
               affectedFilesPendingEmit = append(
                 affectedFilesPendingEmit,
                 pendingEmit === fullEmitForOptions ? fileId : (
@@ -142829,17 +142829,17 @@ ${lanes.join("\n")}
           version: version2
         };
         return buildInfo;
-        function relativeToBuildInfoEnsuringAbsolutePath(path2) {
-          return relativeToBuildInfo(getNormalizedAbsolutePath(path2, currentDirectory));
+        function relativeToBuildInfoEnsuringAbsolutePath(path3) {
+          return relativeToBuildInfo(getNormalizedAbsolutePath(path3, currentDirectory));
         }
-        function relativeToBuildInfo(path2) {
-          return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path2, state.program.getCanonicalFileName));
+        function relativeToBuildInfo(path3) {
+          return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path3, state.program.getCanonicalFileName));
         }
-        function toFileId(path2) {
-          let fileId = fileNameToFileId.get(path2);
+        function toFileId(path3) {
+          let fileId = fileNameToFileId.get(path3);
           if (fileId === void 0) {
-            fileNames.push(relativeToBuildInfo(path2));
-            fileNameToFileId.set(path2, fileId = fileNames.length);
+            fileNames.push(relativeToBuildInfo(path3));
+            fileNameToFileId.set(path3, fileId = fileNames.length);
           }
           return fileId;
         }
@@ -142853,8 +142853,8 @@ ${lanes.join("\n")}
           }
           return fileIdListId;
         }
-        function tryAddRoot(path2, fileId) {
-          const file = state.program.getSourceFile(path2);
+        function tryAddRoot(path3, fileId) {
+          const file = state.program.getSourceFile(path3);
           if (!state.program.getFileIncludeReasons().get(file.path).some(
             (r) => r.kind === 0
             /* RootFile */
@@ -142871,10 +142871,10 @@ ${lanes.join("\n")}
         }
         function toResolvedRoot() {
           let result;
-          rootFileNames.forEach((path2) => {
-            const file = state.program.getSourceFileByPath(path2);
-            if (file && path2 !== file.resolvedPath) {
-              result = append(result, [toFileId(file.resolvedPath), toFileId(path2)]);
+          rootFileNames.forEach((path3) => {
+            const file = state.program.getSourceFileByPath(path3);
+            if (file && path3 !== file.resolvedPath) {
+              result = append(result, [toFileId(file.resolvedPath), toFileId(path3)]);
             }
           });
           return result;
@@ -142982,8 +142982,8 @@ ${lanes.join("\n")}
         function toChangeFileSet() {
           let changeFileSet;
           if (state.changedFilesSet.size) {
-            for (const path2 of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
-              changeFileSet = append(changeFileSet, toFileId(path2));
+            for (const path3 of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
+              changeFileSet = append(changeFileSet, toFileId(path3));
             }
           }
           return changeFileSet;
@@ -143482,8 +143482,8 @@ ${lanes.join("\n")}
         const changedFilesSet = new Set(map(buildInfo.changeFileSet, toFilePath));
         if (isIncrementalBundleEmitBuildInfo(buildInfo)) {
           buildInfo.fileInfos.forEach((fileInfo, index) => {
-            const path2 = toFilePath(index + 1);
-            fileInfos.set(path2, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
+            const path3 = toFilePath(index + 1);
+            fileInfos.set(path3, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
           });
           state = {
             fileInfos,
@@ -143502,10 +143502,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 path2 = toFilePath(index + 1);
+            const path3 = toFilePath(index + 1);
             const stateFileInfo = toBuilderStateFileInfoForMultiEmit(fileInfo);
-            fileInfos.set(path2, stateFileInfo);
-            if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path2, stateFileInfo.signature);
+            fileInfos.set(path3, stateFileInfo);
+            if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path3, stateFileInfo.signature);
           });
           (_d = buildInfo.emitSignatures) == null ? void 0 : _d.forEach((value) => {
             if (isNumber(value)) emitSignatures.delete(toFilePath(value));
@@ -143559,11 +143559,11 @@ ${lanes.join("\n")}
           close: noop,
           hasChangedEmitSignature: returnFalse
         };
-        function toPathInBuildInfoDirectory(path2) {
-          return toPath(path2, buildInfoDirectory, getCanonicalFileName);
+        function toPathInBuildInfoDirectory(path3) {
+          return toPath(path3, buildInfoDirectory, getCanonicalFileName);
         }
-        function toAbsolutePath(path2) {
-          return getNormalizedAbsolutePath(path2, buildInfoDirectory);
+        function toAbsolutePath(path3) {
+          return getNormalizedAbsolutePath(path3, buildInfoDirectory);
         }
         function toFilePath(fileId) {
           return filePaths[fileId - 1];
@@ -143602,30 +143602,30 @@ ${lanes.join("\n")}
         const roots = /* @__PURE__ */ new Map();
         const resolvedRoots = new Map(program.resolvedRoot);
         program.fileInfos.forEach((fileInfo, index) => {
-          const path2 = toPath(program.fileNames[index], buildInfoDirectory, getCanonicalFileName);
+          const path3 = toPath(program.fileNames[index], buildInfoDirectory, getCanonicalFileName);
           const version22 = isString(fileInfo) ? fileInfo : fileInfo.version;
-          fileInfos.set(path2, version22);
+          fileInfos.set(path3, version22);
           if (rootIndex < program.root.length) {
             const current = program.root[rootIndex];
             const fileId = index + 1;
             if (isArray(current)) {
               if (current[0] <= fileId && fileId <= current[1]) {
-                addRoot(fileId, path2);
+                addRoot(fileId, path3);
                 if (current[1] === fileId) rootIndex++;
               }
             } else if (current === fileId) {
-              addRoot(fileId, path2);
+              addRoot(fileId, path3);
               rootIndex++;
             }
           }
         });
         return { fileInfos, roots };
-        function addRoot(fileId, path2) {
+        function addRoot(fileId, path3) {
           const root = resolvedRoots.get(fileId);
           if (root) {
-            roots.set(toPath(program.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path2);
+            roots.set(toPath(program.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path3);
           } else {
-            roots.set(path2, void 0);
+            roots.set(path3, void 0);
           }
         }
       }
@@ -143700,11 +143700,11 @@ ${lanes.join("\n")}
           newConfigFileParsingDiagnostics
         );
       }
-      function removeIgnoredPath(path2) {
-        if (endsWith(path2, "/node_modules/.staging")) {
-          return removeSuffix(path2, "/.staging");
+      function removeIgnoredPath(path3) {
+        if (endsWith(path3, "/node_modules/.staging")) {
+          return removeSuffix(path3, "/.staging");
         }
-        return some(ignoredPaths, (searchPath) => path2.includes(searchPath)) ? void 0 : path2;
+        return some(ignoredPaths, (searchPath) => path3.includes(searchPath)) ? void 0 : path3;
       }
       function perceivedOsRootLengthForWatching(pathComponents2, length2) {
         if (length2 <= 1) return 1;
@@ -143730,8 +143730,8 @@ ${lanes.join("\n")}
         const perceivedOsRootLength = perceivedOsRootLengthForWatching(pathComponents2, length2);
         return length2 > perceivedOsRootLength + 1;
       }
-      function canWatchDirectoryOrFilePath(path2) {
-        return canWatchDirectoryOrFile(getPathComponents(path2));
+      function canWatchDirectoryOrFilePath(path3) {
+        return canWatchDirectoryOrFile(getPathComponents(path3));
       }
       function canWatchAtTypes(atTypes) {
         return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(getDirectoryPath(atTypes));
@@ -144025,11 +144025,11 @@ ${lanes.join("\n")}
           filesWithChangedSetOfUnresolvedImports = void 0;
           return collected;
         }
-        function isFileWithInvalidatedNonRelativeUnresolvedImports(path2) {
+        function isFileWithInvalidatedNonRelativeUnresolvedImports(path3) {
           if (!filesWithInvalidatedNonRelativeUnresolvedImports) {
             return false;
           }
-          const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path2);
+          const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path3);
           return !!value && !!value.length;
         }
         function createHasInvalidatedResolutions(customHasInvalidatedResolutions, customHasInvalidatedLibResolutions) {
@@ -144037,7 +144037,7 @@ ${lanes.join("\n")}
           const collected = filesWithInvalidatedResolutions;
           filesWithInvalidatedResolutions = void 0;
           return {
-            hasInvalidatedResolutions: (path2) => customHasInvalidatedResolutions(path2) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path2)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path2),
+            hasInvalidatedResolutions: (path3) => customHasInvalidatedResolutions(path3) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path3)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path3),
             hasInvalidatedLibResolutions: (libFileName) => {
               var _a;
               return customHasInvalidatedLibResolutions(libFileName) || !!((_a = resolvedLibraries == null ? void 0 : resolvedLibraries.get(libFileName)) == null ? void 0 : _a.isInvalidated);
@@ -144093,11 +144093,11 @@ ${lanes.join("\n")}
               if (expected) impliedFormatPackageJsons.set(newFile.resolvedPath, newFile.packageJsonLocations);
               else impliedFormatPackageJsons.delete(newFile.resolvedPath);
             });
-            impliedFormatPackageJsons.forEach((existing, path2) => {
-              const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path2);
-              if (!newFile || newFile.resolvedPath !== path2) {
+            impliedFormatPackageJsons.forEach((existing, path3) => {
+              const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path3);
+              if (!newFile || newFile.resolvedPath !== path3) {
                 existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
-                impliedFormatPackageJsons.delete(path2);
+                impliedFormatPackageJsons.delete(path3);
               }
             });
           }
@@ -144116,16 +144116,16 @@ ${lanes.join("\n")}
             packageDirWatchers.delete(packageDirPath);
           }
         }
-        function closeDirectoryWatchesOfFailedLookup(watcher, path2) {
+        function closeDirectoryWatchesOfFailedLookup(watcher, path3) {
           if (watcher.refCount === 0) {
-            directoryWatchesOfFailedLookups.delete(path2);
+            directoryWatchesOfFailedLookups.delete(path3);
             watcher.watcher.close();
           }
         }
-        function closeFileWatcherOfAffectingLocation(watcher, path2) {
+        function closeFileWatcherOfAffectingLocation(watcher, path3) {
           var _a;
           if (watcher.files === 0 && watcher.resolutions === 0 && !((_a = watcher.symlinks) == null ? void 0 : _a.size)) {
-            fileWatchesOfAffectingLocations.delete(path2);
+            fileWatchesOfAffectingLocations.delete(path3);
             watcher.watcher.close();
           }
         }
@@ -144144,10 +144144,10 @@ ${lanes.join("\n")}
           logChanges
         }) {
           var _a;
-          const path2 = resolutionHost.toPath(containingFile);
-          const resolutionsInFile = perFileCache.get(path2) || perFileCache.set(path2, createModeAwareCache()).get(path2);
+          const path3 = resolutionHost.toPath(containingFile);
+          const resolutionsInFile = perFileCache.get(path3) || perFileCache.set(path3, createModeAwareCache()).get(path3);
           const resolvedModules = [];
-          const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path2);
+          const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path3);
           const program = resolutionHost.getCurrentProgram();
           const oldRedirect = program && ((_a = program.getRedirectFromSourceFile(containingFile)) == null ? void 0 : _a.resolvedRef);
           const unmatchedRedirects = oldRedirect ? !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : !!redirectedReference;
@@ -144165,13 +144165,13 @@ ${lanes.join("\n")}
               }
               resolutionsInFile.set(name, mode, resolution);
               if (resolution !== existingResolution) {
-                watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path2, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
+                watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path3, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
                 if (existingResolution) {
-                  stopWatchFailedLookupLocationOfResolution(existingResolution, path2, getResolutionWithResolvedFileName);
+                  stopWatchFailedLookupLocationOfResolution(existingResolution, path3, getResolutionWithResolvedFileName);
                 }
               }
               if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
-                filesWithChangedSetOfUnresolvedImports.push(path2);
+                filesWithChangedSetOfUnresolvedImports.push(path3);
                 logChanges = false;
               }
             } else {
@@ -144202,7 +144202,7 @@ ${lanes.join("\n")}
           if (resolutionsInFile.size() !== seenNamesInFile.size()) {
             resolutionsInFile.forEach((resolution, name, mode) => {
               if (!seenNamesInFile.has(name, mode)) {
-                stopWatchFailedLookupLocationOfResolution(resolution, path2, getResolutionWithResolvedFileName);
+                stopWatchFailedLookupLocationOfResolution(resolution, path3, getResolutionWithResolvedFileName);
                 resolutionsInFile.delete(name, mode);
               }
             });
@@ -144276,18 +144276,18 @@ ${lanes.join("\n")}
           if (!resolution || resolution.isInvalidated) {
             const existingResolution = resolution;
             resolution = resolveLibrary(libraryName, resolveFrom, options, host, libraryResolutionCache);
-            const path2 = resolutionHost.toPath(resolveFrom);
+            const path3 = resolutionHost.toPath(resolveFrom);
             watchFailedLookupLocationsOfExternalModuleResolutions(
               libraryName,
               resolution,
-              path2,
+              path3,
               getResolvedModuleFromResolution,
               /*deferWatchingNonRelativeResolution*/
               false
             );
             resolvedLibraries.set(libFileName, resolution);
             if (existingResolution) {
-              stopWatchFailedLookupLocationOfResolution(existingResolution, path2, getResolvedModuleFromResolution);
+              stopWatchFailedLookupLocationOfResolution(existingResolution, path3, getResolvedModuleFromResolution);
             }
           } else {
             if (isTraceEnabled(options, host)) {
@@ -144306,8 +144306,8 @@ ${lanes.join("\n")}
         }
         function resolveSingleModuleNameWithoutWatching(moduleName, containingFile) {
           var _a, _b;
-          const path2 = resolutionHost.toPath(containingFile);
-          const resolutionsInFile = resolvedModuleNames.get(path2);
+          const path3 = resolutionHost.toPath(containingFile);
+          const resolutionsInFile = resolvedModuleNames.get(path3);
           const resolution = resolutionsInFile == null ? void 0 : resolutionsInFile.get(
             moduleName,
             /*mode*/
@@ -144464,13 +144464,13 @@ ${lanes.join("\n")}
             (symlinkWatcher.symlinks ?? (symlinkWatcher.symlinks = /* @__PURE__ */ new Set())).add(affectingLocation);
           }
         }
-        function invalidateAffectingFileWatcher(path2, packageJsonMap) {
+        function invalidateAffectingFileWatcher(path3, packageJsonMap) {
           var _a;
-          const watcher = fileWatchesOfAffectingLocations.get(path2);
-          if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path2);
-          if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path2);
+          const watcher = fileWatchesOfAffectingLocations.get(path3);
+          if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path3);
+          if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path3);
           (_a = watcher == null ? void 0 : watcher.symlinks) == null ? void 0 : _a.forEach((path22) => invalidateAffectingFileWatcher(path22, packageJsonMap));
-          packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path2));
+          packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path3));
         }
         function watchFailedLookupLocationOfNonRelativeModuleResolutions() {
           nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfResolution);
@@ -144709,7 +144709,7 @@ ${lanes.join("\n")}
         function invalidatePackageJsonMap() {
           const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
           if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) {
-            packageJsonMap.forEach((_value, path2) => isInvalidatedFailedLookup(path2) ? packageJsonMap.delete(path2) : void 0);
+            packageJsonMap.forEach((_value, path3) => isInvalidatedFailedLookup(path3) ? packageJsonMap.delete(path3) : void 0);
           }
         }
         function invalidateResolutionsOfFailedLookupLocations() {
@@ -145327,9 +145327,9 @@ ${lanes.join("\n")}
           getDefaultLibLocation: maybeBind(host, host.getDefaultLibLocation),
           getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
           writeFile: createWriteFileMeasuringIO(
-            (path2, data, writeByteOrderMark) => host.writeFile(path2, data, writeByteOrderMark),
-            (path2) => host.createDirectory(path2),
-            (path2) => host.directoryExists(path2)
+            (path3, data, writeByteOrderMark) => host.writeFile(path3, data, writeByteOrderMark),
+            (path3) => host.createDirectory(path3),
+            (path3) => host.directoryExists(path3)
           ),
           getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
           useCaseSensitiveFileNames: () => useCaseSensitiveFileNames2,
@@ -145400,16 +145400,16 @@ ${lanes.join("\n")}
           getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
           getDefaultLibLocation,
           getDefaultLibFileName: (options) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
-          fileExists: (path2) => system.fileExists(path2),
-          readFile: (path2, encoding) => system.readFile(path2, encoding),
-          directoryExists: (path2) => system.directoryExists(path2),
-          getDirectories: (path2) => system.getDirectories(path2),
-          readDirectory: (path2, extensions, exclude, include, depth) => system.readDirectory(path2, extensions, exclude, include, depth),
+          fileExists: (path3) => system.fileExists(path3),
+          readFile: (path3, encoding) => system.readFile(path3, encoding),
+          directoryExists: (path3) => system.directoryExists(path3),
+          getDirectories: (path3) => system.getDirectories(path3),
+          readDirectory: (path3, extensions, exclude, include, depth) => system.readDirectory(path3, extensions, exclude, include, depth),
           realpath: maybeBind(system, system.realpath),
           getEnvironmentVariable: maybeBind(system, system.getEnvironmentVariable),
           trace: (s) => system.write(s + system.newLine),
-          createDirectory: (path2) => system.createDirectory(path2),
-          writeFile: (path2, data, writeByteOrderMark) => system.writeFile(path2, data, writeByteOrderMark),
+          createDirectory: (path3) => system.createDirectory(path3),
+          writeFile: (path3, data, writeByteOrderMark) => system.writeFile(path3, data, writeByteOrderMark),
           createHash: maybeBind(system, system.createHash),
           createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
           storeSignatureInfo: system.storeSignatureInfo,
@@ -145722,7 +145722,7 @@ ${lanes.join("\n")}
             originalWriteFile,
             readFileWithCache
           } = changeCompilerHostLikeToUseCache(compilerHost, toPath3);
-          if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path2) => getSourceVersion(path2, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+          if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path3) => getSourceVersion(path3, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
             if (hasChangedConfigFileParsingErrors) {
               if (reportFileChangeDetectedOnCreateProgram) {
                 reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
@@ -145816,14 +145816,14 @@ ${lanes.join("\n")}
           return typeof hostSourceFile.version === "boolean";
         }
         function fileExists(fileName) {
-          const path2 = toPath3(fileName);
-          if (isFileMissingOnHost(sourceFilesCache.get(path2))) {
+          const path3 = toPath3(fileName);
+          if (isFileMissingOnHost(sourceFilesCache.get(path3))) {
             return false;
           }
           return directoryStructureHost.fileExists(fileName);
         }
-        function getVersionedSourceFileByPath(fileName, path2, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
-          const hostSourceFile = sourceFilesCache.get(path2);
+        function getVersionedSourceFileByPath(fileName, path3, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
+          const hostSourceFile = sourceFilesCache.get(path3);
           if (isFileMissingOnHost(hostSourceFile)) {
             return void 0;
           }
@@ -145835,41 +145835,41 @@ ${lanes.join("\n")}
                 hostSourceFile.sourceFile = sourceFile;
                 hostSourceFile.version = sourceFile.version;
                 if (!hostSourceFile.fileWatcher) {
-                  hostSourceFile.fileWatcher = watchFilePath(path2, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
+                  hostSourceFile.fileWatcher = watchFilePath(path3, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
                 }
               } else {
                 if (hostSourceFile.fileWatcher) {
                   hostSourceFile.fileWatcher.close();
                 }
-                sourceFilesCache.set(path2, false);
+                sourceFilesCache.set(path3, false);
               }
             } else {
               if (sourceFile) {
-                const fileWatcher = watchFilePath(path2, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
-                sourceFilesCache.set(path2, { sourceFile, version: sourceFile.version, fileWatcher });
+                const fileWatcher = watchFilePath(path3, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
+                sourceFilesCache.set(path3, { sourceFile, version: sourceFile.version, fileWatcher });
               } else {
-                sourceFilesCache.set(path2, false);
+                sourceFilesCache.set(path3, false);
               }
             }
             return sourceFile;
           }
           return hostSourceFile.sourceFile;
         }
-        function nextSourceFileVersion(path2) {
-          const hostSourceFile = sourceFilesCache.get(path2);
+        function nextSourceFileVersion(path3) {
+          const hostSourceFile = sourceFilesCache.get(path3);
           if (hostSourceFile !== void 0) {
             if (isFileMissingOnHost(hostSourceFile)) {
-              sourceFilesCache.set(path2, { version: false });
+              sourceFilesCache.set(path3, { version: false });
             } else {
               hostSourceFile.version = false;
             }
           }
         }
-        function getSourceVersion(path2, readFileWithCache) {
-          const hostSourceFile = sourceFilesCache.get(path2);
+        function getSourceVersion(path3, readFileWithCache) {
+          const hostSourceFile = sourceFilesCache.get(path3);
           if (!hostSourceFile) return void 0;
           if (hostSourceFile.version) return hostSourceFile.version;
-          const text = readFileWithCache(path2);
+          const text = readFileWithCache(path3);
           return text !== void 0 ? getSourceFileVersionAsHashFromText(compilerHost, text) : void 0;
         }
         function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) {
@@ -146048,28 +146048,28 @@ ${lanes.join("\n")}
         }
         function onReleaseParsedCommandLine(fileName) {
           var _a;
-          const path2 = toPath3(fileName);
-          const config = parsedConfigs == null ? void 0 : parsedConfigs.get(path2);
+          const path3 = toPath3(fileName);
+          const config = parsedConfigs == null ? void 0 : parsedConfigs.get(path3);
           if (!config) return;
-          parsedConfigs.delete(path2);
+          parsedConfigs.delete(path3);
           if (config.watchedDirectories) clearMap(config.watchedDirectories, closeFileWatcherOf);
           (_a = config.watcher) == null ? void 0 : _a.close();
-          clearSharedExtendedConfigFileWatcher(path2, sharedExtendedConfigFileWatchers);
+          clearSharedExtendedConfigFileWatcher(path3, sharedExtendedConfigFileWatchers);
         }
-        function watchFilePath(path2, file, callback, pollingInterval, options, watchType) {
-          return watchFile2(file, (fileName, eventKind) => callback(fileName, eventKind, path2), pollingInterval, options, watchType);
+        function watchFilePath(path3, file, callback, pollingInterval, options, watchType) {
+          return watchFile2(file, (fileName, eventKind) => callback(fileName, eventKind, path3), pollingInterval, options, watchType);
         }
-        function onSourceFileChange(fileName, eventKind, path2) {
-          updateCachedSystemWithFile(fileName, path2, eventKind);
-          if (eventKind === 2 && sourceFilesCache.has(path2)) {
-            resolutionCache.invalidateResolutionOfFile(path2);
+        function onSourceFileChange(fileName, eventKind, path3) {
+          updateCachedSystemWithFile(fileName, path3, eventKind);
+          if (eventKind === 2 && sourceFilesCache.has(path3)) {
+            resolutionCache.invalidateResolutionOfFile(path3);
           }
-          nextSourceFileVersion(path2);
+          nextSourceFileVersion(path3);
           scheduleProgramUpdate();
         }
-        function updateCachedSystemWithFile(fileName, path2, eventKind) {
+        function updateCachedSystemWithFile(fileName, path3, eventKind) {
           if (cachedDirectoryStructureHost) {
-            cachedDirectoryStructureHost.addOrDeleteFile(fileName, path2, eventKind);
+            cachedDirectoryStructureHost.addOrDeleteFile(fileName, path3, eventKind);
           }
         }
         function watchMissingFilePath(missingFilePath, missingFileName) {
@@ -146290,9 +146290,9 @@ ${lanes.join("\n")}
       }
       function createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus) {
         const host = createProgramHost(system, createProgram2);
-        host.getModifiedTime = system.getModifiedTime ? (path2) => system.getModifiedTime(path2) : returnUndefined;
-        host.setModifiedTime = system.setModifiedTime ? (path2, date) => system.setModifiedTime(path2, date) : noop;
-        host.deleteFile = system.deleteFile ? (path2) => system.deleteFile(path2) : noop;
+        host.getModifiedTime = system.getModifiedTime ? (path3) => system.getModifiedTime(path3) : returnUndefined;
+        host.setModifiedTime = system.setModifiedTime ? (path3, date) => system.setModifiedTime(path3, date) : noop;
+        host.deleteFile = system.deleteFile ? (path3) => system.deleteFile(path3) : noop;
         host.reportDiagnostic = reportDiagnostic || createDiagnosticReporter(system);
         host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system);
         host.now = maybeBind(system, system.now);
@@ -146463,8 +146463,8 @@ ${lanes.join("\n")}
       }
       function toResolvedConfigFilePath(state, fileName) {
         const { resolvedConfigFilePaths } = state;
-        const path2 = resolvedConfigFilePaths.get(fileName);
-        if (path2 !== void 0) return path2;
+        const path3 = resolvedConfigFilePaths.get(fileName);
+        if (path3 !== void 0) return path3;
         const resolvedPath = toPath2(state, fileName);
         resolvedConfigFilePaths.set(fileName, resolvedPath);
         return resolvedPath;
@@ -146852,7 +146852,7 @@ ${lanes.join("\n")}
             void 0,
             (name, text, writeByteOrderMark, onError, sourceFiles, data) => {
               var _a2;
-              const path2 = toPath2(state, name);
+              const path3 = toPath2(state, name);
               emittedOutputs.set(toPath2(state, name), name);
               if (data == null ? void 0 : data.buildInfo) {
                 now || (now = getCurrentTime(state.host));
@@ -146882,7 +146882,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(path2, now || (now = getCurrentTime(state.host)));
+                (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path3, now || (now = getCurrentTime(state.host)));
               }
             },
             cancellationToken,
@@ -147066,8 +147066,8 @@ ${lanes.join("\n")}
         return !!value.watcher;
       }
       function getModifiedTime2(state, fileName) {
-        const path2 = toPath2(state, fileName);
-        const existing = state.filesWatched.get(path2);
+        const path3 = toPath2(state, fileName);
+        const existing = state.filesWatched.get(path3);
         if (state.watch && !!existing) {
           if (!isFileWatcherWithModifiedTime(existing)) return existing;
           if (existing.modifiedTime) return existing.modifiedTime;
@@ -147075,20 +147075,20 @@ ${lanes.join("\n")}
         const result = getModifiedTime(state.host, fileName);
         if (state.watch) {
           if (existing) existing.modifiedTime = result;
-          else state.filesWatched.set(path2, result);
+          else state.filesWatched.set(path3, result);
         }
         return result;
       }
       function watchFile(state, file, callback, pollingInterval, options, watchType, project) {
-        const path2 = toPath2(state, file);
-        const existing = state.filesWatched.get(path2);
+        const path3 = toPath2(state, file);
+        const existing = state.filesWatched.get(path3);
         if (existing && isFileWatcherWithModifiedTime(existing)) {
           existing.callbacks.push(callback);
         } else {
           const watcher = state.watchFile(
             file,
             (fileName, eventKind, modifiedTime) => {
-              const existing2 = Debug.checkDefined(state.filesWatched.get(path2));
+              const existing2 = Debug.checkDefined(state.filesWatched.get(path3));
               Debug.assert(isFileWatcherWithModifiedTime(existing2));
               existing2.modifiedTime = modifiedTime;
               existing2.callbacks.forEach((cb) => cb(fileName, eventKind, modifiedTime));
@@ -147098,14 +147098,14 @@ ${lanes.join("\n")}
             watchType,
             project
           );
-          state.filesWatched.set(path2, { callbacks: [callback], watcher, modifiedTime: existing });
+          state.filesWatched.set(path3, { callbacks: [callback], watcher, modifiedTime: existing });
         }
         return {
           close: () => {
-            const existing2 = Debug.checkDefined(state.filesWatched.get(path2));
+            const existing2 = Debug.checkDefined(state.filesWatched.get(path3));
             Debug.assert(isFileWatcherWithModifiedTime(existing2));
             if (existing2.callbacks.length === 1) {
-              state.filesWatched.delete(path2);
+              state.filesWatched.delete(path3);
               closeFileWatcherOf(existing2);
             } else {
               unorderedRemoveItem(existing2.callbacks, callback);
@@ -147120,19 +147120,19 @@ ${lanes.join("\n")}
         return result;
       }
       function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
-        const path2 = toPath2(state, buildInfoPath);
+        const path3 = toPath2(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
-        return (existing == null ? void 0 : existing.path) === path2 ? existing : void 0;
+        return (existing == null ? void 0 : existing.path) === path3 ? existing : void 0;
       }
       function getBuildInfo3(state, buildInfoPath, resolvedConfigPath, modifiedTime) {
-        const path2 = toPath2(state, buildInfoPath);
+        const path3 = toPath2(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
-        if (existing !== void 0 && existing.path === path2) {
+        if (existing !== void 0 && existing.path === path3) {
           return existing.buildInfo || void 0;
         }
         const value = state.readFileWithCache(buildInfoPath);
         const buildInfo = value ? getBuildInfo(buildInfoPath, value) : void 0;
-        state.buildInfoCache.set(resolvedConfigPath, { path: path2, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
+        state.buildInfoCache.set(resolvedConfigPath, { path: path3, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
         return buildInfo;
       }
       function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) {
@@ -147313,11 +147313,11 @@ ${lanes.join("\n")}
           const outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
           for (const output of outputs) {
             if (output === buildInfoPath) continue;
-            const path2 = toPath2(state, output);
-            let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path2);
+            const path3 = toPath2(state, output);
+            let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path3);
             if (!outputTime) {
               outputTime = getModifiedTime(state.host, output);
-              outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path2, outputTime);
+              outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path3, outputTime);
             }
             if (outputTime === missingFileModifiedTime) {
               return {
@@ -147371,7 +147371,7 @@ ${lanes.join("\n")}
         const packageJsonLookups = state.lastCachedPackageJsonLookups.get(resolvedPath);
         const dependentPackageFileStatus = packageJsonLookups && forEachKey(
           packageJsonLookups,
-          (path2) => checkConfigFileUpToDateStatus(state, path2, oldestOutputFileTime, oldestOutputFileName)
+          (path3) => checkConfigFileUpToDateStatus(state, path3, oldestOutputFileTime, oldestOutputFileName)
         );
         if (dependentPackageFileStatus) return dependentPackageFileStatus;
         return {
@@ -147421,8 +147421,8 @@ ${lanes.join("\n")}
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
           let reportVerbose = !!state.options.verbose;
           for (const file of outputs) {
-            const path2 = toPath2(state, file);
-            if (skipOutputs == null ? void 0 : skipOutputs.has(path2)) continue;
+            const path3 = toPath2(state, file);
+            if (skipOutputs == null ? void 0 : skipOutputs.has(path3)) continue;
             if (reportVerbose) {
               reportVerbose = false;
               reportStatus(state, verboseMessage, proj.options.configFilePath);
@@ -147430,8 +147430,8 @@ ${lanes.join("\n")}
             host.setModifiedTime(file, now || (now = getCurrentTime(state.host)));
             if (file === buildInfoPath) getBuildInfoCacheEntry(state, buildInfoPath, projectPath).modifiedTime = now;
             else if (outputTimeStampMap) {
-              outputTimeStampMap.set(path2, now);
-              modifiedOutputs.add(path2);
+              outputTimeStampMap.set(path3, now);
+              modifiedOutputs.add(path3);
             }
           }
         }
@@ -147859,8 +147859,8 @@ ${lanes.join("\n")}
           close: () => stopWatching(state)
         };
       }
-      function relName(state, path2) {
-        return convertToRelativePath(path2, state.compilerHost.getCurrentDirectory(), state.compilerHost.getCanonicalFileName);
+      function relName(state, path3) {
+        return convertToRelativePath(path3, state.compilerHost.getCurrentDirectory(), state.compilerHost.getCanonicalFileName);
       }
       function reportStatus(state, message, ...args) {
         state.host.reportSolutionBuilderStatus(createCompilerDiagnostic(message, ...args));
@@ -148079,13 +148079,13 @@ ${lanes.join("\n")}
         } else if (file.isDeclarationFile) {
           return "Definitions";
         }
-        const path2 = file.path;
-        if (fileExtensionIsOneOf(path2, supportedTSExtensionsFlat)) {
+        const path3 = file.path;
+        if (fileExtensionIsOneOf(path3, supportedTSExtensionsFlat)) {
           return "TypeScript";
-        } else if (fileExtensionIsOneOf(path2, supportedJSExtensionsFlat)) {
+        } else if (fileExtensionIsOneOf(path3, supportedJSExtensionsFlat)) {
           return "JavaScript";
         } else if (fileExtensionIs(
-          path2,
+          path3,
           ".json"
           /* Json */
         )) {
@@ -148697,7 +148697,7 @@ ${lanes.join("\n")}
             );
           }
         }
-        const commandLine = parseCommandLine(commandLineArgs, (path2) => system.readFile(path2));
+        const commandLine = parseCommandLine(commandLineArgs, (path3) => system.readFile(path3));
         if (commandLine.options.generateCpuProfile && system.enableCPUProfiler) {
           system.enableCPUProfiler(commandLine.options.generateCpuProfile, () => executeCommandLineWorker(
             system,
@@ -150573,12 +150573,12 @@ ${lanes.join("\n")}
         return nodeCoreModules.has(moduleName) ? "node" : moduleName;
       }
       function loadSafeList(host, safeListPath) {
-        const result = readConfigFile(safeListPath, (path2) => host.readFile(path2));
+        const result = readConfigFile(safeListPath, (path3) => host.readFile(path3));
         return new Map(Object.entries(result.config));
       }
       function loadTypesMap(host, typesMapPath) {
         var _a;
-        const result = readConfigFile(typesMapPath, (path2) => host.readFile(path2));
+        const result = readConfigFile(typesMapPath, (path3) => host.readFile(path3));
         if ((_a = result.config) == null ? void 0 : _a.simpleMap) {
           return new Map(Object.entries(result.config.simpleMap));
         }
@@ -150590,9 +150590,9 @@ ${lanes.join("\n")}
         }
         const inferredTypings = /* @__PURE__ */ new Map();
         fileNames = mapDefined(fileNames, (fileName) => {
-          const path2 = normalizePath(fileName);
-          if (hasJSFileExtension(path2)) {
-            return path2;
+          const path3 = normalizePath(fileName);
+          if (hasJSFileExtension(path3)) {
+            return path3;
           }
         });
         const filesToWatch = [];
@@ -150654,7 +150654,7 @@ ${lanes.join("\n")}
           let manifestTypingNames;
           if (host.fileExists(manifestPath)) {
             filesToWatch2.push(manifestPath);
-            manifest = readConfigFile(manifestPath, (path2) => host.readFile(path2)).config;
+            manifest = readConfigFile(manifestPath, (path3) => host.readFile(path3)).config;
             manifestTypingNames = flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], getOwnKeys);
             addInferredTypings(manifestTypingNames, `Typing names in '${manifestPath}' dependencies`);
           }
@@ -150688,7 +150688,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, (path2) => host.readFile(path2));
+            const result2 = readConfigFile(normalizedFileName, (path3) => host.readFile(path3));
             const manifest2 = result2.config;
             if (!manifest2.name) {
               continue;
@@ -153468,14 +153468,14 @@ ${lanes.join("\n")}
       function tryGetDirectories(host, directoryName) {
         return tryIOAndConsumeErrors(host, host.getDirectories, directoryName) || [];
       }
-      function tryReadDirectory(host, path2, extensions, exclude, include) {
-        return tryIOAndConsumeErrors(host, host.readDirectory, path2, extensions, exclude, include) || emptyArray;
+      function tryReadDirectory(host, path3, extensions, exclude, include) {
+        return tryIOAndConsumeErrors(host, host.readDirectory, path3, extensions, exclude, include) || emptyArray;
       }
-      function tryFileExists(host, path2) {
-        return tryIOAndConsumeErrors(host, host.fileExists, path2);
+      function tryFileExists(host, path3) {
+        return tryIOAndConsumeErrors(host, host.fileExists, path3);
       }
-      function tryDirectoryExists(host, path2) {
-        return tryAndIgnoreErrors(() => directoryProbablyExists(path2, host)) || false;
+      function tryDirectoryExists(host, path3) {
+        return tryAndIgnoreErrors(() => directoryProbablyExists(path3, host)) || false;
       }
       function tryAndIgnoreErrors(cb) {
         try {
@@ -154317,13 +154317,13 @@ ${lanes.join("\n")}
       function getIsExcluded(excludePatterns, host) {
         var _a;
         const realpathsWithSymlinks = (_a = host.getSymlinkCache) == null ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
-        return ({ fileName, path: path2 }) => {
+        return ({ fileName, path: path3 }) => {
           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(path2),
+              getDirectoryPath(path3),
               (dirPath) => {
                 const symlinks = realpathsWithSymlinks.get(ensureTrailingDirectorySeparator(dirPath));
                 if (symlinks) {
@@ -155979,14 +155979,14 @@ ${lanes.join("\n")}
           return settingsOrHost;
         }
         function acquireDocument(fileName, compilationSettings, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
-          const path2 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path3 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-          return acquireDocumentWithKey(fileName, path2, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
+          return acquireDocumentWithKey(fileName, path3, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
         }
-        function acquireDocumentWithKey(fileName, path2, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
+        function acquireDocumentWithKey(fileName, path3, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
           return acquireOrUpdateDocument(
             fileName,
-            path2,
+            path3,
             compilationSettings,
             key,
             scriptSnapshot,
@@ -155998,14 +155998,14 @@ ${lanes.join("\n")}
           );
         }
         function updateDocument(fileName, compilationSettings, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
-          const path2 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path3 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-          return updateDocumentWithKey(fileName, path2, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
+          return updateDocumentWithKey(fileName, path3, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions);
         }
-        function updateDocumentWithKey(fileName, path2, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
+        function updateDocumentWithKey(fileName, path3, compilationSettings, key, scriptSnapshot, version22, scriptKind, languageVersionOrOptions) {
           return acquireOrUpdateDocument(
             fileName,
-            path2,
+            path3,
             getCompilationSettings(compilationSettings),
             key,
             scriptSnapshot,
@@ -156021,7 +156021,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, path2, compilationSettingsOrHost, key, scriptSnapshot, version22, acquiring, scriptKind, languageVersionOrOptions) {
+        function acquireOrUpdateDocument(fileName, path3, compilationSettingsOrHost, key, scriptSnapshot, version22, acquiring, scriptKind, languageVersionOrOptions) {
           var _a, _b, _c, _d;
           scriptKind = ensureScriptKind(fileName, scriptKind);
           const compilationSettings = getCompilationSettings(compilationSettingsOrHost);
@@ -156029,7 +156029,7 @@ ${lanes.join("\n")}
           const scriptTarget = scriptKind === 6 ? 100 : getEmitScriptTarget(compilationSettings);
           const sourceFileOptions = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : {
             languageVersion: scriptTarget,
-            impliedNodeFormat: host && getImpliedNodeFormatForFile(path2, (_d = (_c = (_b = (_a = host.getCompilerHost) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getModuleResolutionCache) == null ? void 0 : _c.call(_b)) == null ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
+            impliedNodeFormat: host && getImpliedNodeFormatForFile(path3, (_d = (_c = (_b = (_a = host.getCompilerHost) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getModuleResolutionCache) == null ? void 0 : _c.call(_b)) == null ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
             setExternalModuleIndicator: getSetExternalModuleIndicator(compilationSettings),
             jsDocParsingMode
           };
@@ -156042,15 +156042,15 @@ ${lanes.join("\n")}
             if (buckets.size > oldBucketCount) {
               tracing.instant(tracing.Phase.Session, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: keyWithMode });
             }
-            const otherBucketKey = !isDeclarationFileName(path2) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path2) && bucketKey);
+            const otherBucketKey = !isDeclarationFileName(path3) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path3) && bucketKey);
             if (otherBucketKey) {
-              tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path: path2, key1: otherBucketKey, key2: keyWithMode });
+              tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path: path3, key1: otherBucketKey, key2: keyWithMode });
             }
           }
-          const bucketEntry = bucket.get(path2);
+          const bucketEntry = bucket.get(path3);
           let entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind);
           if (!entry && externalCache) {
-            const sourceFile = externalCache.getDocument(keyWithMode, path2);
+            const sourceFile = externalCache.getDocument(keyWithMode, path3);
             if (sourceFile && sourceFile.scriptKind === scriptKind && sourceFile.text === getSnapshotText(scriptSnapshot)) {
               Debug.assert(acquiring);
               entry = {
@@ -156071,7 +156071,7 @@ ${lanes.join("\n")}
               scriptKind
             );
             if (externalCache) {
-              externalCache.setDocument(keyWithMode, path2, sourceFile);
+              externalCache.setDocument(keyWithMode, path3, sourceFile);
             }
             entry = {
               sourceFile,
@@ -156082,7 +156082,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, path2, entry.sourceFile);
+                externalCache.setDocument(keyWithMode, path3, entry.sourceFile);
               }
             }
             if (acquiring) {
@@ -156093,35 +156093,35 @@ ${lanes.join("\n")}
           return entry.sourceFile;
           function setBucketEntry() {
             if (!bucketEntry) {
-              bucket.set(path2, entry);
+              bucket.set(path3, entry);
             } else if (isDocumentRegistryEntry(bucketEntry)) {
               const scriptKindMap = /* @__PURE__ */ new Map();
               scriptKindMap.set(bucketEntry.sourceFile.scriptKind, bucketEntry);
               scriptKindMap.set(scriptKind, entry);
-              bucket.set(path2, scriptKindMap);
+              bucket.set(path3, scriptKindMap);
             } else {
               bucketEntry.set(scriptKind, entry);
             }
           }
         }
         function releaseDocument(fileName, compilationSettings, scriptKind, impliedNodeFormat) {
-          const path2 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path3 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(compilationSettings);
-          return releaseDocumentWithKey(path2, key, scriptKind, impliedNodeFormat);
+          return releaseDocumentWithKey(path3, key, scriptKind, impliedNodeFormat);
         }
-        function releaseDocumentWithKey(path2, key, scriptKind, impliedNodeFormat) {
+        function releaseDocumentWithKey(path3, key, scriptKind, impliedNodeFormat) {
           const bucket = Debug.checkDefined(buckets.get(getDocumentRegistryBucketKeyWithMode(key, impliedNodeFormat)));
-          const bucketEntry = bucket.get(path2);
+          const bucketEntry = bucket.get(path3);
           const entry = getDocumentRegistryEntry(bucketEntry, scriptKind);
           entry.languageServiceRefCount--;
           Debug.assert(entry.languageServiceRefCount >= 0);
           if (entry.languageServiceRefCount === 0) {
             if (isDocumentRegistryEntry(bucketEntry)) {
-              bucket.delete(path2);
+              bucket.delete(path3);
             } else {
               bucketEntry.delete(scriptKind);
               if (bucketEntry.size === 1) {
-                bucket.set(path2, firstDefinedIterator(bucketEntry.values(), identity));
+                bucket.set(path3, firstDefinedIterator(bucketEntry.values(), identity));
               }
             }
           }
@@ -156157,10 +156157,10 @@ ${lanes.join("\n")}
       }
       function getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper) {
         const canonicalOldPath = getCanonicalFileName(oldFileOrDirPath);
-        return (path2) => {
-          const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path2, pos: 0 });
-          const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path2);
-          return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path2, getCanonicalFileName) : updatedPath;
+        return (path3) => {
+          const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path3, pos: 0 });
+          const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path3);
+          return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path3, getCanonicalFileName) : updatedPath;
         };
         function getUpdatedPath(pathToUpdate) {
           if (getCanonicalFileName(pathToUpdate) === canonicalOldPath) return newFileOrDirPath;
@@ -156236,10 +156236,10 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function relativePath(path2) {
+        function relativePath(path3) {
           return getRelativePathFromDirectory(
             configDir,
-            path2,
+            path3,
             /*ignoreCase*/
             !useCaseSensitiveFileNames2
           );
@@ -157047,8 +157047,8 @@ ${lanes.join("\n")}
           return toPath(fileName, currentDirectory, getCanonicalFileName);
         }
         function getDocumentPositionMapper2(generatedFileName, sourceFileName) {
-          const path2 = toPath3(generatedFileName);
-          const value = documentPositionMappers.get(path2);
+          const path3 = toPath3(generatedFileName);
+          const value = documentPositionMappers.get(path3);
           if (value) return value;
           let mapper;
           if (host.getDocumentPositionMapper) {
@@ -157062,7 +157062,7 @@ ${lanes.join("\n")}
               (f) => !host.fileExists || host.fileExists(f) ? host.readFile(f) : void 0
             );
           }
-          documentPositionMappers.set(path2, mapper || identitySourceMapConsumer);
+          documentPositionMappers.set(path3, mapper || identitySourceMapConsumer);
           return mapper || identitySourceMapConsumer;
         }
         function tryGetSourcePosition(info) {
@@ -157090,21 +157090,21 @@ ${lanes.join("\n")}
         function getSourceFile(fileName) {
           const program = host.getProgram();
           if (!program) return void 0;
-          const path2 = toPath3(fileName);
-          const file = program.getSourceFileByPath(path2);
-          return file && file.resolvedPath === path2 ? file : void 0;
+          const path3 = toPath3(fileName);
+          const file = program.getSourceFileByPath(path3);
+          return file && file.resolvedPath === path3 ? file : void 0;
         }
         function getOrCreateSourceFileLike(fileName) {
-          const path2 = toPath3(fileName);
-          const fileFromCache = sourceFileLike.get(path2);
+          const path3 = toPath3(fileName);
+          const fileFromCache = sourceFileLike.get(path3);
           if (fileFromCache !== void 0) return fileFromCache ? fileFromCache : void 0;
           if (!host.readFile || host.fileExists && !host.fileExists(fileName)) {
-            sourceFileLike.set(path2, false);
+            sourceFileLike.set(path3, false);
             return void 0;
           }
           const text = host.readFile(fileName);
           const file = text ? createSourceFileLike(text) : false;
-          sourceFileLike.set(path2, file);
+          sourceFileLike.set(path3, file);
           return file ? file : void 0;
         }
         function getSourceFileLike(fileName) {
@@ -165190,12 +165190,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             directoryExists: (directoryName) => {
               return directoryProbablyExists(directoryName, host);
             },
-            getDirectories: (path2) => {
-              return host.getDirectories ? host.getDirectories(path2) : [];
+            getDirectories: (path3) => {
+              return host.getDirectories ? host.getDirectories(path3) : [];
             },
-            readDirectory: (path2, extensions, exclude, include, depth) => {
+            readDirectory: (path3, extensions, exclude, include, depth) => {
               Debug.checkDefined(host.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'");
-              return host.readDirectory(path2, extensions, exclude, include, depth);
+              return host.readDirectory(path3, extensions, exclude, include, depth);
             },
             onReleaseOldSourceFile,
             onReleaseParsedCommandLine,
@@ -165258,11 +165258,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           program.getTypeChecker();
           return;
           function getParsedCommandLine(fileName) {
-            const path2 = toPath(fileName, currentDirectory, getCanonicalFileName);
-            const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path2);
+            const path3 = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path3);
             if (existing !== void 0) return existing || void 0;
             const result = host.getParsedCommandLine ? host.getParsedCommandLine(fileName) : getParsedCommandLineOfConfigFileUsingSourceFile(fileName);
-            (parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path2, result || false);
+            (parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path3, result || false);
             return result;
           }
           function getParsedCommandLineOfConfigFileUsingSourceFile(configFileName) {
@@ -165304,7 +165304,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           function getOrCreateSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
             return getOrCreateSourceFileByPath(fileName, toPath(fileName, currentDirectory, getCanonicalFileName), languageVersionOrOptions, onError, shouldCreateNewSourceFile);
           }
-          function getOrCreateSourceFileByPath(fileName, path2, languageVersionOrOptions, _onError, shouldCreateNewSourceFile) {
+          function getOrCreateSourceFileByPath(fileName, path3, 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) {
@@ -165313,17 +165313,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             const scriptKind = getScriptKind(fileName, host);
             const scriptVersion = host.getScriptVersion(fileName);
             if (!shouldCreateNewSourceFile) {
-              const oldSourceFile = program && program.getSourceFileByPath(path2);
+              const oldSourceFile = program && program.getSourceFileByPath(path3);
               if (oldSourceFile) {
                 if (scriptKind === oldSourceFile.scriptKind || releasedScriptKinds.has(oldSourceFile.resolvedPath)) {
-                  return documentRegistry.updateDocumentWithKey(fileName, path2, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
+                  return documentRegistry.updateDocumentWithKey(fileName, path3, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
                 } else {
                   documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions()), oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat);
                   releasedScriptKinds.add(oldSourceFile.resolvedPath);
                 }
               }
             }
-            return documentRegistry.acquireDocumentWithKey(fileName, path2, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
+            return documentRegistry.acquireDocumentWithKey(fileName, path3, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
           }
         }
         function getProgram() {
@@ -165929,7 +165929,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           return isArray(action) ? Promise.all(action.map((a) => applySingleCodeActionCommand(a))) : applySingleCodeActionCommand(action);
         }
         function applySingleCodeActionCommand(action) {
-          const getPath = (path2) => toPath(path2, currentDirectory, getCanonicalFileName);
+          const getPath = (path3) => toPath(path3, 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`");
         }
@@ -166273,8 +166273,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           function isLetterOrDigit(char) {
             return char >= 97 && char <= 122 || char >= 65 && char <= 90 || char >= 48 && char <= 57;
           }
-          function isNodeModulesFile(path2) {
-            return path2.includes("/node_modules/");
+          function isNodeModulesFile(path3) {
+            return path3.includes("/node_modules/");
           }
         }
         function getRenameInfo2(fileName, position, preferences) {
@@ -179908,11 +179908,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           }
         });
       }
-      function generateJSDocParamTagsForDestructuring(path2, pattern, initializer, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
+      function generateJSDocParamTagsForDestructuring(path3, pattern, initializer, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
         if (!isJs) {
           return [
             getJSDocParamAnnotation(
-              path2,
+              path3,
               initializer,
               dotDotDotToken,
               isJs,
@@ -179926,7 +179926,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             )
           ];
         }
-        return patternWorker(path2, pattern, initializer, dotDotDotToken, { tabstop: 1 });
+        return patternWorker(path3, pattern, initializer, dotDotDotToken, { tabstop: 1 });
         function patternWorker(path22, pattern2, initializer2, dotDotDotToken2, counter) {
           if (isObjectBindingPattern(pattern2) && !dotDotDotToken2) {
             const oldTabstop = counter.tabstop;
@@ -184549,21 +184549,21 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function getFragmentDirectory(fragment) {
         return containsSlash(fragment) ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
       }
-      function getCompletionsForPathMapping(path2, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost) {
-        const parsedPath = tryParsePattern(path2);
+      function getCompletionsForPathMapping(path3, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost) {
+        const parsedPath = tryParsePattern(path3);
         if (!parsedPath) {
           return emptyArray;
         }
         if (typeof parsedPath === "string") {
           return justPathMappingName(
-            path2,
+            path3,
             "script"
             /* scriptElement */
           );
         }
         const remainingFragment = tryRemovePrefix(fragment, parsedPath.prefix);
         if (remainingFragment === void 0) {
-          const starIsFullPathComponent = endsWith(path2, "/*");
+          const starIsFullPathComponent = endsWith(path3, "/*");
           return starIsFullPathComponent ? justPathMappingName(
             parsedPath.prefix,
             "directory"
@@ -184649,9 +184649,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         function getDirectoryMatches(directoryName) {
           return mapDefined(tryGetDirectories(host, directoryName), (dir) => dir === "node_modules" ? void 0 : directoryResult(dir));
         }
-        function trimPrefixAndSuffix(path2, prefix) {
+        function trimPrefixAndSuffix(path3, prefix) {
           return firstDefined(matchingSuffixes, (suffix) => {
-            const inner = withoutStartAndEnd(normalizePath(path2), prefix, suffix);
+            const inner = withoutStartAndEnd(normalizePath(path3), prefix, suffix);
             return inner === void 0 ? void 0 : removeLeadingDirectorySeparator(inner);
           });
         }
@@ -184659,8 +184659,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function withoutStartAndEnd(s, start, end) {
         return startsWith(s, start) && endsWith(s, end) ? s.slice(start.length, s.length - end.length) : void 0;
       }
-      function removeLeadingDirectorySeparator(path2) {
-        return path2[0] === directorySeparator ? path2.slice(1) : path2;
+      function removeLeadingDirectorySeparator(path3) {
+        return path3[0] === directorySeparator ? path3.slice(1) : path3;
       }
       function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) {
         const ambientModules = checker.getAmbientModules().map((sym) => stripQuotes(sym.name));
@@ -184775,10 +184775,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           /* ESNext */
         ) ? void 0 : createTextSpan(textStart + offset, length2);
       }
-      function isPathRelativeToScript(path2) {
-        if (path2 && path2.length >= 2 && path2.charCodeAt(0) === 46) {
-          const slashIndex = path2.length >= 3 && path2.charCodeAt(1) === 46 ? 2 : 1;
-          const slashCharCode = path2.charCodeAt(slashIndex);
+      function isPathRelativeToScript(path3) {
+        if (path3 && path3.length >= 2 && path3.charCodeAt(0) === 46) {
+          const slashIndex = path3.length >= 3 && path3.charCodeAt(1) === 46 ? 2 : 1;
+          const slashCharCode = path3.charCodeAt(slashIndex);
           return slashCharCode === 47 || slashCharCode === 92;
         }
         return false;
@@ -200749,17 +200749,17 @@ ${options.prefix}` : "\n" : options.prefix
       function createNormalizedPathMap() {
         const map2 = /* @__PURE__ */ new Map();
         return {
-          get(path2) {
-            return map2.get(path2);
+          get(path3) {
+            return map2.get(path3);
           },
-          set(path2, value) {
-            map2.set(path2, value);
+          set(path3, value) {
+            map2.set(path3, value);
           },
-          contains(path2) {
-            return map2.has(path2);
+          contains(path3) {
+            return map2.has(path3);
           },
-          remove(path2) {
-            map2.delete(path2);
+          remove(path3) {
+            map2.delete(path3);
           }
         };
       }
@@ -201272,12 +201272,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, path2, initialVersion) {
+        constructor(host, fileName, scriptKind, hasMixedContent, path3, initialVersion) {
           this.host = host;
           this.fileName = fileName;
           this.scriptKind = scriptKind;
           this.hasMixedContent = hasMixedContent;
-          this.path = path2;
+          this.path = path3;
           this.containingProjects = [];
           this.isDynamic = isDynamicFileName(fileName);
           this.textStorage = new TextStorage(host, this, initialVersion);
@@ -201912,8 +201912,8 @@ ${options.prefix}` : "\n" : options.prefix
         useCaseSensitiveFileNames() {
           return this.projectService.host.useCaseSensitiveFileNames;
         }
-        readDirectory(path2, extensions, exclude, include, depth) {
-          return this.directoryStructureHost.readDirectory(path2, extensions, exclude, include, depth);
+        readDirectory(path3, extensions, exclude, include, depth) {
+          return this.directoryStructureHost.readDirectory(path3, extensions, exclude, include, depth);
         }
         readFile(fileName) {
           return this.projectService.host.readFile(fileName);
@@ -201922,8 +201922,8 @@ ${options.prefix}` : "\n" : options.prefix
           return this.projectService.host.writeFile(fileName, content);
         }
         fileExists(file) {
-          const path2 = this.toPath(file);
-          return !!this.projectService.getScriptInfoForPath(path2) || !this.isWatchedMissingFile(path2) && this.directoryStructureHost.fileExists(file);
+          const path3 = this.toPath(file);
+          return !!this.projectService.getScriptInfoForPath(path3) || !this.isWatchedMissingFile(path3) && this.directoryStructureHost.fileExists(file);
         }
         /** @internal */
         resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
@@ -201948,11 +201948,11 @@ ${options.prefix}` : "\n" : options.prefix
         resolveLibrary(libraryName, resolveFrom, options, libFileName) {
           return this.resolutionCache.resolveLibrary(libraryName, resolveFrom, options, libFileName);
         }
-        directoryExists(path2) {
-          return this.directoryStructureHost.directoryExists(path2);
+        directoryExists(path3) {
+          return this.directoryStructureHost.directoryExists(path3);
         }
-        getDirectories(path2) {
-          return this.directoryStructureHost.getDirectories(path2);
+        getDirectories(path3) {
+          return this.directoryStructureHost.getDirectories(path3);
         }
         /** @internal */
         getCachedDirectoryStructureHost() {
@@ -202215,16 +202215,16 @@ ${options.prefix}` : "\n" : options.prefix
             }
           }));
         }
-        getSourceFile(path2) {
+        getSourceFile(path3) {
           if (!this.program) {
             return void 0;
           }
-          return this.program.getSourceFileByPath(path2);
+          return this.program.getSourceFileByPath(path3);
         }
         /** @internal */
-        getSourceFileOrConfigFile(path2) {
+        getSourceFileOrConfigFile(path3) {
           const options = this.program.getCompilerOptions();
-          return path2 === options.configFilePath ? options.configFile : this.getSourceFile(path2);
+          return path3 === options.configFilePath ? options.configFile : this.getSourceFile(path3);
         }
         close() {
           var _a;
@@ -202401,8 +202401,8 @@ ${options.prefix}` : "\n" : options.prefix
         }
         // add a root file that doesnt exist on host
         addMissingFileRoot(fileName) {
-          const path2 = this.projectService.toPath(fileName);
-          this.rootFilesMap.set(path2, { fileName });
+          const path3 = this.projectService.toPath(fileName);
+          this.rootFilesMap.set(path3, { fileName });
           this.markAsDirty();
         }
         removeFile(info, fileExists, detachFromProject) {
@@ -202568,22 +202568,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 = (path2, typingsWatcherType) => {
-            const canonicalPath = this.toPath(path2);
+          const createProjectWatcher = (path3, typingsWatcherType) => {
+            const canonicalPath = this.toPath(path3);
             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(
-                  path2,
+                  path3,
                   () => !this.typingWatchers.isInvoked ? this.onTypingInstallerWatchInvoke() : this.writeLog(`TypingWatchers already invoked`),
                   2e3,
                   this.projectService.getWatchOptions(this),
                   watchType,
                   this
                 ) : this.projectService.watchFactory.watchDirectory(
-                  path2,
+                  path3,
                   (f) => {
                     if (this.typingWatchers.isInvoked) return this.writeLog(`TypingWatchers already invoked`);
                     if (!fileExtensionIs(
@@ -202598,7 +202598,7 @@ ${options.prefix}` : "\n" : options.prefix
                   this.projectService.getWatchOptions(this),
                   watchType,
                   this
-                ) : (this.writeLog(`Skipping watcher creation at ${path2}:: ${getDetailWatchInfo(watchType, this)}`), noopFileWatcher)
+                ) : (this.writeLog(`Skipping watcher creation at ${path3}:: ${getDetailWatchInfo(watchType, this)}`), noopFileWatcher)
               );
             }
           };
@@ -202643,9 +202643,9 @@ ${options.prefix}` : "\n" : options.prefix
               /* DirectoryWatcher */
             );
           }
-          toRemove.forEach((watch, path2) => {
+          toRemove.forEach((watch, path3) => {
             watch.close();
-            this.typingWatchers.delete(path2);
+            this.typingWatchers.delete(path3);
           });
         }
         /** @internal */
@@ -202679,9 +202679,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, path2) => {
+            this.rootFilesMap.forEach((value, path3) => {
               var _a2;
-              const file = this.program.getSourceFileByPath(path2);
+              const file = this.program.getSourceFileByPath(path3);
               const info = value.info;
               if (!file || ((_a2 = value.info) == null ? void 0 : _a2.path) === file.resolvedPath) return;
               value.info = this.projectService.getScriptInfo(file.fileName);
@@ -202837,8 +202837,8 @@ ${options.prefix}` : "\n" : options.prefix
           );
           return fileWatcher;
         }
-        isWatchedMissingFile(path2) {
-          return !!this.missingFilesMap && this.missingFilesMap.has(path2);
+        isWatchedMissingFile(path3) {
+          return !!this.missingFilesMap && this.missingFilesMap.has(path3);
         }
         /** @internal */
         addGeneratedFileWatch(generatedFile, sourceFile) {
@@ -202847,17 +202847,17 @@ ${options.prefix}` : "\n" : options.prefix
               this.generatedFilesMap = this.createGeneratedFileWatcher(generatedFile);
             }
           } else {
-            const path2 = this.toPath(sourceFile);
+            const path3 = 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(path2)) return;
+              if (this.generatedFilesMap.has(path3)) return;
             } else {
               this.generatedFilesMap = /* @__PURE__ */ new Map();
             }
-            this.generatedFilesMap.set(path2, this.createGeneratedFileWatcher(generatedFile));
+            this.generatedFilesMap.set(path3, this.createGeneratedFileWatcher(generatedFile));
           }
         }
         createGeneratedFileWatcher(generatedFile) {
@@ -203257,7 +203257,7 @@ ${options.prefix}` : "\n" : options.prefix
         isDefaultProjectForOpenFiles() {
           return !!forEachEntry(
             this.projectService.openFiles,
-            (_projectRootPath, path2) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path2)) === this
+            (_projectRootPath, path3) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path3)) === this
           );
         }
         /** @internal */
@@ -204431,33 +204431,33 @@ ${options.prefix}` : "\n" : options.prefix
           getCurrentDirectory: () => service.host.getCurrentDirectory(),
           useCaseSensitiveFileNames: service.host.useCaseSensitiveFileNames
         };
-        function watchFile2(path2, callback) {
+        function watchFile2(path3, callback) {
           return getOrCreateFileWatcher(
             watchedFiles,
-            path2,
+            path3,
             callback,
-            (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path: path2 } })
+            (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path: path3 } })
           );
         }
-        function watchDirectory(path2, callback, recursive) {
+        function watchDirectory(path3, callback, recursive) {
           return getOrCreateFileWatcher(
             recursive ? watchedDirectoriesRecursive : watchedDirectories,
-            path2,
+            path3,
             callback,
             (id) => ({
               eventName: CreateDirectoryWatcherEvent,
               data: {
                 id,
-                path: path2,
+                path: path3,
                 recursive: !!recursive,
                 // Special case node_modules as we watch it for changes to closed script infos as well
-                ignoreUpdate: !path2.endsWith("/node_modules") ? true : void 0
+                ignoreUpdate: !path3.endsWith("/node_modules") ? true : void 0
               }
             })
           );
         }
-        function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path2, callback, event) {
-          const key = service.toPath(path2);
+        function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path3, callback, event) {
+          const key = service.toPath(path3);
           let id = pathToId.get(key);
           if (!id) pathToId.set(key, id = ids++);
           let callbacks = idToCallbacks.get(id);
@@ -204626,13 +204626,13 @@ ${options.prefix}` : "\n" : options.prefix
           return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());
         }
         /** @internal */
-        setDocument(key, path2, sourceFile) {
-          const info = Debug.checkDefined(this.getScriptInfoForPath(path2));
+        setDocument(key, path3, sourceFile) {
+          const info = Debug.checkDefined(this.getScriptInfoForPath(path3));
           info.cacheSourceFile = { key, sourceFile };
         }
         /** @internal */
-        getDocument(key, path2) {
-          const info = this.getScriptInfoForPath(path2);
+        getDocument(key, path3) {
+          const info = this.getScriptInfoForPath(path3);
           return info && info.cacheSourceFile && info.cacheSourceFile.key === key ? info.cacheSourceFile.sourceFile : void 0;
         }
         /** @internal */
@@ -204754,7 +204754,7 @@ ${options.prefix}` : "\n" : options.prefix
           const event = {
             eventName: ProjectsUpdatedInBackgroundEvent,
             data: {
-              openFiles: arrayFrom(this.openFiles.keys(), (path2) => this.getScriptInfoForPath(path2).fileName)
+              openFiles: arrayFrom(this.openFiles.keys(), (path3) => this.getScriptInfoForPath(path3).fileName)
             }
           };
           this.eventHandler(event);
@@ -204976,11 +204976,11 @@ ${options.prefix}` : "\n" : options.prefix
         }
         delayUpdateSourceInfoProjects(sourceInfos) {
           if (sourceInfos) {
-            sourceInfos.forEach((_value, path2) => this.delayUpdateProjectsOfScriptInfoPath(path2));
+            sourceInfos.forEach((_value, path3) => this.delayUpdateProjectsOfScriptInfoPath(path3));
           }
         }
-        delayUpdateProjectsOfScriptInfoPath(path2) {
-          const info = this.getScriptInfoForPath(path2);
+        delayUpdateProjectsOfScriptInfoPath(path3) {
+          const info = this.getScriptInfoForPath(path3);
           if (info) {
             this.delayUpdateProjectGraphs(
               info.containingProjects,
@@ -205074,8 +205074,8 @@ ${options.prefix}` : "\n" : options.prefix
             const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath);
             if (!project) return;
             if (configuredProjectForConfig !== project && this.getHostPreferences().includeCompletionsForModuleExports) {
-              const path2 = this.toPath(configFileName);
-              if (find((_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path2)) {
+              const path3 = this.toPath(configFileName);
+              if (find((_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path3)) {
                 project.markAutoImportProviderAsDirty();
               }
             }
@@ -205130,10 +205130,10 @@ ${options.prefix}` : "\n" : options.prefix
                 });
                 return;
               }
-              const path2 = this.toPath(canonicalConfigFilePath);
-              project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path2);
+              const path3 = this.toPath(canonicalConfigFilePath);
+              project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path3);
               this.delayUpdateProjectGraph(project);
-              if (this.getHostPreferences().includeCompletionsForModuleExports && find((_c = project.getCurrentProgram()) == null ? void 0 : _c.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path2)) {
+              if (this.getHostPreferences().includeCompletionsForModuleExports && find((_c = project.getCurrentProgram()) == null ? void 0 : _c.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path3)) {
                 project.markAutoImportProviderAsDirty();
               }
             }
@@ -205158,20 +205158,20 @@ ${options.prefix}` : "\n" : options.prefix
             canonicalConfigFilePath,
             "Change in config file detected"
           );
-          this.openFiles.forEach((_projectRootPath, path2) => {
+          this.openFiles.forEach((_projectRootPath, path3) => {
             var _a, _b;
-            const configFileForOpenFile = this.configFileForOpenFiles.get(path2);
-            if (!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(path2))) return;
-            this.configFileForOpenFiles.delete(path2);
-            const info = this.getScriptInfoForPath(path2);
+            const configFileForOpenFile = this.configFileForOpenFiles.get(path3);
+            if (!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(path3))) return;
+            this.configFileForOpenFiles.delete(path3);
+            const info = this.getScriptInfoForPath(path3);
             const newConfigFileNameForInfo = this.getConfigFileNameForFile(
               info,
               /*findFromCacheOnly*/
               false
             );
             if (!newConfigFileNameForInfo) return;
-            if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path2))) {
-              (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path2, configFileForOpenFile);
+            if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path3))) {
+              (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path3, configFileForOpenFile);
             }
           });
           this.delayEnsureProjectForOpenFiles();
@@ -205266,8 +205266,8 @@ ${options.prefix}` : "\n" : options.prefix
           return project;
         }
         assignOrphanScriptInfosToInferredProject() {
-          this.openFiles.forEach((projectRootPath, path2) => {
-            const info = this.getScriptInfoForPath(path2);
+          this.openFiles.forEach((projectRootPath, path3) => {
+            const info = this.getScriptInfoForPath(path3);
             if (info.isOrphan()) {
               this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             }
@@ -205579,8 +205579,8 @@ ${options.prefix}` : "\n" : options.prefix
           this.configuredProjects.forEach(printProjectWithoutFileNames);
           this.inferredProjects.forEach(printProjectWithoutFileNames);
           this.logger.info("Open files: ");
-          this.openFiles.forEach((projectRootPath, path2) => {
-            const info = this.getScriptInfoForPath(path2);
+          this.openFiles.forEach((projectRootPath, path3) => {
+            const info = this.getScriptInfoForPath(path3);
             this.logger.info(`	FileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`);
             this.logger.info(`		Projects: ${info.containingProjects.map((p) => p.getProjectName())}`);
           });
@@ -205906,12 +205906,12 @@ ${options.prefix}` : "\n" : options.prefix
             const newRootFile = propertyReader.getFileName(f);
             const fileName = toNormalizedPath(newRootFile);
             const isDynamic = isDynamicFileName(fileName);
-            let path2;
+            let path3;
             if (!isDynamic && !project.fileExists(newRootFile)) {
-              path2 = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
-              const existingValue = projectRootFilesMap.get(path2);
+              path3 = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
+              const existingValue = projectRootFilesMap.get(path3);
               if (existingValue) {
-                if (((_a = existingValue.info) == null ? void 0 : _a.path) === path2) {
+                if (((_a = existingValue.info) == null ? void 0 : _a.path) === path3) {
                   project.removeFile(
                     existingValue.info,
                     /*fileExists*/
@@ -205923,7 +205923,7 @@ ${options.prefix}` : "\n" : options.prefix
                 }
                 existingValue.fileName = fileName;
               } else {
-                projectRootFilesMap.set(path2, { fileName });
+                projectRootFilesMap.set(path3, { fileName });
               }
             } else {
               const scriptKind = propertyReader.getScriptKind(f, this.hostConfiguration.extraFileExtensions);
@@ -205937,8 +205937,8 @@ ${options.prefix}` : "\n" : options.prefix
                 /*deferredDeleteOk*/
                 false
               ));
-              path2 = scriptInfo.path;
-              const existingValue = projectRootFilesMap.get(path2);
+              path3 = scriptInfo.path;
+              const existingValue = projectRootFilesMap.get(path3);
               if (!existingValue || existingValue.info !== scriptInfo) {
                 project.addRoot(scriptInfo, fileName);
                 if (scriptInfo.isScriptOpen()) {
@@ -205948,11 +205948,11 @@ ${options.prefix}` : "\n" : options.prefix
                 existingValue.fileName = fileName;
               }
             }
-            newRootScriptInfoMap.set(path2, true);
+            newRootScriptInfoMap.set(path3, true);
           }
           if (projectRootFilesMap.size > newRootScriptInfoMap.size) {
-            projectRootFilesMap.forEach((value, path2) => {
-              if (!newRootScriptInfoMap.has(path2)) {
+            projectRootFilesMap.forEach((value, path3) => {
+              if (!newRootScriptInfoMap.has(path3)) {
                 if (value.info) {
                   project.removeFile(
                     value.info,
@@ -205961,7 +205961,7 @@ ${options.prefix}` : "\n" : options.prefix
                     true
                   );
                 } else {
-                  projectRootFilesMap.delete(path2);
+                  projectRootFilesMap.delete(path3);
                 }
               }
             });
@@ -206198,8 +206198,8 @@ ${options.prefix}` : "\n" : options.prefix
         }
         /** @internal */
         getScriptInfoOrConfig(uncheckedFileName) {
-          const path2 = toNormalizedPath(uncheckedFileName);
-          const info = this.getScriptInfoForNormalizedPath(path2);
+          const path3 = toNormalizedPath(uncheckedFileName);
+          const info = this.getScriptInfoForNormalizedPath(path3);
           if (info) return info;
           const configProject = this.configuredProjects.get(this.toPath(uncheckedFileName));
           return configProject && configProject.getCompilerOptions().configFile;
@@ -206211,7 +206211,7 @@ ${options.prefix}` : "\n" : options.prefix
               this.filenameToScriptInfo.entries(),
               (entry) => entry[1].deferredDelete ? void 0 : entry
             ),
-            ([path2, scriptInfo]) => ({ path: path2, fileName: scriptInfo.fileName })
+            ([path3, scriptInfo]) => ({ path: path3, fileName: scriptInfo.fileName })
           );
           this.logger.msg(
             `Could not find file ${JSON.stringify(fileName)}.
@@ -206243,7 +206243,7 @@ All files are: ${JSON.stringify(names)}`,
                   if (!projects) {
                     projects = createMultiMap();
                     projects.add(toAddInfo.path, project);
-                  } else if (!forEachEntry(projects, (projs, path2) => path2 === toAddInfo.path ? false : contains(projs, project))) {
+                  } else if (!forEachEntry(projects, (projs, path3) => path3 === toAddInfo.path ? false : contains(projs, project))) {
                     projects.add(toAddInfo.path, project);
                   }
                 }
@@ -206405,8 +206405,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 path2 = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
-          let info = this.filenameToScriptInfo.get(path2);
+          const path3 = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
+          let info = this.filenameToScriptInfo.get(path3);
           if (!info) {
             const isDynamic = isDynamicFileName(fileName);
             Debug.assert(isRootedDiskPath(fileName) || isDynamic || openedByClient, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })}
@@ -206418,7 +206418,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, path2, this.filenameToScriptInfoVersion.get(path2));
+            info = new ScriptInfo(this.host, fileName, scriptKind, hasMixedContent, path3, this.filenameToScriptInfoVersion.get(path3));
             this.filenameToScriptInfo.set(info.path, info);
             this.filenameToScriptInfoVersion.delete(info.path);
             if (!openedByClient) {
@@ -206565,9 +206565,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 path2 = project.toPath(fileName);
-            const sourceFile = project.getSourceFile(path2);
-            if (sourceFile && sourceFile.resolvedPath === path2) return sourceFile;
+            const path3 = project.toPath(fileName);
+            const sourceFile = project.getSourceFile(path3);
+            if (sourceFile && sourceFile.resolvedPath === path3) return sourceFile;
           }
           const info = this.getOrCreateScriptInfoNotOpenedByClient(
             fileName,
@@ -206733,8 +206733,8 @@ Dynamic files must always be opened with service's current directory or service
               }
             });
           });
-          this.openFiles.forEach((_projectRootPath, path2) => {
-            const info = this.getScriptInfoForPath(path2);
+          this.openFiles.forEach((_projectRootPath, path3) => {
+            const info = this.getScriptInfoForPath(path3);
             if (find(info.containingProjects, isExternalProject)) return;
             this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
               info,
@@ -206787,14 +206787,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, path2) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
-              this.getScriptInfoForPath(path2),
+            (_config, path3) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+              this.getScriptInfoForPath(path3),
               5
               /* Create */
             )
           );
-          this.openFiles.forEach((projectRootPath, path2) => {
-            const info = this.getScriptInfoForPath(path2);
+          this.openFiles.forEach((projectRootPath, path3) => {
+            const info = this.getScriptInfoForPath(path3);
             if (info.isOrphan()) {
               this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             } else {
@@ -207305,9 +207305,9 @@ Dynamic files must always be opened with service's current directory or service
             }
           });
           if (!toRemoveConfiguredProjects.size) return toRemoveConfiguredProjects;
-          forEachEntry(this.openFiles, (_projectRootPath, path2) => {
-            if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path2)) return;
-            const info = this.getScriptInfoForPath(path2);
+          forEachEntry(this.openFiles, (_projectRootPath, path3) => {
+            if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path3)) return;
+            const info = this.getScriptInfoForPath(path3);
             if (find(info.containingProjects, isExternalProject)) return;
             const result = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
               info,
@@ -207356,8 +207356,8 @@ Dynamic files must always be opened with service's current directory or service
                 sourceInfos = info.sourceMapFilePath.sourceInfos;
               }
               if (!sourceInfos) return;
-              if (!forEachKey(sourceInfos, (path2) => {
-                const info2 = this.getScriptInfoForPath(path2);
+              if (!forEachKey(sourceInfos, (path3) => {
+                const info2 = this.getScriptInfoForPath(path3);
                 return !!info2 && (info2.isScriptOpen() || !info2.isOrphan());
               })) {
                 return;
@@ -207381,7 +207381,7 @@ Dynamic files must always be opened with service's current directory or service
                 sourceInfos = info.sourceMapFilePath.sourceInfos;
               }
               if (sourceInfos) {
-                sourceInfos.forEach((_value, path2) => toRemoveScriptInfos.delete(path2));
+                sourceInfos.forEach((_value, path3) => toRemoveScriptInfos.delete(path3));
               }
             }
           });
@@ -207864,9 +207864,9 @@ Dynamic files must always be opened with service's current directory or service
             }
           );
         }
-        watchPackageJsonFile(file, path2, project) {
+        watchPackageJsonFile(file, path3, project) {
           Debug.assert(project !== void 0);
-          let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path2);
+          let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path3);
           if (!result) {
             let watcher = this.watchFactory.watchFile(
               file,
@@ -207874,11 +207874,11 @@ Dynamic files must always be opened with service's current directory or service
                 switch (eventKind) {
                   case 0:
                   case 1:
-                    this.packageJsonCache.addOrUpdate(fileName, path2);
+                    this.packageJsonCache.addOrUpdate(fileName, path3);
                     this.onPackageJsonChange(result);
                     break;
                   case 2:
-                    this.packageJsonCache.delete(path2);
+                    this.packageJsonCache.delete(path3);
                     this.onPackageJsonChange(result);
                     result.projects.clear();
                     result.close();
@@ -207895,11 +207895,11 @@ Dynamic files must always be opened with service's current directory or service
                 if (result.projects.size || !watcher) return;
                 watcher.close();
                 watcher = void 0;
-                (_a = this.packageJsonFilesMap) == null ? void 0 : _a.delete(path2);
-                this.packageJsonCache.invalidate(path2);
+                (_a = this.packageJsonFilesMap) == null ? void 0 : _a.delete(path3);
+                this.packageJsonCache.invalidate(path3);
               }
             };
-            this.packageJsonFilesMap.set(path2, result);
+            this.packageJsonFilesMap.set(path3, result);
           }
           result.projects.add(project);
           (project.packageJsonWatches ?? (project.packageJsonWatches = /* @__PURE__ */ new Set())).add(result);
@@ -208089,14 +208089,14 @@ Dynamic files must always be opened with service's current directory or service
             );
           }
         };
-        function addOrUpdate(fileName, path2) {
+        function addOrUpdate(fileName, path3) {
           const packageJsonInfo = Debug.checkDefined(createPackageJsonInfo(fileName, host.host));
-          packageJsons.set(path2, packageJsonInfo);
-          directoriesWithoutPackageJson.delete(getDirectoryPath(path2));
+          packageJsons.set(path3, packageJsonInfo);
+          directoriesWithoutPackageJson.delete(getDirectoryPath(path3));
         }
-        function invalidate(path2) {
-          packageJsons.delete(path2);
-          directoriesWithoutPackageJson.delete(getDirectoryPath(path2));
+        function invalidate(path3) {
+          packageJsons.delete(path3);
+          directoriesWithoutPackageJson.delete(getDirectoryPath(path3));
         }
         function directoryHasPackageJson(directory) {
           return packageJsons.has(combinePaths(directory, "package.json")) ? -1 : directoriesWithoutPackageJson.has(directory) ? 0 : 3;
@@ -208293,8 +208293,8 @@ ${json}${newLine}`;
       function combineProjectOutput(defaultValue, getValue, projects, action) {
         const outputs = flatMapToMutable(isArray(projects) ? projects : projects.projects, (project) => action(project, defaultValue));
         if (!isArray(projects) && projects.symLinkedProjects) {
-          projects.symLinkedProjects.forEach((projects2, path2) => {
-            const value = getValue(path2);
+          projects.symLinkedProjects.forEach((projects2, path3) => {
+            const value = getValue(path3);
             outputs.push(...flatMap(projects2, (project) => action(project, value)));
           });
         }
@@ -208440,9 +208440,9 @@ ${json}${newLine}`;
         });
         return results.filter((o) => o.references.length !== 0);
       }
-      function forEachProjectInProjects(projects, path2, cb) {
+      function forEachProjectInProjects(projects, path3, cb) {
         for (const project of isArray(projects) ? projects : projects.projects) {
-          cb(project, path2);
+          cb(project, path3);
         }
         if (!isArray(projects) && projects.symLinkedProjects) {
           projects.symLinkedProjects.forEach((symlinkedProjects, symlinkedPath) => {
@@ -208456,8 +208456,8 @@ ${json}${newLine}`;
         const resultsMap = /* @__PURE__ */ new Map();
         const queue = createQueue();
         queue.enqueue({ project: defaultProject, location: initialLocation });
-        forEachProjectInProjects(projects, initialLocation.fileName, (project, path2) => {
-          const location = { fileName: path2, pos: initialLocation.pos };
+        forEachProjectInProjects(projects, initialLocation.fileName, (project, path3) => {
+          const location = { fileName: path3, pos: initialLocation.pos };
           queue.enqueue({ project, location });
         });
         const projectService = defaultProject.projectService;
@@ -210299,8 +210299,8 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
                 nodeModulesPathParts.packageRootIndex
               );
               const packageName = getPackageNameFromTypesPackageName(unmangleScopedPackageName(packageNamePathPart));
-              const path2 = project.toPath(fileName);
-              if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path2)) {
+              const path3 = project.toPath(fileName);
+              if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path3)) {
                 return (_b = auxiliaryProject.resolutionCache.resolveSingleModuleNameWithoutWatching(packageName, resolveFromFile).resolvedModule) == null ? void 0 : _b.resolvedFileName;
               } else {
                 const pathToFileInPackage = fileName.substring(nodeModulesPathParts.packageRootIndex + 1);
@@ -211080,7 +211080,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           }
           return combineProjectOutput(
             info,
-            (path2) => this.projectService.getScriptInfoForPath(path2),
+            (path3) => this.projectService.getScriptInfoForPath(path3),
             projects,
             (project, info2) => {
               if (!project.compileOnSaveEnabled || !project.languageServiceEnabled || project.isOrphan()) {
@@ -211107,7 +211107,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
             return args.richResponse ? { emitSkipped: true, diagnostics: [] } : false;
           }
           const scriptInfo = project.getScriptInfo(file);
-          const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path2, data, writeByteOrderMark) => this.host.writeFile(path2, data, writeByteOrderMark));
+          const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path3, data, writeByteOrderMark) => this.host.writeFile(path3, data, writeByteOrderMark));
           return args.richResponse ? {
             emitSkipped,
             diagnostics: args.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics) : diagnostics.map((d) => formatDiagnosticToProtocol(
@@ -213047,11 +213047,12 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 });
 
 // package.json
-var version = "0.5.8";
+var version = "0.6.0";
 
 // src/index.ts
 var import_generator_helper = require("@prisma/generator-helper");
 var import_typescript = __toESM(require_typescript());
+var import_path2 = __toESM(require("path"));
 
 // src/config.ts
 var import_zod = require("zod");
@@ -213235,7 +213236,7 @@ var getZodConstructor = (field, getRelatedModelName = (name) => name.toString(),
         break;
     }
   } else if (field.kind === "enum") {
-    zodType = `z.nativeEnum(${field.type})`;
+    zodType = `z.enum(${field.type})`;
   } else if (field.kind === "object") {
     zodType = getRelatedModelName(field.type);
   }
@@ -213252,8 +213253,42 @@ var getZodConstructor = (field, getRelatedModelName = (name) => name.toString(),
 // src/generator.ts
 var parseNativeTypes = (schemaPath) => {
   var _a;
-  const fullSchemaPath = schemaPath.endsWith("schema.prisma") ? schemaPath : import_path.default.join(schemaPath, "schema.prisma");
-  const schemaContent = (0, import_fs.readFileSync)(fullSchemaPath, "utf-8");
+  let schemaContent = "";
+  let resolvedPath = schemaPath;
+  try {
+    if (!(0, import_fs.existsSync)(resolvedPath)) {
+      const withFile = import_path.default.join(schemaPath, "schema.prisma");
+      const parentDir = import_path.default.dirname(schemaPath);
+      if ((0, import_fs.existsSync)(withFile)) {
+        resolvedPath = withFile;
+      } else if ((0, import_fs.existsSync)(parentDir)) {
+        resolvedPath = parentDir;
+      } else {
+        console.warn(`Schema path not found: ${schemaPath}`);
+        return /* @__PURE__ */ new Map();
+      }
+    }
+    const stat = (0, import_fs.statSync)(resolvedPath);
+    if (stat.isFile()) {
+      schemaContent = (0, import_fs.readFileSync)(resolvedPath, "utf-8");
+    } else if (stat.isDirectory()) {
+      const prismaFiles = findPrismaFiles(resolvedPath);
+      if (prismaFiles.length === 0) {
+        console.warn(`No .prisma files found in ${resolvedPath}`);
+        return /* @__PURE__ */ new Map();
+      }
+      prismaFiles.forEach((filePath) => {
+        schemaContent += (0, import_fs.readFileSync)(filePath, "utf-8") + "\n";
+      });
+    }
+  } catch (error) {
+    console.error(`Error reading schema path: ${schemaPath}`, error);
+    return /* @__PURE__ */ new Map();
+  }
+  if (!schemaContent) {
+    console.warn(`No schema content found at ${schemaPath}`);
+    return /* @__PURE__ */ new Map();
+  }
   const nativeTypes = /* @__PURE__ */ new Map();
   const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g;
   const fieldRegex = /(\w+)\s+(\w+(?:\[\])?)\s+([^;\n]+)/g;
@@ -213277,6 +213312,28 @@ var parseNativeTypes = (schemaPath) => {
   }
   return nativeTypes;
 };
+var findPrismaFiles = (dir) => {
+  const prismaFiles = [];
+  try {
+    const files = (0, import_fs.readdirSync)(dir);
+    files.forEach((file) => {
+      const fullPath = import_path.default.join(dir, file);
+      try {
+        const stat = (0, import_fs.statSync)(fullPath);
+        if (stat.isDirectory() && !file.startsWith(".")) {
+          prismaFiles.push(...findPrismaFiles(fullPath));
+        } else if (file.endsWith(".prisma")) {
+          prismaFiles.push(fullPath);
+        }
+      } catch (error) {
+        console.warn(`Could not read ${fullPath}`);
+      }
+    });
+  } catch (error) {
+    console.error(`Error reading directory ${dir}`);
+  }
+  return prismaFiles;
+};
 var writeImportsForModel = (model, sourceFile, config, { schemaPath, outputPath, clientPath }) => {
   const { relatedModelName } = useModelNames(config);
   const importList = [
@@ -213287,11 +213344,12 @@ var writeImportsForModel = (model, sourceFile, config, { schemaPath, outputPath,
     }
   ];
   if (config.imports) {
+    const baseDir = schemaPath.endsWith(".prisma") ? import_path.default.dirname(schemaPath) : schemaPath;
     importList.push({
       kind: import_ts_morph.StructureKind.ImportDeclaration,
       namespaceImport: "imports",
       moduleSpecifier: dotSlash(
-        import_path.default.relative(outputPath, import_path.default.resolve(import_path.default.dirname(schemaPath), config.imports))
+        import_path.default.relative(outputPath, import_path.default.resolve(baseDir, config.imports))
       )
     });
   }
@@ -213369,8 +213427,7 @@ var writeTypeSpecificSchemas = (model, sourceFile, config, _prismaOptions) => {
 };
 var generateSchemaForModel = (model, sourceFile, config, { schemaPath }) => {
   const { modelName } = useModelNames(config);
-  const actualSchemaPath = schemaPath.includes("schema.prisma") ? schemaPath : import_path.default.join(schemaPath, "schema.prisma");
-  const nativeTypes = parseNativeTypes(actualSchemaPath);
+  const nativeTypes = parseNativeTypes(schemaPath);
   const modelNativeTypes = nativeTypes.get(model.name) || /* @__PURE__ */ new Map();
   sourceFile.addVariableStatement({
     declarationKind: import_ts_morph.VariableDeclarationKind.Const,
@@ -213444,11 +213501,11 @@ var populateModelFile = (model, sourceFile, config, prismaOptions) => {
     generateRelatedSchemaForModel(model, sourceFile, config, prismaOptions);
 };
 var generateBarrelFile = (models, indexFile) => {
-  models.forEach(
-    (model) => indexFile.addExportDeclaration({
+  models.forEach((model) => {
+    indexFile.addExportDeclaration({
       moduleSpecifier: `./${model.name.toLowerCase()}`
-    })
-  );
+    });
+  });
 };
 
 // src/index.ts
@@ -213464,7 +213521,8 @@ var import_ts_morph2 = require("ts-morph");
   onGenerate(options) {
     const project = new import_ts_morph2.Project();
     const models = [...options.dmmf.datamodel.models];
-    const { schemaPath } = options;
+    const schemaPath = options.schemaPath;
+    const schemaDir = import_path2.default.dirname(schemaPath);
     const outputPath = options.generator.output.value;
     const clientPath = options.otherGenerators.find(
       (each) => each.provider.value === "prisma-client-js"
@@ -213478,7 +213536,8 @@ var import_ts_morph2 = require("ts-morph");
     const prismaOptions = {
       clientPath,
       outputPath,
-      schemaPath
+      schemaPath: schemaDir
+      // Pass the directory, not the file
     };
     const indexFile = project.createSourceFile(
       `${outputPath}/index.ts`,